libs/input/SpriteController.cpp

   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.installPixels(SkImageInfo::MakeN32Premul(outBuffer.width, outBuffer.height),
 210                                             outBuffer.bits, bpr);
 211
 212                 SkCanvas surfaceCanvas(surfaceBitmap);
 213
 214                 SkPaint paint;
 215                 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
 216                 surfaceCanvas.drawBitmap(update.state.icon.bitmap, 0, 0, &paint);
 217
 218                 if (outBuffer.width > update.state.icon.bitmap.width()) {
 219                     paint.setColor(0); // transparent fill color
 220                     surfaceCanvas.drawRectCoords(update.state.icon.bitmap.width(), 0,
 221                             outBuffer.width, update.state.icon.bitmap.height(), paint);
 222                 }
 223                 if (outBuffer.height > update.state.icon.bitmap.height()) {
 224                     paint.setColor(0); // transparent fill color
 225                     surfaceCanvas.drawRectCoords(0, update.state.icon.bitmap.height(),
 226                             outBuffer.width, outBuffer.height, paint);
 227                 }
 228
 229                 status = surface->unlockAndPost();
 230                 if (status) {
 231                     ALOGE("Error %d unlocking and posting sprite surface after drawing.", status);
 232                 } else {
 233                     update.state.surfaceDrawn = true;
 234                     update.surfaceChanged = surfaceChanged = true;
 235                 }
 236             }
 237         }
 238     }
 239
 240     // Set sprite surface properties and make them visible.
 241     bool haveTransaction = false;
 242     for (size_t i = 0; i < numSprites; i++) {
 243         SpriteUpdate& update = updates.editItemAt(i);
 244
 245         bool wantSurfaceVisibleAndDrawn = update.state.wantSurfaceVisible()
 246                 && update.state.surfaceDrawn;
 247         bool becomingVisible = wantSurfaceVisibleAndDrawn && !update.state.surfaceVisible;
 248         bool becomingHidden = !wantSurfaceVisibleAndDrawn && update.state.surfaceVisible;
 249         if (update.state.surfaceControl != NULL && (becomingVisible || becomingHidden
 250                 || (wantSurfaceVisibleAndDrawn && (update.state.dirty & (DIRTY_ALPHA
 251                         | DIRTY_POSITION | DIRTY_TRANSFORMATION_MATRIX | DIRTY_LAYER
 252                         | DIRTY_VISIBILITY | DIRTY_HOTSPOT))))) {
 253             status_t status;
 254             if (!haveTransaction) {
 255                 SurfaceComposerClient::openGlobalTransaction();
 256                 haveTransaction = true;
 257             }
 258
 259             if (wantSurfaceVisibleAndDrawn
 260                     && (becomingVisible || (update.state.dirty & DIRTY_ALPHA))) {
 261                 status = update.state.surfaceControl->setAlpha(update.state.alpha);
 262                 if (status) {
 263                     ALOGE("Error %d setting sprite surface alpha.", status);
 264                 }
 265             }
 266
 267             if (wantSurfaceVisibleAndDrawn
 268                     && (becomingVisible || (update.state.dirty & (DIRTY_POSITION
 269                             | DIRTY_HOTSPOT)))) {
 270                 status = update.state.surfaceControl->setPosition(
 271                         update.state.positionX - update.state.icon.hotSpotX,
 272                         update.state.positionY - update.state.icon.hotSpotY);
 273                 if (status) {
 274                     ALOGE("Error %d setting sprite surface position.", status);
 275                 }
 276             }
 277
 278             if (wantSurfaceVisibleAndDrawn
 279                     && (becomingVisible
 280                             || (update.state.dirty & DIRTY_TRANSFORMATION_MATRIX))) {
 281                 status = update.state.surfaceControl->setMatrix(
 282                         update.state.transformationMatrix.dsdx,
 283                         update.state.transformationMatrix.dtdx,
 284                         update.state.transformationMatrix.dsdy,
 285                         update.state.transformationMatrix.dtdy);
 286                 if (status) {
 287                     ALOGE("Error %d setting sprite surface transformation matrix.", status);
 288                 }
 289             }
 290
 291             int32_t surfaceLayer = mOverlayLayer + update.state.layer;
 292             if (wantSurfaceVisibleAndDrawn
 293                     && (becomingVisible || (update.state.dirty & DIRTY_LAYER))) {
 294                 status = update.state.surfaceControl->setLayer(surfaceLayer);
 295                 if (status) {
 296                     ALOGE("Error %d setting sprite surface layer.", status);
 297                 }
 298             }
 299
 300             if (becomingVisible) {
 301                 status = update.state.surfaceControl->show();
 302                 if (status) {
 303                     ALOGE("Error %d showing sprite surface.", status);
 304                 } else {
 305                     update.state.surfaceVisible = true;
 306                     update.surfaceChanged = surfaceChanged = true;
 307                 }
 308             } else if (becomingHidden) {
 309                 status = update.state.surfaceControl->hide();
 310                 if (status) {
 311                     ALOGE("Error %d hiding sprite surface.", status);
 312                 } else {
 313                     update.state.surfaceVisible = false;
 314                     update.surfaceChanged = surfaceChanged = true;
 315                 }
 316             }
 317         }
 318     }
 319
 320     if (haveTransaction) {
 321         SurfaceComposerClient::closeGlobalTransaction();
 322     }
 323
 324     // If any surfaces were changed, write back the new surface properties to the sprites.
 325     if (surfaceChanged) { // acquire lock
 326         AutoMutex _l(mLock);
 327
 328         for (size_t i = 0; i < numSprites; i++) {
 329             const SpriteUpdate& update = updates.itemAt(i);
 330
 331             if (update.surfaceChanged) {
 332                 update.sprite->setSurfaceLocked(update.state.surfaceControl,
 333                         update.state.surfaceWidth, update.state.surfaceHeight,
 334                         update.state.surfaceDrawn, update.state.surfaceVisible);
 335             }
 336         }
 337     } // release lock
 338
 339     // Clear the sprite update vector outside the lock.  It is very important that
 340     // we do not clear sprite references inside the lock since we could be releasing
 341     // the last remaining reference to the sprite here which would result in the
 342     // sprite being deleted and the lock being reacquired by the sprite destructor
 343     // while already held.
 344     updates.clear();
 345 }
 346
 347 void SpriteController::doDisposeSurfaces() {
 348     // Collect disposed surfaces.
 349     Vector<sp<SurfaceControl> > disposedSurfaces;
 350     { // acquire lock
 351         AutoMutex _l(mLock);
 352
 353         disposedSurfaces = mLocked.disposedSurfaces;
 354         mLocked.disposedSurfaces.clear();
 355     } // release lock
 356
 357     // Release the last reference to each surface outside of the lock.
 358     // We don't want the surfaces to be deleted while we are holding our lock.
 359     disposedSurfaces.clear();
 360 }
 361
 362 void SpriteController::ensureSurfaceComposerClient() {
 363     if (mSurfaceComposerClient == NULL) {
 364         mSurfaceComposerClient = new SurfaceComposerClient();
 365     }
 366 }
 367
 368 sp<SurfaceControl> SpriteController::obtainSurface(int32_t width, int32_t height) {
 369     ensureSurfaceComposerClient();
 370
 371     sp<SurfaceControl> surfaceControl = mSurfaceComposerClient->createSurface(
 372             String8("Sprite"), width, height, PIXEL_FORMAT_RGBA_8888,
 373             ISurfaceComposerClient::eHidden);
 374     if (surfaceControl == NULL || !surfaceControl->isValid()) {
 375         ALOGE("Error creating sprite surface.");
 376         return NULL;
 377     }
 378     return surfaceControl;
 379 }
 380
 381
 382 // --- SpriteController::SpriteImpl ---
 383
 384 SpriteController::SpriteImpl::SpriteImpl(const sp<SpriteController> controller) :
 385         mController(controller) {
 386 }
 387
 388 SpriteController::SpriteImpl::~SpriteImpl() {
 389     AutoMutex _m(mController->mLock);
 390
 391     // Let the controller take care of deleting the last reference to sprite
 392     // surfaces so that we do not block the caller on an IPC here.
 393     if (mLocked.state.surfaceControl != NULL) {
 394         mController->disposeSurfaceLocked(mLocked.state.surfaceControl);
 395         mLocked.state.surfaceControl.clear();
 396     }
 397 }
 398
 399 void SpriteController::SpriteImpl::setIcon(const SpriteIcon& icon) {
 400     AutoMutex _l(mController->mLock);
 401
 402     uint32_t dirty;
 403     if (icon.isValid()) {
 404         icon.bitmap.copyTo(&mLocked.state.icon.bitmap, kN32_SkColorType);
 405
 406         if (!mLocked.state.icon.isValid()
 407                 || mLocked.state.icon.hotSpotX != icon.hotSpotX
 408                 || mLocked.state.icon.hotSpotY != icon.hotSpotY) {
 409             mLocked.state.icon.hotSpotX = icon.hotSpotX;
 410             mLocked.state.icon.hotSpotY = icon.hotSpotY;
 411             dirty = DIRTY_BITMAP | DIRTY_HOTSPOT;
 412         } else {
 413             dirty = DIRTY_BITMAP;
 414         }
 415     } else if (mLocked.state.icon.isValid()) {
 416         mLocked.state.icon.bitmap.reset();
 417         dirty = DIRTY_BITMAP | DIRTY_HOTSPOT;
 418     } else {
 419         return; // setting to invalid icon and already invalid so nothing to do
 420     }
 421
 422     invalidateLocked(dirty);
 423 }
 424
 425 void SpriteController::SpriteImpl::setVisible(bool visible) {
 426     AutoMutex _l(mController->mLock);
 427
 428     if (mLocked.state.visible != visible) {
 429         mLocked.state.visible = visible;
 430         invalidateLocked(DIRTY_VISIBILITY);
 431     }
 432 }
 433
 434 void SpriteController::SpriteImpl::setPosition(float x, float y) {
 435     AutoMutex _l(mController->mLock);
 436
 437     if (mLocked.state.positionX != x || mLocked.state.positionY != y) {
 438         mLocked.state.positionX = x;
 439         mLocked.state.positionY = y;
 440         invalidateLocked(DIRTY_POSITION);
 441     }
 442 }
 443
 444 void SpriteController::SpriteImpl::setLayer(int32_t layer) {
 445     AutoMutex _l(mController->mLock);
 446
 447     if (mLocked.state.layer != layer) {
 448         mLocked.state.layer = layer;
 449         invalidateLocked(DIRTY_LAYER);
 450     }
 451 }
 452
 453 void SpriteController::SpriteImpl::setAlpha(float alpha) {
 454     AutoMutex _l(mController->mLock);
 455
 456     if (mLocked.state.alpha != alpha) {
 457         mLocked.state.alpha = alpha;
 458         invalidateLocked(DIRTY_ALPHA);
 459     }
 460 }
 461
 462 void SpriteController::SpriteImpl::setTransformationMatrix(
 463         const SpriteTransformationMatrix& matrix) {
 464     AutoMutex _l(mController->mLock);
 465
 466     if (mLocked.state.transformationMatrix != matrix) {
 467         mLocked.state.transformationMatrix = matrix;
 468         invalidateLocked(DIRTY_TRANSFORMATION_MATRIX);
 469     }
 470 }
 471
 472 void SpriteController::SpriteImpl::invalidateLocked(uint32_t dirty) {
 473     bool wasDirty = mLocked.state.dirty;
 474     mLocked.state.dirty |= dirty;
 475
 476     if (!wasDirty) {
 477         mController->invalidateSpriteLocked(this);
 478     }
 479 }
 480
 481 } // namespace android