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