private static final String IMAGE_CACHE_FILE = "imgcache";
private static final int IMAGE_CACHE_MAX_ENTRIES = 5000;
private static final int IMAGE_CACHE_MAX_BYTES = 200 * 1024 * 1024;
- private static final int IMAGE_CACHE_VERSION = 6;
+ private static final int IMAGE_CACHE_VERSION = 7;
private BlobCache mCache;
private final ThreadPool mThreadPool;
private final AlbumLabelMaker mLabelMaker;
private final String mLoadingText;
- private final TextureUploader mTextureUploader;
+
+ private final TiledTexture.Uploader mContentUploader;
+ private final TextureUploader mLabelUploader;
private int mActiveRequestCount = 0;
private boolean mIsActive = false;
public MediaItem coverItem;
public Texture content;
public BitmapTexture labelTexture;
- public BitmapTexture bitmapTexture;
+ public TiledTexture bitmapTexture;
public Path setPath;
public String title;
public int totalCount;
mLabelMaker = new AlbumLabelMaker(activity.getAndroidContext(), labelSpec);
mLoadingText = activity.getAndroidContext().getString(R.string.loading);
- mTextureUploader = new TextureUploader(activity.getGLRoot());
+ mContentUploader = new TiledTexture.Uploader(activity.getGLRoot());
+ mLabelUploader = new TextureUploader(activity.getGLRoot());
mHandler = new SynchronizedHandler(activity.getGLRoot()) {
@Override
if (index < mContentStart || index >= mContentEnd) return;
AlbumSetEntry entry = mData[index % mData.length];
if (entry.bitmapTexture != null) {
- mTextureUploader.addBgTexture(entry.bitmapTexture);
+ mContentUploader.addTexture(entry.bitmapTexture);
}
if (entry.labelTexture != null) {
- mTextureUploader.addBgTexture(entry.labelTexture);
+ mLabelUploader.addBgTexture(entry.labelTexture);
}
}
private void updateTextureUploadQueue() {
if (!mIsActive) return;
- mTextureUploader.clear();
+ mContentUploader.clear();
+ mLabelUploader.clear();
// Upload foreground texture
for (int i = mActiveStart, n = mActiveEnd; i < n; ++i) {
AlbumSetEntry entry = mData[i % mData.length];
if (entry.bitmapTexture != null) {
- mTextureUploader.addFgTexture(entry.bitmapTexture);
+ mContentUploader.addTexture(entry.bitmapTexture);
}
if (entry.labelTexture != null) {
- mTextureUploader.addFgTexture(entry.labelTexture);
+ mLabelUploader.addFgTexture(entry.labelTexture);
}
}
public void pause() {
mIsActive = false;
- mTextureUploader.clear();
+ mLabelUploader.clear();
+ mContentUploader.clear();
+ TiledTexture.freeResources();
for (int i = mContentStart, n = mContentEnd; i < n; ++i) {
freeSlotContent(i);
}
public void resume() {
mIsActive = true;
+ TiledTexture.prepareResources();
for (int i = mContentStart, n = mContentEnd; i < n; ++i) {
prepareSlotContent(i);
}
if (bitmap == null) return; // error or recycled
AlbumSetEntry entry = mData[mSlotIndex % mData.length];
- BitmapTexture texture = new BitmapTexture(bitmap);
+ TiledTexture texture = new TiledTexture(bitmap);
entry.bitmapTexture = texture;
entry.content = texture;
if (isActiveSlot(mSlotIndex)) {
- mTextureUploader.addFgTexture(texture);
+ mContentUploader.addTexture(texture);
--mActiveRequestCount;
if (mActiveRequestCount == 0) requestNonactiveImages();
if (mListener != null) mListener.onContentChanged();
} else {
- mTextureUploader.addBgTexture(texture);
+ mContentUploader.addTexture(texture);
}
}
}
entry.labelTexture = texture;
if (isActiveSlot(mSlotIndex)) {
- mTextureUploader.addFgTexture(texture);
+ mLabelUploader.addFgTexture(texture);
--mActiveRequestCount;
if (mActiveRequestCount == 0) requestNonactiveImages();
if (mListener != null) mListener.onContentChanged();
} else {
- mTextureUploader.addBgTexture(texture);
+ mLabelUploader.addBgTexture(texture);
}
}
}
}
}
- private static Texture checkTexture(Texture texture) {
+ private static Texture checkLabelTexture(Texture texture) {
return ((texture instanceof UploadedTexture)
&& ((UploadedTexture) texture).isUploading())
? null
: texture;
}
+ private static Texture checkContentTexture(Texture texture) {
+ return ((texture instanceof TiledTexture)
+ && !((TiledTexture) texture).isReady())
+ ? null
+ : texture;
+ }
+
@Override
public int renderSlot(GLCanvas canvas, int index, int pass, int width, int height) {
AlbumSetEntry entry = mDataWindow.get(index);
GLCanvas canvas, AlbumSetEntry entry, int width, int height) {
int renderRequestFlags = 0;
- Texture content = checkTexture(entry.content);
+ Texture content = checkContentTexture(entry.content);
if (content == null) {
content = mWaitLoadingTexture;
entry.isWaitLoadingDisplayed = true;
protected int renderLabel(
GLCanvas canvas, AlbumSetEntry entry, int width, int height) {
- Texture content = checkTexture(entry.labelTexture);
+ Texture content = checkLabelTexture(entry.labelTexture);
if (content == null) {
content = mWaitLoadingTexture;
}
public int rotation;
public int mediaType;
public boolean isWaitDisplayed;
- public BitmapTexture bitmapTexture;
+ public TiledTexture bitmapTexture;
public Texture content;
private BitmapLoader contentLoader;
private PanoSupportListener mPanoSupportListener;
private final AlbumEntry mData[];
private final SynchronizedHandler mHandler;
private final JobLimiter mThreadPool;
- private final TextureUploader mTextureUploader;
+ private final TiledTexture.Uploader mTileUploader;
private int mSize;
};
mThreadPool = new JobLimiter(activity.getThreadPool(), JOB_LIMIT);
- mTextureUploader = new TextureUploader(activity.getGLRoot());
+ mTileUploader = new TiledTexture.Uploader(activity.getGLRoot());
}
public void setListener(Listener listener) {
if (index < mContentEnd && index >= mContentStart) {
AlbumEntry entry = mData[index % mData.length];
if (entry.bitmapTexture != null) {
- mTextureUploader.addBgTexture(entry.bitmapTexture);
+ mTileUploader.addTexture(entry.bitmapTexture);
}
}
}
private void updateTextureUploadQueue() {
if (!mIsActive) return;
- mTextureUploader.clear();
+ mTileUploader.clear();
// add foreground textures
for (int i = mActiveStart, n = mActiveEnd; i < n; ++i) {
AlbumEntry entry = mData[i % mData.length];
if (entry.bitmapTexture != null) {
- mTextureUploader.addFgTexture(entry.bitmapTexture);
+ mTileUploader.addTexture(entry.bitmapTexture);
}
}
public void updateEntry() {
Bitmap bitmap = getBitmap();
if (bitmap == null) return; // error or recycled
-
AlbumEntry entry = mData[mSlotIndex % mData.length];
- entry.bitmapTexture = new BitmapTexture(bitmap);
+ entry.bitmapTexture = new TiledTexture(bitmap);
entry.content = entry.bitmapTexture;
if (isActiveSlot(mSlotIndex)) {
- mTextureUploader.addFgTexture(entry.bitmapTexture);
+ mTileUploader.addTexture(entry.bitmapTexture);
--mActiveRequestCount;
if (mActiveRequestCount == 0) requestNonactiveImages();
if (mListener != null) mListener.onContentChanged();
} else {
- mTextureUploader.addBgTexture(entry.bitmapTexture);
+ mTileUploader.addTexture(entry.bitmapTexture);
}
}
}
public void resume() {
mIsActive = true;
+ TiledTexture.prepareResources();
for (int i = mContentStart, n = mContentEnd; i < n; ++i) {
prepareSlotContent(i);
}
public void pause() {
mIsActive = false;
- mTextureUploader.clear();
+ mTileUploader.clear();
+ TiledTexture.freeResources();
for (int i = mContentStart, n = mContentEnd; i < n; ++i) {
freeSlotContent(i);
}
}
private static Texture checkTexture(Texture texture) {
- return (texture instanceof UploadedTexture)
- && ((UploadedTexture) texture).isUploading()
+ return (texture instanceof TiledTexture)
+ && !((TiledTexture) texture).isReady()
? null
: texture;
}
private static final String TAG = "FadeInTexture";
private final int mColor;
+ private final TiledTexture mTexture;
- public FadeInTexture(int color, BasicTexture texture) {
- super(texture);
+ public FadeInTexture(int color, TiledTexture texture) {
+ super(texture.getWidth(), texture.getHeight(), texture.isOpaque());
mColor = color;
+ mTexture = texture;
}
@Override
public void draw(GLCanvas canvas, int x, int y, int w, int h) {
if (isAnimating()) {
- canvas.drawMixed(mTexture, mColor, getRatio(), x, y, w, h);
+ mTexture.drawMixed(canvas, mColor, getRatio(), x, y, w, h);
} else {
mTexture.draw(canvas, x, y, w, h);
}
@SuppressWarnings("unused")
private static final String TAG = "FadeOutTexture";
+ private final BasicTexture mTexture;
+
public FadeOutTexture(BasicTexture texture) {
- super(texture);
+ super(texture.getWidth(), texture.getHeight(), texture.isOpaque());
+ mTexture = texture;
}
@Override
// The duration of the fading animation in milliseconds
public static final int DURATION = 180;
- protected final BasicTexture mTexture;
private final long mStartTime;
private final int mWidth;
private final int mHeight;
private final boolean mIsOpaque;
private boolean mIsAnimating;
- public FadeTexture(BasicTexture texture) {
- mTexture = texture;
- mWidth = mTexture.getWidth();
- mHeight = mTexture.getHeight();
- mIsOpaque = mTexture.isOpaque();
+ public FadeTexture(int width, int height, boolean opaque) {
+ mWidth = width;
+ mHeight = height;
+ mIsOpaque = opaque;
mStartTime = now();
mIsAnimating = true;
}
// split into tiles. By doing so, we may increase the time required to
// upload the whole bitmap but we reduce the time of uploading each tile
// so it make the animation more smooth and prevents jank.
-public class TiledTexture {
+public class TiledTexture implements Texture {
private static final int CONTENT_SIZE = 254;
private static final int BORDER_SIZE = 1;
private static final int TILE_SIZE = CONTENT_SIZE + 2 * BORDER_SIZE;
private boolean uploadNextTile(GLCanvas canvas) {
if (mUploadIndex == mTiles.length) return true;
+
Tile next = mTiles[mUploadIndex++];
boolean hasBeenLoad = next.isLoaded();
next.updateContent(canvas);
}
// Draws the texture on to the specified rectangle.
+ @Override
public void draw(GLCanvas canvas, int x, int y, int width, int height) {
RectF src = mSrcRect;
RectF dest = mDestRect;
canvas.drawTexture(t, src, dest);
}
}
+
+ @Override
+ public int getWidth() {
+ return mWidth;
+ }
+
+ @Override
+ public int getHeight() {
+ return mHeight;
+ }
+
+ @Override
+ public void draw(GLCanvas canvas, int x, int y) {
+ draw(canvas, x, y, mWidth, mHeight);
+ }
+
+ @Override
+ public boolean isOpaque() {
+ return false;
+ }
}
}
private static void initializeThumbnailSizes(DisplayMetrics metrics, Resources r) {
- int maxDimensionPixels = Math.max(metrics.heightPixels, metrics.widthPixels);
- // Never need to completely fill the screen
- maxDimensionPixels = maxDimensionPixels / 2;
- MediaItem.setThumbnailSizes(maxDimensionPixels, 200);
- TiledScreenNail.setMaxSide(maxDimensionPixels);
+ int maxPixels = Math.max(metrics.heightPixels, metrics.widthPixels);
+
+ // For screen-nails, we never need to completely fill the screen
+ MediaItem.setThumbnailSizes(maxPixels / 2, maxPixels / 5);
+ TiledScreenNail.setMaxSide(maxPixels / 2);
}
public static boolean isHighResolution(Context context) {
OSDN Git Service
