Merge changes I6925c703,Idbd10c00,I4dbdd28c,I68ced121,I340824fe, ... into main

import android.text.TextUtils;

import android.util.ArraySet;

import android.util.EventLog;

import android.util.IndentingPrintWriter;

import android.util.IntArray;

import android.util.Pair;

import android.util.Slog;

import com.android.internal.util.ArrayUtils;

import com.android.internal.util.DumpUtils;

import com.android.internal.util.FrameworkStatsLog;

import com.android.internal.util.IndentingPrintWriter;

import com.android.internal.util.SettingsWrapper;

import com.android.server.AnimationThread;

import com.android.server.DisplayThread;

 * avoid this by making all potentially reentrant out-calls asynchronous.

 * </p>

 */

@SuppressWarnings("MissingPermission")

public final class DisplayManagerService extends SystemService {

    private static final String TAG = "DisplayManagerService";

    private WindowManagerInternal mWindowManagerInternal;

    private InputManagerInternal mInputManagerInternal;

    private ActivityManagerInternal mActivityManagerInternal;

    private ActivityManager mActivityManager;

    private UidImportanceListener mUidImportanceListener = new UidImportanceListener();

    private final UidImportanceListener mUidImportanceListener = new UidImportanceListener();

    @Nullable

    private IMediaProjectionManager mProjectionService;

    private DeviceStateManagerInternal mDeviceStateManager;

    @GuardedBy("mSyncRoot")

    private int[] mUserDisabledHdrTypes = {};

    @Display.HdrCapabilities.HdrType

    private int[] mSupportedHdrOutputType;

    @GuardedBy("mSyncRoot")

    private boolean mAreUserDisabledHdrTypesAllowed = true;

    public boolean mSafeMode;

    // All callback records indexed by calling process id.

    public final SparseArray<CallbackRecord> mCallbacks =

            new SparseArray<CallbackRecord>();

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

    /**

     *  All {@link IVirtualDevice} and {@link DisplayWindowPolicyController}s indexed by

            new HighBrightnessModeMetadataMapper();

    // List of all currently registered display adapters.

    private final ArrayList<DisplayAdapter> mDisplayAdapters = new ArrayList<DisplayAdapter>();

    private final ArrayList<DisplayAdapter> mDisplayAdapters = new ArrayList<>();

    /**

     * Repository of all active {@link DisplayDevice}s.

    // List of all display transaction listeners.

    private final CopyOnWriteArrayList<DisplayTransactionListener> mDisplayTransactionListeners =

            new CopyOnWriteArrayList<DisplayTransactionListener>();

            new CopyOnWriteArrayList<>();

    /** List of all display group listeners. */

    private final CopyOnWriteArrayList<DisplayGroupListener> mDisplayGroupListeners =

    // Temporary callback list, used when sending display events to applications.

    // May be used outside of the lock but only on the handler thread.

    private final ArrayList<CallbackRecord> mTempCallbacks = new ArrayList<CallbackRecord>();

    private final ArrayList<CallbackRecord> mTempCallbacks = new ArrayList<>();

    // Pending callback records indexed by calling process uid and pid.

    // Must be used outside of the lock mSyncRoot and should be selflocked.

    // Must be used outside of the lock mSyncRoot and should be self-locked.

    @GuardedBy("mPendingCallbackSelfLocked")

    public final SparseArray<SparseArray<PendingCallback>> mPendingCallbackSelfLocked =

    private final SparseArray<SparseArray<PendingCallback>> mPendingCallbackSelfLocked =

            new SparseArray<>();

    // Temporary viewports, used when sending new viewport information to the

    private final BroadcastReceiver mIdleModeReceiver = new BroadcastReceiver() {

        @Override

        public void onReceive(Context context, Intent intent) {

            final DisplayManagerInternal dmi =

                    LocalServices.getService(DisplayManagerInternal.class);

            if (Intent.ACTION_DOCK_EVENT.equals(intent.getAction())) {

                int dockState = intent.getIntExtra(Intent.EXTRA_DOCK_STATE,

                        Intent.EXTRA_DOCK_STATE_UNDOCKED);

    @EnabledSince(targetSdkVersion = android.os.Build.VERSION_CODES.S)

    static final long DISPLAY_MODE_RETURNS_PHYSICAL_REFRESH_RATE = 170503758L;

    private final Uri mScreenResolutionModeUri = Settings.Secure.getUriFor(

            Settings.Secure.SCREEN_RESOLUTION_MODE);

    public DisplayManagerService(Context context) {

        this(context, new Injector());

    }

            mWindowManagerInternal = LocalServices.getService(WindowManagerInternal.class);

            mInputManagerInternal = LocalServices.getService(InputManagerInternal.class);

            mActivityManagerInternal = LocalServices.getService(ActivityManagerInternal.class);

            mActivityManager = mContext.getSystemService(ActivityManager.class);

            mActivityManager.addOnUidImportanceListener(mUidImportanceListener, IMPORTANCE_CACHED);

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

            activityManager.addOnUidImportanceListener(mUidImportanceListener, IMPORTANCE_CACHED);

            mDeviceStateManager = LocalServices.getService(DeviceStateManagerInternal.class);

            mContext.getSystemService(DeviceStateManager.class).registerCallback(

                device.setUserPreferredDisplayModeLocked(mode);

            });

        } else {

            mLogicalDisplayMapper.forEachLocked((LogicalDisplay display) -> {

                configurePreferredDisplayModeLocked(display);

            });

            mLogicalDisplayMapper.forEachLocked(this::configurePreferredDisplayModeLocked);

        }

    }

            // If HDR conversion introduces latency, disable that in case minimal

            // post-processing is requested

            boolean disableHdrConversionForLatency =

                    mppRequest ? hdrConversionIntroducesLatencyLocked() : false;

                    mppRequest && hdrConversionIntroducesLatencyLocked();

            if (display.getRequestedMinimalPostProcessingLocked() != mppRequest) {

                display.setRequestedMinimalPostProcessingLocked(mppRequest);

                    autoHdrTypes);

        }

        @Display.HdrCapabilities.HdrType

        int[] getSupportedHdrOutputTypes() {

            return DisplayControl.getSupportedHdrOutputTypes();

        }

        }

        @Override // Binder call

        public void dump(FileDescriptor fd, final PrintWriter pw, String[] args) {

        public void dump(@NonNull FileDescriptor fd, @NonNull final PrintWriter pw, String[] args) {

            if (!DumpUtils.checkDumpPermission(mContext, TAG, pw)) return;

            final long token = Binder.clearCallingIdentity();

        @Override // Binder call

        public void onShellCommand(FileDescriptor in, FileDescriptor out,

                FileDescriptor err, String[] args, ShellCallback callback,

                ResultReceiver resultReceiver) {

                FileDescriptor err, @NonNull String[] args, ShellCallback callback,

                @NonNull ResultReceiver resultReceiver) {

            new DisplayManagerShellCommand(DisplayManagerService.this, mFlags).exec(this, in, out,

                    err, args, callback, resultReceiver);

        }

                && (brightness <= PowerManager.BRIGHTNESS_MAX);

    }

    private static boolean isValidResolution(Point resolution) {

        return (resolution != null) && (resolution.x > 0) && (resolution.y > 0);

    }

    private static boolean isValidRefreshRate(float refreshRate) {

        return !Float.isNaN(refreshRate) && (refreshRate > 0.0f);

    }

    @VisibleForTesting

    void overrideSensorManager(SensorManager sensorManager) {

        synchronized (mSyncRoot) {

        }

    };

    private class BrightnessPair {

    private static class BrightnessPair {

        public float brightness;

        public float sdrBrightness;