| /* |
| * 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.bitmap; |
| |
| import android.graphics.Bitmap; |
| |
| /** |
| * A simple bitmap wrapper. Currently supports reference counting and logical width/height |
| * (which may differ from a bitmap's reported width/height due to bitmap reuse). |
| */ |
| public class ReusableBitmap implements Poolable { |
| |
| public final Bitmap bmp; |
| private int mWidth; |
| private int mHeight; |
| private int mOrientation; |
| |
| private int mRefCount = 0; |
| private final boolean mReusable; |
| |
| public ReusableBitmap(final Bitmap bitmap) { |
| this(bitmap, true /* reusable */); |
| } |
| |
| public ReusableBitmap(final Bitmap bitmap, final boolean reusable) { |
| bmp = bitmap; |
| mReusable = reusable; |
| } |
| |
| @Override |
| public boolean isEligibleForPooling() { |
| return mReusable; |
| } |
| |
| public void setLogicalWidth(int w) { |
| mWidth = w; |
| } |
| |
| public void setLogicalHeight(int h) { |
| mHeight = h; |
| } |
| |
| public int getLogicalWidth() { |
| return mWidth; |
| } |
| |
| public int getLogicalHeight() { |
| return mHeight; |
| } |
| |
| public int getOrientation() { |
| return mOrientation; |
| } |
| |
| public void setOrientation(final int orientation) { |
| mOrientation = orientation; |
| } |
| |
| public int getByteCount() { |
| return bmp.getByteCount(); |
| } |
| |
| @Override |
| public void acquireReference() { |
| mRefCount++; |
| } |
| |
| @Override |
| public void releaseReference() { |
| if (mRefCount == 0) { |
| throw new IllegalStateException(); |
| } |
| mRefCount--; |
| } |
| |
| @Override |
| public int getRefCount() { |
| return mRefCount; |
| } |
| |
| @Override |
| public String toString() { |
| final StringBuilder sb = new StringBuilder("["); |
| sb.append(super.toString()); |
| sb.append(" refCount="); |
| sb.append(mRefCount); |
| sb.append(" mReusable="); |
| sb.append(mReusable); |
| sb.append(" bmp="); |
| sb.append(bmp); |
| sb.append(" logicalW/H="); |
| sb.append(mWidth); |
| sb.append("/"); |
| sb.append(mHeight); |
| if (bmp != null) { |
| sb.append(" sz="); |
| sb.append(bmp.getByteCount() >> 10); |
| sb.append("KB"); |
| } |
| sb.append("]"); |
| return sb.toString(); |
| } |
| |
| /** |
| * Singleton class to represent a null Bitmap. We don't want to just use a regular |
| * ReusableBitmap with a null bmp field because that will render that ReusableBitmap useless |
| * and unable to be used by another decode process. |
| */ |
| public final static class NullReusableBitmap extends ReusableBitmap { |
| private static NullReusableBitmap sInstance; |
| |
| /** |
| * Get a singleton. |
| */ |
| public static NullReusableBitmap getInstance() { |
| if (sInstance == null) { |
| sInstance = new NullReusableBitmap(); |
| } |
| return sInstance; |
| } |
| |
| private NullReusableBitmap() { |
| super(null /* bmp */, false /* reusable */); |
| } |
| |
| @Override |
| public int getByteCount() { |
| return 0; |
| } |
| |
| @Override |
| public void releaseReference() { } |
| |
| @Override |
| public void acquireReference() { } |
| } |
| } |