Home | History | Annotate | Download | only in input 
      1 /*
      2  * Copyright (C) 2011 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 "Sprites"
     18 
     19 //#define LOG_NDEBUG 0
     20 
     21 #include "SpriteController.h"
     22 
     23 #include <cutils/log.h>
     24 #include <utils/String8.h>
     25 #include <gui/Surface.h>
     26 
     27 #include <SkBitmap.h>
     28 #include <SkCanvas.h>
     29 #include <SkColor.h>
     30 #include <SkPaint.h>
     31 #include <SkXfermode.h>
     32 #include <android/native_window.h>
     33 
     34 namespace android {
     35 
     36 // --- SpriteController ---
     37 
     38 SpriteController::SpriteController(const sp<Looper>& looper, int32_t overlayLayer) :
     39         mLooper(looper), mOverlayLayer(overlayLayer) {
     40     mHandler = new WeakMessageHandler(this);
     41 
     42     mLocked.transactionNestingCount = 0;
     43     mLocked.deferredSpriteUpdate = false;
     44 }
     45 
     46 SpriteController::~SpriteController() {
     47     mLooper->removeMessages(mHandler);
     48 
     49     if (mSurfaceComposerClient != NULL) {
     50         mSurfaceComposerClient->dispose();
     51         mSurfaceComposerClient.clear();
     52     }
     53 }
     54 
     55 sp<Sprite> SpriteController::createSprite() {
     56     return new SpriteImpl(this);
     57 }
     58 
     59 void SpriteController::openTransaction() {
     60     AutoMutex _l(mLock);
     61 
     62     mLocked.transactionNestingCount += 1;
     63 }
     64 
     65 void SpriteController::closeTransaction() {
     66     AutoMutex _l(mLock);
     67 
     68     LOG_ALWAYS_FATAL_IF(mLocked.transactionNestingCount == 0,
     69             "Sprite closeTransaction() called but there is no open sprite transaction");
     70 
     71     mLocked.transactionNestingCount -= 1;
     72     if (mLocked.transactionNestingCount == 0 && mLocked.deferredSpriteUpdate) {
     73         mLocked.deferredSpriteUpdate = false;
     74         mLooper->sendMessage(mHandler, Message(MSG_UPDATE_SPRITES));
     75     }
     76 }
     77 
     78 void SpriteController::invalidateSpriteLocked(const sp<SpriteImpl>& sprite) {
     79     bool wasEmpty = mLocked.invalidatedSprites.isEmpty();
     80     mLocked.invalidatedSprites.push(sprite);
     81     if (wasEmpty) {
     82         if (mLocked.transactionNestingCount != 0) {
     83             mLocked.deferredSpriteUpdate = true;
     84         } else {
     85             mLooper->sendMessage(mHandler, Message(MSG_UPDATE_SPRITES));
     86         }
     87     }
     88 }
     89 
     90 void SpriteController::disposeSurfaceLocked(const sp<SurfaceControl>& surfaceControl) {
     91     bool wasEmpty = mLocked.disposedSurfaces.isEmpty();
     92     mLocked.disposedSurfaces.push(surfaceControl);
     93     if (wasEmpty) {
     94         mLooper->sendMessage(mHandler, Message(MSG_DISPOSE_SURFACES));
     95     }
     96 }
     97 
     98 void SpriteController::handleMessage(const Message& message) {
     99     switch (message.what) {
    100     case MSG_UPDATE_SPRITES:
    101         doUpdateSprites();
    102         break;
    103     case MSG_DISPOSE_SURFACES:
    104         doDisposeSurfaces();
    105         break;
    106     }
    107 }
    108 
    109 void SpriteController::doUpdateSprites() {
    110     // Collect information about sprite updates.
    111     // Each sprite update record includes a reference to its associated sprite so we can
    112     // be certain the sprites will not be deleted while this function runs.  Sprites
    113     // may invalidate themselves again during this time but we will handle those changes
    114     // in the next iteration.
    115     Vector<SpriteUpdate> updates;
    116     size_t numSprites;
    117     { // acquire lock
    118         AutoMutex _l(mLock);
    119 
    120         numSprites = mLocked.invalidatedSprites.size();
    121         for (size_t i = 0; i < numSprites; i++) {
    122             const sp<SpriteImpl>& sprite = mLocked.invalidatedSprites.itemAt(i);
    123 
    124             updates.push(SpriteUpdate(sprite, sprite->getStateLocked()));
    125             sprite->resetDirtyLocked();
    126         }
    127         mLocked.invalidatedSprites.clear();
    128     } // release lock
    129 
    130     // Create missing surfaces.
    131     bool surfaceChanged = false;
    132     for (size_t i = 0; i < numSprites; i++) {
    133         SpriteUpdate& update = updates.editItemAt(i);
    134 
    135         if (update.state.surfaceControl == NULL && update.state.wantSurfaceVisible()) {
    136             update.state.surfaceWidth = update.state.icon.bitmap.width();
    137             update.state.surfaceHeight = update.state.icon.bitmap.height();
    138             update.state.surfaceDrawn = false;
    139             update.state.surfaceVisible = false;
    140             update.state.surfaceControl = obtainSurface(
    141                     update.state.surfaceWidth, update.state.surfaceHeight);
    142             if (update.state.surfaceControl != NULL) {
    143                 update.surfaceChanged = surfaceChanged = true;
    144             }
    145         }
    146     }
    147 
    148     // Resize sprites if needed, inside a global transaction.
    149     bool haveGlobalTransaction = false;
    150     for (size_t i = 0; i < numSprites; i++) {
    151         SpriteUpdate& update = updates.editItemAt(i);
    152 
    153         if (update.state.surfaceControl != NULL && update.state.wantSurfaceVisible()) {
    154             int32_t desiredWidth = update.state.icon.bitmap.width();
    155             int32_t desiredHeight = update.state.icon.bitmap.height();
    156             if (update.state.surfaceWidth < desiredWidth
    157                     || update.state.surfaceHeight < desiredHeight) {
    158                 if (!haveGlobalTransaction) {
    159                     SurfaceComposerClient::openGlobalTransaction();
    160                     haveGlobalTransaction = true;
    161                 }
    162 
    163                 status_t status = update.state.surfaceControl->setSize(desiredWidth, desiredHeight);
    164                 if (status) {
    165                     ALOGE("Error %d resizing sprite surface from %dx%d to %dx%d",
    166                             status, update.state.surfaceWidth, update.state.surfaceHeight,
    167                             desiredWidth, desiredHeight);
    168                 } else {
    169                     update.state.surfaceWidth = desiredWidth;
    170                     update.state.surfaceHeight = desiredHeight;
    171                     update.state.surfaceDrawn = false;
    172                     update.surfaceChanged = surfaceChanged = true;
    173 
    174                     if (update.state.surfaceVisible) {
    175                         status = update.state.surfaceControl->hide();
    176                         if (status) {
    177                             ALOGE("Error %d hiding sprite surface after resize.", status);
    178                         } else {
    179                             update.state.surfaceVisible = false;
    180                         }
    181                     }
    182                 }
    183             }
    184         }
    185     }
    186     if (haveGlobalTransaction) {
    187         SurfaceComposerClient::closeGlobalTransaction();
    188     }
    189 
    190     // Redraw sprites if needed.
    191     for (size_t i = 0; i < numSprites; i++) {
    192         SpriteUpdate& update = updates.editItemAt(i);
    193 
    194         if ((update.state.dirty & DIRTY_BITMAP) && update.state.surfaceDrawn) {
    195             update.state.surfaceDrawn = false;
    196             update.surfaceChanged = surfaceChanged = true;
    197         }
    198 
    199         if (update.state.surfaceControl != NULL && !update.state.surfaceDrawn
    200                 && update.state.wantSurfaceVisible()) {
    201             sp<Surface> surface = update.state.surfaceControl->getSurface();
    202             ANativeWindow_Buffer outBuffer;
    203             status_t status = surface->lock(&outBuffer, NULL);
    204             if (status) {
    205                 ALOGE("Error %d locking sprite surface before drawing.", status);
    206             } else {
    207                 SkBitmap surfaceBitmap;
    208                 ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);
    209                 surfaceBitmap.setConfig(SkBitmap::kARGB_8888_Config,
    210                         outBuffer.width, outBuffer.height, bpr);
    211                 surfaceBitmap.setPixels(outBuffer.bits);
    212 
    213                 SkCanvas surfaceCanvas(surfaceBitmap);
    214 
    215                 SkPaint paint;
    216                 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
    217                 surfaceCanvas.drawBitmap(update.state.icon.bitmap, 0, 0, &paint);
    218 
    219                 if (outBuffer.width > uint32_t(update.state.icon.bitmap.width())) {
    220                     paint.setColor(0); // transparent fill color
    221                     surfaceCanvas.drawRectCoords(update.state.icon.bitmap.width(), 0,
    222                             outBuffer.width, update.state.icon.bitmap.height(), paint);
    223                 }
    224                 if (outBuffer.height > uint32_t(update.state.icon.bitmap.height())) {
    225                     paint.setColor(0); // transparent fill color
    226                     surfaceCanvas.drawRectCoords(0, update.state.icon.bitmap.height(),
    227                             outBuffer.width, outBuffer.height, paint);
    228                 }
    229 
    230                 status = surface->unlockAndPost();
    231                 if (status) {
    232                     ALOGE("Error %d unlocking and posting sprite surface after drawing.", status);
    233                 } else {
    234                     update.state.surfaceDrawn = true;
    235                     update.surfaceChanged = surfaceChanged = true;
    236                 }
    237             }
    238         }
    239     }
    240 
    241     // Set sprite surface properties and make them visible.
    242     bool haveTransaction = false;
    243     for (size_t i = 0; i < numSprites; i++) {
    244         SpriteUpdate& update = updates.editItemAt(i);
    245 
    246         bool wantSurfaceVisibleAndDrawn = update.state.wantSurfaceVisible()
    247                 && update.state.surfaceDrawn;
    248         bool becomingVisible = wantSurfaceVisibleAndDrawn && !update.state.surfaceVisible;
    249         bool becomingHidden = !wantSurfaceVisibleAndDrawn && update.state.surfaceVisible;
    250         if (update.state.surfaceControl != NULL && (becomingVisible || becomingHidden
    251                 || (wantSurfaceVisibleAndDrawn && (update.state.dirty & (DIRTY_ALPHA
    252                         | DIRTY_POSITION | DIRTY_TRANSFORMATION_MATRIX | DIRTY_LAYER
    253                         | DIRTY_VISIBILITY | DIRTY_HOTSPOT))))) {
    254             status_t status;
    255             if (!haveTransaction) {
    256                 SurfaceComposerClient::openGlobalTransaction();
    257                 haveTransaction = true;
    258             }
    259 
    260             if (wantSurfaceVisibleAndDrawn
    261                     && (becomingVisible || (update.state.dirty & DIRTY_ALPHA))) {
    262                 status = update.state.surfaceControl->setAlpha(update.state.alpha);
    263                 if (status) {
    264                     ALOGE("Error %d setting sprite surface alpha.", status);
    265                 }
    266             }
    267 
    268             if (wantSurfaceVisibleAndDrawn
    269                     && (becomingVisible || (update.state.dirty & (DIRTY_POSITION
    270                             | DIRTY_HOTSPOT)))) {
    271                 status = update.state.surfaceControl->setPosition(
    272                         update.state.positionX - update.state.icon.hotSpotX,
    273                         update.state.positionY - update.state.icon.hotSpotY);
    274                 if (status) {
    275                     ALOGE("Error %d setting sprite surface position.", status);
    276                 }
    277             }
    278 
    279             if (wantSurfaceVisibleAndDrawn
    280                     && (becomingVisible
    281                             || (update.state.dirty & DIRTY_TRANSFORMATION_MATRIX))) {
    282                 status = update.state.surfaceControl->setMatrix(
    283                         update.state.transformationMatrix.dsdx,
    284                         update.state.transformationMatrix.dtdx,
    285                         update.state.transformationMatrix.dsdy,
    286                         update.state.transformationMatrix.dtdy);
    287                 if (status) {
    288                     ALOGE("Error %d setting sprite surface transformation matrix.", status);
    289                 }
    290             }
    291 
    292             int32_t surfaceLayer = mOverlayLayer + update.state.layer;
    293             if (wantSurfaceVisibleAndDrawn
    294                     && (becomingVisible || (update.state.dirty & DIRTY_LAYER))) {
    295                 status = update.state.surfaceControl->setLayer(surfaceLayer);
    296                 if (status) {
    297                     ALOGE("Error %d setting sprite surface layer.", status);
    298                 }
    299             }
    300 
    301             if (becomingVisible) {
    302                 status = update.state.surfaceControl->show();
    303                 if (status) {
    304                     ALOGE("Error %d showing sprite surface.", status);
    305                 } else {
    306                     update.state.surfaceVisible = true;
    307                     update.surfaceChanged = surfaceChanged = true;
    308                 }
    309             } else if (becomingHidden) {
    310                 status = update.state.surfaceControl->hide();
    311                 if (status) {
    312                     ALOGE("Error %d hiding sprite surface.", status);
    313                 } else {
    314                     update.state.surfaceVisible = false;
    315                     update.surfaceChanged = surfaceChanged = true;
    316                 }
    317             }
    318         }
    319     }
    320 
    321     if (haveTransaction) {
    322         SurfaceComposerClient::closeGlobalTransaction();
    323     }
    324 
    325     // If any surfaces were changed, write back the new surface properties to the sprites.
    326     if (surfaceChanged) { // acquire lock
    327         AutoMutex _l(mLock);
    328 
    329         for (size_t i = 0; i < numSprites; i++) {
    330             const SpriteUpdate& update = updates.itemAt(i);
    331 
    332             if (update.surfaceChanged) {
    333                 update.sprite->setSurfaceLocked(update.state.surfaceControl,
    334                         update.state.surfaceWidth, update.state.surfaceHeight,
    335                         update.state.surfaceDrawn, update.state.surfaceVisible);
    336             }
    337         }
    338     } // release lock
    339 
    340     // Clear the sprite update vector outside the lock.  It is very important that
    341     // we do not clear sprite references inside the lock since we could be releasing
    342     // the last remaining reference to the sprite here which would result in the
    343     // sprite being deleted and the lock being reacquired by the sprite destructor
    344     // while already held.
    345     updates.clear();
    346 }
    347 
    348 void SpriteController::doDisposeSurfaces() {
    349     // Collect disposed surfaces.
    350     Vector<sp<SurfaceControl> > disposedSurfaces;
    351     { // acquire lock
    352         AutoMutex _l(mLock);
    353 
    354         disposedSurfaces = mLocked.disposedSurfaces;
    355         mLocked.disposedSurfaces.clear();
    356     } // release lock
    357 
    358     // Release the last reference to each surface outside of the lock.
    359     // We don't want the surfaces to be deleted while we are holding our lock.
    360     disposedSurfaces.clear();
    361 }
    362 
    363 void SpriteController::ensureSurfaceComposerClient() {
    364     if (mSurfaceComposerClient == NULL) {
    365         mSurfaceComposerClient = new SurfaceComposerClient();
    366     }
    367 }
    368 
    369 sp<SurfaceControl> SpriteController::obtainSurface(int32_t width, int32_t height) {
    370     ensureSurfaceComposerClient();
    371 
    372     sp<SurfaceControl> surfaceControl = mSurfaceComposerClient->createSurface(
    373             String8("Sprite"), width, height, PIXEL_FORMAT_RGBA_8888,
    374             ISurfaceComposerClient::eHidden);
    375     if (surfaceControl == NULL || !surfaceControl->isValid()) {
    376         ALOGE("Error creating sprite surface.");
    377         return NULL;
    378     }
    379     return surfaceControl;
    380 }
    381 
    382 
    383 // --- SpriteController::SpriteImpl ---
    384 
    385 SpriteController::SpriteImpl::SpriteImpl(const sp<SpriteController> controller) :
    386         mController(controller) {
    387 }
    388 
    389 SpriteController::SpriteImpl::~SpriteImpl() {
    390     AutoMutex _m(mController->mLock);
    391 
    392     // Let the controller take care of deleting the last reference to sprite
    393     // surfaces so that we do not block the caller on an IPC here.
    394     if (mLocked.state.surfaceControl != NULL) {
    395         mController->disposeSurfaceLocked(mLocked.state.surfaceControl);
    396         mLocked.state.surfaceControl.clear();
    397     }
    398 }
    399 
    400 void SpriteController::SpriteImpl::setIcon(const SpriteIcon& icon) {
    401     AutoMutex _l(mController->mLock);
    402 
    403     uint32_t dirty;
    404     if (icon.isValid()) {
    405         icon.bitmap.copyTo(&mLocked.state.icon.bitmap, SkBitmap::kARGB_8888_Config);
    406 
    407         if (!mLocked.state.icon.isValid()
    408                 || mLocked.state.icon.hotSpotX != icon.hotSpotX
    409                 || mLocked.state.icon.hotSpotY != icon.hotSpotY) {
    410             mLocked.state.icon.hotSpotX = icon.hotSpotX;
    411             mLocked.state.icon.hotSpotY = icon.hotSpotY;
    412             dirty = DIRTY_BITMAP | DIRTY_HOTSPOT;
    413         } else {
    414             dirty = DIRTY_BITMAP;
    415         }
    416     } else if (mLocked.state.icon.isValid()) {
    417         mLocked.state.icon.bitmap.reset();
    418         dirty = DIRTY_BITMAP | DIRTY_HOTSPOT;
    419     } else {
    420         return; // setting to invalid icon and already invalid so nothing to do
    421     }
    422 
    423     invalidateLocked(dirty);
    424 }
    425 
    426 void SpriteController::SpriteImpl::setVisible(bool visible) {
    427     AutoMutex _l(mController->mLock);
    428 
    429     if (mLocked.state.visible != visible) {
    430         mLocked.state.visible = visible;
    431         invalidateLocked(DIRTY_VISIBILITY);
    432     }
    433 }
    434 
    435 void SpriteController::SpriteImpl::setPosition(float x, float y) {
    436     AutoMutex _l(mController->mLock);
    437 
    438     if (mLocked.state.positionX != x || mLocked.state.positionY != y) {
    439         mLocked.state.positionX = x;
    440         mLocked.state.positionY = y;
    441         invalidateLocked(DIRTY_POSITION);
    442     }
    443 }
    444 
    445 void SpriteController::SpriteImpl::setLayer(int32_t layer) {
    446     AutoMutex _l(mController->mLock);
    447 
    448     if (mLocked.state.layer != layer) {
    449         mLocked.state.layer = layer;
    450         invalidateLocked(DIRTY_LAYER);
    451     }
    452 }
    453 
    454 void SpriteController::SpriteImpl::setAlpha(float alpha) {
    455     AutoMutex _l(mController->mLock);
    456 
    457     if (mLocked.state.alpha != alpha) {
    458         mLocked.state.alpha = alpha;
    459         invalidateLocked(DIRTY_ALPHA);
    460     }
    461 }
    462 
    463 void SpriteController::SpriteImpl::setTransformationMatrix(
    464         const SpriteTransformationMatrix& matrix) {
    465     AutoMutex _l(mController->mLock);
    466 
    467     if (mLocked.state.transformationMatrix != matrix) {
    468         mLocked.state.transformationMatrix = matrix;
    469         invalidateLocked(DIRTY_TRANSFORMATION_MATRIX);
    470     }
    471 }
    472 
    473 void SpriteController::SpriteImpl::invalidateLocked(uint32_t dirty) {
    474     bool wasDirty = mLocked.state.dirty;
    475     mLocked.state.dirty |= dirty;
    476 
    477     if (!wasDirty) {
    478         mController->invalidateSpriteLocked(this);
    479     }
    480 }
    481 
    482 } // namespace android
    483