• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
26 #include <SkBitmap.h>
27 #include <SkCanvas.h>
28 #include <SkColor.h>
29 #include <SkPaint.h>
30 #include <SkXfermode.h>
31 
32 namespace android {
33 
34 // --- SpriteController ---
35 
SpriteController(const sp<Looper> & looper,int32_t overlayLayer)36 SpriteController::SpriteController(const sp<Looper>& looper, int32_t overlayLayer) :
37         mLooper(looper), mOverlayLayer(overlayLayer) {
38     mHandler = new WeakMessageHandler(this);
39 
40     mLocked.transactionNestingCount = 0;
41     mLocked.deferredSpriteUpdate = false;
42 }
43 
~SpriteController()44 SpriteController::~SpriteController() {
45     mLooper->removeMessages(mHandler);
46 
47     if (mSurfaceComposerClient != NULL) {
48         mSurfaceComposerClient->dispose();
49         mSurfaceComposerClient.clear();
50     }
51 }
52 
createSprite()53 sp<Sprite> SpriteController::createSprite() {
54     return new SpriteImpl(this);
55 }
56 
openTransaction()57 void SpriteController::openTransaction() {
58     AutoMutex _l(mLock);
59 
60     mLocked.transactionNestingCount += 1;
61 }
62 
closeTransaction()63 void SpriteController::closeTransaction() {
64     AutoMutex _l(mLock);
65 
66     LOG_ALWAYS_FATAL_IF(mLocked.transactionNestingCount == 0,
67             "Sprite closeTransaction() called but there is no open sprite transaction");
68 
69     mLocked.transactionNestingCount -= 1;
70     if (mLocked.transactionNestingCount == 0 && mLocked.deferredSpriteUpdate) {
71         mLocked.deferredSpriteUpdate = false;
72         mLooper->sendMessage(mHandler, Message(MSG_UPDATE_SPRITES));
73     }
74 }
75 
invalidateSpriteLocked(const sp<SpriteImpl> & sprite)76 void SpriteController::invalidateSpriteLocked(const sp<SpriteImpl>& sprite) {
77     bool wasEmpty = mLocked.invalidatedSprites.isEmpty();
78     mLocked.invalidatedSprites.push(sprite);
79     if (wasEmpty) {
80         if (mLocked.transactionNestingCount != 0) {
81             mLocked.deferredSpriteUpdate = true;
82         } else {
83             mLooper->sendMessage(mHandler, Message(MSG_UPDATE_SPRITES));
84         }
85     }
86 }
87 
disposeSurfaceLocked(const sp<SurfaceControl> & surfaceControl)88 void SpriteController::disposeSurfaceLocked(const sp<SurfaceControl>& surfaceControl) {
89     bool wasEmpty = mLocked.disposedSurfaces.isEmpty();
90     mLocked.disposedSurfaces.push(surfaceControl);
91     if (wasEmpty) {
92         mLooper->sendMessage(mHandler, Message(MSG_DISPOSE_SURFACES));
93     }
94 }
95 
handleMessage(const Message & message)96 void SpriteController::handleMessage(const Message& message) {
97     switch (message.what) {
98     case MSG_UPDATE_SPRITES:
99         doUpdateSprites();
100         break;
101     case MSG_DISPOSE_SURFACES:
102         doDisposeSurfaces();
103         break;
104     }
105 }
106 
doUpdateSprites()107 void SpriteController::doUpdateSprites() {
108     // Collect information about sprite updates.
109     // Each sprite update record includes a reference to its associated sprite so we can
110     // be certain the sprites will not be deleted while this function runs.  Sprites
111     // may invalidate themselves again during this time but we will handle those changes
112     // in the next iteration.
113     Vector<SpriteUpdate> updates;
114     size_t numSprites;
115     { // acquire lock
116         AutoMutex _l(mLock);
117 
118         numSprites = mLocked.invalidatedSprites.size();
119         for (size_t i = 0; i < numSprites; i++) {
120             const sp<SpriteImpl>& sprite = mLocked.invalidatedSprites.itemAt(i);
121 
122             updates.push(SpriteUpdate(sprite, sprite->getStateLocked()));
123             sprite->resetDirtyLocked();
124         }
125         mLocked.invalidatedSprites.clear();
126     } // release lock
127 
128     // Create missing surfaces.
129     bool surfaceChanged = false;
130     for (size_t i = 0; i < numSprites; i++) {
131         SpriteUpdate& update = updates.editItemAt(i);
132 
133         if (update.state.surfaceControl == NULL && update.state.wantSurfaceVisible()) {
134             update.state.surfaceWidth = update.state.icon.bitmap.width();
135             update.state.surfaceHeight = update.state.icon.bitmap.height();
136             update.state.surfaceDrawn = false;
137             update.state.surfaceVisible = false;
138             update.state.surfaceControl = obtainSurface(
139                     update.state.surfaceWidth, update.state.surfaceHeight);
140             if (update.state.surfaceControl != NULL) {
141                 update.surfaceChanged = surfaceChanged = true;
142             }
143         }
144     }
145 
146     // Resize sprites if needed, inside a global transaction.
147     bool haveGlobalTransaction = false;
148     for (size_t i = 0; i < numSprites; i++) {
149         SpriteUpdate& update = updates.editItemAt(i);
150 
151         if (update.state.surfaceControl != NULL && update.state.wantSurfaceVisible()) {
152             int32_t desiredWidth = update.state.icon.bitmap.width();
153             int32_t desiredHeight = update.state.icon.bitmap.height();
154             if (update.state.surfaceWidth < desiredWidth
155                     || update.state.surfaceHeight < desiredHeight) {
156                 if (!haveGlobalTransaction) {
157                     SurfaceComposerClient::openGlobalTransaction();
158                     haveGlobalTransaction = true;
159                 }
160 
161                 status_t status = update.state.surfaceControl->setSize(desiredWidth, desiredHeight);
162                 if (status) {
163                     LOGE("Error %d resizing sprite surface from %dx%d to %dx%d",
164                             status, update.state.surfaceWidth, update.state.surfaceHeight,
165                             desiredWidth, desiredHeight);
166                 } else {
167                     update.state.surfaceWidth = desiredWidth;
168                     update.state.surfaceHeight = desiredHeight;
169                     update.state.surfaceDrawn = false;
170                     update.surfaceChanged = surfaceChanged = true;
171 
172                     if (update.state.surfaceVisible) {
173                         status = update.state.surfaceControl->hide();
174                         if (status) {
175                             LOGE("Error %d hiding sprite surface after resize.", status);
176                         } else {
177                             update.state.surfaceVisible = false;
178                         }
179                     }
180                 }
181             }
182         }
183     }
184     if (haveGlobalTransaction) {
185         SurfaceComposerClient::closeGlobalTransaction();
186     }
187 
188     // Redraw sprites if needed.
189     for (size_t i = 0; i < numSprites; i++) {
190         SpriteUpdate& update = updates.editItemAt(i);
191 
192         if ((update.state.dirty & DIRTY_BITMAP) && update.state.surfaceDrawn) {
193             update.state.surfaceDrawn = false;
194             update.surfaceChanged = surfaceChanged = true;
195         }
196 
197         if (update.state.surfaceControl != NULL && !update.state.surfaceDrawn
198                 && update.state.wantSurfaceVisible()) {
199             sp<Surface> surface = update.state.surfaceControl->getSurface();
200             Surface::SurfaceInfo surfaceInfo;
201             status_t status = surface->lock(&surfaceInfo);
202             if (status) {
203                 LOGE("Error %d locking sprite surface before drawing.", status);
204             } else {
205                 SkBitmap surfaceBitmap;
206                 ssize_t bpr = surfaceInfo.s * bytesPerPixel(surfaceInfo.format);
207                 surfaceBitmap.setConfig(SkBitmap::kARGB_8888_Config,
208                         surfaceInfo.w, surfaceInfo.h, bpr);
209                 surfaceBitmap.setPixels(surfaceInfo.bits);
210 
211                 SkCanvas surfaceCanvas;
212                 surfaceCanvas.setBitmapDevice(surfaceBitmap);
213 
214                 SkPaint paint;
215                 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
216                 surfaceCanvas.drawBitmap(update.state.icon.bitmap, 0, 0, &paint);
217 
218                 if (surfaceInfo.w > uint32_t(update.state.icon.bitmap.width())) {
219                     paint.setColor(0); // transparent fill color
220                     surfaceCanvas.drawRectCoords(update.state.icon.bitmap.width(), 0,
221                             surfaceInfo.w, update.state.icon.bitmap.height(), paint);
222                 }
223                 if (surfaceInfo.h > uint32_t(update.state.icon.bitmap.height())) {
224                     paint.setColor(0); // transparent fill color
225                     surfaceCanvas.drawRectCoords(0, update.state.icon.bitmap.height(),
226                             surfaceInfo.w, surfaceInfo.h, paint);
227                 }
228 
229                 status = surface->unlockAndPost();
230                 if (status) {
231                     LOGE("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                     LOGE("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                     LOGE("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                     LOGE("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                     LOGE("Error %d setting sprite surface layer.", status);
297                 }
298             }
299 
300             if (becomingVisible) {
301                 status = update.state.surfaceControl->show(surfaceLayer);
302                 if (status) {
303                     LOGE("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                     LOGE("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 
doDisposeSurfaces()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 
ensureSurfaceComposerClient()362 void SpriteController::ensureSurfaceComposerClient() {
363     if (mSurfaceComposerClient == NULL) {
364         mSurfaceComposerClient = new SurfaceComposerClient();
365     }
366 }
367 
obtainSurface(int32_t width,int32_t height)368 sp<SurfaceControl> SpriteController::obtainSurface(int32_t width, int32_t height) {
369     ensureSurfaceComposerClient();
370 
371     sp<SurfaceControl> surfaceControl = mSurfaceComposerClient->createSurface(
372             String8("Sprite"), 0, width, height, PIXEL_FORMAT_RGBA_8888);
373     if (surfaceControl == NULL || !surfaceControl->isValid()
374             || !surfaceControl->getSurface()->isValid()) {
375         LOGE("Error creating sprite surface.");
376         return NULL;
377     }
378     return surfaceControl;
379 }
380 
381 
382 // --- SpriteController::SpriteImpl ---
383 
SpriteImpl(const sp<SpriteController> controller)384 SpriteController::SpriteImpl::SpriteImpl(const sp<SpriteController> controller) :
385         mController(controller) {
386 }
387 
~SpriteImpl()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 
setIcon(const SpriteIcon & icon)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, SkBitmap::kARGB_8888_Config);
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 
setVisible(bool visible)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 
setPosition(float x,float y)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 
setLayer(int32_t layer)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 
setAlpha(float alpha)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 
setTransformationMatrix(const SpriteTransformationMatrix & matrix)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 
invalidateLocked(uint32_t dirty)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
482