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