ISurfaceComposer.cpp revision c18790018be5d7ea7061ccbc81f3044e74adc823
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/IGraphicBufferProducer.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 void setTransactionState( 72 const Vector<ComposerState>& state, 73 const Vector<DisplayState>& displays, 74 uint32_t flags) 75 { 76 Parcel data, reply; 77 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 78 { 79 Vector<ComposerState>::const_iterator b(state.begin()); 80 Vector<ComposerState>::const_iterator e(state.end()); 81 data.writeInt32(state.size()); 82 for ( ; b != e ; ++b ) { 83 b->write(data); 84 } 85 } 86 { 87 Vector<DisplayState>::const_iterator b(displays.begin()); 88 Vector<DisplayState>::const_iterator e(displays.end()); 89 data.writeInt32(displays.size()); 90 for ( ; b != e ; ++b ) { 91 b->write(data); 92 } 93 } 94 data.writeInt32(flags); 95 remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply); 96 } 97 98 virtual void bootFinished() 99 { 100 Parcel data, reply; 101 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 102 remote()->transact(BnSurfaceComposer::BOOT_FINISHED, data, &reply); 103 } 104 105 virtual status_t captureScreen(const sp<IBinder>& display, 106 const sp<IGraphicBufferProducer>& producer, 107 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 108 uint32_t minLayerZ, uint32_t maxLayerZ, 109 bool useIdentityTransform) 110 { 111 Parcel data, reply; 112 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 113 data.writeStrongBinder(display); 114 data.writeStrongBinder(producer->asBinder()); 115 data.write(sourceCrop); 116 data.writeInt32(reqWidth); 117 data.writeInt32(reqHeight); 118 data.writeInt32(minLayerZ); 119 data.writeInt32(maxLayerZ); 120 data.writeInt32(static_cast<int32_t>(useIdentityTransform)); 121 remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply); 122 return reply.readInt32(); 123 } 124 125 virtual bool authenticateSurfaceTexture( 126 const sp<IGraphicBufferProducer>& bufferProducer) const 127 { 128 Parcel data, reply; 129 int err = NO_ERROR; 130 err = data.writeInterfaceToken( 131 ISurfaceComposer::getInterfaceDescriptor()); 132 if (err != NO_ERROR) { 133 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing " 134 "interface descriptor: %s (%d)", strerror(-err), -err); 135 return false; 136 } 137 err = data.writeStrongBinder(bufferProducer->asBinder()); 138 if (err != NO_ERROR) { 139 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing " 140 "strong binder to parcel: %s (%d)", strerror(-err), -err); 141 return false; 142 } 143 err = remote()->transact(BnSurfaceComposer::AUTHENTICATE_SURFACE, data, 144 &reply); 145 if (err != NO_ERROR) { 146 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error " 147 "performing transaction: %s (%d)", strerror(-err), -err); 148 return false; 149 } 150 int32_t result = 0; 151 err = reply.readInt32(&result); 152 if (err != NO_ERROR) { 153 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error " 154 "retrieving result: %s (%d)", strerror(-err), -err); 155 return false; 156 } 157 return result != 0; 158 } 159 160 virtual sp<IDisplayEventConnection> createDisplayEventConnection() 161 { 162 Parcel data, reply; 163 sp<IDisplayEventConnection> result; 164 int err = data.writeInterfaceToken( 165 ISurfaceComposer::getInterfaceDescriptor()); 166 if (err != NO_ERROR) { 167 return result; 168 } 169 err = remote()->transact( 170 BnSurfaceComposer::CREATE_DISPLAY_EVENT_CONNECTION, 171 data, &reply); 172 if (err != NO_ERROR) { 173 ALOGE("ISurfaceComposer::createDisplayEventConnection: error performing " 174 "transaction: %s (%d)", strerror(-err), -err); 175 return result; 176 } 177 result = interface_cast<IDisplayEventConnection>(reply.readStrongBinder()); 178 return result; 179 } 180 181 virtual sp<IBinder> createDisplay(const String8& displayName, bool secure) 182 { 183 Parcel data, reply; 184 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 185 data.writeString8(displayName); 186 data.writeInt32(secure ? 1 : 0); 187 remote()->transact(BnSurfaceComposer::CREATE_DISPLAY, data, &reply); 188 return reply.readStrongBinder(); 189 } 190 191 virtual void destroyDisplay(const sp<IBinder>& display) 192 { 193 Parcel data, reply; 194 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 195 data.writeStrongBinder(display); 196 remote()->transact(BnSurfaceComposer::DESTROY_DISPLAY, data, &reply); 197 } 198 199 virtual sp<IBinder> getBuiltInDisplay(int32_t id) 200 { 201 Parcel data, reply; 202 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 203 data.writeInt32(id); 204 remote()->transact(BnSurfaceComposer::GET_BUILT_IN_DISPLAY, data, &reply); 205 return reply.readStrongBinder(); 206 } 207 208 virtual void blank(const sp<IBinder>& display) 209 { 210 Parcel data, reply; 211 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 212 data.writeStrongBinder(display); 213 remote()->transact(BnSurfaceComposer::BLANK, data, &reply); 214 } 215 216 virtual void unblank(const sp<IBinder>& display) 217 { 218 Parcel data, reply; 219 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 220 data.writeStrongBinder(display); 221 remote()->transact(BnSurfaceComposer::UNBLANK, data, &reply); 222 } 223 224 virtual status_t getDisplayConfigs(const sp<IBinder>& display, 225 Vector<DisplayInfo>* configs) 226 { 227 Parcel data, reply; 228 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 229 data.writeStrongBinder(display); 230 remote()->transact(BnSurfaceComposer::GET_DISPLAY_CONFIGS, data, &reply); 231 status_t result = reply.readInt32(); 232 if (result == NO_ERROR) { 233 size_t numConfigs = static_cast<size_t>(reply.readInt32()); 234 configs->clear(); 235 configs->resize(numConfigs); 236 for (size_t c = 0; c < numConfigs; ++c) { 237 memcpy(&(configs->editItemAt(c)), 238 reply.readInplace(sizeof(DisplayInfo)), 239 sizeof(DisplayInfo)); 240 } 241 } 242 return result; 243 } 244 245 virtual int getActiveConfig(const sp<IBinder>& display) 246 { 247 Parcel data, reply; 248 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 249 data.writeStrongBinder(display); 250 remote()->transact(BnSurfaceComposer::GET_ACTIVE_CONFIG, data, &reply); 251 return reply.readInt32(); 252 } 253 254 virtual status_t setActiveConfig(const sp<IBinder>& display, int id) 255 { 256 Parcel data, reply; 257 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 258 data.writeStrongBinder(display); 259 data.writeInt32(id); 260 remote()->transact(BnSurfaceComposer::SET_ACTIVE_CONFIG, data, &reply); 261 return reply.readInt32(); 262 } 263 264 virtual status_t clearAnimationFrameStats() { 265 Parcel data, reply; 266 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 267 remote()->transact(BnSurfaceComposer::CLEAR_ANIMATION_FRAME_STATS, data, &reply); 268 return reply.readInt32(); 269 } 270 271 virtual status_t getAnimationFrameStats(FrameStats* outStats) const { 272 Parcel data, reply; 273 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 274 remote()->transact(BnSurfaceComposer::GET_ANIMATION_FRAME_STATS, data, &reply); 275 reply.read(*outStats); 276 return reply.readInt32(); 277 } 278}; 279 280IMPLEMENT_META_INTERFACE(SurfaceComposer, "android.ui.ISurfaceComposer"); 281 282// ---------------------------------------------------------------------- 283 284status_t BnSurfaceComposer::onTransact( 285 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 286{ 287 switch(code) { 288 case CREATE_CONNECTION: { 289 CHECK_INTERFACE(ISurfaceComposer, data, reply); 290 sp<IBinder> b = createConnection()->asBinder(); 291 reply->writeStrongBinder(b); 292 return NO_ERROR; 293 } 294 case CREATE_GRAPHIC_BUFFER_ALLOC: { 295 CHECK_INTERFACE(ISurfaceComposer, data, reply); 296 sp<IBinder> b = createGraphicBufferAlloc()->asBinder(); 297 reply->writeStrongBinder(b); 298 return NO_ERROR; 299 } 300 case SET_TRANSACTION_STATE: { 301 CHECK_INTERFACE(ISurfaceComposer, data, reply); 302 size_t count = data.readInt32(); 303 ComposerState s; 304 Vector<ComposerState> state; 305 state.setCapacity(count); 306 for (size_t i=0 ; i<count ; i++) { 307 s.read(data); 308 state.add(s); 309 } 310 count = data.readInt32(); 311 DisplayState d; 312 Vector<DisplayState> displays; 313 displays.setCapacity(count); 314 for (size_t i=0 ; i<count ; i++) { 315 d.read(data); 316 displays.add(d); 317 } 318 uint32_t flags = data.readInt32(); 319 setTransactionState(state, displays, flags); 320 return NO_ERROR; 321 } 322 case BOOT_FINISHED: { 323 CHECK_INTERFACE(ISurfaceComposer, data, reply); 324 bootFinished(); 325 return NO_ERROR; 326 } 327 case CAPTURE_SCREEN: { 328 CHECK_INTERFACE(ISurfaceComposer, data, reply); 329 sp<IBinder> display = data.readStrongBinder(); 330 sp<IGraphicBufferProducer> producer = 331 interface_cast<IGraphicBufferProducer>(data.readStrongBinder()); 332 Rect sourceCrop; 333 data.read(sourceCrop); 334 uint32_t reqWidth = data.readInt32(); 335 uint32_t reqHeight = data.readInt32(); 336 uint32_t minLayerZ = data.readInt32(); 337 uint32_t maxLayerZ = data.readInt32(); 338 bool useIdentityTransform = static_cast<bool>(data.readInt32()); 339 340 status_t res = captureScreen(display, producer, 341 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, 342 useIdentityTransform); 343 reply->writeInt32(res); 344 return NO_ERROR; 345 } 346 case AUTHENTICATE_SURFACE: { 347 CHECK_INTERFACE(ISurfaceComposer, data, reply); 348 sp<IGraphicBufferProducer> bufferProducer = 349 interface_cast<IGraphicBufferProducer>(data.readStrongBinder()); 350 int32_t result = authenticateSurfaceTexture(bufferProducer) ? 1 : 0; 351 reply->writeInt32(result); 352 return NO_ERROR; 353 } 354 case CREATE_DISPLAY_EVENT_CONNECTION: { 355 CHECK_INTERFACE(ISurfaceComposer, data, reply); 356 sp<IDisplayEventConnection> connection(createDisplayEventConnection()); 357 reply->writeStrongBinder(connection->asBinder()); 358 return NO_ERROR; 359 } 360 case CREATE_DISPLAY: { 361 CHECK_INTERFACE(ISurfaceComposer, data, reply); 362 String8 displayName = data.readString8(); 363 bool secure = bool(data.readInt32()); 364 sp<IBinder> display(createDisplay(displayName, secure)); 365 reply->writeStrongBinder(display); 366 return NO_ERROR; 367 } 368 case DESTROY_DISPLAY: { 369 CHECK_INTERFACE(ISurfaceComposer, data, reply); 370 sp<IBinder> display = data.readStrongBinder(); 371 destroyDisplay(display); 372 return NO_ERROR; 373 } 374 case GET_BUILT_IN_DISPLAY: { 375 CHECK_INTERFACE(ISurfaceComposer, data, reply); 376 int32_t id = data.readInt32(); 377 sp<IBinder> display(getBuiltInDisplay(id)); 378 reply->writeStrongBinder(display); 379 return NO_ERROR; 380 } 381 case BLANK: { 382 CHECK_INTERFACE(ISurfaceComposer, data, reply); 383 sp<IBinder> display = data.readStrongBinder(); 384 blank(display); 385 return NO_ERROR; 386 } 387 case UNBLANK: { 388 CHECK_INTERFACE(ISurfaceComposer, data, reply); 389 sp<IBinder> display = data.readStrongBinder(); 390 unblank(display); 391 return NO_ERROR; 392 } 393 case GET_DISPLAY_CONFIGS: { 394 CHECK_INTERFACE(ISurfaceComposer, data, reply); 395 Vector<DisplayInfo> configs; 396 sp<IBinder> display = data.readStrongBinder(); 397 status_t result = getDisplayConfigs(display, &configs); 398 reply->writeInt32(result); 399 if (result == NO_ERROR) { 400 reply->writeInt32(static_cast<int32_t>(configs.size())); 401 for (size_t c = 0; c < configs.size(); ++c) { 402 memcpy(reply->writeInplace(sizeof(DisplayInfo)), 403 &configs[c], sizeof(DisplayInfo)); 404 } 405 } 406 return NO_ERROR; 407 } 408 case GET_ACTIVE_CONFIG: { 409 CHECK_INTERFACE(ISurfaceComposer, data, reply); 410 sp<IBinder> display = data.readStrongBinder(); 411 int id = getActiveConfig(display); 412 reply->writeInt32(id); 413 return NO_ERROR; 414 } 415 case SET_ACTIVE_CONFIG: { 416 CHECK_INTERFACE(ISurfaceComposer, data, reply); 417 sp<IBinder> display = data.readStrongBinder(); 418 int id = data.readInt32(); 419 status_t result = setActiveConfig(display, id); 420 reply->writeInt32(result); 421 return NO_ERROR; 422 } 423 case CLEAR_ANIMATION_FRAME_STATS: { 424 CHECK_INTERFACE(ISurfaceComposer, data, reply); 425 status_t result = clearAnimationFrameStats(); 426 reply->writeInt32(result); 427 return NO_ERROR; 428 } 429 case GET_ANIMATION_FRAME_STATS: { 430 CHECK_INTERFACE(ISurfaceComposer, data, reply); 431 FrameStats stats; 432 status_t result = getAnimationFrameStats(&stats); 433 reply->write(stats); 434 reply->writeInt32(result); 435 return NO_ERROR; 436 } 437 default: { 438 return BBinder::onTransact(code, data, reply, flags); 439 } 440 } 441 // should be unreachable 442 return NO_ERROR; 443} 444 445// ---------------------------------------------------------------------------- 446 447}; 448