libs/gui/SurfaceComposerClient.cpp

   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     void setDisplaySurface(const sp<IBinder>& token,
 174             const 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 void Composer::setDisplaySurface(const sp<IBinder>& token,
 477         const sp<IGraphicBufferProducer>& bufferProducer) {
 478     Mutex::Autolock _l(mLock);
 479     DisplayState& s(getDisplayStateLocked(token));
 480     s.surface = bufferProducer;
 481     s.what |= DisplayState::eSurfaceChanged;
 482 }
 483
 484 void Composer::setDisplayLayerStack(const sp<IBinder>& token,
 485         uint32_t layerStack) {
 486     Mutex::Autolock _l(mLock);
 487     DisplayState& s(getDisplayStateLocked(token));
 488     s.layerStack = layerStack;
 489     s.what |= DisplayState::eLayerStackChanged;
 490 }
 491
 492 void Composer::setDisplayProjection(const sp<IBinder>& token,
 493         uint32_t orientation,
 494         const Rect& layerStackRect,
 495         const Rect& displayRect) {
 496     Mutex::Autolock _l(mLock);
 497     DisplayState& s(getDisplayStateLocked(token));
 498     s.orientation = orientation;
 499     s.viewport = layerStackRect;
 500     s.frame = displayRect;
 501     s.what |= DisplayState::eDisplayProjectionChanged;
 502     mForceSynchronous = true; // TODO: do we actually still need this?
 503 }
 504
 505 void Composer::setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t height) {
 506     Mutex::Autolock _l(mLock);
 507     DisplayState& s(getDisplayStateLocked(token));
 508     s.width = width;
 509     s.height = height;
 510     s.what |= DisplayState::eDisplaySizeChanged;
 511 }
 512
 513 // ---------------------------------------------------------------------------
 514
 515 SurfaceComposerClient::SurfaceComposerClient()
 516     : mStatus(NO_INIT), mComposer(Composer::getInstance())
 517 {
 518 }
 519
 520 void SurfaceComposerClient::onFirstRef() {
 521     sp<ISurfaceComposer> sm(ComposerService::getComposerService());
 522     if (sm != 0) {
 523         sp<ISurfaceComposerClient> conn = sm->createConnection();
 524         if (conn != 0) {
 525             mClient = conn;
 526             mStatus = NO_ERROR;
 527         }
 528     }
 529 }
 530
 531 SurfaceComposerClient::~SurfaceComposerClient() {
 532     dispose();
 533 }
 534
 535 status_t SurfaceComposerClient::initCheck() const {
 536     return mStatus;
 537 }
 538
 539 sp<IBinder> SurfaceComposerClient::connection() const {
 540     return IInterface::asBinder(mClient);
 541 }
 542
 543 status_t SurfaceComposerClient::linkToComposerDeath(
 544         const sp<IBinder::DeathRecipient>& recipient,
 545         void* cookie, uint32_t flags) {
 546     sp<ISurfaceComposer> sm(ComposerService::getComposerService());
 547     return IInterface::asBinder(sm)->linkToDeath(recipient, cookie, flags);
 548 }
 549
 550 void SurfaceComposerClient::dispose() {
 551     // this can be called more than once.
 552     sp<ISurfaceComposerClient> client;
 553     Mutex::Autolock _lm(mLock);
 554     if (mClient != 0) {
 555         client = mClient; // hold ref while lock is held
 556         mClient.clear();
 557     }
 558     mStatus = NO_INIT;
 559 }
 560
 561 sp<SurfaceControl> SurfaceComposerClient::createSurface(
 562         const String8& name,
 563         uint32_t w,
 564         uint32_t h,
 565         PixelFormat format,
 566         uint32_t flags)
 567 {
 568     sp<SurfaceControl> sur;
 569     if (mStatus == NO_ERROR) {
 570         sp<IBinder> handle;
 571         sp<IGraphicBufferProducer> gbp;
 572         status_t err = mClient->createSurface(name, w, h, format, flags,
 573                 &handle, &gbp);
 574         ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));
 575         if (err == NO_ERROR) {
 576             sur = new SurfaceControl(this, handle, gbp);
 577         }
 578     }
 579     return sur;
 580 }
 581
 582 sp<IBinder> SurfaceComposerClient::createDisplay(const String8& displayName,
 583         bool secure) {
 584     return Composer::getInstance().createDisplay(displayName, secure);
 585 }
 586
 587 void SurfaceComposerClient::destroyDisplay(const sp<IBinder>& display) {
 588     Composer::getInstance().destroyDisplay(display);
 589 }
 590
 591 sp<IBinder> SurfaceComposerClient::getBuiltInDisplay(int32_t id) {
 592     return Composer::getInstance().getBuiltInDisplay(id);
 593 }
 594
 595 status_t SurfaceComposerClient::destroySurface(const sp<IBinder>& sid) {
 596     if (mStatus != NO_ERROR)
 597         return mStatus;
 598     status_t err = mClient->destroySurface(sid);
 599     return err;
 600 }
 601
 602 status_t SurfaceComposerClient::clearLayerFrameStats(const sp<IBinder>& token) const {
 603     if (mStatus != NO_ERROR) {
 604         return mStatus;
 605     }
 606     return mClient->clearLayerFrameStats(token);
 607 }
 608
 609 status_t SurfaceComposerClient::getLayerFrameStats(const sp<IBinder>& token,
 610         FrameStats* outStats) const {
 611     if (mStatus != NO_ERROR) {
 612         return mStatus;
 613     }
 614     return mClient->getLayerFrameStats(token, outStats);
 615 }
 616
 617 status_t SurfaceComposerClient::getTransformToDisplayInverse(const sp<IBinder>& token,
 618         bool* outTransformToDisplayInverse) const {
 619     if (mStatus != NO_ERROR) {
 620         return mStatus;
 621     }
 622     return mClient->getTransformToDisplayInverse(token, outTransformToDisplayInverse);
 623 }
 624
 625 inline Composer& SurfaceComposerClient::getComposer() {
 626     return mComposer;
 627 }
 628
 629 // ----------------------------------------------------------------------------
 630
 631 void SurfaceComposerClient::openGlobalTransaction() {
 632     Composer::openGlobalTransaction();
 633 }
 634
 635 void SurfaceComposerClient::closeGlobalTransaction(bool synchronous) {
 636     Composer::closeGlobalTransaction(synchronous);
 637 }
 638
 639 void SurfaceComposerClient::setAnimationTransaction() {
 640     Composer::setAnimationTransaction();
 641 }
 642
 643 // ----------------------------------------------------------------------------
 644
 645 status_t SurfaceComposerClient::setCrop(const sp<IBinder>& id, const Rect& crop) {
 646     return getComposer().setCrop(this, id, crop);
 647 }
 648
 649 status_t SurfaceComposerClient::setFinalCrop(const sp<IBinder>& id,
 650         const Rect& crop) {
 651     return getComposer().setFinalCrop(this, id, crop);
 652 }
 653
 654 status_t SurfaceComposerClient::setPosition(const sp<IBinder>& id, float x, float y) {
 655     return getComposer().setPosition(this, id, x, y);
 656 }
 657
 658 status_t SurfaceComposerClient::setSize(const sp<IBinder>& id, uint32_t w, uint32_t h) {
 659     return getComposer().setSize(this, id, w, h);
 660 }
 661
 662 status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, uint32_t z) {
 663     return getComposer().setLayer(this, id, z);
 664 }
 665
 666 status_t SurfaceComposerClient::hide(const sp<IBinder>& id) {
 667     return getComposer().setFlags(this, id,
 668             layer_state_t::eLayerHidden,
 669             layer_state_t::eLayerHidden);
 670 }
 671
 672 status_t SurfaceComposerClient::show(const sp<IBinder>& id) {
 673     return getComposer().setFlags(this, id,
 674             0,
 675             layer_state_t::eLayerHidden);
 676 }
 677
 678 status_t SurfaceComposerClient::setFlags(const sp<IBinder>& id, uint32_t flags,
 679         uint32_t mask) {
 680     return getComposer().setFlags(this, id, flags, mask);
 681 }
 682
 683 status_t SurfaceComposerClient::setTransparentRegionHint(const sp<IBinder>& id,
 684         const Region& transparentRegion) {
 685     return getComposer().setTransparentRegionHint(this, id, transparentRegion);
 686 }
 687
 688 status_t SurfaceComposerClient::setAlpha(const sp<IBinder>& id, float alpha) {
 689     return getComposer().setAlpha(this, id, alpha);
 690 }
 691
 692 status_t SurfaceComposerClient::setLayerStack(const sp<IBinder>& id, uint32_t layerStack) {
 693     return getComposer().setLayerStack(this, id, layerStack);
 694 }
 695
 696 status_t SurfaceComposerClient::setMatrix(const sp<IBinder>& id, float dsdx, float dtdx,
 697         float dsdy, float dtdy) {
 698     return getComposer().setMatrix(this, id, dsdx, dtdx, dsdy, dtdy);
 699 }
 700
 701 status_t SurfaceComposerClient::deferTransactionUntil(const sp<IBinder>& id,
 702         const sp<IBinder>& handle, uint64_t frameNumber) {
 703     return getComposer().deferTransactionUntil(this, id, handle, frameNumber);
 704 }
 705
 706 status_t SurfaceComposerClient::setOverrideScalingMode(
 707         const sp<IBinder>& id, int32_t overrideScalingMode) {
 708     return getComposer().setOverrideScalingMode(
 709             this, id, overrideScalingMode);
 710 }
 711
 712 status_t SurfaceComposerClient::setGeometryAppliesWithResize(
 713         const sp<IBinder>& id) {
 714     return getComposer().setGeometryAppliesWithResize(this, id);
 715 }
 716
 717 // ----------------------------------------------------------------------------
 718
 719 void SurfaceComposerClient::setDisplaySurface(const sp<IBinder>& token,
 720         const sp<IGraphicBufferProducer>& bufferProducer) {
 721     Composer::getInstance().setDisplaySurface(token, bufferProducer);
 722 }
 723
 724 void SurfaceComposerClient::setDisplayLayerStack(const sp<IBinder>& token,
 725         uint32_t layerStack) {
 726     Composer::getInstance().setDisplayLayerStack(token, layerStack);
 727 }
 728
 729 void SurfaceComposerClient::setDisplayProjection(const sp<IBinder>& token,
 730         uint32_t orientation,
 731         const Rect& layerStackRect,
 732         const Rect& displayRect) {
 733     Composer::getInstance().setDisplayProjection(token, orientation,
 734             layerStackRect, displayRect);
 735 }
 736
 737 void SurfaceComposerClient::setDisplaySize(const sp<IBinder>& token,
 738         uint32_t width, uint32_t height) {
 739     Composer::getInstance().setDisplaySize(token, width, height);
 740 }
 741
 742 // ----------------------------------------------------------------------------
 743
 744 status_t SurfaceComposerClient::getDisplayConfigs(
 745         const sp<IBinder>& display, Vector<DisplayInfo>* configs)
 746 {
 747     return ComposerService::getComposerService()->getDisplayConfigs(display, configs);
 748 }
 749
 750 status_t SurfaceComposerClient::getDisplayInfo(const sp<IBinder>& display,
 751         DisplayInfo* info) {
 752     Vector<DisplayInfo> configs;
 753     status_t result = getDisplayConfigs(display, &configs);
 754     if (result != NO_ERROR) {
 755         return result;
 756     }
 757
 758     int activeId = getActiveConfig(display);
 759     if (activeId < 0) {
 760         ALOGE("No active configuration found");
 761         return NAME_NOT_FOUND;
 762     }
 763
 764     *info = configs[static_cast<size_t>(activeId)];
 765     return NO_ERROR;
 766 }
 767
 768 int SurfaceComposerClient::getActiveConfig(const sp<IBinder>& display) {
 769     return ComposerService::getComposerService()->getActiveConfig(display);
 770 }
 771
 772 status_t SurfaceComposerClient::setActiveConfig(const sp<IBinder>& display, int id) {
 773     return ComposerService::getComposerService()->setActiveConfig(display, id);
 774 }
 775
 776 status_t SurfaceComposerClient::getDisplayColorModes(const sp<IBinder>& display,
 777         Vector<android_color_mode_t>* outColorModes) {
 778     return ComposerService::getComposerService()->getDisplayColorModes(display, outColorModes);
 779 }
 780
 781 android_color_mode_t SurfaceComposerClient::getActiveColorMode(const sp<IBinder>& display) {
 782     return ComposerService::getComposerService()->getActiveColorMode(display);
 783 }
 784
 785 status_t SurfaceComposerClient::setActiveColorMode(const sp<IBinder>& display,
 786         android_color_mode_t colorMode) {
 787     return ComposerService::getComposerService()->setActiveColorMode(display, colorMode);
 788 }
 789
 790 void SurfaceComposerClient::setDisplayPowerMode(const sp<IBinder>& token,
 791         int mode) {
 792     ComposerService::getComposerService()->setPowerMode(token, mode);
 793 }
 794
 795 status_t SurfaceComposerClient::clearAnimationFrameStats() {
 796     return ComposerService::getComposerService()->clearAnimationFrameStats();
 797 }
 798
 799 status_t SurfaceComposerClient::getAnimationFrameStats(FrameStats* outStats) {
 800     return ComposerService::getComposerService()->getAnimationFrameStats(outStats);
 801 }
 802
 803 status_t SurfaceComposerClient::getHdrCapabilities(const sp<IBinder>& display,
 804         HdrCapabilities* outCapabilities) {
 805     return ComposerService::getComposerService()->getHdrCapabilities(display,
 806             outCapabilities);
 807 }
 808
 809 // ----------------------------------------------------------------------------
 810
 811 status_t ScreenshotClient::capture(
 812         const sp<IBinder>& display,
 813         const sp<IGraphicBufferProducer>& producer,
 814         Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
 815         uint32_t minLayerZ, uint32_t maxLayerZ, bool useIdentityTransform) {
 816     sp<ISurfaceComposer> s(ComposerService::getComposerService());
 817     if (s == NULL) return NO_INIT;
 818     return s->captureScreen(display, producer, sourceCrop,
 819             reqWidth, reqHeight, minLayerZ, maxLayerZ, useIdentityTransform);
 820 }
 821
 822 ScreenshotClient::ScreenshotClient()
 823     : mHaveBuffer(false) {
 824     memset(&mBuffer, 0, sizeof(mBuffer));
 825 }
 826
 827 ScreenshotClient::~ScreenshotClient() {
 828     ScreenshotClient::release();
 829 }
 830
 831 sp<CpuConsumer> ScreenshotClient::getCpuConsumer() const {
 832     if (mCpuConsumer == NULL) {
 833         sp<IGraphicBufferConsumer> consumer;
 834         BufferQueue::createBufferQueue(&mProducer, &consumer);
 835         mCpuConsumer = new CpuConsumer(consumer, 1);
 836         mCpuConsumer->setName(String8("ScreenshotClient"));
 837     }
 838     return mCpuConsumer;
 839 }
 840
 841 status_t ScreenshotClient::update(const sp<IBinder>& display,
 842         Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
 843         uint32_t minLayerZ, uint32_t maxLayerZ,
 844         bool useIdentityTransform, uint32_t rotation) {
 845     sp<ISurfaceComposer> s(ComposerService::getComposerService());
 846     if (s == NULL) return NO_INIT;
 847     sp<CpuConsumer> cpuConsumer = getCpuConsumer();
 848
 849     if (mHaveBuffer) {
 850         mCpuConsumer->unlockBuffer(mBuffer);
 851         memset(&mBuffer, 0, sizeof(mBuffer));
 852         mHaveBuffer = false;
 853     }
 854
 855     status_t err = s->captureScreen(display, mProducer, sourceCrop,
 856             reqWidth, reqHeight, minLayerZ, maxLayerZ, useIdentityTransform,
 857             static_cast<ISurfaceComposer::Rotation>(rotation));
 858
 859     if (err == NO_ERROR) {
 860         err = mCpuConsumer->lockNextBuffer(&mBuffer);
 861         if (err == NO_ERROR) {
 862             mHaveBuffer = true;
 863         }
 864     }
 865     return err;
 866 }
 867
 868 status_t ScreenshotClient::update(const sp<IBinder>& display,
 869         Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
 870         uint32_t minLayerZ, uint32_t maxLayerZ,
 871         bool useIdentityTransform) {
 872
 873     return ScreenshotClient::update(display, sourceCrop, reqWidth, reqHeight,
 874             minLayerZ, maxLayerZ, useIdentityTransform, ISurfaceComposer::eRotateNone);
 875 }
 876
 877 status_t ScreenshotClient::update(const sp<IBinder>& display, Rect sourceCrop,
 878         bool useIdentityTransform) {
 879     return ScreenshotClient::update(display, sourceCrop, 0, 0, 0, -1U,
 880             useIdentityTransform, ISurfaceComposer::eRotateNone);
 881 }
 882
 883 status_t ScreenshotClient::update(const sp<IBinder>& display, Rect sourceCrop,
 884         uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform) {
 885     return ScreenshotClient::update(display, sourceCrop, reqWidth, reqHeight,
 886             0, -1U, useIdentityTransform, ISurfaceComposer::eRotateNone);
 887 }
 888
 889 void ScreenshotClient::release() {
 890     if (mHaveBuffer) {
 891         mCpuConsumer->unlockBuffer(mBuffer);
 892         memset(&mBuffer, 0, sizeof(mBuffer));
 893         mHaveBuffer = false;
 894     }
 895     mCpuConsumer.clear();
 896 }
 897
 898 void const* ScreenshotClient::getPixels() const {
 899     return mBuffer.data;
 900 }
 901
 902 uint32_t ScreenshotClient::getWidth() const {
 903     return mBuffer.width;
 904 }
 905
 906 uint32_t ScreenshotClient::getHeight() const {
 907     return mBuffer.height;
 908 }
 909
 910 PixelFormat ScreenshotClient::getFormat() const {
 911     return mBuffer.format;
 912 }
 913
 914 uint32_t ScreenshotClient::getStride() const {
 915     return mBuffer.stride;
 916 }
 917
 918 size_t ScreenshotClient::getSize() const {
 919     return mBuffer.stride * mBuffer.height * bytesPerPixel(mBuffer.format);
 920 }
 921
 922 // ----------------------------------------------------------------------------
 923 }; // namespace android