android/hardware/display/DisplayManagerGlobal.java - platform/prebuilts/fullsdk/sources/android-29 - Git at Google

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.hardware.display;

 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.annotation.UnsupportedAppUsage;
 import android.content.Context;
 import android.content.pm.ParceledListSlice;
 import android.content.res.Resources;
 import android.graphics.ColorSpace;
 import android.graphics.Point;
 import android.hardware.display.DisplayManager.DisplayListener;
 import android.media.projection.IMediaProjection;
 import android.media.projection.MediaProjection;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Looper;
 import android.os.Message;
 import android.os.RemoteException;
 import android.os.ServiceManager;
 import android.text.TextUtils;
 import android.util.Log;
 import android.util.Pair;
 import android.util.SparseArray;
 import android.view.Display;
 import android.view.DisplayAdjustments;
 import android.view.DisplayInfo;
 import android.view.Surface;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;

 /**
  * Manager communication with the display manager service on behalf of
  * an application process.  You're probably looking for {@link DisplayManager}.
  *
  * @hide
  */
 public final class DisplayManagerGlobal {
     private static final String TAG = "DisplayManager";
     private static final boolean DEBUG = false;

     // True if display info and display ids should be cached.
     //
     // FIXME: The cache is currently disabled because it's unclear whether we have the
     // necessary guarantees that the caches will always be flushed before clients
     // attempt to observe their new state.  For example, depending on the order
     // in which the binder transactions take place, we might have a problem where
     // an application could start processing a configuration change due to a display
     // orientation change before the display info cache has actually been invalidated.
     private static final boolean USE_CACHE = false;

     public static final int EVENT_DISPLAY_ADDED = 1;
     public static final int EVENT_DISPLAY_CHANGED = 2;
     public static final int EVENT_DISPLAY_REMOVED = 3;

     @UnsupportedAppUsage
     private static DisplayManagerGlobal sInstance;

     private final Object mLock = new Object();

     @UnsupportedAppUsage
     private final IDisplayManager mDm;

     private DisplayManagerCallback mCallback;
     private final ArrayList<DisplayListenerDelegate> mDisplayListeners =
             new ArrayList<DisplayListenerDelegate>();

     private final SparseArray<DisplayInfo> mDisplayInfoCache = new SparseArray<DisplayInfo>();
     private final ColorSpace mWideColorSpace;
     private int[] mDisplayIdCache;

     private int mWifiDisplayScanNestCount;

     private DisplayManagerGlobal(IDisplayManager dm) {
         mDm = dm;
         try {
             mWideColorSpace =
                     ColorSpace.get(
                             ColorSpace.Named.values()[mDm.getPreferredWideGamutColorSpaceId()]);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Gets an instance of the display manager global singleton.
      *
      * @return The display manager instance, may be null early in system startup
      * before the display manager has been fully initialized.
      */
     @UnsupportedAppUsage
     public static DisplayManagerGlobal getInstance() {
         synchronized (DisplayManagerGlobal.class) {
             if (sInstance == null) {
                 IBinder b = ServiceManager.getService(Context.DISPLAY_SERVICE);
                 if (b != null) {
                     sInstance = new DisplayManagerGlobal(IDisplayManager.Stub.asInterface(b));
                 }
             }
             return sInstance;
         }
     }

     /**
      * Get information about a particular logical display.
      *
      * @param displayId The logical display id.
      * @return Information about the specified display, or null if it does not exist.
      * This object belongs to an internal cache and should be treated as if it were immutable.
      */
     @UnsupportedAppUsage
     public DisplayInfo getDisplayInfo(int displayId) {
         try {
             synchronized (mLock) {
                 DisplayInfo info;
                 if (USE_CACHE) {
                     info = mDisplayInfoCache.get(displayId);
                     if (info != null) {
                         return info;
                     }
                 }

                 info = mDm.getDisplayInfo(displayId);
                 if (info == null) {
                     return null;
                 }

                 if (USE_CACHE) {
                     mDisplayInfoCache.put(displayId, info);
                 }
                 registerCallbackIfNeededLocked();

                 if (DEBUG) {
                     Log.d(TAG, "getDisplayInfo: displayId=" + displayId + ", info=" + info);
                 }
                 return info;
             }
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Gets all currently valid logical display ids.
      *
      * @return An array containing all display ids.
      */
     @UnsupportedAppUsage
     public int[] getDisplayIds() {
         try {
             synchronized (mLock) {
                 if (USE_CACHE) {
                     if (mDisplayIdCache != null) {
                         return mDisplayIdCache;
                     }
                 }

                 int[] displayIds = mDm.getDisplayIds();
                 if (USE_CACHE) {
                     mDisplayIdCache = displayIds;
                 }
                 registerCallbackIfNeededLocked();
                 return displayIds;
             }
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Check if specified UID's content is present on display and should be granted access to it.
      *
      * @param uid UID to be checked.
      * @param displayId id of the display where presence of the content is checked.
      * @return {@code true} if UID is present on display, {@code false} otherwise.
      */
     public boolean isUidPresentOnDisplay(int uid, int displayId) {
         try {
             return mDm.isUidPresentOnDisplay(uid, displayId);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Gets information about a logical display.
      *
      * The display metrics may be adjusted to provide compatibility
      * for legacy applications or limited screen areas.
      *
      * @param displayId The logical display id.
      * @param daj The compatibility info and activityToken.
      * @return The display object, or null if there is no display with the given id.
      */
     public Display getCompatibleDisplay(int displayId, DisplayAdjustments daj) {
         DisplayInfo displayInfo = getDisplayInfo(displayId);
         if (displayInfo == null) {
             return null;
         }
         return new Display(this, displayId, displayInfo, daj);
     }

     /**
      * Gets information about a logical display.
      *
      * The display metrics may be adjusted to provide compatibility
      * for legacy applications or limited screen areas.
      *
      * @param displayId The logical display id.
      * @param resources Resources providing compatibility info.
      * @return The display object, or null if there is no display with the given id.
      */
     public Display getCompatibleDisplay(int displayId, Resources resources) {
         DisplayInfo displayInfo = getDisplayInfo(displayId);
         if (displayInfo == null) {
             return null;
         }
         return new Display(this, displayId, displayInfo, resources);
     }

     /**
      * Gets information about a logical display without applying any compatibility metrics.
      *
      * @param displayId The logical display id.
      * @return The display object, or null if there is no display with the given id.
      */
     @UnsupportedAppUsage
     public Display getRealDisplay(int displayId) {
         return getCompatibleDisplay(displayId, DisplayAdjustments.DEFAULT_DISPLAY_ADJUSTMENTS);
     }

     /**
      * Register a listener for display-related changes.
      *
      * @param listener The listener that will be called when display changes occur.
      * @param handler Handler for the thread that will be receiving the callbacks. May be null.
      * If null, listener will use the handler for the current thread, and if still null,
      * the handler for the main thread.
      * If that is still null, a runtime exception will be thrown.
      */
     public void registerDisplayListener(@NonNull DisplayListener listener,
             @Nullable Handler handler) {
         if (listener == null) {
             throw new IllegalArgumentException("listener must not be null");
         }

         synchronized (mLock) {
             int index = findDisplayListenerLocked(listener);
             if (index < 0) {
                 Looper looper = getLooperForHandler(handler);
                 mDisplayListeners.add(new DisplayListenerDelegate(listener, looper));
                 registerCallbackIfNeededLocked();
             }
         }
     }

     public void unregisterDisplayListener(DisplayListener listener) {
         if (listener == null) {
             throw new IllegalArgumentException("listener must not be null");
         }

         synchronized (mLock) {
             int index = findDisplayListenerLocked(listener);
             if (index >= 0) {
                 DisplayListenerDelegate d = mDisplayListeners.get(index);
                 d.clearEvents();
                 mDisplayListeners.remove(index);
             }
         }
     }

     private static Looper getLooperForHandler(@Nullable Handler handler) {
         Looper looper = handler != null ? handler.getLooper() : Looper.myLooper();
         if (looper == null) {
             looper = Looper.getMainLooper();
         }
         if (looper == null) {
             throw new RuntimeException("Could not get Looper for the UI thread.");
         }
         return looper;
     }

     private int findDisplayListenerLocked(DisplayListener listener) {
         final int numListeners = mDisplayListeners.size();
         for (int i = 0; i < numListeners; i++) {
             if (mDisplayListeners.get(i).mListener == listener) {
                 return i;
             }
         }
         return -1;
     }

     private void registerCallbackIfNeededLocked() {
         if (mCallback == null) {
             mCallback = new DisplayManagerCallback();
             try {
                 mDm.registerCallback(mCallback);
             } catch (RemoteException ex) {
                 throw ex.rethrowFromSystemServer();
             }
         }
     }

     private void handleDisplayEvent(int displayId, int event) {
         synchronized (mLock) {
             if (USE_CACHE) {
                 mDisplayInfoCache.remove(displayId);

                 if (event == EVENT_DISPLAY_ADDED || event == EVENT_DISPLAY_REMOVED) {
                     mDisplayIdCache = null;
                 }
             }

             final int numListeners = mDisplayListeners.size();
             for (int i = 0; i < numListeners; i++) {
                 mDisplayListeners.get(i).sendDisplayEvent(displayId, event);
             }
         }
     }

     public void startWifiDisplayScan() {
         synchronized (mLock) {
             if (mWifiDisplayScanNestCount++ == 0) {
                 registerCallbackIfNeededLocked();
                 try {
                     mDm.startWifiDisplayScan();
                 } catch (RemoteException ex) {
                     throw ex.rethrowFromSystemServer();
                 }
             }
         }
     }

     public void stopWifiDisplayScan() {
         synchronized (mLock) {
             if (--mWifiDisplayScanNestCount == 0) {
                 try {
                     mDm.stopWifiDisplayScan();
                 } catch (RemoteException ex) {
                     throw ex.rethrowFromSystemServer();
                 }
             } else if (mWifiDisplayScanNestCount < 0) {
                 Log.wtf(TAG, "Wifi display scan nest count became negative: "
                         + mWifiDisplayScanNestCount);
                 mWifiDisplayScanNestCount = 0;
             }
         }
     }

     public void connectWifiDisplay(String deviceAddress) {
         if (deviceAddress == null) {
             throw new IllegalArgumentException("deviceAddress must not be null");
         }

         try {
             mDm.connectWifiDisplay(deviceAddress);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     public void pauseWifiDisplay() {
         try {
             mDm.pauseWifiDisplay();
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     public void resumeWifiDisplay() {
         try {
             mDm.resumeWifiDisplay();
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     @UnsupportedAppUsage
     public void disconnectWifiDisplay() {
         try {
             mDm.disconnectWifiDisplay();
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     public void renameWifiDisplay(String deviceAddress, String alias) {
         if (deviceAddress == null) {
             throw new IllegalArgumentException("deviceAddress must not be null");
         }

         try {
             mDm.renameWifiDisplay(deviceAddress, alias);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     public void forgetWifiDisplay(String deviceAddress) {
         if (deviceAddress == null) {
             throw new IllegalArgumentException("deviceAddress must not be null");
         }

         try {
             mDm.forgetWifiDisplay(deviceAddress);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     @UnsupportedAppUsage
     public WifiDisplayStatus getWifiDisplayStatus() {
         try {
             return mDm.getWifiDisplayStatus();
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     public void requestColorMode(int displayId, int colorMode) {
         try {
             mDm.requestColorMode(displayId, colorMode);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     public VirtualDisplay createVirtualDisplay(Context context, MediaProjection projection,
             String name, int width, int height, int densityDpi, Surface surface, int flags,
             VirtualDisplay.Callback callback, Handler handler, String uniqueId) {
         if (TextUtils.isEmpty(name)) {
             throw new IllegalArgumentException("name must be non-null and non-empty");
         }
         if (width <= 0 || height <= 0 || densityDpi <= 0) {
             throw new IllegalArgumentException("width, height, and densityDpi must be "
                     + "greater than 0");
         }

         VirtualDisplayCallback callbackWrapper = new VirtualDisplayCallback(callback, handler);
         IMediaProjection projectionToken = projection != null ? projection.getProjection() : null;
         int displayId;
         try {
             displayId = mDm.createVirtualDisplay(callbackWrapper, projectionToken,
                     context.getPackageName(), name, width, height, densityDpi, surface, flags,
                     uniqueId);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
         if (displayId < 0) {
             Log.e(TAG, "Could not create virtual display: " + name);
             return null;
         }
         Display display = getRealDisplay(displayId);
         if (display == null) {
             Log.wtf(TAG, "Could not obtain display info for newly created "
                     + "virtual display: " + name);
             try {
                 mDm.releaseVirtualDisplay(callbackWrapper);
             } catch (RemoteException ex) {
                 throw ex.rethrowFromSystemServer();
             }
             return null;
         }
         return new VirtualDisplay(this, display, callbackWrapper, surface);
     }

     public void setVirtualDisplaySurface(IVirtualDisplayCallback token, Surface surface) {
         try {
             mDm.setVirtualDisplaySurface(token, surface);
             setVirtualDisplayState(token, surface != null);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     public void resizeVirtualDisplay(IVirtualDisplayCallback token,
             int width, int height, int densityDpi) {
         try {
             mDm.resizeVirtualDisplay(token, width, height, densityDpi);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     public void releaseVirtualDisplay(IVirtualDisplayCallback token) {
         try {
             mDm.releaseVirtualDisplay(token);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     void setVirtualDisplayState(IVirtualDisplayCallback token, boolean isOn) {
         try {
             mDm.setVirtualDisplayState(token, isOn);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Gets the stable device display size, in pixels.
      */
     public Point getStableDisplaySize() {
         try {
             return mDm.getStableDisplaySize();
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Retrieves brightness change events.
      */
     public List<BrightnessChangeEvent> getBrightnessEvents(String callingPackage) {
         try {
             ParceledListSlice<BrightnessChangeEvent> events =
                     mDm.getBrightnessEvents(callingPackage);
             if (events == null) {
                 return Collections.emptyList();
             }
             return events.getList();
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Gets the preferred wide gamut color space for all displays.
      * The wide gamut color space is returned from composition pipeline
      * based on hardware capability.
      *
      * @hide
      */
     public ColorSpace getPreferredWideGamutColorSpace() {
         return mWideColorSpace;
     }

     /**
      * Sets the global brightness configuration for a given user.
      *
      * @hide
      */
     public void setBrightnessConfigurationForUser(BrightnessConfiguration c, int userId,
             String packageName) {
         try {
             mDm.setBrightnessConfigurationForUser(c, userId, packageName);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Gets the global brightness configuration for a given user or null if one hasn't been set.
      *
      * @hide
      */
     public BrightnessConfiguration getBrightnessConfigurationForUser(int userId) {
         try {
             return mDm.getBrightnessConfigurationForUser(userId);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Gets the default brightness configuration or null if one hasn't been configured.
      *
      * @hide
      */
     public BrightnessConfiguration getDefaultBrightnessConfiguration() {
         try {
             return mDm.getDefaultBrightnessConfiguration();
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Temporarily sets the brightness of the display.
      * <p>
      * Requires the {@link android.Manifest.permission#CONTROL_DISPLAY_BRIGHTNESS} permission.
      * </p>
      *
      * @param brightness The brightness value from 0 to 255.
      *
      * @hide Requires signature permission.
      */
     public void setTemporaryBrightness(int brightness) {
         try {
             mDm.setTemporaryBrightness(brightness);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Temporarily sets the auto brightness adjustment factor.
      * <p>
      * Requires the {@link android.Manifest.permission#CONTROL_DISPLAY_BRIGHTNESS} permission.
      * </p>
      *
      * @param adjustment The adjustment factor from -1.0 to 1.0.
      *
      * @hide Requires signature permission.
      */
     public void setTemporaryAutoBrightnessAdjustment(float adjustment) {
         try {
             mDm.setTemporaryAutoBrightnessAdjustment(adjustment);
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Returns the minimum brightness curve, which guarantess that any brightness curve that dips
      * below it is rejected by the system.
      * This prevent auto-brightness from setting the screen so dark as to prevent the user from
      * resetting or disabling it, and maps lux to the absolute minimum nits that are still readable
      * in that ambient brightness.
      *
      * @return The minimum brightness curve (as lux values and their corresponding nits values).
      */
     public Pair<float[], float[]> getMinimumBrightnessCurve() {
         try {
             Curve curve = mDm.getMinimumBrightnessCurve();
             return Pair.create(curve.getX(), curve.getY());
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     /**
      * Retrieves ambient brightness stats.
      */
     public List<AmbientBrightnessDayStats> getAmbientBrightnessStats() {
         try {
             ParceledListSlice<AmbientBrightnessDayStats> stats = mDm.getAmbientBrightnessStats();
             if (stats == null) {
                 return Collections.emptyList();
             }
             return stats.getList();
         } catch (RemoteException ex) {
             throw ex.rethrowFromSystemServer();
         }
     }

     private final class DisplayManagerCallback extends IDisplayManagerCallback.Stub {
         @Override
         public void onDisplayEvent(int displayId, int event) {
             if (DEBUG) {
                 Log.d(TAG, "onDisplayEvent: displayId=" + displayId + ", event=" + event);
             }
             handleDisplayEvent(displayId, event);
         }
     }

     private static final class DisplayListenerDelegate extends Handler {
         public final DisplayListener mListener;

         DisplayListenerDelegate(DisplayListener listener, @NonNull Looper looper) {
             super(looper, null, true /*async*/);
             mListener = listener;
         }

         public void sendDisplayEvent(int displayId, int event) {
             Message msg = obtainMessage(event, displayId, 0);
             sendMessage(msg);
         }

         public void clearEvents() {
             removeCallbacksAndMessages(null);
         }

         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case EVENT_DISPLAY_ADDED:
                     mListener.onDisplayAdded(msg.arg1);
                     break;
                 case EVENT_DISPLAY_CHANGED:
                     mListener.onDisplayChanged(msg.arg1);
                     break;
                 case EVENT_DISPLAY_REMOVED:
                     mListener.onDisplayRemoved(msg.arg1);
                     break;
             }
         }
     }

     private final static class VirtualDisplayCallback extends IVirtualDisplayCallback.Stub {
         private VirtualDisplayCallbackDelegate mDelegate;

         public VirtualDisplayCallback(VirtualDisplay.Callback callback, Handler handler) {
             if (callback != null) {
                 mDelegate = new VirtualDisplayCallbackDelegate(callback, handler);
             }
         }

         @Override // Binder call
         public void onPaused() {
             if (mDelegate != null) {
                 mDelegate.sendEmptyMessage(VirtualDisplayCallbackDelegate.MSG_DISPLAY_PAUSED);
             }
         }

         @Override // Binder call
         public void onResumed() {
             if (mDelegate != null) {
                 mDelegate.sendEmptyMessage(VirtualDisplayCallbackDelegate.MSG_DISPLAY_RESUMED);
             }
         }

         @Override // Binder call
         public void onStopped() {
             if (mDelegate != null) {
                 mDelegate.sendEmptyMessage(VirtualDisplayCallbackDelegate.MSG_DISPLAY_STOPPED);
             }
         }
     }

     private final static class VirtualDisplayCallbackDelegate extends Handler {
         public static final int MSG_DISPLAY_PAUSED = 0;
         public static final int MSG_DISPLAY_RESUMED = 1;
         public static final int MSG_DISPLAY_STOPPED = 2;

         private final VirtualDisplay.Callback mCallback;

         public VirtualDisplayCallbackDelegate(VirtualDisplay.Callback callback,
                 Handler handler) {
             super(handler != null ? handler.getLooper() : Looper.myLooper(), null, true /*async*/);
             mCallback = callback;
         }

         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case MSG_DISPLAY_PAUSED:
                     mCallback.onPaused();
                     break;
                 case MSG_DISPLAY_RESUMED:
                     mCallback.onResumed();
                     break;
                 case MSG_DISPLAY_STOPPED:
                     mCallback.onStopped();
                     break;
             }
         }
     }
 }
	/*
	* Copyright (C) 2012 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.hardware.display;

	import android.annotation.NonNull;
	import android.annotation.Nullable;
	import android.annotation.UnsupportedAppUsage;
	import android.content.Context;
	import android.content.pm.ParceledListSlice;
	import android.content.res.Resources;
	import android.graphics.ColorSpace;
	import android.graphics.Point;
	import android.hardware.display.DisplayManager.DisplayListener;
	import android.media.projection.IMediaProjection;
	import android.media.projection.MediaProjection;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.Looper;
	import android.os.Message;
	import android.os.RemoteException;
	import android.os.ServiceManager;
	import android.text.TextUtils;
	import android.util.Log;
	import android.util.Pair;
	import android.util.SparseArray;
	import android.view.Display;
	import android.view.DisplayAdjustments;
	import android.view.DisplayInfo;
	import android.view.Surface;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;

	/**
	* Manager communication with the display manager service on behalf of
	* an application process. You're probably looking for {@link DisplayManager}.
	*
	* @hide
	*/
	public final class DisplayManagerGlobal {
	private static final String TAG = "DisplayManager";
	private static final boolean DEBUG = false;

	// True if display info and display ids should be cached.
	//
	// FIXME: The cache is currently disabled because it's unclear whether we have the
	// necessary guarantees that the caches will always be flushed before clients
	// attempt to observe their new state. For example, depending on the order
	// in which the binder transactions take place, we might have a problem where
	// an application could start processing a configuration change due to a display
	// orientation change before the display info cache has actually been invalidated.
	private static final boolean USE_CACHE = false;

	public static final int EVENT_DISPLAY_ADDED = 1;
	public static final int EVENT_DISPLAY_CHANGED = 2;
	public static final int EVENT_DISPLAY_REMOVED = 3;

	@UnsupportedAppUsage
	private static DisplayManagerGlobal sInstance;

	private final Object mLock = new Object();

	@UnsupportedAppUsage
	private final IDisplayManager mDm;

	private DisplayManagerCallback mCallback;
	private final ArrayList<DisplayListenerDelegate> mDisplayListeners =
	new ArrayList<DisplayListenerDelegate>();

	private final SparseArray<DisplayInfo> mDisplayInfoCache = new SparseArray<DisplayInfo>();
	private final ColorSpace mWideColorSpace;
	private int[] mDisplayIdCache;

	private int mWifiDisplayScanNestCount;

	private DisplayManagerGlobal(IDisplayManager dm) {
	mDm = dm;
	try {
	mWideColorSpace =
	ColorSpace.get(
	ColorSpace.Named.values()[mDm.getPreferredWideGamutColorSpaceId()]);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Gets an instance of the display manager global singleton.
	*
	* @return The display manager instance, may be null early in system startup
	* before the display manager has been fully initialized.
	*/
	@UnsupportedAppUsage
	public static DisplayManagerGlobal getInstance() {
	synchronized (DisplayManagerGlobal.class) {
	if (sInstance == null) {
	IBinder b = ServiceManager.getService(Context.DISPLAY_SERVICE);
	if (b != null) {
	sInstance = new DisplayManagerGlobal(IDisplayManager.Stub.asInterface(b));
	}
	}
	return sInstance;
	}
	}

	/**
	* Get information about a particular logical display.
	*
	* @param displayId The logical display id.
	* @return Information about the specified display, or null if it does not exist.
	* This object belongs to an internal cache and should be treated as if it were immutable.
	*/
	@UnsupportedAppUsage
	public DisplayInfo getDisplayInfo(int displayId) {
	try {
	synchronized (mLock) {
	DisplayInfo info;
	if (USE_CACHE) {
	info = mDisplayInfoCache.get(displayId);
	if (info != null) {
	return info;
	}
	}

	info = mDm.getDisplayInfo(displayId);
	if (info == null) {
	return null;
	}

	if (USE_CACHE) {
	mDisplayInfoCache.put(displayId, info);
	}
	registerCallbackIfNeededLocked();

	if (DEBUG) {
	Log.d(TAG, "getDisplayInfo: displayId=" + displayId + ", info=" + info);
	}
	return info;
	}
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Gets all currently valid logical display ids.
	*
	* @return An array containing all display ids.
	*/
	@UnsupportedAppUsage
	public int[] getDisplayIds() {
	try {
	synchronized (mLock) {
	if (USE_CACHE) {
	if (mDisplayIdCache != null) {
	return mDisplayIdCache;
	}
	}

	int[] displayIds = mDm.getDisplayIds();
	if (USE_CACHE) {
	mDisplayIdCache = displayIds;
	}
	registerCallbackIfNeededLocked();
	return displayIds;
	}
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Check if specified UID's content is present on display and should be granted access to it.
	*
	* @param uid UID to be checked.
	* @param displayId id of the display where presence of the content is checked.
	* @return {@code true} if UID is present on display, {@code false} otherwise.
	*/
	public boolean isUidPresentOnDisplay(int uid, int displayId) {
	try {
	return mDm.isUidPresentOnDisplay(uid, displayId);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Gets information about a logical display.
	*
	* The display metrics may be adjusted to provide compatibility
	* for legacy applications or limited screen areas.
	*
	* @param displayId The logical display id.
	* @param daj The compatibility info and activityToken.
	* @return The display object, or null if there is no display with the given id.
	*/
	public Display getCompatibleDisplay(int displayId, DisplayAdjustments daj) {
	DisplayInfo displayInfo = getDisplayInfo(displayId);
	if (displayInfo == null) {
	return null;
	}
	return new Display(this, displayId, displayInfo, daj);
	}

	/**
	* Gets information about a logical display.
	*
	* The display metrics may be adjusted to provide compatibility
	* for legacy applications or limited screen areas.
	*
	* @param displayId The logical display id.
	* @param resources Resources providing compatibility info.
	* @return The display object, or null if there is no display with the given id.
	*/
	public Display getCompatibleDisplay(int displayId, Resources resources) {
	DisplayInfo displayInfo = getDisplayInfo(displayId);
	if (displayInfo == null) {
	return null;
	}
	return new Display(this, displayId, displayInfo, resources);
	}

	/**
	* Gets information about a logical display without applying any compatibility metrics.
	*
	* @param displayId The logical display id.
	* @return The display object, or null if there is no display with the given id.
	*/
	@UnsupportedAppUsage
	public Display getRealDisplay(int displayId) {
	return getCompatibleDisplay(displayId, DisplayAdjustments.DEFAULT_DISPLAY_ADJUSTMENTS);
	}

	/**
	* Register a listener for display-related changes.
	*
	* @param listener The listener that will be called when display changes occur.
	* @param handler Handler for the thread that will be receiving the callbacks. May be null.
	* If null, listener will use the handler for the current thread, and if still null,
	* the handler for the main thread.
	* If that is still null, a runtime exception will be thrown.
	*/
	public void registerDisplayListener(@NonNull DisplayListener listener,
	@Nullable Handler handler) {
	if (listener == null) {
	throw new IllegalArgumentException("listener must not be null");
	}

	synchronized (mLock) {
	int index = findDisplayListenerLocked(listener);
	if (index < 0) {
	Looper looper = getLooperForHandler(handler);
	mDisplayListeners.add(new DisplayListenerDelegate(listener, looper));
	registerCallbackIfNeededLocked();
	}
	}
	}

	public void unregisterDisplayListener(DisplayListener listener) {
	if (listener == null) {
	throw new IllegalArgumentException("listener must not be null");
	}

	synchronized (mLock) {
	int index = findDisplayListenerLocked(listener);
	if (index >= 0) {
	DisplayListenerDelegate d = mDisplayListeners.get(index);
	d.clearEvents();
	mDisplayListeners.remove(index);
	}
	}
	}

	private static Looper getLooperForHandler(@Nullable Handler handler) {
	Looper looper = handler != null ? handler.getLooper() : Looper.myLooper();
	if (looper == null) {
	looper = Looper.getMainLooper();
	}
	if (looper == null) {
	throw new RuntimeException("Could not get Looper for the UI thread.");
	}
	return looper;
	}

	private int findDisplayListenerLocked(DisplayListener listener) {
	final int numListeners = mDisplayListeners.size();
	for (int i = 0; i < numListeners; i++) {
	if (mDisplayListeners.get(i).mListener == listener) {
	return i;
	}
	}
	return -1;
	}

	private void registerCallbackIfNeededLocked() {
	if (mCallback == null) {
	mCallback = new DisplayManagerCallback();
	try {
	mDm.registerCallback(mCallback);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}
	}

	private void handleDisplayEvent(int displayId, int event) {
	synchronized (mLock) {
	if (USE_CACHE) {
	mDisplayInfoCache.remove(displayId);

	if (event == EVENT_DISPLAY_ADDED \|\| event == EVENT_DISPLAY_REMOVED) {
	mDisplayIdCache = null;
	}
	}

	final int numListeners = mDisplayListeners.size();
	for (int i = 0; i < numListeners; i++) {
	mDisplayListeners.get(i).sendDisplayEvent(displayId, event);
	}
	}
	}

	public void startWifiDisplayScan() {
	synchronized (mLock) {
	if (mWifiDisplayScanNestCount++ == 0) {
	registerCallbackIfNeededLocked();
	try {
	mDm.startWifiDisplayScan();
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}
	}
	}

	public void stopWifiDisplayScan() {
	synchronized (mLock) {
	if (--mWifiDisplayScanNestCount == 0) {
	try {
	mDm.stopWifiDisplayScan();
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	} else if (mWifiDisplayScanNestCount < 0) {
	Log.wtf(TAG, "Wifi display scan nest count became negative: "
	+ mWifiDisplayScanNestCount);
	mWifiDisplayScanNestCount = 0;
	}
	}
	}

	public void connectWifiDisplay(String deviceAddress) {
	if (deviceAddress == null) {
	throw new IllegalArgumentException("deviceAddress must not be null");
	}

	try {
	mDm.connectWifiDisplay(deviceAddress);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	public void pauseWifiDisplay() {
	try {
	mDm.pauseWifiDisplay();
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	public void resumeWifiDisplay() {
	try {
	mDm.resumeWifiDisplay();
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	@UnsupportedAppUsage
	public void disconnectWifiDisplay() {
	try {
	mDm.disconnectWifiDisplay();
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	public void renameWifiDisplay(String deviceAddress, String alias) {
	if (deviceAddress == null) {
	throw new IllegalArgumentException("deviceAddress must not be null");
	}

	try {
	mDm.renameWifiDisplay(deviceAddress, alias);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	public void forgetWifiDisplay(String deviceAddress) {
	if (deviceAddress == null) {
	throw new IllegalArgumentException("deviceAddress must not be null");
	}

	try {
	mDm.forgetWifiDisplay(deviceAddress);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	@UnsupportedAppUsage
	public WifiDisplayStatus getWifiDisplayStatus() {
	try {
	return mDm.getWifiDisplayStatus();
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	public void requestColorMode(int displayId, int colorMode) {
	try {
	mDm.requestColorMode(displayId, colorMode);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	public VirtualDisplay createVirtualDisplay(Context context, MediaProjection projection,
	String name, int width, int height, int densityDpi, Surface surface, int flags,
	VirtualDisplay.Callback callback, Handler handler, String uniqueId) {
	if (TextUtils.isEmpty(name)) {
	throw new IllegalArgumentException("name must be non-null and non-empty");
	}
	if (width <= 0 \|\| height <= 0 \|\| densityDpi <= 0) {
	throw new IllegalArgumentException("width, height, and densityDpi must be "
	+ "greater than 0");
	}

	VirtualDisplayCallback callbackWrapper = new VirtualDisplayCallback(callback, handler);
	IMediaProjection projectionToken = projection != null ? projection.getProjection() : null;
	int displayId;
	try {
	displayId = mDm.createVirtualDisplay(callbackWrapper, projectionToken,
	context.getPackageName(), name, width, height, densityDpi, surface, flags,
	uniqueId);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	if (displayId < 0) {
	Log.e(TAG, "Could not create virtual display: " + name);
	return null;
	}
	Display display = getRealDisplay(displayId);
	if (display == null) {
	Log.wtf(TAG, "Could not obtain display info for newly created "
	+ "virtual display: " + name);
	try {
	mDm.releaseVirtualDisplay(callbackWrapper);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	return null;
	}
	return new VirtualDisplay(this, display, callbackWrapper, surface);
	}

	public void setVirtualDisplaySurface(IVirtualDisplayCallback token, Surface surface) {
	try {
	mDm.setVirtualDisplaySurface(token, surface);
	setVirtualDisplayState(token, surface != null);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	public void resizeVirtualDisplay(IVirtualDisplayCallback token,
	int width, int height, int densityDpi) {
	try {
	mDm.resizeVirtualDisplay(token, width, height, densityDpi);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	public void releaseVirtualDisplay(IVirtualDisplayCallback token) {
	try {
	mDm.releaseVirtualDisplay(token);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	void setVirtualDisplayState(IVirtualDisplayCallback token, boolean isOn) {
	try {
	mDm.setVirtualDisplayState(token, isOn);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Gets the stable device display size, in pixels.
	*/
	public Point getStableDisplaySize() {
	try {
	return mDm.getStableDisplaySize();
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Retrieves brightness change events.
	*/
	public List<BrightnessChangeEvent> getBrightnessEvents(String callingPackage) {
	try {
	ParceledListSlice<BrightnessChangeEvent> events =
	mDm.getBrightnessEvents(callingPackage);
	if (events == null) {
	return Collections.emptyList();
	}
	return events.getList();
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Gets the preferred wide gamut color space for all displays.
	* The wide gamut color space is returned from composition pipeline
	* based on hardware capability.
	*
	* @hide
	*/
	public ColorSpace getPreferredWideGamutColorSpace() {
	return mWideColorSpace;
	}

	/**
	* Sets the global brightness configuration for a given user.
	*
	* @hide
	*/
	public void setBrightnessConfigurationForUser(BrightnessConfiguration c, int userId,
	String packageName) {
	try {
	mDm.setBrightnessConfigurationForUser(c, userId, packageName);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Gets the global brightness configuration for a given user or null if one hasn't been set.
	*
	* @hide
	*/
	public BrightnessConfiguration getBrightnessConfigurationForUser(int userId) {
	try {
	return mDm.getBrightnessConfigurationForUser(userId);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Gets the default brightness configuration or null if one hasn't been configured.
	*
	* @hide
	*/
	public BrightnessConfiguration getDefaultBrightnessConfiguration() {
	try {
	return mDm.getDefaultBrightnessConfiguration();
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Temporarily sets the brightness of the display.
	* <p>
	* Requires the {@link android.Manifest.permission#CONTROL_DISPLAY_BRIGHTNESS} permission.
	* </p>
	*
	* @param brightness The brightness value from 0 to 255.
	*
	* @hide Requires signature permission.
	*/
	public void setTemporaryBrightness(int brightness) {
	try {
	mDm.setTemporaryBrightness(brightness);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Temporarily sets the auto brightness adjustment factor.
	* <p>
	* Requires the {@link android.Manifest.permission#CONTROL_DISPLAY_BRIGHTNESS} permission.
	* </p>
	*
	* @param adjustment The adjustment factor from -1.0 to 1.0.
	*
	* @hide Requires signature permission.
	*/
	public void setTemporaryAutoBrightnessAdjustment(float adjustment) {
	try {
	mDm.setTemporaryAutoBrightnessAdjustment(adjustment);
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Returns the minimum brightness curve, which guarantess that any brightness curve that dips
	* below it is rejected by the system.
	* This prevent auto-brightness from setting the screen so dark as to prevent the user from
	* resetting or disabling it, and maps lux to the absolute minimum nits that are still readable
	* in that ambient brightness.
	*
	* @return The minimum brightness curve (as lux values and their corresponding nits values).
	*/
	public Pair<float[], float[]> getMinimumBrightnessCurve() {
	try {
	Curve curve = mDm.getMinimumBrightnessCurve();
	return Pair.create(curve.getX(), curve.getY());
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	/**
	* Retrieves ambient brightness stats.
	*/
	public List<AmbientBrightnessDayStats> getAmbientBrightnessStats() {
	try {
	ParceledListSlice<AmbientBrightnessDayStats> stats = mDm.getAmbientBrightnessStats();
	if (stats == null) {
	return Collections.emptyList();
	}
	return stats.getList();
	} catch (RemoteException ex) {
	throw ex.rethrowFromSystemServer();
	}
	}

	private final class DisplayManagerCallback extends IDisplayManagerCallback.Stub {
	@Override
	public void onDisplayEvent(int displayId, int event) {
	if (DEBUG) {
	Log.d(TAG, "onDisplayEvent: displayId=" + displayId + ", event=" + event);
	}
	handleDisplayEvent(displayId, event);
	}
	}

	private static final class DisplayListenerDelegate extends Handler {
	public final DisplayListener mListener;

	DisplayListenerDelegate(DisplayListener listener, @NonNull Looper looper) {
	super(looper, null, true /async/);
	mListener = listener;
	}

	public void sendDisplayEvent(int displayId, int event) {
	Message msg = obtainMessage(event, displayId, 0);
	sendMessage(msg);
	}

	public void clearEvents() {
	removeCallbacksAndMessages(null);
	}

	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case EVENT_DISPLAY_ADDED:
	mListener.onDisplayAdded(msg.arg1);
	break;
	case EVENT_DISPLAY_CHANGED:
	mListener.onDisplayChanged(msg.arg1);
	break;
	case EVENT_DISPLAY_REMOVED:
	mListener.onDisplayRemoved(msg.arg1);
	break;
	}
	}
	}

	private final static class VirtualDisplayCallback extends IVirtualDisplayCallback.Stub {
	private VirtualDisplayCallbackDelegate mDelegate;

	public VirtualDisplayCallback(VirtualDisplay.Callback callback, Handler handler) {
	if (callback != null) {
	mDelegate = new VirtualDisplayCallbackDelegate(callback, handler);
	}
	}

	@Override // Binder call
	public void onPaused() {
	if (mDelegate != null) {
	mDelegate.sendEmptyMessage(VirtualDisplayCallbackDelegate.MSG_DISPLAY_PAUSED);
	}
	}

	@Override // Binder call
	public void onResumed() {
	if (mDelegate != null) {
	mDelegate.sendEmptyMessage(VirtualDisplayCallbackDelegate.MSG_DISPLAY_RESUMED);
	}
	}

	@Override // Binder call
	public void onStopped() {
	if (mDelegate != null) {
	mDelegate.sendEmptyMessage(VirtualDisplayCallbackDelegate.MSG_DISPLAY_STOPPED);
	}
	}
	}

	private final static class VirtualDisplayCallbackDelegate extends Handler {
	public static final int MSG_DISPLAY_PAUSED = 0;
	public static final int MSG_DISPLAY_RESUMED = 1;
	public static final int MSG_DISPLAY_STOPPED = 2;

	private final VirtualDisplay.Callback mCallback;

	public VirtualDisplayCallbackDelegate(VirtualDisplay.Callback callback,
	Handler handler) {
	super(handler != null ? handler.getLooper() : Looper.myLooper(), null, true /async/);
	mCallback = callback;
	}

	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case MSG_DISPLAY_PAUSED:
	mCallback.onPaused();
	break;
	case MSG_DISPLAY_RESUMED:
	mCallback.onResumed();
	break;
	case MSG_DISPLAY_STOPPED:
	mCallback.onStopped();
	break;
	}
	}
	}
	}