Refactor DisplayManagerService

    private final Context mContext;

    private final DisplayManagerHandler mHandler;

    private final HandlerExecutor mHandlerExecutor;

    private final Handler mUiHandler;

    private final DisplayModeDirector mDisplayModeDirector;

    private final ExternalDisplayPolicy mExternalDisplayPolicy;

    public boolean mSafeMode;

    // All callback records indexed by calling process id.

    @GuardedBy("mSyncRoot")

    private final SparseArray<CallbackRecord> mCallbacks = new SparseArray<>();

    /**

        mContext = context;

        mFlags = injector.getFlags();

        mHandler = new DisplayManagerHandler(displayThreadLooper);

        mHandlerExecutor = new HandlerExecutor(mHandler);

        mUiHandler = UiThread.getHandler();

        mDisplayDeviceRepo = new DisplayDeviceRepository(mSyncRoot, mPersistentDataStore);

        mLogicalDisplayMapper = new LogicalDisplayMapper(mContext,

            mWindowManagerInternal = LocalServices.getService(WindowManagerInternal.class);

            mInputManagerInternal = LocalServices.getService(InputManagerInternal.class);

            mActivityManagerInternal = LocalServices.getService(ActivityManagerInternal.class);

            ActivityManager activityManager = mContext.getSystemService(ActivityManager.class);

            activityManager.addOnUidImportanceListener(mUidImportanceListener, IMPORTANCE_CACHED);

            mDeviceStateManager = LocalServices.getService(DeviceStateManagerInternal.class);

            mContext.getSystemService(DeviceStateManager.class).registerCallback(

                    new HandlerExecutor(mHandler), new DeviceStateListener());

                    mHandlerExecutor, new DeviceStateListener());

            mLogicalDisplayMapper.onWindowManagerReady();

            scheduleTraversalLocked(false);

    private class UidImportanceListener implements ActivityManager.OnUidImportanceListener {

        @Override

        public void onUidImportance(int uid, int importance) {

          onUidImportanceInternal(uid, importance);

        }

        private void onUidImportanceInternal(int uid, int importance) {

            synchronized (mPendingCallbackSelfLocked) {

                if (importance >= IMPORTANCE_GONE) {

                    // Clean up as the app is already gone

        // After releasing the lock, send the notifications out.

        for (int i = 0; i < mTempCallbacks.size(); i++) {

            CallbackRecord callbackRecord = mTempCallbacks.get(i);

            deliverEventInternal(callbackRecord, displayId, event);

        }

        mTempCallbacks.clear();

    }

    private void deliverEventInternal(CallbackRecord callbackRecord, int displayId, int event) {

        final int uid = callbackRecord.mUid;

        final int pid = callbackRecord.mPid;

        if (isUidCached(uid)) {

            callbackRecord.notifyDisplayEventAsync(displayId, event);

        }

    }

        mTempCallbacks.clear();

    }

    private boolean extraLogging(String packageName) {

        return mExtraDisplayEventLogging && mExtraDisplayLoggingPackageName.equals(packageName);

        public boolean mWifiDisplayScanRequested;

        CallbackRecord(int pid, int uid, IDisplayManagerCallback callback,

        CallbackRecord(int pid, int uid, @NonNull IDisplayManagerCallback callback,

                @EventsMask long eventsMask) {

            mPid = pid;

            mUid = uid;

        }

        /**

         * @return {@code false} if RemoteException happens; otherwise {@code true} for success.

         * @return {@code false} if RemoteException happens; otherwise {@code true} for

         * success.  This returns true even if the event was deferred because the remote client is

         * cached.

         */

        public boolean notifyDisplayEventAsync(int displayId, @DisplayEvent int event) {

            if (!shouldSendEvent(event)) {

                            "notifyDisplayEventAsync#notSendingEvent=" + event + ",mEventsMask="

                                    + mEventsMask);

                }

                // The client is not interested in this event, so do nothing.

                return true;

            }

            return transmitDisplayEvent(displayId, event);

        }

        /**

         * Transmit a single display event.  The client is presumed ready.  Return true on success

         * and false if the client died.

         */

        private boolean transmitDisplayEvent(int displayId, @DisplayEvent int event) {

            // The client is ready to receive the event.

            try {

                mCallback.onDisplayEvent(displayId, event);

                return true;

            }

        }

        /**

         * Return true if the client is interested in this event.

         */

        private boolean shouldSendEvent(@DisplayEvent int event) {

            final long mask = mEventsMask.get();

            switch (event) {

import android.annotation.NonNull;

import android.annotation.Nullable;

import android.app.ActivityManagerInternal;

import android.app.ActivityOptions.LaunchCookie;

import android.app.PropertyInvalidatedCache;

import android.companion.virtual.IVirtualDevice;

    @Mock DisplayDeviceConfig mMockDisplayDeviceConfig;

    @Mock PackageManagerInternal mMockPackageManagerInternal;

    @Mock DisplayManagerInternal mMockDisplayManagerInternal;

    @Mock ActivityManagerInternal mMockActivityManagerInternal;

    @Mock DisplayAdapter mMockDisplayAdapter;

    @Captor ArgumentCaptor<ContentRecordingSession> mContentRecordingSessionCaptor;

                PackageManagerInternal.class, mMockPackageManagerInternal);

        mLocalServiceKeeperRule.overrideLocalService(

                DisplayManagerInternal.class, mMockDisplayManagerInternal);

        mLocalServiceKeeperRule.overrideLocalService(

                ActivityManagerInternal.class, mMockActivityManagerInternal);

        Display display = mock(Display.class);

        when(display.getDisplayAdjustments()).thenReturn(new DisplayAdjustments());

        when(display.getBrightnessInfo()).thenReturn(mock(BrightnessInfo.class));