osmdroid API解读（四）

osmdroid API解读（四）

osmdroid-android模块 org.osmdroid.tileprovider包（一）

1.MapTile

地图瓦片使用观察者模式分割，瓦片由tile provider下发。本类必须保持不变，因为其备用于缓存hash map的key

public class MapTile {

public static final int MAPTILE_SUCCESS_ID = 0;
public static final int MAPTILE_FAIL_ID = MAPTILE_SUCCESS_ID + 1;

private final int x;//瓦片的坐标位置x
private final int y;//瓦片的坐标位置y
private final int zoomLevel;//该瓦片缩放等级
private Date expires;//瓦片到期时间

public MapTile(final int zoomLevel, final int tileX, final int tileY) {
this.zoomLevel = zoomLevel;
this.x = tileX;
this.y = tileY;
}

public Date getExpires() {
return expires;
}

public void setExpires(Date expires) {
this.expires = expires;
}

public int getZoomLevel() {
return zoomLevel;
}

public int getX() {
return x;
}

public int getY() {
return y;
}

@Override
public String toString() {
return "/" + zoomLevel + "/" + x + "/" + y;
}

@Override
public boolean equals(final Object obj) {
if (obj == null)
return false;
if (obj == this)
return true;
if (!(obj instanceof MapTile))
return false;
final MapTile rhs = (MapTile) obj;
return zoomLevel == rhs.zoomLevel && x == rhs.x && y == rhs.y;
}

@Override
public int hashCode() {
int code = 17;
code *= 37 + zoomLevel;
code *= 37 + x;
code *= 37 + y;
return code;
}
}

1.1 LRUMapTileCache

瓦片集合缓存，继承自LinkedHashMap，以MapTile（用于定位图片位置）为key，Drawable为value。用于管理一系列的瓦片。

public class LRUMapTileCache extends LinkedHashMap<MapTile, Drawable> {

public interface TileRemovedListener {
void onTileRemoved(MapTile mapTile);
}

private static final long serialVersionUID = -541142277575493335L;

private int mCapacity;//瓦片容量
private TileRemovedListener mTileRemovedListener;//瓦片移除监听器

public LRUMapTileCache(final int aCapacity) {
super(aCapacity + 2, 0.1f, true);
mCapacity = aCapacity;
}

public void ensureCapacity(final int aCapacity) {
if (aCapacity > mCapacity) {
Log.i(IMapView.LOGTAG, "Tile cache increased from " + mCapacity + " to " + aCapacity);
mCapacity = aCapacity;
}
}

@Override//移除瓦片
public Drawable remove(final Object aKey) {
final Drawable drawable = super.remove(aKey);
// Only recycle if we are running on a project less than 2.3.3 Gingerbread.
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.GINGERBREAD) {
if (drawable instanceof BitmapDrawable) {
final Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();
if (bitmap != null) {
bitmap.recycle();
}
}
}
if (getTileRemovedListener() != null && aKey instanceof MapTile)
getTileRemovedListener().onTileRemoved((MapTile) aKey);
if (drawable instanceof ReusableBitmapDrawable)
BitmapPool.getInstance().returnDrawableToPool((ReusableBitmapDrawable) drawable);
return drawable;
}

@Override//清除所有瓦片
public void clear() {
// remove them all individually so that they get recycled
while (!isEmpty()) {
remove(keySet().iterator().next());
}

// and then clear
super.clear();
}

@Override
protected boolean removeEldestEntry(final java.util.Map.Entry<MapTile, Drawable> aEldest) {
if (size() > mCapacity) {
final MapTile eldest = aEldest.getKey();
if (Configuration.getInstance().isDebugMode()) {
Log.d(IMapView.LOGTAG,"LRU Remove old tile: " + eldest);
}
remove(eldest);
// don't return true because we've already removed it
}
return false;
}

public TileRemovedListener getTileRemovedListener() {
return mTileRemovedListener;
}

public void setTileRemovedListener(TileRemovedListener tileRemovedListener) {
mTileRemovedListener = tileRemovedListener;
}
}

1.2 MapTileCache

持有瓦片集合LRUMapTileCache，并有相应的瓦片操作方法

public class MapTileCache {

protected final Object mCachedTilesLockObject = new Object();
protected LRUMapTileCache mCachedTiles;//持有的瓦片集合

public MapTileCache() {
this(Configuration.getInstance().getCacheMapTileCount());
}

//最大缓存尺寸
public MapTileCache(final int aMaximumCacheSize) {
this.mCachedTiles = new LRUMapTileCache(aMaximumCacheSize);
}

public void ensureCapacity(final int aCapacity) {
synchronized (mCachedTilesLockObject) {
mCachedTiles.ensureCapacity(aCapacity);
}
}

public Drawable getMapTile(final MapTile aTile) {
synchronized (mCachedTilesLockObject) {
return this.mCachedTiles.get(aTile);
}
}

public void putTile(final MapTile aTile, final Drawable aDrawable) {
if (aDrawable != null) {
synchronized (mCachedTilesLockObject) {
this.mCachedTiles.put(aTile, aDrawable);
}
}
}

public boolean containsTile(final MapTile aTile) {
synchronized (mCachedTilesLockObject) {
return this.mCachedTiles.containsKey(aTile);
}
}

public void clear() {
synchronized (mCachedTilesLockObject) {
this.mCachedTiles.clear();
}
}
}

2.ExpirableBitmapDrawable

可过期图片，提供了不同的时间状态（更新状态 过期 缩放 没有发现 等状态）。

public class ExpirableBitmapDrawable extends BitmapDrawable {
//状态
public static final int UP_TO_DATE  = -1;
public static final int EXPIRED     = -2;
public static final int SCALED      = -3;
public static final int NOT_FOUND   = -4;
private static final int defaultStatus  = UP_TO_DATE;

private static final int[] settableStatuses = new int[] {EXPIRED, SCALED, NOT_FOUND};

private int[] mState;

public ExpirableBitmapDrawable(final Bitmap pBitmap) {
super(pBitmap);
mState = new int[0];
}

@Override
public int[] getState() {
return mState;
}

@Override
public boolean isStateful() {
return mState.length > 0;
}

@Override
public boolean setState(final int[] pStateSet) {
mState = pStateSet;
return true;
}

@Deprecated
public static boolean isDrawableExpired(final Drawable pTile) {
return getState(pTile) == EXPIRED;
}

public static int getState(final Drawable pTile) {
for(final int statusItem : pTile.getState()) {
for (final int statusReference : settableStatuses) {
if (statusItem == statusReference) {
return statusItem;
}
}
}
return defaultStatus;
}

/**
* @deprecated use {@link #setState(Drawable, int)} instead
*/
@Deprecated
public static void setDrawableExpired(final Drawable pTile) {
setState(pTile, EXPIRED);
}

public static void setState(final Drawable pTile, final int status) {
pTile.setState(new int[]{status});
}
}

2.1 ReusableBitmapDrawable

继承自ExpirableBitmapDrawable，保持对图片使用引用跟踪。具体看内部方法。

public class ReusableBitmapDrawable extends ExpirableBitmapDrawable {

private boolean mBitmapRecycled = false;
private int mUsageRefCount = 0;

public ReusableBitmapDrawable(Bitmap pBitmap) {
super(pBitmap);
}
//开始使用图片
public void beginUsingDrawable() {
synchronized (this) {
mUsageRefCount++;
}
}
//结束使用图片
public void finishUsingDrawable() {
synchronized (this) {
mUsageRefCount--;
if (mUsageRefCount < 0)
throw new IllegalStateException("Unbalanced endUsingDrawable() called.");
}
}
//回收
public Bitmap tryRecycle() {
synchronized (this) {
if (mUsageRefCount == 0) {
mBitmapRecycled = true;
return getBitmap();
}
}
return null;
}
//检测是否有效
public boolean isBitmapValid() {
synchronized (this) {
return !mBitmapRecycled;
}
}
}

2.2 BitmapPool

持有并管理所有的瓦片图片。

public class BitmapPool {
final LinkedList<Bitmap> mPool = new LinkedList<Bitmap>();

private static BitmapPool sInstance;

public static BitmapPool getInstance() {
if (sInstance == null)
sInstance = new BitmapPool();

return sInstance;
}

public void returnDrawableToPool(ReusableBitmapDrawable drawable) {
Bitmap b = drawable.tryRecycle();
if (b != null && b.isMutable())
synchronized (mPool) {
mPool.addLast(b);
}
}

public void applyReusableOptions(final BitmapFactory.Options aBitmapOptions) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
aBitmapOptions.inBitmap = obtainBitmapFromPool();
aBitmapOptions.inSampleSize = 1;
aBitmapOptions.inMutable = true;
}
}

public Bitmap obtainBitmapFromPool() {
synchronized (mPool) {
if (mPool.isEmpty()) {
return null;
} else {
final Bitmap bitmap = mPool.removeFirst();
if (bitmap.isRecycled()) {
return obtainBitmapFromPool(); // recurse
} else {
return bitmap;
}
}
}
}

public Bitmap obtainSizedBitmapFromPool(final int aWidth, final int aHeight) {
synchronized (mPool) {
if (mPool.isEmpty()) {
return null;
} else {
for (final Bitmap bitmap : mPool) {
if (bitmap.isRecycled()) {
mPool.remove(bitmap);
return obtainSizedBitmapFromPool(aWidth, aHeight); // recurse to prevent ConcurrentModificationException
} else if (bitmap.getWidth() == aWidth && bitmap.getHeight() == aHeight) {
mPool.remove(bitmap);
return bitmap;
}
}
}
}

return null;
}

public void clearBitmapPool() {
synchronized (sInstance.mPool) {
while (!sInstance.mPool.isEmpty()) {
Bitmap bitmap = sInstance.mPool.remove();
bitmap.recycle();
}
}
}
}