public RectCache(int capity) {
mCapity = capity;
mRectsCachePool = Pools.finitePool(manager, mCapity);
for (int i = 0; i < mCapity; i++) {
mRectsCachePool.release(new RectPoolableCache(new float[4]));
}
}
public class CacheManager implements ICacheManager {
@SuppressWarnings("unused")
private static final String TAG = "CacheManager";
public static final byte RESULT_SUCCESS = 0;
public static final byte RESULT_FAILED = 1;
public static final byte RESULT_FAILED_OVERSIZE = 2;
public HandlerThread mThread;
Danmakus mCaches = new Danmakus();
DrawingCachePoolManager mCachePoolManager = new DrawingCachePoolManager();
Pool<DrawingCache> mCachePool = Pools.finitePool(mCachePoolManager, 800);
private int mMaxSize;
private int mRealSize;
private int mScreenSize = 3;
private CacheHandler mHandler;
private boolean mEndFlag;
public CacheManager(int maxSize, int screenSize) {
mEndFlag = false;
mRealSize = 0;
mMaxSize = maxSize;
mScreenSize = screenSize;
}
public void seek(long mills) {
if (mHandler == null) return;
mHandler.requestCancelCaching();
mHandler.removeMessages(CacheHandler.BUILD_CACHES);
mHandler.obtainMessage(CacheHandler.SEEK, mills).sendToTarget();
}
@Override
public void addDanmaku(BaseDanmaku danmaku) {
if (mHandler != null) {
if (danmaku.isLive) {
if (danmaku.isTimeOut()) {
return;
}
mHandler.createCache(danmaku);
} else {
mHandler.obtainMessage(CacheHandler.ADD_DANMAKKU, danmaku).sendToTarget();
}
}
}
public void invalidateDanmaku(BaseDanmaku danmaku) {
if (mHandler != null && danmaku.hasDrawingCache()) {
mHandler.obtainMessage(CacheHandler.REBUILD_CACHE, danmaku).sendToTarget();
}
}
public void begin() {
if (mThread == null) {
mThread = new HandlerThread("DFM Cache-Building Thread");
mThread.start();
}
if (mHandler == null) mHandler = new CacheHandler(mThread.getLooper());
mHandler.begin();
}
public void end() {
mEndFlag = true;
synchronized (mDrawingNotify) {
mDrawingNotify.notifyAll();
}
if (mHandler != null) {
mHandler.pause();
mHandler = null;
}
if (mThread != null) {
try {
mThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
mThread.quit();
mThread = null;
}
}
public void resume() {
if (mHandler != null) {
mHandler.resume();
} else {
begin();
}
}
public float getPoolPercent() {
if (mMaxSize == 0) {
return 0;
}
return mRealSize / (float) mMaxSize;
}
public boolean isPoolFull() {
return mRealSize + 5120 >= mMaxSize;
}
private void evictAll() {
if (mCaches != null) {
IDanmakuIterator it = mCaches.iterator();
while (it.hasNext()) {
BaseDanmaku danmaku = it.next();
entryRemoved(true, danmaku, null);
}
mCaches.clear();
}
mRealSize = 0;
}
private void evictAllNotInScreen() {
evictAllNotInScreen(false);
}
private void evictAllNotInScreen(boolean removeAllReferences) {
if (mCaches != null) {
IDanmakuIterator it = mCaches.iterator();
while (it.hasNext()) {
BaseDanmaku danmaku = it.next();
IDrawingCache<?> cache = danmaku.cache;
boolean hasReferences = cache != null && cache.hasReferences();
if (removeAllReferences && hasReferences) {
if (cache.get() != null) {
mRealSize -= cache.size();
cache.destroy();
}
entryRemoved(true, danmaku, null);
it.remove();
continue;
}
if (danmaku.hasDrawingCache() == false || danmaku.isOutside()) {
entryRemoved(true, danmaku, null);
it.remove();
}
}
// mCaches.clear();
}
mRealSize = 0;
}
protected void entryRemoved(boolean evicted, BaseDanmaku oldValue, BaseDanmaku newValue) {
if (oldValue.cache != null) {
IDrawingCache<?> cache = oldValue.cache;
long releasedSize = clearCache(oldValue);
if (releasedSize <= 0) return;
mRealSize -= releasedSize;
mCachePool.release((DrawingCache) cache);
}
}
private long clearCache(BaseDanmaku oldValue) {
if (oldValue.cache.hasReferences()) {
oldValue.cache.decreaseReference();
oldValue.cache = null;
return 0;
}
long size = sizeOf(oldValue);
oldValue.cache.destroy();
oldValue.cache = null;
return size;
}
protected int sizeOf(BaseDanmaku value) {
if (value.cache != null && !value.cache.hasReferences()) {
return value.cache.size();
}
return 0;
}
private void clearCachePool() {
DrawingCache item;
while ((item = mCachePool.acquire()) != null) {
item.destroy();
}
}
private boolean push(BaseDanmaku item, int itemSize, boolean forcePush) {
int size = itemSize; // sizeOf(item);
while (mRealSize + size > mMaxSize && mCaches.size() > 0) {
BaseDanmaku oldValue = mCaches.first();
if (oldValue.isTimeOut()) {
entryRemoved(false, oldValue, item);
mCaches.removeItem(oldValue);
} else {
if (forcePush) {
break;
}
return false;
}
}
this.mCaches.addItem(item);
mRealSize += size;
// Log.e("CACHE", "realsize:"+mRealSize + ",size" + size);
return true;
}
private void clearTimeOutCaches() {
clearTimeOutCaches(mTimer.currMillisecond);
}
private void clearTimeOutCaches(long time) {
IDanmakuIterator it = mCaches.iterator();
while (it.hasNext() && !mEndFlag) {
BaseDanmaku val = it.next();
if (val.isTimeOut()) {
synchronized (mDrawingNotify) {
try {
mDrawingNotify.wait(30);
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
entryRemoved(false, val, null);
it.remove();
} else {
break;
}
}
}
private BaseDanmaku findReuseableCache(
BaseDanmaku refDanmaku, boolean strictMode, int maximumTimes) {
IDanmakuIterator it = mCaches.iterator();
int slopPixel = 0;
if (!strictMode) {
slopPixel = mDisp.getSlopPixel() * 2;
}
int count = 0;
while (it.hasNext() && count++ < maximumTimes) { // limit maximum times
BaseDanmaku danmaku = it.next();
if (!danmaku.hasDrawingCache()) {
continue;
}
if (danmaku.paintWidth == refDanmaku.paintWidth
&& danmaku.paintHeight == refDanmaku.paintHeight
&& danmaku.underlineColor == refDanmaku.underlineColor
&& danmaku.borderColor == refDanmaku.borderColor
&& danmaku.textColor == refDanmaku.textColor
&& danmaku.text.equals(refDanmaku.text)) {
return danmaku;
}
if (strictMode) {
continue;
}
if (!danmaku.isTimeOut()) {
break;
}
if (danmaku.cache.hasReferences()) {
continue;
}
float widthGap = danmaku.cache.width() - refDanmaku.paintWidth;
float heightGap = danmaku.cache.height() - refDanmaku.paintHeight;
if (widthGap >= 0 && widthGap <= slopPixel && heightGap >= 0 && heightGap <= slopPixel) {
return danmaku;
}
}
return null;
}
public class CacheHandler extends Handler {
private static final int PREPARE = 0x1;
public static final int ADD_DANMAKKU = 0x2;
public static final int BUILD_CACHES = 0x3;
public static final int CLEAR_TIMEOUT_CACHES = 0x4;
public static final int SEEK = 0x5;
public static final int QUIT = 0x6;
public static final int CLEAR_ALL_CACHES = 0x7;
public static final int CLEAR_OUTSIDE_CACHES = 0x8;
public static final int CLEAR_OUTSIDE_CACHES_AND_RESET = 0x9;
public static final int DISPATCH_ACTIONS = 0x10;
public static final int REBUILD_CACHE = 0x11;
private boolean mPause;
private boolean mSeekedFlag;
private boolean mCancelFlag;
public CacheHandler(android.os.Looper looper) {
super(looper);
}
public void requestCancelCaching() {
mCancelFlag = true;
}
@Override
public void handleMessage(Message msg) {
int what = msg.what;
switch (what) {
case PREPARE:
evictAllNotInScreen();
for (int i = 0; i < 300; i++) {
mCachePool.release(new DrawingCache());
}
case DISPATCH_ACTIONS:
// Log.e(TAG,"dispatch_actions:"+mCacheTimer.currMillisecond+":"+mTimer.currMillisecond);
long delayed = dispatchAction();
if (delayed <= 0) {
delayed = mContext.mDanmakuFactory.MAX_DANMAKU_DURATION / 2;
}
sendEmptyMessageDelayed(DISPATCH_ACTIONS, delayed);
break;
case BUILD_CACHES:
removeMessages(BUILD_CACHES);
boolean repositioned = ((mTaskListener != null && mReadyState == false) || mSeekedFlag);
prepareCaches(repositioned);
if (repositioned) mSeekedFlag = false;
if (mTaskListener != null && mReadyState == false) {
mTaskListener.ready();
mReadyState = true;
}
//
// Log.i(TAG,"BUILD_CACHES:"+mCacheTimer.currMillisecond+":"+mTimer.currMillisecond);
break;
case ADD_DANMAKKU:
BaseDanmaku item = (BaseDanmaku) msg.obj;
addDanmakuAndBuildCache(item);
break;
case REBUILD_CACHE:
BaseDanmaku cacheitem = (BaseDanmaku) msg.obj;
if (cacheitem.isLive) {
clearCache(cacheitem);
createCache(cacheitem);
} else {
entryRemoved(true, cacheitem, null);
addDanmakuAndBuildCache(cacheitem);
}
break;
case CLEAR_TIMEOUT_CACHES:
clearTimeOutCaches();
break;
case SEEK:
Long seekMills = (Long) msg.obj;
if (seekMills != null) {
mCacheTimer.update(seekMills.longValue());
mSeekedFlag = true;
evictAllNotInScreen();
resume();
}
break;
case QUIT:
removeCallbacksAndMessages(null);
mPause = true;
evictAll();
clearCachePool();
this.getLooper().quit();
break;
case CLEAR_ALL_CACHES:
evictAll();
mCacheTimer.update(
mTimer.currMillisecond - mContext.mDanmakuFactory.MAX_DANMAKU_DURATION);
mSeekedFlag = true;
break;
case CLEAR_OUTSIDE_CACHES:
evictAllNotInScreen(true);
mCacheTimer.update(mTimer.currMillisecond);
break;
case CLEAR_OUTSIDE_CACHES_AND_RESET:
evictAllNotInScreen(true);
mCacheTimer.update(mTimer.currMillisecond);
requestClear();
break;
}
}
private long dispatchAction() {
float level = getPoolPercent();
BaseDanmaku firstCache = mCaches.first();
// TODO 如果firstcache大于当前时间超过半屏并且水位在0.5f以下,
long gapTime = firstCache != null ? firstCache.time - mTimer.currMillisecond : 0;
long doubleScreenDuration = mContext.mDanmakuFactory.MAX_DANMAKU_DURATION * 2;
if (level < 0.6f && gapTime > mContext.mDanmakuFactory.MAX_DANMAKU_DURATION) {
mCacheTimer.update(mTimer.currMillisecond);
removeMessages(BUILD_CACHES);
sendEmptyMessage(BUILD_CACHES);
return 0;
} else if (level > 0.4f && gapTime < -doubleScreenDuration) {
// clear timeout caches
removeMessages(CLEAR_TIMEOUT_CACHES);
sendEmptyMessage(CLEAR_TIMEOUT_CACHES);
return 0;
}
if (level >= 0.9f) {
return 0;
}
// check cache time
long deltaTime = mCacheTimer.currMillisecond - mTimer.currMillisecond;
if (deltaTime < 0) {
mCacheTimer.update(mTimer.currMillisecond);
sendEmptyMessage(CLEAR_OUTSIDE_CACHES);
sendEmptyMessage(BUILD_CACHES);
return 0;
} else if (deltaTime > doubleScreenDuration) {
return 0;
}
removeMessages(BUILD_CACHES);
sendEmptyMessage(BUILD_CACHES);
return 0;
}
private void releaseDanmakuCache(BaseDanmaku item, DrawingCache cache) {
if (cache == null) {
cache = (DrawingCache) item.cache;
}
item.cache = null;
if (cache == null) {
return;
}
cache.destroy();
mCachePool.release(cache);
}
private long prepareCaches(boolean repositioned) {
long curr = mCacheTimer.currMillisecond;
long end = curr + mContext.mDanmakuFactory.MAX_DANMAKU_DURATION * mScreenSize;
if (end < mTimer.currMillisecond) {
return 0;
}
long startTime = SystemClock.uptimeMillis();
IDanmakus danmakus = null;
int tryCount = 0;
boolean hasException = false;
do {
try {
danmakus = danmakuList.subnew(curr, end);
} catch (Exception e) {
hasException = true;
SystemClock.sleep(10);
}
} while (++tryCount < 3 && danmakus == null && hasException);
if (danmakus == null) {
mCacheTimer.update(end);
return 0;
}
BaseDanmaku first = danmakus.first();
BaseDanmaku last = danmakus.last();
if (first == null || last == null) {
mCacheTimer.update(end);
return 0;
}
long deltaTime = first.time - mTimer.currMillisecond;
long sleepTime = 30 + 10 * deltaTime / mContext.mDanmakuFactory.MAX_DANMAKU_DURATION;
sleepTime = Math.min(100, sleepTime);
if (repositioned) {
sleepTime = 0;
}
IDanmakuIterator itr = danmakus.iterator();
BaseDanmaku item = null;
long consumingTime = 0;
int orderInScreen = 0;
int currScreenIndex = 0;
int sizeInScreen = danmakus.size();
// String message = "";
while (!mPause && !mCancelFlag) {
boolean hasNext = itr.hasNext();
if (!hasNext) {
// message = "break at not hasNext";
break;
}
item = itr.next();
if (last.time < mTimer.currMillisecond) {
// message = "break at last.time < mTimer.currMillisecond";
break;
}
if (item.hasDrawingCache()) {
continue;
}
if (repositioned == false && (item.isTimeOut() || !item.isOutside())) {
continue;
}
if (!item.hasPassedFilter()) {
mContext.mDanmakuFilters.filter(
item, orderInScreen, sizeInScreen, null, true, mContext);
}
// Log.e("prepareCache", currScreenIndex+","+orderInScreen+"," + item.time+"skip:"+skip);
if (item.priority == 0 && item.isFiltered()) {
continue;
}
if (item.getType() == BaseDanmaku.TYPE_SCROLL_RL) {
// 同屏弹幕密度只对滚动弹幕有效
int screenIndex =
(int) ((item.time - curr) / mContext.mDanmakuFactory.MAX_DANMAKU_DURATION);
if (currScreenIndex == screenIndex) orderInScreen++;
else {
orderInScreen = 0;
currScreenIndex = screenIndex;
}
}
if (!repositioned) {
try {
synchronized (mDrawingNotify) {
mDrawingNotify.wait(sleepTime);
}
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
// build cache
if (buildCache(item, false) == RESULT_FAILED) {
// message = "break at build failed";
break;
}
if (!repositioned) {
consumingTime = SystemClock.uptimeMillis() - startTime;
if (consumingTime >= DanmakuFactory.COMMON_DANMAKU_DURATION * mScreenSize) {
// message = "break at consumingTime out:" + consumingTime;
break;
}
}
}
consumingTime = SystemClock.uptimeMillis() - startTime;
if (item != null) {
mCacheTimer.update(item.time);
// Log.i("cache","stop at :"+item.time+","+count+",size:"+danmakus.size()+","+message);
} else {
mCacheTimer.update(end);
}
return consumingTime;
}
public boolean createCache(BaseDanmaku item) {
// measure
if (!item.isMeasured()) {
item.measure(mDisp);
}
DrawingCache cache = null;
try {
cache = mCachePool.acquire();
cache = DanmakuUtils.buildDanmakuDrawingCache(item, mDisp, cache);
item.cache = cache;
} catch (OutOfMemoryError e) {
// Log.e("cache", "break at error: oom");
if (cache != null) {
mCachePool.release(cache);
}
item.cache = null;
return false;
} catch (Exception e) {
// Log.e("cache", "break at exception:" + e.getMessage());
if (cache != null) {
mCachePool.release(cache);
}
item.cache = null;
return false;
}
return true;
}
private byte buildCache(BaseDanmaku item, boolean forceInsert) {
// measure
if (!item.isMeasured()) {
item.measure(mDisp);
}
DrawingCache cache = null;
try {
// try to find reuseable cache
BaseDanmaku danmaku = findReuseableCache(item, true, 20);
if (danmaku != null) {
cache = (DrawingCache) danmaku.cache;
}
if (cache != null) {
cache.increaseReference();
item.cache = cache;
// Log.w("cache", danmaku.text + "DrawingCache hit!!:" + item.paintWidth + "," +
// danmaku.paintWidth);
mCacheManager.push(item, 0, forceInsert);
return RESULT_SUCCESS;
}
// try to find reuseable cache from timeout || no-refrerence caches
danmaku = findReuseableCache(item, false, 50);
if (danmaku != null) {
cache = (DrawingCache) danmaku.cache;
}
if (cache != null) {
danmaku.cache = null;
// Log.e("cache", danmaku.text + "DrawingCache hit!!:" + item.paintWidth + "," +
// danmaku.paintWidth);
cache = DanmakuUtils.buildDanmakuDrawingCache(item, mDisp, cache); // redraw
item.cache = cache;
mCacheManager.push(item, 0, forceInsert);
return RESULT_SUCCESS;
}
// guess cache size
if (!forceInsert) {
int cacheSize =
DanmakuUtils.getCacheSize((int) item.paintWidth, (int) item.paintHeight);
if (mRealSize + cacheSize > mMaxSize) {
// Log.d("cache", "break at MaxSize:"+mMaxSize);
return RESULT_FAILED;
}
}
cache = mCachePool.acquire();
cache = DanmakuUtils.buildDanmakuDrawingCache(item, mDisp, cache);
item.cache = cache;
boolean pushed = mCacheManager.push(item, sizeOf(item), forceInsert);
if (!pushed) {
releaseDanmakuCache(item, cache);
// Log.e("cache", "break at push failed:" + mMaxSize);
}
return pushed ? RESULT_SUCCESS : RESULT_FAILED;
} catch (OutOfMemoryError e) {
// Log.e("cache", "break at error: oom");
releaseDanmakuCache(item, cache);
return RESULT_FAILED;
} catch (Exception e) {
// Log.e("cache", "break at exception:" + e.getMessage());
releaseDanmakuCache(item, cache);
return RESULT_FAILED;
}
}
private final void addDanmakuAndBuildCache(BaseDanmaku danmaku) {
if (danmaku.isTimeOut()
|| danmaku.time
> mCacheTimer.currMillisecond + mContext.mDanmakuFactory.MAX_DANMAKU_DURATION) {
return;
}
if (danmaku.priority == 0 && danmaku.isFiltered()) {
return;
}
if (!danmaku.hasDrawingCache()) {
buildCache(danmaku, true);
}
if (danmaku.isLive) {
mCacheTimer.update(
mTimer.currMillisecond + mContext.mDanmakuFactory.MAX_DANMAKU_DURATION * mScreenSize);
}
}
public void begin() {
sendEmptyMessage(PREPARE);
sendEmptyMessageDelayed(
CLEAR_TIMEOUT_CACHES, mContext.mDanmakuFactory.MAX_DANMAKU_DURATION);
}
public void pause() {
mPause = true;
removeCallbacksAndMessages(null);
sendEmptyMessage(QUIT);
}
public void resume() {
mCancelFlag = false;
mPause = false;
removeMessages(DISPATCH_ACTIONS);
sendEmptyMessage(DISPATCH_ACTIONS);
sendEmptyMessageDelayed(
CLEAR_TIMEOUT_CACHES, mContext.mDanmakuFactory.MAX_DANMAKU_DURATION);
}
public boolean isPause() {
return mPause;
}
public void requestBuildCacheAndDraw(long correctionTime) {
removeMessages(CacheHandler.BUILD_CACHES);
mSeekedFlag = true;
mCancelFlag = false;
mCacheTimer.update(mTimer.currMillisecond + correctionTime);
sendEmptyMessage(CacheHandler.BUILD_CACHES);
}
}
public long getFirstCacheTime() {
if (mCaches != null && mCaches.size() > 0) {
BaseDanmaku firstItem = mCaches.first();
if (firstItem == null) return 0;
return firstItem.time;
}
return 0;
}
public void requestBuild(long correctionTime) {
if (mHandler != null) {
mHandler.requestBuildCacheAndDraw(correctionTime);
}
}
public void requestClearAll() {
if (mHandler == null) {
return;
}
mHandler.removeMessages(CacheHandler.BUILD_CACHES);
mHandler.requestCancelCaching();
mHandler.removeMessages(CacheHandler.CLEAR_ALL_CACHES);
mHandler.sendEmptyMessage(CacheHandler.CLEAR_ALL_CACHES);
}
public void requestClearUnused() {
if (mHandler == null) {
return;
}
mHandler.removeMessages(CacheHandler.CLEAR_OUTSIDE_CACHES_AND_RESET);
mHandler.sendEmptyMessage(CacheHandler.CLEAR_OUTSIDE_CACHES_AND_RESET);
}
public void requestClearTimeout() {
if (mHandler == null) {
return;
}
mHandler.removeMessages(CacheHandler.CLEAR_TIMEOUT_CACHES);
mHandler.sendEmptyMessage(CacheHandler.CLEAR_TIMEOUT_CACHES);
}
public void post(Runnable runnable) {
if (mHandler == null) {
return;
}
mHandler.post(runnable);
}
}
