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 #define LOG_TAG "SurfaceComposerClient" 18 19 #include <stdint.h> 20 #include <sys/types.h> 21 22 #include <utils/Errors.h> 23 #include <utils/Log.h> 24 #include <utils/Singleton.h> 25 #include <utils/SortedVector.h> 26 #include <utils/String8.h> 27 #include <utils/threads.h> 28 29 #include <binder/IServiceManager.h> 30 31 #include <system/graphics.h> 32 33 #include <ui/DisplayInfo.h> 34 35 #include <gui/BufferItemConsumer.h> 36 #include <gui/CpuConsumer.h> 37 #include <gui/IGraphicBufferProducer.h> 38 #include <gui/ISurfaceComposer.h> 39 #include <gui/ISurfaceComposerClient.h> 40 #include <gui/Surface.h> 41 #include <gui/SurfaceComposerClient.h> 42 43 #include <private/gui/ComposerService.h> 44 #include <private/gui/LayerState.h> 45 46 namespace android { 47 // --------------------------------------------------------------------------- 48 49 ANDROID_SINGLETON_STATIC_INSTANCE(ComposerService); 50 51 ComposerService::ComposerService() 52 : Singleton<ComposerService>() { 53 Mutex::Autolock _l(mLock); 54 connectLocked(); 55 } 56 57 void ComposerService::connectLocked() { 58 const String16 name("SurfaceFlinger"); 59 while (getService(name, &mComposerService) != NO_ERROR) { 60 usleep(250000); 61 } 62 assert(mComposerService != NULL); 63 64 // Create the death listener. 65 class DeathObserver : public IBinder::DeathRecipient { 66 ComposerService& mComposerService; 67 virtual void binderDied(const wp<IBinder>& who) { 68 ALOGW("ComposerService remote (surfaceflinger) died [%p]", 69 who.unsafe_get()); 70 mComposerService.composerServiceDied(); 71 } 72 public: 73 explicit DeathObserver(ComposerService& mgr) : mComposerService(mgr) { } 74 }; 75 76 mDeathObserver = new DeathObserver(*const_cast<ComposerService*>(this)); 77 IInterface::asBinder(mComposerService)->linkToDeath(mDeathObserver); 78 } 79 80 /*static*/ sp<ISurfaceComposer> ComposerService::getComposerService() { 81 ComposerService& instance = ComposerService::getInstance(); 82 Mutex::Autolock _l(instance.mLock); 83 if (instance.mComposerService == NULL) { 84 ComposerService::getInstance().connectLocked(); 85 assert(instance.mComposerService != NULL); 86 ALOGD("ComposerService reconnected"); 87 } 88 return instance.mComposerService; 89 } 90 91 void ComposerService::composerServiceDied() 92 { 93 Mutex::Autolock _l(mLock); 94 mComposerService = NULL; 95 mDeathObserver = NULL; 96 } 97 98 // --------------------------------------------------------------------------- 99 100 static inline 101 int compare_type(const ComposerState& lhs, const ComposerState& rhs) { 102 if (lhs.client < rhs.client) return -1; 103 if (lhs.client > rhs.client) return 1; 104 if (lhs.state.surface < rhs.state.surface) return -1; 105 if (lhs.state.surface > rhs.state.surface) return 1; 106 return 0; 107 } 108 109 static inline 110 int compare_type(const DisplayState& lhs, const DisplayState& rhs) { 111 return compare_type(lhs.token, rhs.token); 112 } 113 114 class Composer : public Singleton<Composer> 115 { 116 friend class Singleton<Composer>; 117 118 mutable Mutex mLock; 119 SortedVector<ComposerState> mComposerStates; 120 SortedVector<DisplayState > mDisplayStates; 121 uint32_t mForceSynchronous; 122 uint32_t mTransactionNestCount; 123 bool mAnimation; 124 125 Composer() : Singleton<Composer>(), 126 mForceSynchronous(0), mTransactionNestCount(0), 127 mAnimation(false) 128 { } 129 130 void openGlobalTransactionImpl(); 131 void closeGlobalTransactionImpl(bool synchronous); 132 void setAnimationTransactionImpl(); 133 status_t enableVSyncInjectionsImpl(bool enable); 134 status_t injectVSyncImpl(nsecs_t when); 135 136 layer_state_t* getLayerStateLocked( 137 const sp<SurfaceComposerClient>& client, const sp<IBinder>& id); 138 139 DisplayState& getDisplayStateLocked(const sp<IBinder>& token); 140 141 public: 142 sp<IBinder> createDisplay(const String8& displayName, bool secure); 143 void destroyDisplay(const sp<IBinder>& display); 144 sp<IBinder> getBuiltInDisplay(int32_t id); 145 146 status_t setPosition(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 147 float x, float y); 148 status_t setSize(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 149 uint32_t w, uint32_t h); 150 status_t setLayer(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 151 int32_t z); 152 status_t setRelativeLayer(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 153 const sp<IBinder>& relativeTo, int32_t z); 154 status_t setFlags(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 155 uint32_t flags, uint32_t mask); 156 status_t setTransparentRegionHint( 157 const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 158 const Region& transparentRegion); 159 status_t setAlpha(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 160 float alpha); 161 status_t setMatrix(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 162 float dsdx, float dtdx, float dtdy, float dsdy); 163 status_t setOrientation(int orientation); 164 status_t setCrop(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 165 const Rect& crop); 166 status_t setFinalCrop(const sp<SurfaceComposerClient>& client, 167 const sp<IBinder>& id, const Rect& crop); 168 status_t setLayerStack(const sp<SurfaceComposerClient>& client, 169 const sp<IBinder>& id, uint32_t layerStack); 170 status_t deferTransactionUntil(const sp<SurfaceComposerClient>& client, 171 const sp<IBinder>& id, const sp<IBinder>& handle, 172 uint64_t frameNumber); 173 status_t deferTransactionUntil(const sp<SurfaceComposerClient>& client, 174 const sp<IBinder>& id, const sp<Surface>& barrierSurface, 175 uint64_t frameNumber); 176 status_t reparentChildren(const sp<SurfaceComposerClient>& client, 177 const sp<IBinder>& id, 178 const sp<IBinder>& newParentHandle); 179 status_t detachChildren(const sp<SurfaceComposerClient>& client, 180 const sp<IBinder>& id); 181 status_t setOverrideScalingMode(const sp<SurfaceComposerClient>& client, 182 const sp<IBinder>& id, int32_t overrideScalingMode); 183 status_t setGeometryAppliesWithResize(const sp<SurfaceComposerClient>& client, 184 const sp<IBinder>& id); 185 186 status_t setDisplaySurface(const sp<IBinder>& token, 187 sp<IGraphicBufferProducer> bufferProducer); 188 void setDisplayLayerStack(const sp<IBinder>& token, uint32_t layerStack); 189 void setDisplayProjection(const sp<IBinder>& token, 190 uint32_t orientation, 191 const Rect& layerStackRect, 192 const Rect& displayRect); 193 void setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t height); 194 195 static void setAnimationTransaction() { 196 Composer::getInstance().setAnimationTransactionImpl(); 197 } 198 199 static void openGlobalTransaction() { 200 Composer::getInstance().openGlobalTransactionImpl(); 201 } 202 203 static void closeGlobalTransaction(bool synchronous) { 204 Composer::getInstance().closeGlobalTransactionImpl(synchronous); 205 } 206 207 static status_t enableVSyncInjections(bool enable) { 208 return Composer::getInstance().enableVSyncInjectionsImpl(enable); 209 } 210 211 static status_t injectVSync(nsecs_t when) { 212 return Composer::getInstance().injectVSyncImpl(when); 213 } 214 }; 215 216 ANDROID_SINGLETON_STATIC_INSTANCE(Composer); 217 218 // --------------------------------------------------------------------------- 219 220 sp<IBinder> Composer::createDisplay(const String8& displayName, bool secure) { 221 return ComposerService::getComposerService()->createDisplay(displayName, 222 secure); 223 } 224 225 void Composer::destroyDisplay(const sp<IBinder>& display) { 226 return ComposerService::getComposerService()->destroyDisplay(display); 227 } 228 229 sp<IBinder> Composer::getBuiltInDisplay(int32_t id) { 230 return ComposerService::getComposerService()->getBuiltInDisplay(id); 231 } 232 233 void Composer::openGlobalTransactionImpl() { 234 { // scope for the lock 235 Mutex::Autolock _l(mLock); 236 mTransactionNestCount += 1; 237 } 238 } 239 240 void Composer::closeGlobalTransactionImpl(bool synchronous) { 241 sp<ISurfaceComposer> sm(ComposerService::getComposerService()); 242 243 Vector<ComposerState> transaction; 244 Vector<DisplayState> displayTransaction; 245 uint32_t flags = 0; 246 247 { // scope for the lock 248 Mutex::Autolock _l(mLock); 249 mForceSynchronous |= synchronous; 250 if (!mTransactionNestCount) { 251 ALOGW("At least one call to closeGlobalTransaction() was not matched by a prior " 252 "call to openGlobalTransaction()."); 253 } else if (--mTransactionNestCount) { 254 return; 255 } 256 257 transaction = mComposerStates; 258 mComposerStates.clear(); 259 260 displayTransaction = mDisplayStates; 261 mDisplayStates.clear(); 262 263 if (mForceSynchronous) { 264 flags |= ISurfaceComposer::eSynchronous; 265 } 266 if (mAnimation) { 267 flags |= ISurfaceComposer::eAnimation; 268 } 269 270 mForceSynchronous = false; 271 mAnimation = false; 272 } 273 274 sm->setTransactionState(transaction, displayTransaction, flags); 275 } 276 277 status_t Composer::enableVSyncInjectionsImpl(bool enable) { 278 sp<ISurfaceComposer> sm(ComposerService::getComposerService()); 279 return sm->enableVSyncInjections(enable); 280 } 281 282 status_t Composer::injectVSyncImpl(nsecs_t when) { 283 sp<ISurfaceComposer> sm(ComposerService::getComposerService()); 284 return sm->injectVSync(when); 285 } 286 287 void Composer::setAnimationTransactionImpl() { 288 Mutex::Autolock _l(mLock); 289 mAnimation = true; 290 } 291 292 layer_state_t* Composer::getLayerStateLocked( 293 const sp<SurfaceComposerClient>& client, const sp<IBinder>& id) { 294 295 ComposerState s; 296 s.client = client->mClient; 297 s.state.surface = id; 298 299 ssize_t index = mComposerStates.indexOf(s); 300 if (index < 0) { 301 // we don't have it, add an initialized layer_state to our list 302 index = mComposerStates.add(s); 303 } 304 305 ComposerState* const out = mComposerStates.editArray(); 306 return &(out[index].state); 307 } 308 309 status_t Composer::setPosition(const sp<SurfaceComposerClient>& client, 310 const sp<IBinder>& id, float x, float y) { 311 Mutex::Autolock _l(mLock); 312 layer_state_t* s = getLayerStateLocked(client, id); 313 if (!s) 314 return BAD_INDEX; 315 s->what |= layer_state_t::ePositionChanged; 316 s->x = x; 317 s->y = y; 318 return NO_ERROR; 319 } 320 321 status_t Composer::setSize(const sp<SurfaceComposerClient>& client, 322 const sp<IBinder>& id, uint32_t w, uint32_t h) { 323 Mutex::Autolock _l(mLock); 324 layer_state_t* s = getLayerStateLocked(client, id); 325 if (!s) 326 return BAD_INDEX; 327 s->what |= layer_state_t::eSizeChanged; 328 s->w = w; 329 s->h = h; 330 331 // Resizing a surface makes the transaction synchronous. 332 mForceSynchronous = true; 333 334 return NO_ERROR; 335 } 336 337 status_t Composer::setLayer(const sp<SurfaceComposerClient>& client, 338 const sp<IBinder>& id, int32_t z) { 339 Mutex::Autolock _l(mLock); 340 layer_state_t* s = getLayerStateLocked(client, id); 341 if (!s) 342 return BAD_INDEX; 343 s->what |= layer_state_t::eLayerChanged; 344 s->z = z; 345 return NO_ERROR; 346 } 347 348 status_t Composer::setRelativeLayer(const sp<SurfaceComposerClient>& client, 349 const sp<IBinder>& id, const sp<IBinder>& relativeTo, 350 int32_t z) { 351 Mutex::Autolock _l(mLock); 352 layer_state_t* s = getLayerStateLocked(client, id); 353 if (!s) { 354 return BAD_INDEX; 355 } 356 s->what |= layer_state_t::eRelativeLayerChanged; 357 s->relativeLayerHandle = relativeTo; 358 s->z = z; 359 return NO_ERROR; 360 } 361 362 status_t Composer::setFlags(const sp<SurfaceComposerClient>& client, 363 const sp<IBinder>& id, uint32_t flags, 364 uint32_t mask) { 365 Mutex::Autolock _l(mLock); 366 layer_state_t* s = getLayerStateLocked(client, id); 367 if (!s) 368 return BAD_INDEX; 369 if ((mask & layer_state_t::eLayerOpaque) || 370 (mask & layer_state_t::eLayerHidden) || 371 (mask & layer_state_t::eLayerSecure)) { 372 s->what |= layer_state_t::eFlagsChanged; 373 } 374 s->flags &= ~mask; 375 s->flags |= (flags & mask); 376 s->mask |= mask; 377 return NO_ERROR; 378 } 379 380 status_t Composer::setTransparentRegionHint( 381 const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 382 const Region& transparentRegion) { 383 Mutex::Autolock _l(mLock); 384 layer_state_t* s = getLayerStateLocked(client, id); 385 if (!s) 386 return BAD_INDEX; 387 s->what |= layer_state_t::eTransparentRegionChanged; 388 s->transparentRegion = transparentRegion; 389 return NO_ERROR; 390 } 391 392 status_t Composer::setAlpha(const sp<SurfaceComposerClient>& client, 393 const sp<IBinder>& id, float alpha) { 394 Mutex::Autolock _l(mLock); 395 layer_state_t* s = getLayerStateLocked(client, id); 396 if (!s) 397 return BAD_INDEX; 398 s->what |= layer_state_t::eAlphaChanged; 399 s->alpha = alpha; 400 return NO_ERROR; 401 } 402 403 status_t Composer::setLayerStack(const sp<SurfaceComposerClient>& client, 404 const sp<IBinder>& id, uint32_t layerStack) { 405 Mutex::Autolock _l(mLock); 406 layer_state_t* s = getLayerStateLocked(client, id); 407 if (!s) 408 return BAD_INDEX; 409 s->what |= layer_state_t::eLayerStackChanged; 410 s->layerStack = layerStack; 411 return NO_ERROR; 412 } 413 414 status_t Composer::setMatrix(const sp<SurfaceComposerClient>& client, 415 const sp<IBinder>& id, float dsdx, float dtdx, 416 float dtdy, float dsdy) { 417 Mutex::Autolock _l(mLock); 418 layer_state_t* s = getLayerStateLocked(client, id); 419 if (!s) 420 return BAD_INDEX; 421 s->what |= layer_state_t::eMatrixChanged; 422 layer_state_t::matrix22_t matrix; 423 matrix.dsdx = dsdx; 424 matrix.dtdx = dtdx; 425 matrix.dsdy = dsdy; 426 matrix.dtdy = dtdy; 427 s->matrix = matrix; 428 return NO_ERROR; 429 } 430 431 status_t Composer::setCrop(const sp<SurfaceComposerClient>& client, 432 const sp<IBinder>& id, const Rect& crop) { 433 Mutex::Autolock _l(mLock); 434 layer_state_t* s = getLayerStateLocked(client, id); 435 if (!s) 436 return BAD_INDEX; 437 s->what |= layer_state_t::eCropChanged; 438 s->crop = crop; 439 return NO_ERROR; 440 } 441 442 status_t Composer::setFinalCrop(const sp<SurfaceComposerClient>& client, 443 const sp<IBinder>& id, const Rect& crop) { 444 Mutex::Autolock _l(mLock); 445 layer_state_t* s = getLayerStateLocked(client, id); 446 if (!s) { 447 return BAD_INDEX; 448 } 449 s->what |= layer_state_t::eFinalCropChanged; 450 s->finalCrop = crop; 451 return NO_ERROR; 452 } 453 454 status_t Composer::deferTransactionUntil( 455 const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 456 const sp<IBinder>& handle, uint64_t frameNumber) { 457 Mutex::Autolock lock(mLock); 458 layer_state_t* s = getLayerStateLocked(client, id); 459 if (!s) { 460 return BAD_INDEX; 461 } 462 s->what |= layer_state_t::eDeferTransaction; 463 s->barrierHandle = handle; 464 s->frameNumber = frameNumber; 465 return NO_ERROR; 466 } 467 468 status_t Composer::deferTransactionUntil( 469 const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, 470 const sp<Surface>& barrierSurface, uint64_t frameNumber) { 471 Mutex::Autolock lock(mLock); 472 layer_state_t* s = getLayerStateLocked(client, id); 473 if (!s) { 474 return BAD_INDEX; 475 } 476 s->what |= layer_state_t::eDeferTransaction; 477 s->barrierGbp = barrierSurface->getIGraphicBufferProducer(); 478 s->frameNumber = frameNumber; 479 return NO_ERROR; 480 } 481 482 status_t Composer::reparentChildren( 483 const sp<SurfaceComposerClient>& client, 484 const sp<IBinder>& id, 485 const sp<IBinder>& newParentHandle) { 486 Mutex::Autolock lock(mLock); 487 layer_state_t* s = getLayerStateLocked(client, id); 488 if (!s) { 489 return BAD_INDEX; 490 } 491 s->what |= layer_state_t::eReparentChildren; 492 s->reparentHandle = newParentHandle; 493 return NO_ERROR; 494 } 495 496 status_t Composer::detachChildren( 497 const sp<SurfaceComposerClient>& client, 498 const sp<IBinder>& id) { 499 Mutex::Autolock lock(mLock); 500 layer_state_t* s = getLayerStateLocked(client, id); 501 if (!s) { 502 return BAD_INDEX; 503 } 504 s->what |= layer_state_t::eDetachChildren; 505 return NO_ERROR; 506 } 507 508 status_t Composer::setOverrideScalingMode( 509 const sp<SurfaceComposerClient>& client, 510 const sp<IBinder>& id, int32_t overrideScalingMode) { 511 Mutex::Autolock lock(mLock); 512 layer_state_t* s = getLayerStateLocked(client, id); 513 if (!s) { 514 return BAD_INDEX; 515 } 516 517 switch (overrideScalingMode) { 518 case NATIVE_WINDOW_SCALING_MODE_FREEZE: 519 case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW: 520 case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP: 521 case NATIVE_WINDOW_SCALING_MODE_NO_SCALE_CROP: 522 case -1: 523 break; 524 default: 525 ALOGE("unknown scaling mode: %d", 526 overrideScalingMode); 527 return BAD_VALUE; 528 } 529 530 s->what |= layer_state_t::eOverrideScalingModeChanged; 531 s->overrideScalingMode = overrideScalingMode; 532 return NO_ERROR; 533 } 534 535 status_t Composer::setGeometryAppliesWithResize( 536 const sp<SurfaceComposerClient>& client, 537 const sp<IBinder>& id) { 538 Mutex::Autolock lock(mLock); 539 layer_state_t* s = getLayerStateLocked(client, id); 540 if (!s) { 541 return BAD_INDEX; 542 } 543 s->what |= layer_state_t::eGeometryAppliesWithResize; 544 return NO_ERROR; 545 } 546 547 // --------------------------------------------------------------------------- 548 549 DisplayState& Composer::getDisplayStateLocked(const sp<IBinder>& token) { 550 DisplayState s; 551 s.token = token; 552 ssize_t index = mDisplayStates.indexOf(s); 553 if (index < 0) { 554 // we don't have it, add an initialized layer_state to our list 555 s.what = 0; 556 index = mDisplayStates.add(s); 557 } 558 return mDisplayStates.editItemAt(static_cast<size_t>(index)); 559 } 560 561 status_t Composer::setDisplaySurface(const sp<IBinder>& token, 562 sp<IGraphicBufferProducer> bufferProducer) { 563 if (bufferProducer.get() != nullptr) { 564 // Make sure that composition can never be stalled by a virtual display 565 // consumer that isn't processing buffers fast enough. 566 status_t err = bufferProducer->setAsyncMode(true); 567 if (err != NO_ERROR) { 568 ALOGE("Composer::setDisplaySurface Failed to enable async mode on the " 569 "BufferQueue. This BufferQueue cannot be used for virtual " 570 "display. (%d)", err); 571 return err; 572 } 573 } 574 Mutex::Autolock _l(mLock); 575 DisplayState& s(getDisplayStateLocked(token)); 576 s.surface = bufferProducer; 577 s.what |= DisplayState::eSurfaceChanged; 578 return NO_ERROR; 579 } 580 581 void Composer::setDisplayLayerStack(const sp<IBinder>& token, 582 uint32_t layerStack) { 583 Mutex::Autolock _l(mLock); 584 DisplayState& s(getDisplayStateLocked(token)); 585 s.layerStack = layerStack; 586 s.what |= DisplayState::eLayerStackChanged; 587 } 588 589 void Composer::setDisplayProjection(const sp<IBinder>& token, 590 uint32_t orientation, 591 const Rect& layerStackRect, 592 const Rect& displayRect) { 593 Mutex::Autolock _l(mLock); 594 DisplayState& s(getDisplayStateLocked(token)); 595 s.orientation = orientation; 596 s.viewport = layerStackRect; 597 s.frame = displayRect; 598 s.what |= DisplayState::eDisplayProjectionChanged; 599 mForceSynchronous = true; // TODO: do we actually still need this? 600 } 601 602 void Composer::setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t height) { 603 Mutex::Autolock _l(mLock); 604 DisplayState& s(getDisplayStateLocked(token)); 605 s.width = width; 606 s.height = height; 607 s.what |= DisplayState::eDisplaySizeChanged; 608 } 609 610 // --------------------------------------------------------------------------- 611 612 SurfaceComposerClient::SurfaceComposerClient() 613 : mStatus(NO_INIT), mComposer(Composer::getInstance()) 614 { 615 } 616 617 SurfaceComposerClient::SurfaceComposerClient(const sp<IGraphicBufferProducer>& root) 618 : mStatus(NO_INIT), mComposer(Composer::getInstance()), mParent(root) 619 { 620 } 621 622 void SurfaceComposerClient::onFirstRef() { 623 sp<ISurfaceComposer> sm(ComposerService::getComposerService()); 624 if (sm != 0) { 625 auto rootProducer = mParent.promote(); 626 sp<ISurfaceComposerClient> conn; 627 conn = (rootProducer != nullptr) ? sm->createScopedConnection(rootProducer) : 628 sm->createConnection(); 629 if (conn != 0) { 630 mClient = conn; 631 mStatus = NO_ERROR; 632 } 633 } 634 } 635 636 SurfaceComposerClient::~SurfaceComposerClient() { 637 dispose(); 638 } 639 640 status_t SurfaceComposerClient::initCheck() const { 641 return mStatus; 642 } 643 644 sp<IBinder> SurfaceComposerClient::connection() const { 645 return IInterface::asBinder(mClient); 646 } 647 648 status_t SurfaceComposerClient::linkToComposerDeath( 649 const sp<IBinder::DeathRecipient>& recipient, 650 void* cookie, uint32_t flags) { 651 sp<ISurfaceComposer> sm(ComposerService::getComposerService()); 652 return IInterface::asBinder(sm)->linkToDeath(recipient, cookie, flags); 653 } 654 655 void SurfaceComposerClient::dispose() { 656 // this can be called more than once. 657 sp<ISurfaceComposerClient> client; 658 Mutex::Autolock _lm(mLock); 659 if (mClient != 0) { 660 client = mClient; // hold ref while lock is held 661 mClient.clear(); 662 } 663 mStatus = NO_INIT; 664 } 665 666 sp<SurfaceControl> SurfaceComposerClient::createSurface( 667 const String8& name, 668 uint32_t w, 669 uint32_t h, 670 PixelFormat format, 671 uint32_t flags, 672 SurfaceControl* parent, 673 uint32_t windowType, 674 uint32_t ownerUid) 675 { 676 sp<SurfaceControl> sur; 677 if (mStatus == NO_ERROR) { 678 sp<IBinder> handle; 679 sp<IBinder> parentHandle; 680 sp<IGraphicBufferProducer> gbp; 681 682 if (parent != nullptr) { 683 parentHandle = parent->getHandle(); 684 } 685 status_t err = mClient->createSurface(name, w, h, format, flags, parentHandle, 686 windowType, ownerUid, &handle, &gbp); 687 ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err)); 688 if (err == NO_ERROR) { 689 sur = new SurfaceControl(this, handle, gbp); 690 } 691 } 692 return sur; 693 } 694 695 sp<IBinder> SurfaceComposerClient::createDisplay(const String8& displayName, 696 bool secure) { 697 return Composer::getInstance().createDisplay(displayName, secure); 698 } 699 700 void SurfaceComposerClient::destroyDisplay(const sp<IBinder>& display) { 701 Composer::getInstance().destroyDisplay(display); 702 } 703 704 sp<IBinder> SurfaceComposerClient::getBuiltInDisplay(int32_t id) { 705 return Composer::getInstance().getBuiltInDisplay(id); 706 } 707 708 status_t SurfaceComposerClient::destroySurface(const sp<IBinder>& sid) { 709 if (mStatus != NO_ERROR) 710 return mStatus; 711 status_t err = mClient->destroySurface(sid); 712 return err; 713 } 714 715 status_t SurfaceComposerClient::clearLayerFrameStats(const sp<IBinder>& token) const { 716 if (mStatus != NO_ERROR) { 717 return mStatus; 718 } 719 return mClient->clearLayerFrameStats(token); 720 } 721 722 status_t SurfaceComposerClient::getLayerFrameStats(const sp<IBinder>& token, 723 FrameStats* outStats) const { 724 if (mStatus != NO_ERROR) { 725 return mStatus; 726 } 727 return mClient->getLayerFrameStats(token, outStats); 728 } 729 730 inline Composer& SurfaceComposerClient::getComposer() { 731 return mComposer; 732 } 733 734 // ---------------------------------------------------------------------------- 735 736 void SurfaceComposerClient::openGlobalTransaction() { 737 Composer::openGlobalTransaction(); 738 } 739 740 void SurfaceComposerClient::closeGlobalTransaction(bool synchronous) { 741 Composer::closeGlobalTransaction(synchronous); 742 } 743 744 void SurfaceComposerClient::setAnimationTransaction() { 745 Composer::setAnimationTransaction(); 746 } 747 748 status_t SurfaceComposerClient::enableVSyncInjections(bool enable) { 749 return Composer::enableVSyncInjections(enable); 750 } 751 752 status_t SurfaceComposerClient::injectVSync(nsecs_t when) { 753 return Composer::injectVSync(when); 754 } 755 756 // ---------------------------------------------------------------------------- 757 758 status_t SurfaceComposerClient::setCrop(const sp<IBinder>& id, const Rect& crop) { 759 return getComposer().setCrop(this, id, crop); 760 } 761 762 status_t SurfaceComposerClient::setFinalCrop(const sp<IBinder>& id, 763 const Rect& crop) { 764 return getComposer().setFinalCrop(this, id, crop); 765 } 766 767 status_t SurfaceComposerClient::setPosition(const sp<IBinder>& id, float x, float y) { 768 return getComposer().setPosition(this, id, x, y); 769 } 770 771 status_t SurfaceComposerClient::setSize(const sp<IBinder>& id, uint32_t w, uint32_t h) { 772 return getComposer().setSize(this, id, w, h); 773 } 774 775 status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, int32_t z) { 776 return getComposer().setLayer(this, id, z); 777 } 778 779 status_t SurfaceComposerClient::setRelativeLayer(const sp<IBinder>& id, 780 const sp<IBinder>& relativeTo, int32_t z) { 781 return getComposer().setRelativeLayer(this, id, relativeTo, z); 782 } 783 784 status_t SurfaceComposerClient::hide(const sp<IBinder>& id) { 785 return getComposer().setFlags(this, id, 786 layer_state_t::eLayerHidden, 787 layer_state_t::eLayerHidden); 788 } 789 790 status_t SurfaceComposerClient::show(const sp<IBinder>& id) { 791 return getComposer().setFlags(this, id, 792 0, 793 layer_state_t::eLayerHidden); 794 } 795 796 status_t SurfaceComposerClient::setFlags(const sp<IBinder>& id, uint32_t flags, 797 uint32_t mask) { 798 return getComposer().setFlags(this, id, flags, mask); 799 } 800 801 status_t SurfaceComposerClient::setTransparentRegionHint(const sp<IBinder>& id, 802 const Region& transparentRegion) { 803 return getComposer().setTransparentRegionHint(this, id, transparentRegion); 804 } 805 806 status_t SurfaceComposerClient::setAlpha(const sp<IBinder>& id, float alpha) { 807 return getComposer().setAlpha(this, id, alpha); 808 } 809 810 status_t SurfaceComposerClient::setLayerStack(const sp<IBinder>& id, uint32_t layerStack) { 811 return getComposer().setLayerStack(this, id, layerStack); 812 } 813 814 status_t SurfaceComposerClient::setMatrix(const sp<IBinder>& id, float dsdx, float dtdx, 815 float dtdy, float dsdy) { 816 return getComposer().setMatrix(this, id, dsdx, dtdx, dtdy, dsdy); 817 } 818 819 status_t SurfaceComposerClient::deferTransactionUntil(const sp<IBinder>& id, 820 const sp<IBinder>& handle, uint64_t frameNumber) { 821 return getComposer().deferTransactionUntil(this, id, handle, frameNumber); 822 } 823 824 status_t SurfaceComposerClient::deferTransactionUntil(const sp<IBinder>& id, 825 const sp<Surface>& barrierSurface, uint64_t frameNumber) { 826 return getComposer().deferTransactionUntil(this, id, barrierSurface, frameNumber); 827 } 828 829 status_t SurfaceComposerClient::reparentChildren(const sp<IBinder>& id, 830 const sp<IBinder>& newParentHandle) { 831 return getComposer().reparentChildren(this, id, newParentHandle); 832 } 833 834 status_t SurfaceComposerClient::detachChildren(const sp<IBinder>& id) { 835 return getComposer().detachChildren(this, id); 836 } 837 838 status_t SurfaceComposerClient::setOverrideScalingMode( 839 const sp<IBinder>& id, int32_t overrideScalingMode) { 840 return getComposer().setOverrideScalingMode( 841 this, id, overrideScalingMode); 842 } 843 844 status_t SurfaceComposerClient::setGeometryAppliesWithResize( 845 const sp<IBinder>& id) { 846 return getComposer().setGeometryAppliesWithResize(this, id); 847 } 848 849 // ---------------------------------------------------------------------------- 850 851 status_t SurfaceComposerClient::setDisplaySurface(const sp<IBinder>& token, 852 sp<IGraphicBufferProducer> bufferProducer) { 853 return Composer::getInstance().setDisplaySurface(token, bufferProducer); 854 } 855 856 void SurfaceComposerClient::setDisplayLayerStack(const sp<IBinder>& token, 857 uint32_t layerStack) { 858 Composer::getInstance().setDisplayLayerStack(token, layerStack); 859 } 860 861 void SurfaceComposerClient::setDisplayProjection(const sp<IBinder>& token, 862 uint32_t orientation, 863 const Rect& layerStackRect, 864 const Rect& displayRect) { 865 Composer::getInstance().setDisplayProjection(token, orientation, 866 layerStackRect, displayRect); 867 } 868 869 void SurfaceComposerClient::setDisplaySize(const sp<IBinder>& token, 870 uint32_t width, uint32_t height) { 871 Composer::getInstance().setDisplaySize(token, width, height); 872 } 873 874 // ---------------------------------------------------------------------------- 875 876 status_t SurfaceComposerClient::getDisplayConfigs( 877 const sp<IBinder>& display, Vector<DisplayInfo>* configs) 878 { 879 return ComposerService::getComposerService()->getDisplayConfigs(display, configs); 880 } 881 882 status_t SurfaceComposerClient::getDisplayInfo(const sp<IBinder>& display, 883 DisplayInfo* info) { 884 Vector<DisplayInfo> configs; 885 status_t result = getDisplayConfigs(display, &configs); 886 if (result != NO_ERROR) { 887 return result; 888 } 889 890 int activeId = getActiveConfig(display); 891 if (activeId < 0) { 892 ALOGE("No active configuration found"); 893 return NAME_NOT_FOUND; 894 } 895 896 *info = configs[static_cast<size_t>(activeId)]; 897 return NO_ERROR; 898 } 899 900 int SurfaceComposerClient::getActiveConfig(const sp<IBinder>& display) { 901 return ComposerService::getComposerService()->getActiveConfig(display); 902 } 903 904 status_t SurfaceComposerClient::setActiveConfig(const sp<IBinder>& display, int id) { 905 return ComposerService::getComposerService()->setActiveConfig(display, id); 906 } 907 908 status_t SurfaceComposerClient::getDisplayColorModes(const sp<IBinder>& display, 909 Vector<android_color_mode_t>* outColorModes) { 910 return ComposerService::getComposerService()->getDisplayColorModes(display, outColorModes); 911 } 912 913 android_color_mode_t SurfaceComposerClient::getActiveColorMode(const sp<IBinder>& display) { 914 return ComposerService::getComposerService()->getActiveColorMode(display); 915 } 916 917 status_t SurfaceComposerClient::setActiveColorMode(const sp<IBinder>& display, 918 android_color_mode_t colorMode) { 919 return ComposerService::getComposerService()->setActiveColorMode(display, colorMode); 920 } 921 922 void SurfaceComposerClient::setDisplayPowerMode(const sp<IBinder>& token, 923 int mode) { 924 ComposerService::getComposerService()->setPowerMode(token, mode); 925 } 926 927 status_t SurfaceComposerClient::clearAnimationFrameStats() { 928 return ComposerService::getComposerService()->clearAnimationFrameStats(); 929 } 930 931 status_t SurfaceComposerClient::getAnimationFrameStats(FrameStats* outStats) { 932 return ComposerService::getComposerService()->getAnimationFrameStats(outStats); 933 } 934 935 status_t SurfaceComposerClient::getHdrCapabilities(const sp<IBinder>& display, 936 HdrCapabilities* outCapabilities) { 937 return ComposerService::getComposerService()->getHdrCapabilities(display, 938 outCapabilities); 939 } 940 941 // ---------------------------------------------------------------------------- 942 943 status_t ScreenshotClient::capture( 944 const sp<IBinder>& display, 945 const sp<IGraphicBufferProducer>& producer, 946 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 947 int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform) { 948 sp<ISurfaceComposer> s(ComposerService::getComposerService()); 949 if (s == NULL) return NO_INIT; 950 return s->captureScreen(display, producer, sourceCrop, 951 reqWidth, reqHeight, minLayerZ, maxLayerZ, useIdentityTransform); 952 } 953 954 status_t ScreenshotClient::captureToBuffer(const sp<IBinder>& display, 955 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 956 int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform, 957 uint32_t rotation, 958 sp<GraphicBuffer>* outBuffer) { 959 sp<ISurfaceComposer> s(ComposerService::getComposerService()); 960 if (s == NULL) return NO_INIT; 961 962 sp<IGraphicBufferConsumer> gbpConsumer; 963 sp<IGraphicBufferProducer> producer; 964 BufferQueue::createBufferQueue(&producer, &gbpConsumer); 965 sp<BufferItemConsumer> consumer(new BufferItemConsumer(gbpConsumer, 966 GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_NEVER, 967 1, true)); 968 969 status_t ret = s->captureScreen(display, producer, sourceCrop, reqWidth, reqHeight, 970 minLayerZ, maxLayerZ, useIdentityTransform, 971 static_cast<ISurfaceComposer::Rotation>(rotation)); 972 if (ret != NO_ERROR) { 973 return ret; 974 } 975 BufferItem b; 976 consumer->acquireBuffer(&b, 0, true); 977 *outBuffer = b.mGraphicBuffer; 978 return ret; 979 } 980 981 ScreenshotClient::ScreenshotClient() 982 : mHaveBuffer(false) { 983 memset(&mBuffer, 0, sizeof(mBuffer)); 984 } 985 986 ScreenshotClient::~ScreenshotClient() { 987 ScreenshotClient::release(); 988 } 989 990 sp<CpuConsumer> ScreenshotClient::getCpuConsumer() const { 991 if (mCpuConsumer == NULL) { 992 sp<IGraphicBufferConsumer> consumer; 993 BufferQueue::createBufferQueue(&mProducer, &consumer); 994 mCpuConsumer = new CpuConsumer(consumer, 1); 995 mCpuConsumer->setName(String8("ScreenshotClient")); 996 } 997 return mCpuConsumer; 998 } 999 1000 status_t ScreenshotClient::update(const sp<IBinder>& display, 1001 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 1002 int32_t minLayerZ, int32_t maxLayerZ, 1003 bool useIdentityTransform, uint32_t rotation) { 1004 sp<ISurfaceComposer> s(ComposerService::getComposerService()); 1005 if (s == NULL) return NO_INIT; 1006 sp<CpuConsumer> cpuConsumer = getCpuConsumer(); 1007 1008 if (mHaveBuffer) { 1009 mCpuConsumer->unlockBuffer(mBuffer); 1010 memset(&mBuffer, 0, sizeof(mBuffer)); 1011 mHaveBuffer = false; 1012 } 1013 1014 status_t err = s->captureScreen(display, mProducer, sourceCrop, 1015 reqWidth, reqHeight, minLayerZ, maxLayerZ, useIdentityTransform, 1016 static_cast<ISurfaceComposer::Rotation>(rotation)); 1017 1018 if (err == NO_ERROR) { 1019 err = mCpuConsumer->lockNextBuffer(&mBuffer); 1020 if (err == NO_ERROR) { 1021 mHaveBuffer = true; 1022 } 1023 } 1024 return err; 1025 } 1026 1027 status_t ScreenshotClient::update(const sp<IBinder>& display, 1028 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 1029 int32_t minLayerZ, int32_t maxLayerZ, 1030 bool useIdentityTransform) { 1031 1032 return ScreenshotClient::update(display, sourceCrop, reqWidth, reqHeight, 1033 minLayerZ, maxLayerZ, useIdentityTransform, ISurfaceComposer::eRotateNone); 1034 } 1035 1036 status_t ScreenshotClient::update(const sp<IBinder>& display, Rect sourceCrop, 1037 bool useIdentityTransform) { 1038 return ScreenshotClient::update(display, sourceCrop, 0, 0, 1039 INT32_MIN, INT32_MAX, 1040 useIdentityTransform, ISurfaceComposer::eRotateNone); 1041 } 1042 1043 status_t ScreenshotClient::update(const sp<IBinder>& display, Rect sourceCrop, 1044 uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform) { 1045 return ScreenshotClient::update(display, sourceCrop, reqWidth, reqHeight, 1046 INT32_MIN, INT32_MAX, 1047 useIdentityTransform, ISurfaceComposer::eRotateNone); 1048 } 1049 1050 void ScreenshotClient::release() { 1051 if (mHaveBuffer) { 1052 mCpuConsumer->unlockBuffer(mBuffer); 1053 memset(&mBuffer, 0, sizeof(mBuffer)); 1054 mHaveBuffer = false; 1055 } 1056 mCpuConsumer.clear(); 1057 } 1058 1059 void const* ScreenshotClient::getPixels() const { 1060 return mBuffer.data; 1061 } 1062 1063 uint32_t ScreenshotClient::getWidth() const { 1064 return mBuffer.width; 1065 } 1066 1067 uint32_t ScreenshotClient::getHeight() const { 1068 return mBuffer.height; 1069 } 1070 1071 PixelFormat ScreenshotClient::getFormat() const { 1072 return mBuffer.format; 1073 } 1074 1075 uint32_t ScreenshotClient::getStride() const { 1076 return mBuffer.stride; 1077 } 1078 1079 size_t ScreenshotClient::getSize() const { 1080 return mBuffer.stride * mBuffer.height * bytesPerPixel(mBuffer.format); 1081 } 1082 1083 android_dataspace ScreenshotClient::getDataSpace() const { 1084 return mBuffer.dataSpace; 1085 } 1086 1087 // ---------------------------------------------------------------------------- 1088 }; // namespace android 1089
