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