1 /* 2 * Copyright (C) 2007 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 #ifndef ANDROID_GUI_SURFACE_COMPOSER_CLIENT_H 18 #define ANDROID_GUI_SURFACE_COMPOSER_CLIENT_H 19 20 #include <stdint.h> 21 #include <sys/types.h> 22 23 #include <binder/IBinder.h> 24 25 #include <utils/RefBase.h> 26 #include <utils/Singleton.h> 27 #include <utils/SortedVector.h> 28 #include <utils/threads.h> 29 30 #include <ui/FrameStats.h> 31 #include <ui/PixelFormat.h> 32 33 #include <gui/CpuConsumer.h> 34 #include <gui/SurfaceControl.h> 35 36 namespace android { 37 38 // --------------------------------------------------------------------------- 39 40 struct DisplayInfo; 41 class Composer; 42 class HdrCapabilities; 43 class ISurfaceComposerClient; 44 class IGraphicBufferProducer; 45 class Region; 46 47 // --------------------------------------------------------------------------- 48 49 class SurfaceComposerClient : public RefBase 50 { 51 friend class Composer; 52 public: 53 SurfaceComposerClient(); 54 SurfaceComposerClient(const sp<IGraphicBufferProducer>& parent); 55 virtual ~SurfaceComposerClient(); 56 57 // Always make sure we could initialize 58 status_t initCheck() const; 59 60 // Return the connection of this client 61 sp<IBinder> connection() const; 62 63 // Forcibly remove connection before all references have gone away. 64 void dispose(); 65 66 // callback when the composer is dies 67 status_t linkToComposerDeath(const sp<IBinder::DeathRecipient>& recipient, 68 void* cookie = NULL, uint32_t flags = 0); 69 70 // Get a list of supported configurations for a given display 71 static status_t getDisplayConfigs(const sp<IBinder>& display, 72 Vector<DisplayInfo>* configs); 73 74 // Get the DisplayInfo for the currently-active configuration 75 static status_t getDisplayInfo(const sp<IBinder>& display, 76 DisplayInfo* info); 77 78 // Get the index of the current active configuration (relative to the list 79 // returned by getDisplayInfo) 80 static int getActiveConfig(const sp<IBinder>& display); 81 82 // Set a new active configuration using an index relative to the list 83 // returned by getDisplayInfo 84 static status_t setActiveConfig(const sp<IBinder>& display, int id); 85 86 // Gets the list of supported color modes for the given display 87 static status_t getDisplayColorModes(const sp<IBinder>& display, 88 Vector<android_color_mode_t>* outColorModes); 89 90 // Gets the active color mode for the given display 91 static android_color_mode_t getActiveColorMode(const sp<IBinder>& display); 92 93 // Sets the active color mode for the given display 94 static status_t setActiveColorMode(const sp<IBinder>& display, android_color_mode_t colorMode); 95 96 /* Triggers screen on/off or low power mode and waits for it to complete */ 97 static void setDisplayPowerMode(const sp<IBinder>& display, int mode); 98 99 // ------------------------------------------------------------------------ 100 // surface creation / destruction 101 102 //! Create a surface 103 sp<SurfaceControl> createSurface( 104 const String8& name,// name of the surface 105 uint32_t w, // width in pixel 106 uint32_t h, // height in pixel 107 PixelFormat format, // pixel-format desired 108 uint32_t flags = 0, // usage flags 109 SurfaceControl* parent = nullptr, // parent 110 uint32_t windowType = 0, // from WindowManager.java (STATUS_BAR, INPUT_METHOD, etc.) 111 uint32_t ownerUid = 0 // UID of the task 112 ); 113 114 //! Create a virtual display 115 static sp<IBinder> createDisplay(const String8& displayName, bool secure); 116 117 //! Destroy a virtual display 118 static void destroyDisplay(const sp<IBinder>& display); 119 120 //! Get the token for the existing default displays. 121 //! Possible values for id are eDisplayIdMain and eDisplayIdHdmi. 122 static sp<IBinder> getBuiltInDisplay(int32_t id); 123 124 // ------------------------------------------------------------------------ 125 // Composer parameters 126 // All composer parameters must be changed within a transaction 127 // several surfaces can be updated in one transaction, all changes are 128 // committed at once when the transaction is closed. 129 // closeGlobalTransaction() requires an IPC with the server. 130 131 //! Open a composer transaction on all active SurfaceComposerClients. 132 static void openGlobalTransaction(); 133 134 //! Close a composer transaction on all active SurfaceComposerClients. 135 static void closeGlobalTransaction(bool synchronous = false); 136 137 static status_t enableVSyncInjections(bool enable); 138 139 static status_t injectVSync(nsecs_t when); 140 141 //! Flag the currently open transaction as an animation transaction. 142 static void setAnimationTransaction(); 143 144 status_t hide(const sp<IBinder>& id); 145 status_t show(const sp<IBinder>& id); 146 status_t setFlags(const sp<IBinder>& id, uint32_t flags, uint32_t mask); 147 status_t setTransparentRegionHint(const sp<IBinder>& id, const Region& transparent); 148 status_t setLayer(const sp<IBinder>& id, int32_t layer); 149 status_t setRelativeLayer(const sp<IBinder>& id, 150 const sp<IBinder>& relativeTo, int32_t layer); 151 status_t setAlpha(const sp<IBinder>& id, float alpha=1.0f); 152 status_t setMatrix(const sp<IBinder>& id, float dsdx, float dtdx, float dtdy, float dsdy); 153 status_t setPosition(const sp<IBinder>& id, float x, float y); 154 status_t setSize(const sp<IBinder>& id, uint32_t w, uint32_t h); 155 status_t setCrop(const sp<IBinder>& id, const Rect& crop); 156 status_t setFinalCrop(const sp<IBinder>& id, const Rect& crop); 157 status_t setLayerStack(const sp<IBinder>& id, uint32_t layerStack); 158 status_t deferTransactionUntil(const sp<IBinder>& id, 159 const sp<IBinder>& handle, uint64_t frameNumber); 160 status_t deferTransactionUntil(const sp<IBinder>& id, 161 const sp<Surface>& handle, uint64_t frameNumber); 162 status_t reparentChildren(const sp<IBinder>& id, 163 const sp<IBinder>& newParentHandle); 164 status_t detachChildren(const sp<IBinder>& id); 165 status_t setOverrideScalingMode(const sp<IBinder>& id, 166 int32_t overrideScalingMode); 167 status_t setGeometryAppliesWithResize(const sp<IBinder>& id); 168 169 status_t destroySurface(const sp<IBinder>& id); 170 171 status_t clearLayerFrameStats(const sp<IBinder>& token) const; 172 status_t getLayerFrameStats(const sp<IBinder>& token, FrameStats* outStats) const; 173 174 static status_t clearAnimationFrameStats(); 175 static status_t getAnimationFrameStats(FrameStats* outStats); 176 177 static status_t getHdrCapabilities(const sp<IBinder>& display, 178 HdrCapabilities* outCapabilities); 179 180 static status_t setDisplaySurface(const sp<IBinder>& token, 181 sp<IGraphicBufferProducer> bufferProducer); 182 static void setDisplayLayerStack(const sp<IBinder>& token, 183 uint32_t layerStack); 184 static void setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t height); 185 186 /* setDisplayProjection() defines the projection of layer stacks 187 * to a given display. 188 * 189 * - orientation defines the display's orientation. 190 * - layerStackRect defines which area of the window manager coordinate 191 * space will be used. 192 * - displayRect defines where on the display will layerStackRect be 193 * mapped to. displayRect is specified post-orientation, that is 194 * it uses the orientation seen by the end-user. 195 */ 196 static void setDisplayProjection(const sp<IBinder>& token, 197 uint32_t orientation, 198 const Rect& layerStackRect, 199 const Rect& displayRect); 200 201 private: 202 virtual void onFirstRef(); 203 Composer& getComposer(); 204 205 mutable Mutex mLock; 206 status_t mStatus; 207 sp<ISurfaceComposerClient> mClient; 208 Composer& mComposer; 209 wp<IGraphicBufferProducer> mParent; 210 }; 211 212 // --------------------------------------------------------------------------- 213 214 class ScreenshotClient 215 { 216 public: 217 // if cropping isn't required, callers may pass in a default Rect, e.g.: 218 // capture(display, producer, Rect(), reqWidth, ...); 219 static status_t capture( 220 const sp<IBinder>& display, 221 const sp<IGraphicBufferProducer>& producer, 222 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 223 int32_t minLayerZ, int32_t maxLayerZ, 224 bool useIdentityTransform); 225 static status_t captureToBuffer( 226 const sp<IBinder>& display, 227 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 228 int32_t minLayerZ, int32_t maxLayerZ, 229 bool useIdentityTransform, 230 uint32_t rotation, 231 sp<GraphicBuffer>* outbuffer); 232 private: 233 mutable sp<CpuConsumer> mCpuConsumer; 234 mutable sp<IGraphicBufferProducer> mProducer; 235 CpuConsumer::LockedBuffer mBuffer; 236 bool mHaveBuffer; 237 238 public: 239 ScreenshotClient(); 240 ~ScreenshotClient(); 241 242 // frees the previous screenshot and captures a new one 243 // if cropping isn't required, callers may pass in a default Rect, e.g.: 244 // update(display, Rect(), useIdentityTransform); 245 status_t update(const sp<IBinder>& display, 246 Rect sourceCrop, bool useIdentityTransform); 247 status_t update(const sp<IBinder>& display, 248 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 249 bool useIdentityTransform); 250 status_t update(const sp<IBinder>& display, 251 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 252 int32_t minLayerZ, int32_t maxLayerZ, 253 bool useIdentityTransform); 254 status_t update(const sp<IBinder>& display, 255 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 256 int32_t minLayerZ, int32_t maxLayerZ, 257 bool useIdentityTransform, uint32_t rotation); 258 259 sp<CpuConsumer> getCpuConsumer() const; 260 261 // release memory occupied by the screenshot 262 void release(); 263 264 // pixels are valid until this object is freed or 265 // release() or update() is called 266 void const* getPixels() const; 267 268 uint32_t getWidth() const; 269 uint32_t getHeight() const; 270 PixelFormat getFormat() const; 271 uint32_t getStride() const; 272 // size of allocated memory in bytes 273 size_t getSize() const; 274 android_dataspace getDataSpace() const; 275 }; 276 277 // --------------------------------------------------------------------------- 278 }; // namespace android 279 280 #endif // ANDROID_GUI_SURFACE_COMPOSER_CLIENT_H 281