SpriteController.cpp revision cc11f15f76a62ded3e403cb2bc818c6aa5bf261c 
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.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 > 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 > 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
348void 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
363void SpriteController::ensureSurfaceComposerClient() {
364    if (mSurfaceComposerClient == NULL) {
365        mSurfaceComposerClient = new SurfaceComposerClient();
366    }
367}
368
369sp<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
385SpriteController::SpriteImpl::SpriteImpl(const sp<SpriteController> controller) :
386        mController(controller) {
387}
388
389SpriteController::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
400void 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, kNative_8888_SkColorType);
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
426void 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
435void 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
445void 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
454void 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
463void 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
473void 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