Home | History | Annotate | Download | only in gui 
      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
    924