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