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