import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
+import java.util.concurrent.CopyOnWriteArrayList;
/**
* Manages attached displays.
new SparseArray<LogicalDisplay>();
private int mNextNonDefaultDisplayId = Display.DEFAULT_DISPLAY + 1;
+ // List of all display transaction listeners.
+ private final CopyOnWriteArrayList<DisplayTransactionListener> mDisplayTransactionListeners =
+ new CopyOnWriteArrayList<DisplayTransactionListener>();
+
// Set to true if all displays have been blanked by the power manager.
private int mAllDisplayBlankStateFromPowerManager;
}
/**
+ * Registers a display transaction listener to provide the client a chance to
+ * update its surfaces within the same transaction as any display layout updates.
+ *
+ * @param listener The listener to register.
+ */
+ public void registerDisplayTransactionListener(DisplayTransactionListener listener) {
+ if (listener == null) {
+ throw new IllegalArgumentException("listener must not be null");
+ }
+
+ // List is self-synchronized copy-on-write.
+ mDisplayTransactionListeners.add(listener);
+ }
+
+ /**
+ * Unregisters a display transaction listener to provide the client a chance to
+ * update its surfaces within the same transaction as any display layout updates.
+ *
+ * @param listener The listener to unregister.
+ */
+ public void unregisterDisplayTransactionListener(DisplayTransactionListener listener) {
+ if (listener == null) {
+ throw new IllegalArgumentException("listener must not be null");
+ }
+
+ // List is self-synchronized copy-on-write.
+ mDisplayTransactionListeners.remove(listener);
+ }
+
+ /**
* Overrides the display information of a particular logical display.
* This is used by the window manager to control the size and characteristics
* of the default display. It is expected to apply the requested change
performTraversalInTransactionLocked();
}
+
+ // List is self-synchronized copy-on-write.
+ for (DisplayTransactionListener listener : mDisplayTransactionListeners) {
+ listener.onDisplayTransaction();
+ }
}
/**
import com.android.server.LightsService;
import com.android.server.TwilightService;
import com.android.server.TwilightService.TwilightState;
+import com.android.server.display.DisplayManagerService;
import android.animation.Animator;
import android.animation.ObjectAnimator;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.hardware.SystemSensorManager;
-import android.hardware.display.DisplayManager;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Slog;
import android.util.Spline;
import android.util.TimeUtils;
-import android.view.Display;
import java.io.PrintWriter;
private final TwilightService mTwilight;
// The display manager.
- private final DisplayManager mDisplayManager;
+ private final DisplayManagerService mDisplayManager;
// The sensor manager.
private final SensorManager mSensorManager;
*/
public DisplayPowerController(Looper looper, Context context, Notifier notifier,
LightsService lights, TwilightService twilight,
+ DisplayManagerService displayManager,
DisplayBlanker displayBlanker,
Callbacks callbacks, Handler callbackHandler) {
mHandler = new DisplayControllerHandler(looper);
mLights = lights;
mTwilight = twilight;
mSensorManager = new SystemSensorManager(mHandler.getLooper());
- mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE);
+ mDisplayManager = displayManager;
final Resources resources = context.getResources();
}
private void initialize() {
- Display display = mDisplayManager.getDisplay(Display.DEFAULT_DISPLAY);
mPowerState = new DisplayPowerState(
- new ElectronBeam(display), mDisplayBlanker,
+ new ElectronBeam(mDisplayManager), mDisplayBlanker,
mLights.getLight(LightsService.LIGHT_ID_BACKLIGHT));
mElectronBeamOnAnimator = ObjectAnimator.ofFloat(
package com.android.server.power;
+import com.android.server.display.DisplayManagerService;
+import com.android.server.display.DisplayTransactionListener;
+
import android.graphics.Bitmap;
import android.graphics.PixelFormat;
import android.opengl.EGL14;
private boolean mPrepared;
private int mMode;
- private final Display mDisplay;
- private final DisplayInfo mDisplayInfo = new DisplayInfo();
+ private final DisplayManagerService mDisplayManager;
private int mDisplayLayerStack; // layer stack associated with primary display
- private int mDisplayRotation;
private int mDisplayWidth; // real width, not rotated
private int mDisplayHeight; // real height, not rotated
private SurfaceSession mSurfaceSession;
private Surface mSurface;
+ private NaturalSurfaceLayout mSurfaceLayout;
private EGLDisplay mEglDisplay;
private EGLConfig mEglConfig;
private EGLContext mEglContext;
*/
public static final int MODE_FADE = 2;
- public ElectronBeam(Display display) {
- mDisplay = display;
+ public ElectronBeam(DisplayManagerService displayManager) {
+ mDisplayManager = displayManager;
}
/**
mMode = mode;
- // Get the display size and adjust it for rotation.
- mDisplay.getDisplayInfo(mDisplayInfo);
- mDisplayLayerStack = mDisplay.getLayerStack();
- mDisplayRotation = mDisplayInfo.rotation;
- if (mDisplayRotation == Surface.ROTATION_90
- || mDisplayRotation == Surface.ROTATION_270) {
- mDisplayWidth = mDisplayInfo.logicalHeight;
- mDisplayHeight = mDisplayInfo.logicalWidth;
- } else {
- mDisplayWidth = mDisplayInfo.logicalWidth;
- mDisplayHeight = mDisplayInfo.logicalHeight;
- }
+ // Get the display size and layer stack.
+ // This is not expected to change while the electron beam surface is showing.
+ DisplayInfo displayInfo = mDisplayManager.getDisplayInfo(Display.DEFAULT_DISPLAY);
+ mDisplayLayerStack = displayInfo.layerStack;
+ mDisplayWidth = displayInfo.getNaturalWidth();
+ mDisplayHeight = displayInfo.getNaturalHeight();
// Prepare the surface for drawing.
if (!tryPrepare()) {
mSurface.setLayerStack(mDisplayLayerStack);
mSurface.setSize(mDisplayWidth, mDisplayHeight);
- switch (mDisplayRotation) {
- case Surface.ROTATION_0:
- mSurface.setPosition(0, 0);
- mSurface.setMatrix(1, 0, 0, 1);
- break;
- case Surface.ROTATION_90:
- mSurface.setPosition(0, mDisplayWidth);
- mSurface.setMatrix(0, -1, 1, 0);
- break;
- case Surface.ROTATION_180:
- mSurface.setPosition(mDisplayWidth, mDisplayHeight);
- mSurface.setMatrix(-1, 0, 0, -1);
- break;
- case Surface.ROTATION_270:
- mSurface.setPosition(mDisplayHeight, 0);
- mSurface.setMatrix(0, 1, -1, 0);
- break;
- }
+ mSurfaceLayout = new NaturalSurfaceLayout(mDisplayManager, mSurface);
+ mSurfaceLayout.onDisplayTransaction();
} finally {
Surface.closeTransaction();
}
private void destroySurface() {
if (mSurface != null) {
+ mSurfaceLayout.dispose();
+ mSurfaceLayout = null;
Surface.openTransaction();
try {
mSurface.destroy();
pw.println(" mPrepared=" + mPrepared);
pw.println(" mMode=" + mMode);
pw.println(" mDisplayLayerStack=" + mDisplayLayerStack);
- pw.println(" mDisplayRotation=" + mDisplayRotation);
pw.println(" mDisplayWidth=" + mDisplayWidth);
pw.println(" mDisplayHeight=" + mDisplayHeight);
pw.println(" mSurfaceVisible=" + mSurfaceVisible);
pw.println(" mSurfaceAlpha=" + mSurfaceAlpha);
}
+
+ /**
+ * Keeps a surface aligned with the natural orientation of the device.
+ * Updates the position and transformation of the matrix whenever the display
+ * is rotated. This is a little tricky because the display transaction
+ * callback can be invoked on any thread, not necessarily the thread that
+ * owns the electron beam.
+ */
+ private static final class NaturalSurfaceLayout implements DisplayTransactionListener {
+ private final DisplayManagerService mDisplayManager;
+ private Surface mSurface;
+
+ public NaturalSurfaceLayout(DisplayManagerService displayManager, Surface surface) {
+ mDisplayManager = displayManager;
+ mSurface = surface;
+ mDisplayManager.registerDisplayTransactionListener(this);
+ }
+
+ public void dispose() {
+ synchronized (this) {
+ mSurface = null;
+ }
+ mDisplayManager.unregisterDisplayTransactionListener(this);
+ }
+
+ @Override
+ public void onDisplayTransaction() {
+ synchronized (this) {
+ if (mSurface == null) {
+ return;
+ }
+
+ DisplayInfo displayInfo = mDisplayManager.getDisplayInfo(Display.DEFAULT_DISPLAY);
+ switch (displayInfo.rotation) {
+ case Surface.ROTATION_0:
+ mSurface.setPosition(0, 0);
+ mSurface.setMatrix(1, 0, 0, 1);
+ break;
+ case Surface.ROTATION_90:
+ mSurface.setPosition(0, displayInfo.logicalHeight);
+ mSurface.setMatrix(0, -1, 1, 0);
+ break;
+ case Surface.ROTATION_180:
+ mSurface.setPosition(displayInfo.logicalWidth, displayInfo.logicalHeight);
+ mSurface.setMatrix(-1, 0, 0, -1);
+ break;
+ case Surface.ROTATION_270:
+ mSurface.setPosition(displayInfo.logicalWidth, 0);
+ mSurface.setMatrix(0, 1, -1, 0);
+ break;
+ }
+ }
+ }
+ }
}