Java CLog类代码示例

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);
                }
            }
        }
    }
}