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 
23 import java.io.PrintWriter;
24 import java.util.concurrent.atomic.AtomicInteger;
25 
26 /**
27  * A display adapter makes zero or more display devices available to the system
28  * and provides facilities for discovering when displays are connected or disconnected.
29  * <p>
30  * For now, all display adapters are registered in the system server but
31  * in principle it could be done from other processes.
32  * </p><p>
33  * Display adapters are guarded by the {@link DisplayManagerService.SyncRoot} lock.
34  * </p>
35  */
36 abstract class DisplayAdapter {
37     private final DisplayManagerService.SyncRoot mSyncRoot;
38     private final Context mContext;
39     private final Handler mHandler;
40     private final Listener mListener;
41     private final String mName;
42 
43     public static final int DISPLAY_DEVICE_EVENT_ADDED = 1;
44     public static final int DISPLAY_DEVICE_EVENT_CHANGED = 2;
45     public static final int DISPLAY_DEVICE_EVENT_REMOVED = 3;
46 
47     /**
48      * Used to generate globally unique display mode ids.
49      */
50     private static final AtomicInteger NEXT_DISPLAY_MODE_ID = new AtomicInteger(1);  // 0 = no mode.
51 
52     /**
53      * Used to generate globally unique color transform ids.
54      *
55      * Valid IDs start at 1 with 0 as the sentinel value for the default mode.
56      */
57     private static final AtomicInteger NEXT_COLOR_TRANSFORM_ID = new AtomicInteger(1);
58 
59     // Called with SyncRoot lock held.
DisplayAdapter(DisplayManagerService.SyncRoot syncRoot, Context context, Handler handler, Listener listener, String name)60     public DisplayAdapter(DisplayManagerService.SyncRoot syncRoot,
61             Context context, Handler handler, Listener listener, String name) {
62         mSyncRoot = syncRoot;
63         mContext = context;
64         mHandler = handler;
65         mListener = listener;
66         mName = name;
67     }
68 
69     /**
70      * Gets the object that the display adapter should synchronize on when handling
71      * calls that come in from outside of the display manager service.
72      */
getSyncRoot()73     public final DisplayManagerService.SyncRoot getSyncRoot() {
74         return mSyncRoot;
75     }
76 
77     /**
78      * Gets the display adapter's context.
79      */
getContext()80     public final Context getContext() {
81         return mContext;
82     }
83 
84     /**
85      * Gets a handler that the display adapter may use to post asynchronous messages.
86      */
getHandler()87     public final Handler getHandler() {
88         return mHandler;
89     }
90 
91     /**
92      * Gets the display adapter name for debugging purposes.
93      */
getName()94     public final String getName() {
95         return mName;
96     }
97 
98     /**
99      * Registers the display adapter with the display manager.
100      *
101      * The display adapter should register any built-in display devices as soon as possible.
102      * The boot process will wait for the default display to be registered.
103      * Other display devices can be registered dynamically later.
104      */
registerLocked()105     public void registerLocked() {
106     }
107 
108     /**
109      * Dumps the local state of the display adapter.
110      */
dumpLocked(PrintWriter pw)111     public void dumpLocked(PrintWriter pw) {
112     }
113 
114     /**
115      * Sends a display device event to the display adapter listener asynchronously.
116      */
sendDisplayDeviceEventLocked( final DisplayDevice device, final int event)117     protected final void sendDisplayDeviceEventLocked(
118             final DisplayDevice device, final int event) {
119         mHandler.post(new Runnable() {
120             @Override
121             public void run() {
122                 mListener.onDisplayDeviceEvent(device, event);
123             }
124         });
125     }
126 
127     /**
128      * Sends a request to perform traversals.
129      */
sendTraversalRequestLocked()130     protected final void sendTraversalRequestLocked() {
131         mHandler.post(new Runnable() {
132             @Override
133             public void run() {
134                 mListener.onTraversalRequested();
135             }
136         });
137     }
138 
createMode(int width, int height, float refreshRate)139     public static Display.Mode createMode(int width, int height, float refreshRate) {
140         return new Display.Mode(
141                 NEXT_DISPLAY_MODE_ID.getAndIncrement(), width, height, refreshRate);
142     }
143 
createColorTransform(int colorTransform)144     public static Display.ColorTransform createColorTransform(int colorTransform) {
145         return new Display.ColorTransform(
146                 NEXT_COLOR_TRANSFORM_ID.getAndIncrement(), colorTransform);
147     }
148 
149     public interface Listener {
onDisplayDeviceEvent(DisplayDevice device, int event)150         public void onDisplayDeviceEvent(DisplayDevice device, int event);
onTraversalRequested()151         public void onTraversalRequested();
152     }
153 }
154