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