services/core/java/com/android/server/display/DisplayAdapter.java

   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.
  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      */
  73     public final DisplayManagerService.SyncRoot getSyncRoot() {
  74         return mSyncRoot;
  75     }
  76
  77     /**
  78      * Gets the display adapter's context.
  79      */
  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      */
  87     public final Handler getHandler() {
  88         return mHandler;
  89     }
  90
  91     /**
  92      * Gets the display adapter name for debugging purposes.
  93      */
  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      */
 105     public void registerLocked() {
 106     }
 107
 108     /**
 109      * Dumps the local state of the display adapter.
 110      */
 111     public void dumpLocked(PrintWriter pw) {
 112     }
 113
 114     /**
 115      * Sends a display device event to the display adapter listener asynchronously.
 116      */
 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      */
 130     protected final void sendTraversalRequestLocked() {
 131         mHandler.post(new Runnable() {
 132             @Override
 133             public void run() {
 134                 mListener.onTraversalRequested();
 135             }
 136         });
 137     }
 138
 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
 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 {
 150         public void onDisplayDeviceEvent(DisplayDevice device, int event);
 151         public void onTraversalRequested();
 152     }
 153 }