import in.srain.cube.util.CLog; //导入依赖的package包/类
public void moveToItem(int item) {
    if (DEBUG) {
        CLog.d(LOG_TAG, "moveToItem: %s", item);
    }
    if (mViewPager == null) {
        throw new IllegalStateException("ViewPager has not been bound.");
    }
    if (mSelectedTabIndex == item) {
        // return;
    }
    mSelectedTabIndex = item;

    // will lead to call moveToItem again, but will not hit here :)
    mViewPager.setCurrentItem(item);
    if (DEBUG) {
        CLog.d(LOG_TAG, "mViewPager.setCurrentItem: %s", item);
    }
    if (mListener != null) {
        mListener.onPageSelected(item);
    }
    updateTab(item);
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
@Override
public void onRequestSuccess(T data) {
    if (DEBUG) {
        CLog.d(LOG_TAG, "%s, onRequestSuccess", getCacheKey());
    }
    if (hasBeenCanceled()) {
        return;
    }
    if (null != mHandler) {
        mHandler.onRequestFinish(data);

        // cache data is not available or
        // cache is available and time duration not reach timeout or not always use the cache
        if (mCacheData == null || (!mHasTimeout && !mUseCacheAnyway)) {
            notifyRequestFinish(ResultType.USE_DATA_FROM_SERVER, data, false);
        } else {
            if (DEBUG) {
                CLog.d(LOG_TAG, "%s, will not notifyRequestFinish", getCacheKey());
            }
        }
    }
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
@Override
public void onRequestFail(FailData failData) {
    RequestManager.getInstance().getRequestProxy(this).onRequestFail(this, failData);
    if (DEBUG) {
        CLog.d(LOG_TAG, "%s, onRequestFail", getCacheKey());
    }
    if (hasBeenCanceled()) {
        return;
    }
    if (null != mHandler) {
        mHandler.onRequestFail(failData);
        if (mCacheData != null && !cacheIsDisabled() && !mUseCacheAnyway) {
            notifyRequestFinish(ResultType.USE_CACHE_ON_FAIL, mCacheData, true);
        }
    }
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
@Override
public void onCacheData(CacheResultType cacheResultType, T data, boolean outOfDate) {
    if (DEBUG) {
        CLog.d(LOG_TAG, "%s, onQueryFinish, out of date: %s", getCacheKey(), outOfDate);
    }
    if (hasBeenCanceled()) {
        return;
    }
    mCacheData = data;
    mOutOfDate = outOfDate;
    if (mHandler != null) {
        mHandler.onCacheData(data, outOfDate);

        if (mUseCacheAnyway) {
            notifyRequestFinish(ResultType.USE_CACHE_ANYWAY, data, mOutOfDate);
        } else {
            if (!outOfDate) {
                notifyRequestFinish(ResultType.USE_CACHE_NOT_EXPIRED, data, false);
            }
        }
    }
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
protected static <T> T doSyncRequest(IRequest<T> request) {
    T data = null;
    try {
        StringBuilder sb = new StringBuilder();
        RequestData requestData = request.getRequestData();
        if (DEBUG) {
            CLog.d(LOG_TAG, "%s", requestData);
        }
        BaseRequestSender requestSender = RequestSenderFactory.create(request);
        if (requestSender != null) {
            requestSender.send();
            requestSender.getResponse(sb);
            if (DEBUG) {
                CLog.d(LOG_TAG, "%s: %s", requestData, sb.toString());
            }
            data = request.onDataFromServer(sb.toString());
        }
    } catch (Exception e) {
        e.printStackTrace();
        request.setFailData(FailData.networkError(request));
    }
    return data;
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
public synchronized void clear() throws IOException {

        // abort edit
        for (CacheEntry cacheEntry : new ArrayList<CacheEntry>(mLruEntries.values())) {
            if (cacheEntry.isUnderEdit()) {
                cacheEntry.abortEdit();
            }
        }
        mLruEntries.clear();
        mSize = 0;

        // delete current directory then rebuild
        if (SimpleDiskLruCache.DEBUG) {
            CLog.d(SimpleDiskLruCache.LOG_TAG, "delete directory");
        }

        waitJobDone();

        // rebuild
        FileUtils.deleteDirectoryQuickly(mDirectory);
        rebuildJournal();
    }
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
public synchronized CacheEntry beginEdit(String key) throws IOException {
    checkNotClosed();
    validateKey(key);

    if (SimpleDiskLruCache.DEBUG) {
        CLog.d(SimpleDiskLruCache.LOG_TAG, "beginEdit: %s", key);
    }
    CacheEntry cacheEntry = mLruEntries.get(key);
    if (cacheEntry == null) {
        cacheEntry = new CacheEntry(mDiskCache, key);
        mNewCreateList.add(key);
        mLruEntries.put(key, cacheEntry);
    }
    mEditList.put(key, cacheEntry);

    addActionLog(ACTION_DIRTY, cacheEntry);
    return cacheEntry;
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
private void waitJobDone() {
    if (SimpleDiskLruCache.DEBUG) {
        CLog.d(SimpleDiskLruCache.LOG_TAG, "waitJobDone");
    }

    // remove synchronized method , exclude this code block for dead lock digging
    synchronized (mLock) {
        if (mIsRunning) {
            while (!mActionQueue.isEmpty()) {
                try {
                    mLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    if (SimpleDiskLruCache.DEBUG) {
        CLog.d(SimpleDiskLruCache.LOG_TAG, "job is done");
    }
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
/**
 * remove files from list, delete files
 */
private synchronized void trimToSize() {

    if (mSize > mCapacity) {
        if (SimpleDiskLruCache.DEBUG) {
            CLog.d(SimpleDiskLruCache.LOG_TAG, "should trim, current is: %s", mSize);
        }
    }
    while (mSize > mCapacity) {
        Map.Entry<String, CacheEntry> toEvict = mLruEntries.entrySet().iterator().next();
        String key = toEvict.getKey();
        CacheEntry cacheEntry = toEvict.getValue();
        mLruEntries.remove(key);

        mSize -= cacheEntry.getSize();
        addActionLog(ACTION_PENDING_DELETE, cacheEntry);
        if (SimpleDiskLruCache.DEBUG) {
            CLog.d(SimpleDiskLruCache.LOG_TAG, "pending remove: %s, size: %s, after remove total: %s", key, cacheEntry.getSize(), mSize);
        }
    }
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
public synchronized boolean delete(String key) throws IOException {
    if (SimpleDiskLruCache.DEBUG) {
        CLog.d(SimpleDiskLruCache.LOG_TAG, "delete: %s", key);
    }
    checkNotClosed();
    validateKey(key);
    CacheEntry cacheEntry = mLruEntries.get(key);
    if (cacheEntry == null) {
        return false;
    }

    // delete at once
    cacheEntry.delete();
    mSize -= cacheEntry.getSize();
    cacheEntry.setSize(0);
    mLruEntries.remove(key);

    addActionLog(ACTION_DELETE, cacheEntry);
    return true;
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
public void setCacheData(final String cacheKey, final String data) {
    if (TextUtils.isEmpty(cacheKey) || TextUtils.isEmpty(data)) {
        return;
    }
    if (DEBUG) {
        CLog.d(LOG_TAG, "key: %s, setCacheData", cacheKey);
    }
    SimpleExecutor.getInstance().execute(

            new Runnable() {
                @Override
                public void run() {
                    CacheMetaData cacheMetaData = CacheMetaData.createForNow(data);
                    putDataToMemoryCache(cacheKey, cacheMetaData);
                    mFileCache.write(cacheKey, cacheMetaData.getCacheData());
                    mFileCache.flushDiskCacheAsyncWithDelay(1000);
                }
            }
    );
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
@Override
public void doInBackground() {
    if (DEBUG) {
        CLog.d(LOG_TAG, "key: %s, doInBackground: mWorkType: %s", mCacheAble.getCacheKey(), mWorkType);
    }
    switch (mWorkType) {

        case DO_READ_FROM_FILE:
            doQueryFromCacheFileInBackground();
            setCurrentStatus(AFTER_READ_FROM_FILE);
            break;

        case DO_READ_FROM_ASSERT:
            doQueryFromAssertCacheFileInBackground();
            setCurrentStatus(AFTER_READ_FROM_ASSERT);
            break;

        case DO_CONVERT:
            doConvertDataInBackground();
            setCurrentStatus(AFTER_CONVERT);
            break;

        default:
            break;
    }
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
/**
 * If disk is not read, will prepare it first.
 *
 * @return
 */
public DiskCache getDiskCache() {
    if (!mDiskCacheReady) {
        if (DEBUG) {
            CLog.d(LOG_TAG, "%s, try to access disk cache, but it is not open, try to open it.", mDiskCache);
        }
        openDiskCacheAsync();
    }
    synchronized (mDiskCacheLock) {
        while (mDiskCacheStarting) {
            try {
                if (DEBUG) {
                    CLog.d(LOG_TAG, "%s, try to access, but disk cache is not ready, wait", mDiskCache);
                }
                mDiskCacheLock.wait();
            } catch (InterruptedException e) {
            }
        }
    }
    return mDiskCache;
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
public static ImageTask obtain() {
    if (!USE_POOL) {
        return null;
    }
    // pop top, make top.next as top
    synchronized (sPoolSync) {
        if (sTop != null) {
            ImageTask m = sTop;
            sTop = m.next;
            m.next = null;
            sPoolSize--;
            m.mHasRecycled = false;
            if (CubeDebug.DEBUG_IMAGE) {
                CLog.d(LOG_TAG, "%s, obtain reused, pool remain: %d", m, sPoolSize);
            }
            return m;
        }
    }
    return null;
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
public void tryToRecycle() {
    if (!USE_POOL) {
        return;
    }
    clearForRecycle();

    // mark top as the next of current, then push current as pop
    synchronized (sPoolSync) {
        if (sPoolSize < MAX_POOL_SIZE) {
            next = sTop;
            sTop = this;
            sPoolSize++;
            if (CubeDebug.DEBUG_IMAGE) {
                CLog.d(LOG_TAG, "%s is put to recycle poll, pool size: %d", this, sPoolSize);
            } else {
                if (CubeDebug.DEBUG_IMAGE) {
                    CLog.d(LOG_TAG, "%s is not recycled, the poll is full: %d", this, sPoolSize);
                }
            }
        }
    }
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
public ImageTask renewForRequest(ImageLoadRequest request) {
    if (CubeDebug.DEBUG_IMAGE) {
        int lastId = mId;
        mId = ++sId;
        CLog.d(LOG_TAG, "%s, renew: %s => %s", this, lastId, mId);
    } else {
        mId = ++sId;
    }
    mStr = null;
    if (ImagePerformanceStatistics.sample(mId)) {
        mImageTaskStatistics = new ImageTaskStatistics();
    }
    mOriginUrl = request.getUrl();
    mRequestSize.set(request.getRequestWidth(), request.getRequestHeight());
    mRequest = request;
    return this;
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
@Override
public void draw(Canvas canvas) {
    CLog.d("test", "draw");
    float yHeight = getProgress() / (float) getMax() * mSize;
    float radius = mSize / 2f;
    float angle = (float) (Math.acos((radius - yHeight) / radius) * 180 / Math.PI);
    float startAngle = 90 + angle;
    float sweepAngle = 360 - angle * 2;
    mPaint.setColor(getUnfinishedColor());
    canvas.drawArc(rectF, startAngle, sweepAngle, false, mPaint);

    canvas.save();
    canvas.rotate(180, mSize / 2, mSize / 2);
    mPaint.setColor(getFinishedColor());
    canvas.drawArc(rectF, 270 - angle, angle * 2, false, mPaint);
    canvas.restore();

    String text = getDrawText();
    if (!TextUtils.isEmpty(text)) {
        float textHeight = mTextPaint.descent() + mTextPaint.ascent();
        canvas.drawText(text, (mSize - mTextPaint.measureText(text)) / 2.0f, (mSize - textHeight) / 2.0f, mTextPaint);
    }
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
/**
 * Detach the ImageView from the ImageTask.
 *
 * @param imageTask
 * @param imageView
 */
public void detachImageViewFromImageTask(ImageTask imageTask, CubeImageView imageView) {
    imageTask.removeImageView(imageView);
    if (imageTask.isLoading()) {
        if (!imageTask.isPreLoad() && !imageTask.stillHasRelatedImageView()) {
            LoadImageTask task = mLoadWorkList.get(imageTask.getIdentityKey());
            if (task != null) {
                task.cancel();
            }
            if (DEBUG) {
                CLog.d(LOG_TAG, "%s previous work is cancelled.", imageTask);
            }
        }
    }
    if (!imageTask.stillHasRelatedImageView()) {
        imageTask.tryToRecycle();
    }
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
/**
 * Add the ImageTask into loading list.
 *
 * @param imageTask
 * @param imageView
 */
public void addImageTask(ImageTask imageTask, CubeImageView imageView) {
    if (!mHasBeenAddedToComponentManager) {
        CLog.w(LOG_TAG, "ImageLoader has not been add to a Component Manager.", this);
    }
    LoadImageTask runningTask = mLoadWorkList.get(imageTask.getIdentityKey());
    if (runningTask != null) {
        if (imageView != null) {
            if (DEBUG) {
                CLog.d(LOG_TAG, MSG_ATTACK_TO_RUNNING_TASK, imageTask, runningTask.getImageTask());
            }
            runningTask.getImageTask().addImageView(imageView);
            runningTask.getImageTask().notifyLoading(mImageLoadHandler, imageView);
        }
        return;
    } else {
        imageTask.addImageView(imageView);
    }

    imageTask.onLoading(mImageLoadHandler);

    LoadImageTask loadImageTask = createLoadImageTask(imageTask);
    mLoadWorkList.put(imageTask.getIdentityKey(), loadImageTask);
    mImageTaskExecutor.execute(loadImageTask);
}
 

import in.srain.cube.util.CLog; //导入依赖的package包/类
/**
 * Check weather this imageTask has cache Drawable data.
 */
public boolean queryCache(ImageTask imageTask, CubeImageView imageView) {
    if (null == mImageProvider) {
        return false;
    }
    BitmapDrawable drawable = mImageProvider.getBitmapFromMemCache(imageTask);

    if (imageTask.getStatistics() != null) {
        imageTask.getStatistics().s0_afterCheckMemoryCache(drawable != null);
    }
    if (drawable == null) {
        return false;
    }

    if (DEBUG) {
        CLog.d(LOG_TAG, MSG_HIT_CACHE, imageTask, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
    }
    imageTask.addImageView(imageView);
    imageTask.onLoadTaskFinish(drawable, mImageLoadHandler);
    return true;
}