summaryrefslogtreecommitdiffstats
path: root/src/com/android/photos/views/TiledImageRenderer.java
diff options
context:
space:
mode:
Diffstat (limited to 'src/com/android/photos/views/TiledImageRenderer.java')
-rw-r--r--src/com/android/photos/views/TiledImageRenderer.java825
1 files changed, 0 insertions, 825 deletions
diff --git a/src/com/android/photos/views/TiledImageRenderer.java b/src/com/android/photos/views/TiledImageRenderer.java
deleted file mode 100644
index c4e493b34..000000000
--- a/src/com/android/photos/views/TiledImageRenderer.java
+++ /dev/null
@@ -1,825 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.photos.views;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.Rect;
-import android.graphics.RectF;
-import android.support.v4.util.LongSparseArray;
-import android.util.DisplayMetrics;
-import android.util.Log;
-import android.util.Pools.Pool;
-import android.util.Pools.SynchronizedPool;
-import android.view.View;
-import android.view.WindowManager;
-
-import com.android.gallery3d.common.Utils;
-import com.android.gallery3d.glrenderer.BasicTexture;
-import com.android.gallery3d.glrenderer.GLCanvas;
-import com.android.gallery3d.glrenderer.UploadedTexture;
-
-/**
- * Handles laying out, decoding, and drawing of tiles in GL
- */
-public class TiledImageRenderer {
- public static final int SIZE_UNKNOWN = -1;
-
- private static final String TAG = "TiledImageRenderer";
- private static final int UPLOAD_LIMIT = 1;
-
- /*
- * This is the tile state in the CPU side.
- * Life of a Tile:
- * ACTIVATED (initial state)
- * --> IN_QUEUE - by queueForDecode()
- * --> RECYCLED - by recycleTile()
- * IN_QUEUE --> DECODING - by decodeTile()
- * --> RECYCLED - by recycleTile)
- * DECODING --> RECYCLING - by recycleTile()
- * --> DECODED - by decodeTile()
- * --> DECODE_FAIL - by decodeTile()
- * RECYCLING --> RECYCLED - by decodeTile()
- * DECODED --> ACTIVATED - (after the decoded bitmap is uploaded)
- * DECODED --> RECYCLED - by recycleTile()
- * DECODE_FAIL -> RECYCLED - by recycleTile()
- * RECYCLED --> ACTIVATED - by obtainTile()
- */
- private static final int STATE_ACTIVATED = 0x01;
- private static final int STATE_IN_QUEUE = 0x02;
- private static final int STATE_DECODING = 0x04;
- private static final int STATE_DECODED = 0x08;
- private static final int STATE_DECODE_FAIL = 0x10;
- private static final int STATE_RECYCLING = 0x20;
- private static final int STATE_RECYCLED = 0x40;
-
- private static Pool<Bitmap> sTilePool = new SynchronizedPool<Bitmap>(64);
-
- // TILE_SIZE must be 2^N
- private int mTileSize;
-
- private TileSource mModel;
- private BasicTexture mPreview;
- protected int mLevelCount; // cache the value of mScaledBitmaps.length
-
- // The mLevel variable indicates which level of bitmap we should use.
- // Level 0 means the original full-sized bitmap, and a larger value means
- // a smaller scaled bitmap (The width and height of each scaled bitmap is
- // half size of the previous one). If the value is in [0, mLevelCount), we
- // use the bitmap in mScaledBitmaps[mLevel] for display, otherwise the value
- // is mLevelCount
- private int mLevel = 0;
-
- private int mOffsetX;
- private int mOffsetY;
-
- private int mUploadQuota;
- private boolean mRenderComplete;
-
- private final RectF mSourceRect = new RectF();
- private final RectF mTargetRect = new RectF();
-
- private final LongSparseArray<Tile> mActiveTiles = new LongSparseArray<Tile>();
-
- // The following three queue are guarded by mQueueLock
- private final Object mQueueLock = new Object();
- private final TileQueue mRecycledQueue = new TileQueue();
- private final TileQueue mUploadQueue = new TileQueue();
- private final TileQueue mDecodeQueue = new TileQueue();
-
- // The width and height of the full-sized bitmap
- protected int mImageWidth = SIZE_UNKNOWN;
- protected int mImageHeight = SIZE_UNKNOWN;
-
- protected int mCenterX;
- protected int mCenterY;
- protected float mScale;
- protected int mRotation;
-
- private boolean mLayoutTiles;
-
- // Temp variables to avoid memory allocation
- private final Rect mTileRange = new Rect();
- private final Rect mActiveRange[] = {new Rect(), new Rect()};
-
- private TileDecoder mTileDecoder;
- private boolean mBackgroundTileUploaded;
-
- private int mViewWidth, mViewHeight;
- private View mParent;
-
- /**
- * Interface for providing tiles to a {@link TiledImageRenderer}
- */
- public static interface TileSource {
-
- /**
- * If the source does not care about the tile size, it should use
- * {@link TiledImageRenderer#suggestedTileSize(Context)}
- */
- public int getTileSize();
- public int getImageWidth();
- public int getImageHeight();
- public int getRotation();
-
- /**
- * Return a Preview image if available. This will be used as the base layer
- * if higher res tiles are not yet available
- */
- public BasicTexture getPreview();
-
- /**
- * The tile returned by this method can be specified this way: Assuming
- * the image size is (width, height), first take the intersection of (0,
- * 0) - (width, height) and (x, y) - (x + tileSize, y + tileSize). If
- * in extending the region, we found some part of the region is outside
- * the image, those pixels are filled with black.
- *
- * If level > 0, it does the same operation on a down-scaled version of
- * the original image (down-scaled by a factor of 2^level), but (x, y)
- * still refers to the coordinate on the original image.
- *
- * The method would be called by the decoder thread.
- */
- public Bitmap getTile(int level, int x, int y, Bitmap reuse);
- }
-
- public static int suggestedTileSize(Context context) {
- return isHighResolution(context) ? 512 : 256;
- }
-
- private static boolean isHighResolution(Context context) {
- DisplayMetrics metrics = new DisplayMetrics();
- WindowManager wm = (WindowManager)
- context.getSystemService(Context.WINDOW_SERVICE);
- wm.getDefaultDisplay().getMetrics(metrics);
- return metrics.heightPixels > 2048 || metrics.widthPixels > 2048;
- }
-
- public TiledImageRenderer(View parent) {
- mParent = parent;
- mTileDecoder = new TileDecoder();
- mTileDecoder.start();
- }
-
- public int getViewWidth() {
- return mViewWidth;
- }
-
- public int getViewHeight() {
- return mViewHeight;
- }
-
- private void invalidate() {
- mParent.postInvalidate();
- }
-
- public void setModel(TileSource model, int rotation) {
- if (mModel != model) {
- mModel = model;
- notifyModelInvalidated();
- }
- if (mRotation != rotation) {
- mRotation = rotation;
- mLayoutTiles = true;
- }
- }
-
- private void calculateLevelCount() {
- if (mPreview != null) {
- mLevelCount = Math.max(0, Utils.ceilLog2(
- mImageWidth / (float) mPreview.getWidth()));
- } else {
- int levels = 1;
- int maxDim = Math.max(mImageWidth, mImageHeight);
- int t = mTileSize;
- while (t < maxDim) {
- t <<= 1;
- levels++;
- }
- mLevelCount = levels;
- }
- }
-
- public void notifyModelInvalidated() {
- invalidateTiles();
- if (mModel == null) {
- mImageWidth = 0;
- mImageHeight = 0;
- mLevelCount = 0;
- mPreview = null;
- } else {
- mImageWidth = mModel.getImageWidth();
- mImageHeight = mModel.getImageHeight();
- mPreview = mModel.getPreview();
- mTileSize = mModel.getTileSize();
- calculateLevelCount();
- }
- mLayoutTiles = true;
- }
-
- public void setViewSize(int width, int height) {
- mViewWidth = width;
- mViewHeight = height;
- }
-
- public void setPosition(int centerX, int centerY, float scale) {
- if (mCenterX == centerX && mCenterY == centerY
- && mScale == scale) {
- return;
- }
- mCenterX = centerX;
- mCenterY = centerY;
- mScale = scale;
- mLayoutTiles = true;
- }
-
- // Prepare the tiles we want to use for display.
- //
- // 1. Decide the tile level we want to use for display.
- // 2. Decide the tile levels we want to keep as texture (in addition to
- // the one we use for display).
- // 3. Recycle unused tiles.
- // 4. Activate the tiles we want.
- private void layoutTiles() {
- if (mViewWidth == 0 || mViewHeight == 0 || !mLayoutTiles) {
- return;
- }
- mLayoutTiles = false;
-
- // The tile levels we want to keep as texture is in the range
- // [fromLevel, endLevel).
- int fromLevel;
- int endLevel;
-
- // We want to use a texture larger than or equal to the display size.
- mLevel = Utils.clamp(Utils.floorLog2(1f / mScale), 0, mLevelCount);
-
- // We want to keep one more tile level as texture in addition to what
- // we use for display. So it can be faster when the scale moves to the
- // next level. We choose the level closest to the current scale.
- if (mLevel != mLevelCount) {
- Rect range = mTileRange;
- getRange(range, mCenterX, mCenterY, mLevel, mScale, mRotation);
- mOffsetX = Math.round(mViewWidth / 2f + (range.left - mCenterX) * mScale);
- mOffsetY = Math.round(mViewHeight / 2f + (range.top - mCenterY) * mScale);
- fromLevel = mScale * (1 << mLevel) > 0.75f ? mLevel - 1 : mLevel;
- } else {
- // Activate the tiles of the smallest two levels.
- fromLevel = mLevel - 2;
- mOffsetX = Math.round(mViewWidth / 2f - mCenterX * mScale);
- mOffsetY = Math.round(mViewHeight / 2f - mCenterY * mScale);
- }
-
- fromLevel = Math.max(0, Math.min(fromLevel, mLevelCount - 2));
- endLevel = Math.min(fromLevel + 2, mLevelCount);
-
- Rect range[] = mActiveRange;
- for (int i = fromLevel; i < endLevel; ++i) {
- getRange(range[i - fromLevel], mCenterX, mCenterY, i, mRotation);
- }
-
- // If rotation is transient, don't update the tile.
- if (mRotation % 90 != 0) {
- return;
- }
-
- synchronized (mQueueLock) {
- mDecodeQueue.clean();
- mUploadQueue.clean();
- mBackgroundTileUploaded = false;
-
- // Recycle unused tiles: if the level of the active tile is outside the
- // range [fromLevel, endLevel) or not in the visible range.
- int n = mActiveTiles.size();
- for (int i = 0; i < n; i++) {
- Tile tile = mActiveTiles.valueAt(i);
- int level = tile.mTileLevel;
- if (level < fromLevel || level >= endLevel
- || !range[level - fromLevel].contains(tile.mX, tile.mY)) {
- mActiveTiles.removeAt(i);
- i--;
- n--;
- recycleTile(tile);
- }
- }
- }
-
- for (int i = fromLevel; i < endLevel; ++i) {
- int size = mTileSize << i;
- Rect r = range[i - fromLevel];
- for (int y = r.top, bottom = r.bottom; y < bottom; y += size) {
- for (int x = r.left, right = r.right; x < right; x += size) {
- activateTile(x, y, i);
- }
- }
- }
- invalidate();
- }
-
- private void invalidateTiles() {
- synchronized (mQueueLock) {
- mDecodeQueue.clean();
- mUploadQueue.clean();
-
- // TODO(xx): disable decoder
- int n = mActiveTiles.size();
- for (int i = 0; i < n; i++) {
- Tile tile = mActiveTiles.valueAt(i);
- recycleTile(tile);
- }
- mActiveTiles.clear();
- }
- }
-
- private void getRange(Rect out, int cX, int cY, int level, int rotation) {
- getRange(out, cX, cY, level, 1f / (1 << (level + 1)), rotation);
- }
-
- // If the bitmap is scaled by the given factor "scale", return the
- // rectangle containing visible range. The left-top coordinate returned is
- // aligned to the tile boundary.
- //
- // (cX, cY) is the point on the original bitmap which will be put in the
- // center of the ImageViewer.
- private void getRange(Rect out,
- int cX, int cY, int level, float scale, int rotation) {
-
- double radians = Math.toRadians(-rotation);
- double w = mViewWidth;
- double h = mViewHeight;
-
- double cos = Math.cos(radians);
- double sin = Math.sin(radians);
- int width = (int) Math.ceil(Math.max(
- Math.abs(cos * w - sin * h), Math.abs(cos * w + sin * h)));
- int height = (int) Math.ceil(Math.max(
- Math.abs(sin * w + cos * h), Math.abs(sin * w - cos * h)));
-
- int left = (int) Math.floor(cX - width / (2f * scale));
- int top = (int) Math.floor(cY - height / (2f * scale));
- int right = (int) Math.ceil(left + width / scale);
- int bottom = (int) Math.ceil(top + height / scale);
-
- // align the rectangle to tile boundary
- int size = mTileSize << level;
- left = Math.max(0, size * (left / size));
- top = Math.max(0, size * (top / size));
- right = Math.min(mImageWidth, right);
- bottom = Math.min(mImageHeight, bottom);
-
- out.set(left, top, right, bottom);
- }
-
- public void freeTextures() {
- mLayoutTiles = true;
-
- mTileDecoder.finishAndWait();
- synchronized (mQueueLock) {
- mUploadQueue.clean();
- mDecodeQueue.clean();
- Tile tile = mRecycledQueue.pop();
- while (tile != null) {
- tile.recycle();
- tile = mRecycledQueue.pop();
- }
- }
-
- int n = mActiveTiles.size();
- for (int i = 0; i < n; i++) {
- Tile texture = mActiveTiles.valueAt(i);
- texture.recycle();
- }
- mActiveTiles.clear();
- mTileRange.set(0, 0, 0, 0);
-
- while (sTilePool.acquire() != null) {}
- }
-
- public boolean draw(GLCanvas canvas) {
- layoutTiles();
- uploadTiles(canvas);
-
- mUploadQuota = UPLOAD_LIMIT;
- mRenderComplete = true;
-
- int level = mLevel;
- int rotation = mRotation;
- int flags = 0;
- if (rotation != 0) {
- flags |= GLCanvas.SAVE_FLAG_MATRIX;
- }
-
- if (flags != 0) {
- canvas.save(flags);
- if (rotation != 0) {
- int centerX = mViewWidth / 2, centerY = mViewHeight / 2;
- canvas.translate(centerX, centerY);
- canvas.rotate(rotation, 0, 0, 1);
- canvas.translate(-centerX, -centerY);
- }
- }
- try {
- if (level != mLevelCount) {
- int size = (mTileSize << level);
- float length = size * mScale;
- Rect r = mTileRange;
-
- for (int ty = r.top, i = 0; ty < r.bottom; ty += size, i++) {
- float y = mOffsetY + i * length;
- for (int tx = r.left, j = 0; tx < r.right; tx += size, j++) {
- float x = mOffsetX + j * length;
- drawTile(canvas, tx, ty, level, x, y, length);
- }
- }
- } else if (mPreview != null) {
- mPreview.draw(canvas, mOffsetX, mOffsetY,
- Math.round(mImageWidth * mScale),
- Math.round(mImageHeight * mScale));
- }
- } finally {
- if (flags != 0) {
- canvas.restore();
- }
- }
-
- if (mRenderComplete) {
- if (!mBackgroundTileUploaded) {
- uploadBackgroundTiles(canvas);
- }
- } else {
- invalidate();
- }
- return mRenderComplete || mPreview != null;
- }
-
- private void uploadBackgroundTiles(GLCanvas canvas) {
- mBackgroundTileUploaded = true;
- int n = mActiveTiles.size();
- for (int i = 0; i < n; i++) {
- Tile tile = mActiveTiles.valueAt(i);
- if (!tile.isContentValid()) {
- queueForDecode(tile);
- }
- }
- }
-
- private void queueForDecode(Tile tile) {
- synchronized (mQueueLock) {
- if (tile.mTileState == STATE_ACTIVATED) {
- tile.mTileState = STATE_IN_QUEUE;
- if (mDecodeQueue.push(tile)) {
- mQueueLock.notifyAll();
- }
- }
- }
- }
-
- private void decodeTile(Tile tile) {
- synchronized (mQueueLock) {
- if (tile.mTileState != STATE_IN_QUEUE) {
- return;
- }
- tile.mTileState = STATE_DECODING;
- }
- boolean decodeComplete = tile.decode();
- synchronized (mQueueLock) {
- if (tile.mTileState == STATE_RECYCLING) {
- tile.mTileState = STATE_RECYCLED;
- if (tile.mDecodedTile != null) {
- sTilePool.release(tile.mDecodedTile);
- tile.mDecodedTile = null;
- }
- mRecycledQueue.push(tile);
- return;
- }
- tile.mTileState = decodeComplete ? STATE_DECODED : STATE_DECODE_FAIL;
- if (!decodeComplete) {
- return;
- }
- mUploadQueue.push(tile);
- }
- invalidate();
- }
-
- private Tile obtainTile(int x, int y, int level) {
- synchronized (mQueueLock) {
- Tile tile = mRecycledQueue.pop();
- if (tile != null) {
- tile.mTileState = STATE_ACTIVATED;
- tile.update(x, y, level);
- return tile;
- }
- return new Tile(x, y, level);
- }
- }
-
- private void recycleTile(Tile tile) {
- synchronized (mQueueLock) {
- if (tile.mTileState == STATE_DECODING) {
- tile.mTileState = STATE_RECYCLING;
- return;
- }
- tile.mTileState = STATE_RECYCLED;
- if (tile.mDecodedTile != null) {
- sTilePool.release(tile.mDecodedTile);
- tile.mDecodedTile = null;
- }
- mRecycledQueue.push(tile);
- }
- }
-
- private void activateTile(int x, int y, int level) {
- long key = makeTileKey(x, y, level);
- Tile tile = mActiveTiles.get(key);
- if (tile != null) {
- if (tile.mTileState == STATE_IN_QUEUE) {
- tile.mTileState = STATE_ACTIVATED;
- }
- return;
- }
- tile = obtainTile(x, y, level);
- mActiveTiles.put(key, tile);
- }
-
- private Tile getTile(int x, int y, int level) {
- return mActiveTiles.get(makeTileKey(x, y, level));
- }
-
- private static long makeTileKey(int x, int y, int level) {
- long result = x;
- result = (result << 16) | y;
- result = (result << 16) | level;
- return result;
- }
-
- private void uploadTiles(GLCanvas canvas) {
- int quota = UPLOAD_LIMIT;
- Tile tile = null;
- while (quota > 0) {
- synchronized (mQueueLock) {
- tile = mUploadQueue.pop();
- }
- if (tile == null) {
- break;
- }
- if (!tile.isContentValid()) {
- if (tile.mTileState == STATE_DECODED) {
- tile.updateContent(canvas);
- --quota;
- } else {
- Log.w(TAG, "Tile in upload queue has invalid state: " + tile.mTileState);
- }
- }
- }
- if (tile != null) {
- invalidate();
- }
- }
-
- // Draw the tile to a square at canvas that locates at (x, y) and
- // has a side length of length.
- private void drawTile(GLCanvas canvas,
- int tx, int ty, int level, float x, float y, float length) {
- RectF source = mSourceRect;
- RectF target = mTargetRect;
- target.set(x, y, x + length, y + length);
- source.set(0, 0, mTileSize, mTileSize);
-
- Tile tile = getTile(tx, ty, level);
- if (tile != null) {
- if (!tile.isContentValid()) {
- if (tile.mTileState == STATE_DECODED) {
- if (mUploadQuota > 0) {
- --mUploadQuota;
- tile.updateContent(canvas);
- } else {
- mRenderComplete = false;
- }
- } else if (tile.mTileState != STATE_DECODE_FAIL){
- mRenderComplete = false;
- queueForDecode(tile);
- }
- }
- if (drawTile(tile, canvas, source, target)) {
- return;
- }
- }
- if (mPreview != null) {
- int size = mTileSize << level;
- float scaleX = (float) mPreview.getWidth() / mImageWidth;
- float scaleY = (float) mPreview.getHeight() / mImageHeight;
- source.set(tx * scaleX, ty * scaleY, (tx + size) * scaleX,
- (ty + size) * scaleY);
- canvas.drawTexture(mPreview, source, target);
- }
- }
-
- private boolean drawTile(
- Tile tile, GLCanvas canvas, RectF source, RectF target) {
- while (true) {
- if (tile.isContentValid()) {
- canvas.drawTexture(tile, source, target);
- return true;
- }
-
- // Parent can be divided to four quads and tile is one of the four.
- Tile parent = tile.getParentTile();
- if (parent == null) {
- return false;
- }
- if (tile.mX == parent.mX) {
- source.left /= 2f;
- source.right /= 2f;
- } else {
- source.left = (mTileSize + source.left) / 2f;
- source.right = (mTileSize + source.right) / 2f;
- }
- if (tile.mY == parent.mY) {
- source.top /= 2f;
- source.bottom /= 2f;
- } else {
- source.top = (mTileSize + source.top) / 2f;
- source.bottom = (mTileSize + source.bottom) / 2f;
- }
- tile = parent;
- }
- }
-
- private class Tile extends UploadedTexture {
- public int mX;
- public int mY;
- public int mTileLevel;
- public Tile mNext;
- public Bitmap mDecodedTile;
- public volatile int mTileState = STATE_ACTIVATED;
-
- public Tile(int x, int y, int level) {
- mX = x;
- mY = y;
- mTileLevel = level;
- }
-
- @Override
- protected void onFreeBitmap(Bitmap bitmap) {
- sTilePool.release(bitmap);
- }
-
- boolean decode() {
- // Get a tile from the original image. The tile is down-scaled
- // by (1 << mTilelevel) from a region in the original image.
- try {
- Bitmap reuse = sTilePool.acquire();
- if (reuse != null && reuse.getWidth() != mTileSize) {
- reuse = null;
- }
- mDecodedTile = mModel.getTile(mTileLevel, mX, mY, reuse);
- } catch (Throwable t) {
- Log.w(TAG, "fail to decode tile", t);
- }
- return mDecodedTile != null;
- }
-
- @Override
- protected Bitmap onGetBitmap() {
- Utils.assertTrue(mTileState == STATE_DECODED);
-
- // We need to override the width and height, so that we won't
- // draw beyond the boundaries.
- int rightEdge = ((mImageWidth - mX) >> mTileLevel);
- int bottomEdge = ((mImageHeight - mY) >> mTileLevel);
- setSize(Math.min(mTileSize, rightEdge), Math.min(mTileSize, bottomEdge));
-
- Bitmap bitmap = mDecodedTile;
- mDecodedTile = null;
- mTileState = STATE_ACTIVATED;
- return bitmap;
- }
-
- // We override getTextureWidth() and getTextureHeight() here, so the
- // texture can be re-used for different tiles regardless of the actual
- // size of the tile (which may be small because it is a tile at the
- // boundary).
- @Override
- public int getTextureWidth() {
- return mTileSize;
- }
-
- @Override
- public int getTextureHeight() {
- return mTileSize;
- }
-
- public void update(int x, int y, int level) {
- mX = x;
- mY = y;
- mTileLevel = level;
- invalidateContent();
- }
-
- public Tile getParentTile() {
- if (mTileLevel + 1 == mLevelCount) {
- return null;
- }
- int size = mTileSize << (mTileLevel + 1);
- int x = size * (mX / size);
- int y = size * (mY / size);
- return getTile(x, y, mTileLevel + 1);
- }
-
- @Override
- public String toString() {
- return String.format("tile(%s, %s, %s / %s)",
- mX / mTileSize, mY / mTileSize, mLevel, mLevelCount);
- }
- }
-
- private static class TileQueue {
- private Tile mHead;
-
- public Tile pop() {
- Tile tile = mHead;
- if (tile != null) {
- mHead = tile.mNext;
- }
- return tile;
- }
-
- public boolean push(Tile tile) {
- if (contains(tile)) {
- Log.w(TAG, "Attempting to add a tile already in the queue!");
- return false;
- }
- boolean wasEmpty = mHead == null;
- tile.mNext = mHead;
- mHead = tile;
- return wasEmpty;
- }
-
- private boolean contains(Tile tile) {
- Tile other = mHead;
- while (other != null) {
- if (other == tile) {
- return true;
- }
- other = other.mNext;
- }
- return false;
- }
-
- public void clean() {
- mHead = null;
- }
- }
-
- private class TileDecoder extends Thread {
-
- public void finishAndWait() {
- interrupt();
- try {
- join();
- } catch (InterruptedException e) {
- Log.w(TAG, "Interrupted while waiting for TileDecoder thread to finish!");
- }
- }
-
- private Tile waitForTile() throws InterruptedException {
- synchronized (mQueueLock) {
- while (true) {
- Tile tile = mDecodeQueue.pop();
- if (tile != null) {
- return tile;
- }
- mQueueLock.wait();
- }
- }
- }
-
- @Override
- public void run() {
- try {
- while (!isInterrupted()) {
- Tile tile = waitForTile();
- decodeTile(tile);
- }
- } catch (InterruptedException ex) {
- // We were finished
- }
- }
-
- }
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-18 18:43:49 +0000