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