/*
* Copyright (C) 2014 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.printspooler.model;
import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.drawable.BitmapDrawable;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.IBinder;
import android.os.ParcelFileDescriptor;
import android.os.RemoteException;
import android.print.PrintAttributes;
import android.print.PrintAttributes.MediaSize;
import android.print.PrintAttributes.Margins;
import android.print.PrintDocumentInfo;
import android.util.ArrayMap;
import android.util.Log;
import android.view.View;
import com.android.internal.annotations.GuardedBy;
import com.android.printspooler.renderer.IPdfRenderer;
import com.android.printspooler.renderer.PdfManipulationService;
import com.android.printspooler.util.BitmapSerializeUtils;
import dalvik.system.CloseGuard;
import libcore.io.IoUtils;
import java.io.IOException;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
public final class PageContentRepository {
private static final String LOG_TAG = "PageContentRepository";
private static final boolean DEBUG = false;
private static final int INVALID_PAGE_INDEX = -1;
private static final int STATE_CLOSED = 0;
private static final int STATE_OPENED = 1;
private static final int STATE_DESTROYED = 2;
private static final int BYTES_PER_PIXEL = 4;
private static final int BYTES_PER_MEGABYTE = 1048576;
private final CloseGuard mCloseGuard = CloseGuard.get();
private final AsyncRenderer mRenderer;
private RenderSpec mLastRenderSpec;
private int mScheduledPreloadFirstShownPage = INVALID_PAGE_INDEX;
private int mScheduledPreloadLastShownPage = INVALID_PAGE_INDEX;
private int mState;
public interface OnPageContentAvailableCallback {
public void onPageContentAvailable(BitmapDrawable content);
}
public PageContentRepository(Context context) {
mRenderer = new AsyncRenderer(context);
mState = STATE_CLOSED;
if (DEBUG) {
Log.i(LOG_TAG, "STATE_CLOSED");
}
mCloseGuard.open("destroy");
}
public void open(ParcelFileDescriptor source, final OpenDocumentCallback callback) {
throwIfNotClosed();
mState = STATE_OPENED;
if (DEBUG) {
Log.i(LOG_TAG, "STATE_OPENED");
}
mRenderer.open(source, callback);
}
public void close(Runnable callback) {
throwIfNotOpened();
mState = STATE_CLOSED;
if (DEBUG) {
Log.i(LOG_TAG, "STATE_CLOSED");
}
mRenderer.close(callback);
}
public void destroy(final Runnable callback) {
if (mState == STATE_OPENED) {
close(new Runnable() {
@Override
public void run() {
destroy(callback);
}
});
return;
}
mState = STATE_DESTROYED;
if (DEBUG) {
Log.i(LOG_TAG, "STATE_DESTROYED");
}
mRenderer.destroy();
if (callback != null) {
callback.run();
}
}
public void startPreload(int firstShownPage, int lastShownPage) {
// If we do not have a render spec we have no clue what size the
// preloaded bitmaps should be, so just take a note for what to do.
if (mLastRenderSpec == null) {
mScheduledPreloadFirstShownPage = firstShownPage;
mScheduledPreloadLastShownPage = lastShownPage;
} else if (mState == STATE_OPENED) {
mRenderer.startPreload(firstShownPage, lastShownPage, mLastRenderSpec);
}
}
public void stopPreload() {
mRenderer.stopPreload();
}
public int getFilePageCount() {
return mRenderer.getPageCount();
}
public PageContentProvider acquirePageContentProvider(int pageIndex, View owner) {
throwIfDestroyed();
if (DEBUG) {
Log.i(LOG_TAG, "Acquiring provider for page: " + pageIndex);
}
return new PageContentProvider(pageIndex, owner);
}
public void releasePageContentProvider(PageContentProvider provider) {
throwIfDestroyed();
if (DEBUG) {
Log.i(LOG_TAG, "Releasing provider for page: " + provider.mPageIndex);
}
provider.cancelLoad();
}
@Override
protected void finalize() throws Throwable {
try {
if (mState != STATE_DESTROYED) {
mCloseGuard.warnIfOpen();
destroy(null);
}
} finally {
super.finalize();
}
}
private void throwIfNotOpened() {
if (mState != STATE_OPENED) {
throw new IllegalStateException("Not opened");
}
}
private void throwIfNotClosed() {
if (mState != STATE_CLOSED) {
throw new IllegalStateException("Not closed");
}
}
private void throwIfDestroyed() {
if (mState == STATE_DESTROYED) {
throw new IllegalStateException("Destroyed");
}
}
public final class PageContentProvider {
private final int mPageIndex;
private View mOwner;
public PageContentProvider(int pageIndex, View owner) {
mPageIndex = pageIndex;
mOwner = owner;
}
public View getOwner() {
return mOwner;
}
public int getPageIndex() {
return mPageIndex;
}
public void getPageContent(RenderSpec renderSpec, OnPageContentAvailableCallback callback) {
throwIfDestroyed();
mLastRenderSpec = renderSpec;
// We tired to preload but didn't know the bitmap size, now
// that we know let us do the work.
if (mScheduledPreloadFirstShownPage != INVALID_PAGE_INDEX
&& mScheduledPreloadLastShownPage != INVALID_PAGE_INDEX) {
startPreload(mScheduledPreloadFirstShownPage, mScheduledPreloadLastShownPage);
mScheduledPreloadFirstShownPage = INVALID_PAGE_INDEX;
mScheduledPreloadLastShownPage = INVALID_PAGE_INDEX;
}
if (mState == STATE_OPENED) {
mRenderer.renderPage(mPageIndex, renderSpec, callback);
} else {
mRenderer.getCachedPage(mPageIndex, renderSpec, callback);
}
}
void cancelLoad() {
throwIfDestroyed();
if (mState == STATE_OPENED) {
mRenderer.cancelRendering(mPageIndex);
}
}
}
private static final class PageContentLruCache {
private final LinkedHashMap<Integer, RenderedPage> mRenderedPages =
new LinkedHashMap<>();
private final int mMaxSizeInBytes;
private int mSizeInBytes;
public PageContentLruCache(int maxSizeInBytes) {
mMaxSizeInBytes = maxSizeInBytes;
}
public RenderedPage getRenderedPage(int pageIndex) {
return mRenderedPages.get(pageIndex);
}
public RenderedPage removeRenderedPage(int pageIndex) {
RenderedPage page = mRenderedPages.remove(pageIndex);
if (page != null) {
mSizeInBytes -= page.getSizeInBytes();
}
return page;
}
public RenderedPage putRenderedPage(int pageIndex, RenderedPage renderedPage) {
RenderedPage oldRenderedPage = mRenderedPages.remove(pageIndex);
if (oldRenderedPage != null) {
if (!oldRenderedPage.renderSpec.equals(renderedPage.renderSpec)) {
throw new IllegalStateException("Wrong page size");
}
} else {
final int contentSizeInBytes = renderedPage.getSizeInBytes();
if (mSizeInBytes + contentSizeInBytes > mMaxSizeInBytes) {
throw new IllegalStateException("Client didn't free space");
}
mSizeInBytes += contentSizeInBytes;
}
return mRenderedPages.put(pageIndex, renderedPage);
}
public void invalidate() {
for (Map.Entry<Integer, RenderedPage> entry : mRenderedPages.entrySet()) {
entry.getValue().state = RenderedPage.STATE_SCRAP;
}
}
public RenderedPage removeLeastNeeded() {
if (mRenderedPages.isEmpty()) {
return null;
}
// First try to remove a rendered page that holds invalidated
// or incomplete content, i.e. its render spec is null.
for (Map.Entry<Integer, RenderedPage> entry : mRenderedPages.entrySet()) {
RenderedPage renderedPage = entry.getValue();
if (renderedPage.state == RenderedPage.STATE_SCRAP) {
Integer pageIndex = entry.getKey();
mRenderedPages.remove(pageIndex);
mSizeInBytes -= renderedPage.getSizeInBytes();
return renderedPage;
}
}
// If all rendered pages contain rendered content, then use the oldest.
final int pageIndex = mRenderedPages.eldest().getKey();
RenderedPage renderedPage = mRenderedPages.remove(pageIndex);
mSizeInBytes -= renderedPage.getSizeInBytes();
return renderedPage;
}
public int getSizeInBytes() {
return mSizeInBytes;
}
public int getMaxSizeInBytes() {
return mMaxSizeInBytes;
}
public void clear() {
Iterator<Map.Entry<Integer, RenderedPage>> iterator =
mRenderedPages.entrySet().iterator();
while (iterator.hasNext()) {
iterator.next();
iterator.remove();
}
}
}
public static final class RenderSpec {
final int bitmapWidth;
final int bitmapHeight;
final PrintAttributes printAttributes = new PrintAttributes.Builder().build();
public RenderSpec(int bitmapWidth, int bitmapHeight,
MediaSize mediaSize, Margins minMargins) {
this.bitmapWidth = bitmapWidth;
this.bitmapHeight = bitmapHeight;
printAttributes.setMediaSize(mediaSize);
printAttributes.setMinMargins(minMargins);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
RenderSpec other = (RenderSpec) obj;
if (bitmapHeight != other.bitmapHeight) {
return false;
}
if (bitmapWidth != other.bitmapWidth) {
return false;
}
if (printAttributes != null) {
if (!printAttributes.equals(other.printAttributes)) {
return false;
}
} else if (other.printAttributes != null) {
return false;
}
return true;
}
public boolean hasSameSize(RenderedPage page) {
Bitmap bitmap = page.content.getBitmap();
return bitmap.getWidth() == bitmapWidth
&& bitmap.getHeight() == bitmapHeight;
}
@Override
public int hashCode() {
int result = bitmapWidth;
result = 31 * result + bitmapHeight;
result = 31 * result + (printAttributes != null ? printAttributes.hashCode() : 0);
return result;
}
}
private static final class RenderedPage {
public static final int STATE_RENDERED = 0;
public static final int STATE_RENDERING = 1;
public static final int STATE_SCRAP = 2;
final BitmapDrawable content;
RenderSpec renderSpec;
int state = STATE_SCRAP;
RenderedPage(BitmapDrawable content) {
this.content = content;
}
public int getSizeInBytes() {
return content.getBitmap().getByteCount();
}
public void erase() {
content.getBitmap().eraseColor(Color.WHITE);
}
}
private static final class AsyncRenderer implements ServiceConnection {
private final Object mLock = new Object();
private final Context mContext;
private final PageContentLruCache mPageContentCache;
private final ArrayMap<Integer, RenderPageTask> mPageToRenderTaskMap = new ArrayMap<>();
private int mPageCount = PrintDocumentInfo.PAGE_COUNT_UNKNOWN;
@GuardedBy("mLock")
private IPdfRenderer mRenderer;
private OpenTask mOpenTask;
private boolean mBoundToService;
private boolean mDestroyed;
public AsyncRenderer(Context context) {
mContext = context;
ActivityManager activityManager = (ActivityManager)
mContext.getSystemService(Context.ACTIVITY_SERVICE);
final int cacheSizeInBytes = activityManager.getMemoryClass() * BYTES_PER_MEGABYTE / 4;
mPageContentCache = new PageContentLruCache(cacheSizeInBytes);
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
synchronized (mLock) {
mRenderer = IPdfRenderer.Stub.asInterface(service);
mLock.notifyAll();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
synchronized (mLock) {
mRenderer = null;
}
}
public void open(ParcelFileDescriptor source, OpenDocumentCallback callback) {
// Opening a new document invalidates the cache as it has pages
// from the last document. We keep the cache even when the document
// is closed to show pages while the other side is writing the new
// document.
mPageContentCache.invalidate();
mOpenTask = new OpenTask(source, callback);
mOpenTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
}
public void close(final Runnable callback) {
cancelAllRendering();
if (mOpenTask != null) {
mOpenTask.cancel();
}
new AsyncTask<Void, Void, Void>() {
@Override
protected void onPreExecute() {
if (mDestroyed) {
cancel(true);
return;
}
}
@Override
protected Void doInBackground(Void... params) {
synchronized (mLock) {
try {
if (mRenderer != null) {
mRenderer.closeDocument();
}
} catch (RemoteException re) {
/* ignore */
}
}
return null;
}
@Override
public void onPostExecute(Void result) {
mPageCount = PrintDocumentInfo.PAGE_COUNT_UNKNOWN;
if (callback != null) {
callback.run();
}
}
}.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
}
public void destroy() {
if (mBoundToService) {
mBoundToService = false;
mContext.unbindService(AsyncRenderer.this);
}
mPageContentCache.invalidate();
mPageContentCache.clear();
mDestroyed = true;
}
public void startPreload(int firstShownPage, int lastShownPage, RenderSpec renderSpec) {
if (DEBUG) {
Log.i(LOG_TAG, "Preloading pages around [" + firstShownPage
+ "-" + lastShownPage + "]");
}
final int bitmapSizeInBytes = renderSpec.bitmapWidth * renderSpec.bitmapHeight
* BYTES_PER_PIXEL;
final int maxCachedPageCount = mPageContentCache.getMaxSizeInBytes()
/ bitmapSizeInBytes;
final int halfPreloadCount = (maxCachedPageCount
- (lastShownPage - firstShownPage)) / 2 - 1;
final int excessFromStart;
if (firstShownPage - halfPreloadCount < 0) {
excessFromStart = halfPreloadCount - firstShownPage;
} else {
excessFromStart = 0;
}
final int excessFromEnd;
if (lastShownPage + halfPreloadCount >= mPageCount) {
excessFromEnd = (lastShownPage + halfPreloadCount) - mPageCount;
} else {
excessFromEnd = 0;
}
final int fromIndex = Math.max(firstShownPage - halfPreloadCount - excessFromEnd, 0);
final int toIndex = Math.min(lastShownPage + halfPreloadCount + excessFromStart,
mPageCount - 1);
for (int i = fromIndex; i <= toIndex; i++) {
renderPage(i, renderSpec, null);
}
}
public void stopPreload() {
final int taskCount = mPageToRenderTaskMap.size();
for (int i = 0; i < taskCount; i++) {
RenderPageTask task = mPageToRenderTaskMap.valueAt(i);
if (task.isPreload() && !task.isCancelled()) {
task.cancel(true);
}
}
}
public int getPageCount() {
return mPageCount;
}
public void getCachedPage(int pageIndex, RenderSpec renderSpec,
OnPageContentAvailableCallback callback) {
RenderedPage renderedPage = mPageContentCache.getRenderedPage(pageIndex);
if (renderedPage != null && renderedPage.state == RenderedPage.STATE_RENDERED
&& renderedPage.renderSpec.equals(renderSpec)) {
if (DEBUG) {
Log.i(LOG_TAG, "Cache hit for page: " + pageIndex);
}
// Announce if needed.
if (callback != null) {
callback.onPageContentAvailable(renderedPage.content);
}
}
}
public void renderPage(int pageIndex, RenderSpec renderSpec,
OnPageContentAvailableCallback callback) {
// First, check if we have a rendered page for this index.
RenderedPage renderedPage = mPageContentCache.getRenderedPage(pageIndex);
if (renderedPage != null && renderedPage.state == RenderedPage.STATE_RENDERED) {
// If we have rendered page with same constraints - done.
if (renderedPage.renderSpec.equals(renderSpec)) {
if (DEBUG) {
Log.i(LOG_TAG, "Cache hit for page: " + pageIndex);
}
// Announce if needed.
if (callback != null) {
callback.onPageContentAvailable(renderedPage.content);
}
return;
} else {
// If the constraints changed, mark the page obsolete.
renderedPage.state = RenderedPage.STATE_SCRAP;
}
}
// Next, check if rendering this page is scheduled.
RenderPageTask renderTask = mPageToRenderTaskMap.get(pageIndex);
if (renderTask != null && !renderTask.isCancelled()) {
// If not rendered and constraints same....
if (renderTask.mRenderSpec.equals(renderSpec)) {
if (renderTask.mCallback != null) {
// If someone else is already waiting for this page - bad state.
if (callback != null && renderTask.mCallback != callback) {
throw new IllegalStateException("Page rendering not cancelled");
}
} else {
// No callback means we are preloading so just let the argument
// callback be attached to our work in progress.
renderTask.mCallback = callback;
}
return;
} else {
// If not rendered and constraints changed - cancel rendering.
renderTask.cancel(true);
}
}
// Oh well, we will have work to do...
renderTask = new RenderPageTask(pageIndex, renderSpec, callback);
mPageToRenderTaskMap.put(pageIndex, renderTask);
renderTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
}
public void cancelRendering(int pageIndex) {
RenderPageTask task = mPageToRenderTaskMap.get(pageIndex);
if (task != null && !task.isCancelled()) {
task.cancel(true);
}
}
private void cancelAllRendering() {
final int taskCount = mPageToRenderTaskMap.size();
for (int i = 0; i < taskCount; i++) {
RenderPageTask task = mPageToRenderTaskMap.valueAt(i);
if (!task.isCancelled()) {
task.cancel(true);
}
}
}
private final class OpenTask extends AsyncTask<Void, Void, Integer> {
private final ParcelFileDescriptor mSource;
private final OpenDocumentCallback mCallback;
public OpenTask(ParcelFileDescriptor source, OpenDocumentCallback callback) {
mSource = source;
mCallback = callback;
}
@Override
protected void onPreExecute() {
if (mDestroyed) {
cancel(true);
return;
}
Intent intent = new Intent(PdfManipulationService.ACTION_GET_RENDERER);
intent.setClass(mContext, PdfManipulationService.class);
intent.setData(Uri.fromParts("fake-scheme", String.valueOf(
AsyncRenderer.this.hashCode()), null));
mContext.bindService(intent, AsyncRenderer.this, Context.BIND_AUTO_CREATE);
mBoundToService = true;
}
@Override
protected Integer doInBackground(Void... params) {
synchronized (mLock) {
while (mRenderer == null && !isCancelled()) {
try {
mLock.wait();
} catch (InterruptedException ie) {
/* ignore */
}
}
try {
return mRenderer.openDocument(mSource);
} catch (RemoteException re) {
Log.e(LOG_TAG, "Cannot open PDF document");
return PdfManipulationService.ERROR_MALFORMED_PDF_FILE;
} finally {
// Close the fd as we passed it to another process
// which took ownership.
IoUtils.closeQuietly(mSource);
}
}
}
@Override
public void onPostExecute(Integer pageCount) {
switch (pageCount) {
case PdfManipulationService.ERROR_MALFORMED_PDF_FILE: {
mPageCount = PrintDocumentInfo.PAGE_COUNT_UNKNOWN;
if (mCallback != null) {
mCallback.onFailure(OpenDocumentCallback.ERROR_MALFORMED_PDF_FILE);
}
} break;
case PdfManipulationService.ERROR_SECURE_PDF_FILE: {
mPageCount = PrintDocumentInfo.PAGE_COUNT_UNKNOWN;
if (mCallback != null) {
mCallback.onFailure(OpenDocumentCallback.ERROR_SECURE_PDF_FILE);
}
} break;
default: {
mPageCount = pageCount;
if (mCallback != null) {
mCallback.onSuccess();
}
} break;
}
mOpenTask = null;
}
@Override
protected void onCancelled(Integer integer) {
mOpenTask = null;
}
public void cancel() {
cancel(true);
synchronized(mLock) {
mLock.notifyAll();
}
}
}
private final class RenderPageTask extends AsyncTask<Void, Void, RenderedPage> {
final int mPageIndex;
final RenderSpec mRenderSpec;
OnPageContentAvailableCallback mCallback;
RenderedPage mRenderedPage;
public RenderPageTask(int pageIndex, RenderSpec renderSpec,
OnPageContentAvailableCallback callback) {
mPageIndex = pageIndex;
mRenderSpec = renderSpec;
mCallback = callback;
}
@Override
protected void onPreExecute() {
mRenderedPage = mPageContentCache.getRenderedPage(mPageIndex);
if (mRenderedPage != null && mRenderedPage.state == RenderedPage.STATE_RENDERED) {
throw new IllegalStateException("Trying to render a rendered page");
}
// Reuse bitmap for the page only if the right size.
if (mRenderedPage != null && !mRenderSpec.hasSameSize(mRenderedPage)) {
if (DEBUG) {
Log.i(LOG_TAG, "Recycling bitmap for page: " + mPageIndex
+ " with different size.");
}
mPageContentCache.removeRenderedPage(mPageIndex);
mRenderedPage = null;
}
final int bitmapSizeInBytes = mRenderSpec.bitmapWidth
* mRenderSpec.bitmapHeight * BYTES_PER_PIXEL;
// Try to find a bitmap to reuse.
while (mRenderedPage == null) {
// Fill the cache greedily.
if (mPageContentCache.getSizeInBytes() <= 0
|| mPageContentCache.getSizeInBytes() + bitmapSizeInBytes
<= mPageContentCache.getMaxSizeInBytes()) {
break;
}
RenderedPage renderedPage = mPageContentCache.removeLeastNeeded();
if (!mRenderSpec.hasSameSize(renderedPage)) {
if (DEBUG) {
Log.i(LOG_TAG, "Recycling bitmap for page: " + mPageIndex
+ " with different size.");
}
continue;
}
mRenderedPage = renderedPage;
renderedPage.erase();
if (DEBUG) {
Log.i(LOG_TAG, "Reused bitmap for page: " + mPageIndex + " cache size: "
+ mPageContentCache.getSizeInBytes() + " bytes");
}
break;
}
if (mRenderedPage == null) {
if (DEBUG) {
Log.i(LOG_TAG, "Created bitmap for page: " + mPageIndex + " cache size: "
+ mPageContentCache.getSizeInBytes() + " bytes");
}
Bitmap bitmap = Bitmap.createBitmap(mRenderSpec.bitmapWidth,
mRenderSpec.bitmapHeight, Bitmap.Config.ARGB_8888);
bitmap.eraseColor(Color.WHITE);
BitmapDrawable content = new BitmapDrawable(mContext.getResources(), bitmap);
mRenderedPage = new RenderedPage(content);
}
mRenderedPage.renderSpec = mRenderSpec;
mRenderedPage.state = RenderedPage.STATE_RENDERING;
mPageContentCache.putRenderedPage(mPageIndex, mRenderedPage);
}
@Override
protected RenderedPage doInBackground(Void... params) {
if (isCancelled()) {
return mRenderedPage;
}
Bitmap bitmap = mRenderedPage.content.getBitmap();
ParcelFileDescriptor[] pipe = null;
try {
pipe = ParcelFileDescriptor.createPipe();
ParcelFileDescriptor source = pipe[0];
ParcelFileDescriptor destination = pipe[1];
mRenderer.renderPage(mPageIndex, bitmap.getWidth(), bitmap.getHeight(),
mRenderSpec.printAttributes, destination);
// We passed the file descriptor to the other side which took
// ownership, so close our copy for the write to complete.
destination.close();
BitmapSerializeUtils.readBitmapPixels(bitmap, source);
} catch (IOException|RemoteException e) {
Log.e(LOG_TAG, "Error rendering page:" + mPageIndex, e);
} finally {
IoUtils.closeQuietly(pipe[0]);
IoUtils.closeQuietly(pipe[1]);
}
return mRenderedPage;
}
@Override
public void onPostExecute(RenderedPage renderedPage) {
if (DEBUG) {
Log.i(LOG_TAG, "Completed rendering page: " + mPageIndex);
}
// This task is done.
mPageToRenderTaskMap.remove(mPageIndex);
// Take a note that the content is rendered.
renderedPage.state = RenderedPage.STATE_RENDERED;
// Announce success if needed.
if (mCallback != null) {
mCallback.onPageContentAvailable(renderedPage.content);
}
}
@Override
protected void onCancelled(RenderedPage renderedPage) {
if (DEBUG) {
Log.i(LOG_TAG, "Cancelled rendering page: " + mPageIndex);
}
// This task is done.
mPageToRenderTaskMap.remove(mPageIndex);
// If canceled before on pre-execute.
if (renderedPage == null) {
return;
}
// Take a note that the content is not rendered.
renderedPage.state = RenderedPage.STATE_SCRAP;
}
public boolean isPreload() {
return mCallback == null;
}
}
}
}
|
