ISurfaceComposer.cpp revision d87f162026454f5a3e6437ed0c9ef51651a6b939 
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// tag as surfaceflinger
18#define LOG_TAG "SurfaceFlinger"
19
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <binder/Parcel.h>
24#include <binder/IMemory.h>
25#include <binder/IPCThreadState.h>
26#include <binder/IServiceManager.h>
27
28#include <surfaceflinger/ISurfaceComposer.h>
29
30#include <ui/DisplayInfo.h>
31
32#include <utils/Log.h>
33
34// ---------------------------------------------------------------------------
35
36#define LIKELY( exp )       (__builtin_expect( (exp) != 0, true  ))
37#define UNLIKELY( exp )     (__builtin_expect( (exp) != 0, false ))
38
39// ---------------------------------------------------------------------------
40
41namespace android {
42
43class BpSurfaceComposer : public BpInterface<ISurfaceComposer>
44{
45public:
46    BpSurfaceComposer(const sp<IBinder>& impl)
47        : BpInterface<ISurfaceComposer>(impl)
48    {
49    }
50
51    virtual sp<ISurfaceComposerClient> createConnection()
52    {
53        uint32_t n;
54        Parcel data, reply;
55        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
56        remote()->transact(BnSurfaceComposer::CREATE_CONNECTION, data, &reply);
57        return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
58    }
59
60    virtual sp<ISurfaceComposerClient> createClientConnection()
61    {
62        uint32_t n;
63        Parcel data, reply;
64        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
65        remote()->transact(BnSurfaceComposer::CREATE_CLIENT_CONNECTION, data, &reply);
66        return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
67    }
68
69    virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc()
70    {
71        uint32_t n;
72        Parcel data, reply;
73        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
74        remote()->transact(BnSurfaceComposer::CREATE_GRAPHIC_BUFFER_ALLOC, data, &reply);
75        return interface_cast<IGraphicBufferAlloc>(reply.readStrongBinder());
76    }
77
78    virtual sp<IMemoryHeap> getCblk() const
79    {
80        Parcel data, reply;
81        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
82        remote()->transact(BnSurfaceComposer::GET_CBLK, data, &reply);
83        return interface_cast<IMemoryHeap>(reply.readStrongBinder());
84    }
85
86    virtual void openGlobalTransaction()
87    {
88        Parcel data, reply;
89        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
90        remote()->transact(BnSurfaceComposer::OPEN_GLOBAL_TRANSACTION, data, &reply);
91    }
92
93    virtual void closeGlobalTransaction()
94    {
95        Parcel data, reply;
96        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
97        remote()->transact(BnSurfaceComposer::CLOSE_GLOBAL_TRANSACTION, data, &reply);
98    }
99
100    virtual status_t freezeDisplay(DisplayID dpy, uint32_t flags)
101    {
102        Parcel data, reply;
103        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
104        data.writeInt32(dpy);
105        data.writeInt32(flags);
106        remote()->transact(BnSurfaceComposer::FREEZE_DISPLAY, data, &reply);
107        return reply.readInt32();
108    }
109
110    virtual status_t unfreezeDisplay(DisplayID dpy, uint32_t flags)
111    {
112        Parcel data, reply;
113        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
114        data.writeInt32(dpy);
115        data.writeInt32(flags);
116        remote()->transact(BnSurfaceComposer::UNFREEZE_DISPLAY, data, &reply);
117        return reply.readInt32();
118    }
119
120    virtual int setOrientation(DisplayID dpy, int orientation, uint32_t flags)
121    {
122        Parcel data, reply;
123        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
124        data.writeInt32(dpy);
125        data.writeInt32(orientation);
126        data.writeInt32(flags);
127        remote()->transact(BnSurfaceComposer::SET_ORIENTATION, data, &reply);
128        return reply.readInt32();
129    }
130
131    virtual void bootFinished()
132    {
133        Parcel data, reply;
134        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
135        remote()->transact(BnSurfaceComposer::BOOT_FINISHED, data, &reply);
136    }
137
138    virtual status_t captureScreen(DisplayID dpy,
139            sp<IMemoryHeap>* heap,
140            uint32_t* width, uint32_t* height, PixelFormat* format,
141            uint32_t reqWidth, uint32_t reqHeight,
142            uint32_t minLayerZ, uint32_t maxLayerZ)
143    {
144        Parcel data, reply;
145        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
146        data.writeInt32(dpy);
147        data.writeInt32(reqWidth);
148        data.writeInt32(reqHeight);
149        data.writeInt32(minLayerZ);
150        data.writeInt32(maxLayerZ);
151        remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply);
152        *heap = interface_cast<IMemoryHeap>(reply.readStrongBinder());
153        *width = reply.readInt32();
154        *height = reply.readInt32();
155        *format = reply.readInt32();
156        return reply.readInt32();
157    }
158
159    virtual status_t turnElectronBeamOff(int32_t mode)
160    {
161        Parcel data, reply;
162        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
163        data.writeInt32(mode);
164        remote()->transact(BnSurfaceComposer::TURN_ELECTRON_BEAM_OFF, data, &reply);
165        return reply.readInt32();
166    }
167
168    virtual status_t turnElectronBeamOn(int32_t mode)
169    {
170        Parcel data, reply;
171        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
172        data.writeInt32(mode);
173        remote()->transact(BnSurfaceComposer::TURN_ELECTRON_BEAM_ON, data, &reply);
174        return reply.readInt32();
175    }
176
177    virtual void signal() const
178    {
179        Parcel data, reply;
180        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
181        remote()->transact(BnSurfaceComposer::SIGNAL, data, &reply, IBinder::FLAG_ONEWAY);
182    }
183
184    virtual bool authenticateSurface(const sp<ISurface>& surface) const
185    {
186        Parcel data, reply;
187        int err = NO_ERROR;
188        err = data.writeInterfaceToken(
189                ISurfaceComposer::getInterfaceDescriptor());
190        if (err != NO_ERROR) {
191            LOGE("ISurfaceComposer::authenticateSurface: error writing "
192                    "interface descriptor: %s (%d)", strerror(-err), -err);
193            return false;
194        }
195        err = data.writeStrongBinder(surface->asBinder());
196        if (err != NO_ERROR) {
197            LOGE("ISurfaceComposer::authenticateSurface: error writing strong "
198                    "binder to parcel: %s (%d)", strerror(-err), -err);
199            return false;
200        }
201        err = remote()->transact(BnSurfaceComposer::AUTHENTICATE_SURFACE, data,
202                &reply);
203        if (err != NO_ERROR) {
204            LOGE("ISurfaceComposer::authenticateSurface: error performing "
205                    "transaction: %s (%d)", strerror(-err), -err);
206            return false;
207        }
208        int32_t result = 0;
209        err = reply.readInt32(&result);
210        if (err != NO_ERROR) {
211            LOGE("ISurfaceComposer::authenticateSurface: error retrieving "
212                    "result: %s (%d)", strerror(-err), -err);
213            return false;
214        }
215        return result != 0;
216    }
217};
218
219IMPLEMENT_META_INTERFACE(SurfaceComposer, "android.ui.ISurfaceComposer");
220
221// ----------------------------------------------------------------------
222
223status_t BnSurfaceComposer::onTransact(
224    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
225{
226    switch(code) {
227        case CREATE_CONNECTION: {
228            CHECK_INTERFACE(ISurfaceComposer, data, reply);
229            sp<IBinder> b = createConnection()->asBinder();
230            reply->writeStrongBinder(b);
231        } break;
232        case CREATE_CLIENT_CONNECTION: {
233            CHECK_INTERFACE(ISurfaceComposer, data, reply);
234            sp<IBinder> b = createClientConnection()->asBinder();
235            reply->writeStrongBinder(b);
236        } break;
237        case CREATE_GRAPHIC_BUFFER_ALLOC: {
238            CHECK_INTERFACE(ISurfaceComposer, data, reply);
239            sp<IBinder> b = createGraphicBufferAlloc()->asBinder();
240            reply->writeStrongBinder(b);
241        } break;
242        case OPEN_GLOBAL_TRANSACTION: {
243            CHECK_INTERFACE(ISurfaceComposer, data, reply);
244            openGlobalTransaction();
245        } break;
246        case CLOSE_GLOBAL_TRANSACTION: {
247            CHECK_INTERFACE(ISurfaceComposer, data, reply);
248            closeGlobalTransaction();
249        } break;
250        case SET_ORIENTATION: {
251            CHECK_INTERFACE(ISurfaceComposer, data, reply);
252            DisplayID dpy = data.readInt32();
253            int orientation = data.readInt32();
254            uint32_t flags = data.readInt32();
255            reply->writeInt32( setOrientation(dpy, orientation, flags) );
256        } break;
257        case FREEZE_DISPLAY: {
258            CHECK_INTERFACE(ISurfaceComposer, data, reply);
259            DisplayID dpy = data.readInt32();
260            uint32_t flags = data.readInt32();
261            reply->writeInt32( freezeDisplay(dpy, flags) );
262        } break;
263        case UNFREEZE_DISPLAY: {
264            CHECK_INTERFACE(ISurfaceComposer, data, reply);
265            DisplayID dpy = data.readInt32();
266            uint32_t flags = data.readInt32();
267            reply->writeInt32( unfreezeDisplay(dpy, flags) );
268        } break;
269        case BOOT_FINISHED: {
270            CHECK_INTERFACE(ISurfaceComposer, data, reply);
271            bootFinished();
272        } break;
273        case SIGNAL: {
274            CHECK_INTERFACE(ISurfaceComposer, data, reply);
275            signal();
276        } break;
277        case GET_CBLK: {
278            CHECK_INTERFACE(ISurfaceComposer, data, reply);
279            sp<IBinder> b = getCblk()->asBinder();
280            reply->writeStrongBinder(b);
281        } break;
282        case CAPTURE_SCREEN: {
283            CHECK_INTERFACE(ISurfaceComposer, data, reply);
284            DisplayID dpy = data.readInt32();
285            uint32_t reqWidth = data.readInt32();
286            uint32_t reqHeight = data.readInt32();
287            uint32_t minLayerZ = data.readInt32();
288            uint32_t maxLayerZ = data.readInt32();
289            sp<IMemoryHeap> heap;
290            uint32_t w, h;
291            PixelFormat f;
292            status_t res = captureScreen(dpy, &heap, &w, &h, &f,
293                    reqWidth, reqHeight, minLayerZ, maxLayerZ);
294            reply->writeStrongBinder(heap->asBinder());
295            reply->writeInt32(w);
296            reply->writeInt32(h);
297            reply->writeInt32(f);
298            reply->writeInt32(res);
299        } break;
300        case TURN_ELECTRON_BEAM_OFF: {
301            CHECK_INTERFACE(ISurfaceComposer, data, reply);
302            int32_t mode = data.readInt32();
303            status_t res = turnElectronBeamOff(mode);
304            reply->writeInt32(res);
305        } break;
306        case TURN_ELECTRON_BEAM_ON: {
307            CHECK_INTERFACE(ISurfaceComposer, data, reply);
308            int32_t mode = data.readInt32();
309            status_t res = turnElectronBeamOn(mode);
310            reply->writeInt32(res);
311        } break;
312        case AUTHENTICATE_SURFACE: {
313            CHECK_INTERFACE(ISurfaceComposer, data, reply);
314            sp<ISurface> surface = interface_cast<ISurface>(data.readStrongBinder());
315            int32_t result = authenticateSurface(surface) ? 1 : 0;
316            reply->writeInt32(result);
317        } break;
318        default:
319            return BBinder::onTransact(code, data, reply, flags);
320    }
321    return NO_ERROR;
322}
323
324// ----------------------------------------------------------------------------
325
326};
327