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