1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.display; 18 19 import android.content.Context; 20 import android.os.Handler; 21 import android.view.Display; 22 import android.view.SurfaceControl; 23 24 import com.android.server.display.feature.DisplayManagerFlags; 25 26 import java.io.PrintWriter; 27 import java.util.concurrent.atomic.AtomicInteger; 28 29 /** 30 * A display adapter makes zero or more display devices available to the system 31 * and provides facilities for discovering when displays are connected or disconnected. 32 * <p> 33 * For now, all display adapters are registered in the system server but 34 * in principle it could be done from other processes. 35 * </p><p> 36 * Display adapters are guarded by the {@link DisplayManagerService.SyncRoot} lock. 37 * </p> 38 */ 39 abstract class DisplayAdapter { 40 private final DisplayManagerService.SyncRoot mSyncRoot; 41 private final Context mContext; 42 private final Handler mHandler; 43 private final Listener mListener; 44 private final String mName; 45 private final DisplayManagerFlags mFeatureFlags; 46 47 public static final int DISPLAY_DEVICE_EVENT_ADDED = 1; 48 public static final int DISPLAY_DEVICE_EVENT_CHANGED = 2; 49 public static final int DISPLAY_DEVICE_EVENT_REMOVED = 3; 50 51 /** 52 * Used to generate globally unique display mode ids. 53 */ 54 private static final AtomicInteger NEXT_DISPLAY_MODE_ID = new AtomicInteger(1); // 0 = no mode. 55 56 // Called with SyncRoot lock held. DisplayAdapter(DisplayManagerService.SyncRoot syncRoot, Context context, Handler handler, Listener listener, String name, DisplayManagerFlags featureFlags)57 DisplayAdapter(DisplayManagerService.SyncRoot syncRoot, Context context, Handler handler, 58 Listener listener, String name, DisplayManagerFlags featureFlags) { 59 mSyncRoot = syncRoot; 60 mContext = context; 61 mHandler = handler; 62 mListener = listener; 63 mName = name; 64 mFeatureFlags = featureFlags; 65 } 66 67 /** 68 * Gets the object that the display adapter should synchronize on when handling 69 * calls that come in from outside of the display manager service. 70 */ getSyncRoot()71 public final DisplayManagerService.SyncRoot getSyncRoot() { 72 return mSyncRoot; 73 } 74 75 /** 76 * Gets the display adapter's context. 77 */ getContext()78 public final Context getContext() { 79 return mContext; 80 } 81 82 /** 83 * Gets a handler that the display adapter may use to post asynchronous messages. 84 */ getHandler()85 public final Handler getHandler() { 86 return mHandler; 87 } 88 89 /** 90 * Gets the display adapter name for debugging purposes. 91 */ getName()92 public final String getName() { 93 return mName; 94 } 95 getFeatureFlags()96 public final DisplayManagerFlags getFeatureFlags() { 97 return mFeatureFlags; 98 } 99 100 /** 101 * Registers the display adapter with the display manager. 102 * 103 * The display adapter should register any built-in display devices as soon as possible. 104 * The boot process will wait for the default display to be registered. 105 * Other display devices can be registered dynamically later. 106 */ registerLocked()107 public void registerLocked() { 108 } 109 110 /** 111 * Dumps the local state of the display adapter. 112 */ dumpLocked(PrintWriter pw)113 public void dumpLocked(PrintWriter pw) { 114 } 115 116 /** 117 * Sends a display device event to the display adapter listener asynchronously. 118 */ sendDisplayDeviceEventLocked( final DisplayDevice device, final int event)119 protected final void sendDisplayDeviceEventLocked( 120 final DisplayDevice device, final int event) { 121 mHandler.post(() -> mListener.onDisplayDeviceEvent(device, event)); 122 } 123 124 /** 125 * Sends a request to perform traversals. 126 */ sendTraversalRequestLocked()127 protected final void sendTraversalRequestLocked() { 128 mHandler.post(() -> mListener.onTraversalRequested()); 129 } 130 createMode(int width, int height, float refreshRate)131 public static Display.Mode createMode(int width, int height, float refreshRate) { 132 return createMode(width, height, refreshRate, refreshRate, new float[0], new int[0]); 133 } 134 createMode(int width, int height, float refreshRate, float vsyncRate, float[] alternativeRefreshRates, @Display.HdrCapabilities.HdrType int[] supportedHdrTypes)135 public static Display.Mode createMode(int width, int height, float refreshRate, float vsyncRate, 136 float[] alternativeRefreshRates, 137 @Display.HdrCapabilities.HdrType int[] supportedHdrTypes) { 138 return new Display.Mode(NEXT_DISPLAY_MODE_ID.getAndIncrement(), width, height, refreshRate, 139 vsyncRate, /* isSynthetic= */ false, alternativeRefreshRates, supportedHdrTypes); 140 } 141 getPowerModeForState(int state)142 static int getPowerModeForState(int state) { 143 switch (state) { 144 case Display.STATE_OFF: 145 return SurfaceControl.POWER_MODE_OFF; 146 case Display.STATE_DOZE: 147 return SurfaceControl.POWER_MODE_DOZE; 148 case Display.STATE_DOZE_SUSPEND: 149 return SurfaceControl.POWER_MODE_DOZE_SUSPEND; 150 case Display.STATE_ON_SUSPEND: 151 return SurfaceControl.POWER_MODE_ON_SUSPEND; 152 default: 153 return SurfaceControl.POWER_MODE_NORMAL; 154 } 155 } 156 157 public interface Listener { onDisplayDeviceEvent(DisplayDevice device, int event)158 void onDisplayDeviceEvent(DisplayDevice device, int event); onTraversalRequested()159 void onTraversalRequested(); 160 } 161 } 162