SpriteController.cpp revision b933055cf3f7f8ea89bfd3bc9c37a3891ff7310a
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 34namespace android { 35 36// --- SpriteController --- 37 38SpriteController::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 46SpriteController::~SpriteController() { 47 mLooper->removeMessages(mHandler); 48 49 if (mSurfaceComposerClient != NULL) { 50 mSurfaceComposerClient->dispose(); 51 mSurfaceComposerClient.clear(); 52 } 53} 54 55sp<Sprite> SpriteController::createSprite() { 56 return new SpriteImpl(this); 57} 58 59void SpriteController::openTransaction() { 60 AutoMutex _l(mLock); 61 62 mLocked.transactionNestingCount += 1; 63} 64 65void 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 78void 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 90void 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 98void 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 109void 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 347void 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 362void SpriteController::ensureSurfaceComposerClient() { 363 if (mSurfaceComposerClient == NULL) { 364 mSurfaceComposerClient = new SurfaceComposerClient(); 365 } 366} 367 368sp<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 384SpriteController::SpriteImpl::SpriteImpl(const sp<SpriteController> controller) : 385 mController(controller) { 386} 387 388SpriteController::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 399void 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, kNative_8888_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 425void 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 434void 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 444void 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 453void 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 462void 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 472void 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 482