packages/PrintSpooler/src/com/android/printspooler/RemotePrintDocumentAdapter.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2013 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;

 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.ICancellationSignal;
 import android.os.ParcelFileDescriptor;
 import android.os.RemoteException;
 import android.print.ILayoutResultCallback;
 import android.print.IPrintDocumentAdapter;
 import android.print.IWriteResultCallback;
 import android.print.PageRange;
 import android.print.PrintAttributes;
 import android.print.PrintDocumentAdapter.LayoutResultCallback;
 import android.print.PrintDocumentAdapter.WriteResultCallback;
 import android.print.PrintDocumentInfo;
 import android.util.Log;
 import android.util.Slog;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.List;

 import libcore.io.IoUtils;

 /**
  * This class represents a remote print document adapter instance.
  */
 final class RemotePrintDocumentAdapter {
     private static final String LOG_TAG = "RemotePrintDocumentAdapter";

     private static final boolean DEBUG = true;

     public static final int STATE_INITIALIZED = 0;
     public static final int STATE_START_COMPLETED = 1;
     public static final int STATE_LAYOUT_COMPLETED = 2;
     public static final int STATE_WRITE_COMPLETED = 3;
     public static final int STATE_FINISH_COMPLETED = 4;

     private final Object mLock = new Object();

     private final List<QueuedAsyncTask> mTaskQueue = new ArrayList<QueuedAsyncTask>();

     private final IPrintDocumentAdapter mRemoteInterface;

     private final File mFile;

     private int mState = STATE_INITIALIZED;

     public RemotePrintDocumentAdapter(IPrintDocumentAdapter printAdatper, File file) {
         mRemoteInterface = printAdatper;
         mFile = file;
     }

     public File getFile() {
         if (DEBUG) {
             Log.i(LOG_TAG, "getFile()");
         }
         synchronized (mLock) {
             if (mState < STATE_WRITE_COMPLETED) {
                 throw new IllegalStateException("Write not completed");
             }
             return mFile;
         }
     }

     public void cancel() {
         synchronized (mLock) {
             final int taskCount = mTaskQueue.size();
             for (int i = 0; i < taskCount; i++) {
                 mTaskQueue.remove(i).cancel();
             }
         }
     }

     public void start() {
         QueuedAsyncTask task = new QueuedAsyncTask() {
             @Override
             protected Void doInBackground(Void... params) {
                 if (DEBUG) {
                     Log.i(LOG_TAG, "start()");
                 }
                 synchronized (mLock) {
                     if (mState != STATE_INITIALIZED) {
                         throw new IllegalStateException("Invalid state: " + mState);
                     }
                 }
                 try {
                     mRemoteInterface.start();
                     synchronized (mLock) {
                         mState = STATE_START_COMPLETED;
                     }
                 } catch (RemoteException re) {
                     Log.e(LOG_TAG, "Error reading file", re);
                 }
                 return null;
             }
         };
         synchronized (mLock) {
             mTaskQueue.add(task);
             task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, (Void[]) null);
         }
     }

     public void layout(PrintAttributes oldAttributes, PrintAttributes newAttributes,
             LayoutResultCallback callback, Bundle metadata) {
         LayoutAsyncTask task = new LayoutAsyncTask(oldAttributes, newAttributes, callback,
                 metadata);
         synchronized (mLock) {
             mTaskQueue.add(task);
             task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, (Void[]) null);
         }
     }

     public void write(List<PageRange> pages, WriteResultCallback callback) {
         WriteAsyncTask task = new WriteAsyncTask(pages, callback);
         mTaskQueue.add(task);
         task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, (Void[]) null);
     }

     public void finish() {
         QueuedAsyncTask task = new QueuedAsyncTask() {
             @Override
             protected Void doInBackground(Void... params) {
                 if (DEBUG) {
                     Log.i(LOG_TAG, "finish");
                 }
                 synchronized (mLock) {
                     if (mState != STATE_LAYOUT_COMPLETED
                             && mState != STATE_WRITE_COMPLETED) {
                         throw new IllegalStateException("Invalid state: " + mState);
                     }
                 }
                 try {
                     mRemoteInterface.finish();
                     synchronized (mLock) {
                         mState = STATE_FINISH_COMPLETED;
                     }
                 } catch (RemoteException re) {
                     Log.e(LOG_TAG, "Error reading file", re);
                     mState = STATE_INITIALIZED;
                 }
                 return null;
             }
         };
         synchronized (mLock) {
             mTaskQueue.add(task);
             task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, (Void[]) null);
         }
     }

     private abstract class QueuedAsyncTask extends AsyncTask<Void, Void, Void> {
         public void cancel() {
             super.cancel(true);
         }
     }

     private final class LayoutAsyncTask extends QueuedAsyncTask {

         private final PrintAttributes mOldAttributes;

         private final PrintAttributes mNewAttributes;

         private final LayoutResultCallback mCallback;

         private final Bundle mMetadata;

         private final ILayoutResultCallback mILayoutResultCallback =
                 new ILayoutResultCallback.Stub() {
             @Override
             public void onLayoutStarted(ICancellationSignal cancellationSignal) {
                 synchronized (mLock) {
                     mCancellationSignal = cancellationSignal;
                     if (isCancelled()) {
                         cancelSignalQuietlyLocked();
                     }
                 }
             }

             @Override
             public void onLayoutFinished(PrintDocumentInfo info, boolean changed) {
                 synchronized (mLock) {
                     mCancellationSignal = null;
                     mCompleted = true;
                     mLock.notifyAll();
                 }
                 mCallback.onLayoutFinished(info, changed);
             }

             @Override
             public void onLayoutFailed(CharSequence error) {
                 synchronized (mLock) {
                     mCancellationSignal = null;
                     mCompleted = true;
                     mLock.notifyAll();
                 }
                 Slog.e(LOG_TAG, "Error laying out print document: " + error);
                 mCallback.onLayoutFailed(error);
             }
         };

         private ICancellationSignal mCancellationSignal;

         private boolean mCompleted;

         public LayoutAsyncTask(PrintAttributes oldAttributes, PrintAttributes newAttributes,
                 LayoutResultCallback callback, Bundle metadata) {
             mOldAttributes = oldAttributes;
             mNewAttributes = newAttributes;
             mCallback = callback;
             mMetadata = metadata;
         }

         @Override
         public void cancel() {
             synchronized (mLock) {
                 throwIfCancelledLocked();
                 cancelSignalQuietlyLocked();
             }
             super.cancel();
         }

         @Override
         protected Void doInBackground(Void... params) {
             synchronized (mLock) {
                 if (mState != STATE_START_COMPLETED
                         && mState != STATE_LAYOUT_COMPLETED
                         && mState != STATE_WRITE_COMPLETED) {
                     throw new IllegalStateException("Invalid state: " + mState);
                 }
             }
             try {
                 mRemoteInterface.layout(mOldAttributes, mNewAttributes,
                         mILayoutResultCallback, mMetadata);
                 synchronized (mLock) {
                     while (true) {
                         if (isCancelled()) {
                             mState = STATE_INITIALIZED;
                             mTaskQueue.remove(this);
                             break;
                         }
                         if (mCompleted) {
                             mState = STATE_LAYOUT_COMPLETED;
                             mTaskQueue.remove(this);
                             break;
                         }
                         try {
                             mLock.wait();
                         } catch (InterruptedException ie) {
                             /* ignore */
                         }
                     }
                 }
             } catch (RemoteException re) {
                 Slog.e(LOG_TAG, "Error calling layout", re);
                 mState = STATE_INITIALIZED;
             }
             return null;
         }

         private void cancelSignalQuietlyLocked() {
             if (mCancellationSignal != null) {
                 try {
                     mCancellationSignal.cancel();
                 } catch (RemoteException re) {
                     Slog.e(LOG_TAG, "Error cancelling layout", re);
                 }
             }
         }

         private void throwIfCancelledLocked() {
             if (isCancelled()) {
                 throw new IllegalStateException("Already cancelled");
             }
         }
     }

     private final class WriteAsyncTask extends QueuedAsyncTask {

         private final List<PageRange> mPages;

         private final WriteResultCallback mCallback;

         private final IWriteResultCallback mIWriteResultCallback =
                 new IWriteResultCallback.Stub() {
             @Override
             public void onWriteStarted(ICancellationSignal cancellationSignal) {
                 synchronized (mLock) {
                     mCancellationSignal = cancellationSignal;
                     if (isCancelled()) {
                         cancelSignalQuietlyLocked();
                     }
                 }
             }

             @Override
             public void onWriteFinished(List<PageRange> pages) {
                 synchronized (mLock) {
                     mCancellationSignal = null;
                     mCompleted = true;
                     mLock.notifyAll();
                 }
                 mCallback.onWriteFinished(pages);
             }

             @Override
             public void onWriteFailed(CharSequence error) {
                 synchronized (mLock) {
                     mCancellationSignal = null;
                     mCompleted = true;
                     mLock.notifyAll();
                 }
                 Slog.e(LOG_TAG, "Error writing print document: " + error);
                 mCallback.onWriteFailed(error);
             }
         };

         private ICancellationSignal mCancellationSignal;

         private boolean mCompleted;

         private Thread mWriteThread;

         public WriteAsyncTask(List<PageRange> pages, WriteResultCallback callback) {
             mPages = pages;
             mCallback = callback;
         }

         @Override
         public void cancel() {
             synchronized (mLock) {
                 throwIfCancelledLocked();
                 cancelSignalQuietlyLocked();
                 mWriteThread.interrupt();
             }
             super.cancel();
         }

         @Override
         protected Void doInBackground(Void... params) {
             if (DEBUG) {
                 Log.i(LOG_TAG, "print()");
             }
             synchronized (mLock) {
                 if (mState != STATE_LAYOUT_COMPLETED) {
                     throw new IllegalStateException("Invalid state: " + mState);
                 }
             }
             InputStream in = null;
             OutputStream out = null;
             ParcelFileDescriptor source = null;
             ParcelFileDescriptor sink = null;
             synchronized (mLock) {
                 mWriteThread = Thread.currentThread();
             }
             try {
                 ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe();
                 source = pipe[0];
                 sink = pipe[1];

                 in = new FileInputStream(source.getFileDescriptor());
                 out = new FileOutputStream(mFile);

                 // Async call to initiate the other process writing the data.
                 mRemoteInterface.write(mPages, sink, mIWriteResultCallback);

                 // Close the source. It is now held by the client.
                 sink.close();
                 sink = null;

                 final byte[] buffer = new byte[8192];
                 while (true) {
                     if (Thread.currentThread().isInterrupted()) {
                         Thread.currentThread().interrupt();
                         break;
                     }
                     final int readByteCount = in.read(buffer);
                     if (readByteCount < 0) {
                         break;
                     }
                     out.write(buffer, 0, readByteCount);
                 }
                 synchronized (mLock) {
                     while (true) {
                         if (isCancelled()) {
                             mState = STATE_INITIALIZED;
                             mTaskQueue.remove(this);
                             break;
                         }
                         if (mCompleted) {
                             mState = STATE_WRITE_COMPLETED;
                             mTaskQueue.remove(this);
                             break;
                         }
                         try {
                             mLock.wait();
                         } catch (InterruptedException ie) {
                             /* ignore */
                         }
                     }
                 }
             } catch (RemoteException re) {
                 Slog.e(LOG_TAG, "Error writing print document", re);
                 mState = STATE_INITIALIZED;
             } catch (IOException ioe) {
                 Slog.e(LOG_TAG, "Error writing print document", ioe);
                 mState = STATE_INITIALIZED;
             } finally {
                 IoUtils.closeQuietly(in);
                 IoUtils.closeQuietly(out);
                 IoUtils.closeQuietly(sink);
                 IoUtils.closeQuietly(source);
             }
             return null;
         }

         private void cancelSignalQuietlyLocked() {
             if (mCancellationSignal != null) {
                 try {
                     mCancellationSignal.cancel();
                 } catch (RemoteException re) {
                     Slog.e(LOG_TAG, "Error cancelling layout", re);
                 }
             }
         }

         private void throwIfCancelledLocked() {
             if (isCancelled()) {
                 throw new IllegalStateException("Already cancelled");
             }
         }
     }
 }
	/*
	* Copyright (C) 2013 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;

	import android.os.AsyncTask;
	import android.os.Bundle;
	import android.os.ICancellationSignal;
	import android.os.ParcelFileDescriptor;
	import android.os.RemoteException;
	import android.print.ILayoutResultCallback;
	import android.print.IPrintDocumentAdapter;
	import android.print.IWriteResultCallback;
	import android.print.PageRange;
	import android.print.PrintAttributes;
	import android.print.PrintDocumentAdapter.LayoutResultCallback;
	import android.print.PrintDocumentAdapter.WriteResultCallback;
	import android.print.PrintDocumentInfo;
	import android.util.Log;
	import android.util.Slog;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.ArrayList;
	import java.util.List;

	import libcore.io.IoUtils;

	/**
	* This class represents a remote print document adapter instance.
	*/
	final class RemotePrintDocumentAdapter {
	private static final String LOG_TAG = "RemotePrintDocumentAdapter";

	private static final boolean DEBUG = true;

	public static final int STATE_INITIALIZED = 0;
	public static final int STATE_START_COMPLETED = 1;
	public static final int STATE_LAYOUT_COMPLETED = 2;
	public static final int STATE_WRITE_COMPLETED = 3;
	public static final int STATE_FINISH_COMPLETED = 4;

	private final Object mLock = new Object();

	private final List<QueuedAsyncTask> mTaskQueue = new ArrayList<QueuedAsyncTask>();

	private final IPrintDocumentAdapter mRemoteInterface;

	private final File mFile;

	private int mState = STATE_INITIALIZED;

	public RemotePrintDocumentAdapter(IPrintDocumentAdapter printAdatper, File file) {
	mRemoteInterface = printAdatper;
	mFile = file;
	}

	public File getFile() {
	if (DEBUG) {
	Log.i(LOG_TAG, "getFile()");
	}
	synchronized (mLock) {
	if (mState < STATE_WRITE_COMPLETED) {
	throw new IllegalStateException("Write not completed");
	}
	return mFile;
	}
	}

	public void cancel() {
	synchronized (mLock) {
	final int taskCount = mTaskQueue.size();
	for (int i = 0; i < taskCount; i++) {
	mTaskQueue.remove(i).cancel();
	}
	}
	}

	public void start() {
	QueuedAsyncTask task = new QueuedAsyncTask() {
	@Override
	protected Void doInBackground(Void... params) {
	if (DEBUG) {
	Log.i(LOG_TAG, "start()");
	}
	synchronized (mLock) {
	if (mState != STATE_INITIALIZED) {
	throw new IllegalStateException("Invalid state: " + mState);
	}
	}
	try {
	mRemoteInterface.start();
	synchronized (mLock) {
	mState = STATE_START_COMPLETED;
	}
	} catch (RemoteException re) {
	Log.e(LOG_TAG, "Error reading file", re);
	}
	return null;
	}
	};
	synchronized (mLock) {
	mTaskQueue.add(task);
	task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, (Void[]) null);
	}
	}

	public void layout(PrintAttributes oldAttributes, PrintAttributes newAttributes,
	LayoutResultCallback callback, Bundle metadata) {
	LayoutAsyncTask task = new LayoutAsyncTask(oldAttributes, newAttributes, callback,
	metadata);
	synchronized (mLock) {
	mTaskQueue.add(task);
	task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, (Void[]) null);
	}
	}

	public void write(List<PageRange> pages, WriteResultCallback callback) {
	WriteAsyncTask task = new WriteAsyncTask(pages, callback);
	mTaskQueue.add(task);
	task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, (Void[]) null);
	}

	public void finish() {
	QueuedAsyncTask task = new QueuedAsyncTask() {
	@Override
	protected Void doInBackground(Void... params) {
	if (DEBUG) {
	Log.i(LOG_TAG, "finish");
	}
	synchronized (mLock) {
	if (mState != STATE_LAYOUT_COMPLETED
	&& mState != STATE_WRITE_COMPLETED) {
	throw new IllegalStateException("Invalid state: " + mState);
	}
	}
	try {
	mRemoteInterface.finish();
	synchronized (mLock) {
	mState = STATE_FINISH_COMPLETED;
	}
	} catch (RemoteException re) {
	Log.e(LOG_TAG, "Error reading file", re);
	mState = STATE_INITIALIZED;
	}
	return null;
	}
	};
	synchronized (mLock) {
	mTaskQueue.add(task);
	task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, (Void[]) null);
	}
	}

	private abstract class QueuedAsyncTask extends AsyncTask<Void, Void, Void> {
	public void cancel() {
	super.cancel(true);
	}
	}

	private final class LayoutAsyncTask extends QueuedAsyncTask {

	private final PrintAttributes mOldAttributes;

	private final PrintAttributes mNewAttributes;

	private final LayoutResultCallback mCallback;

	private final Bundle mMetadata;

	private final ILayoutResultCallback mILayoutResultCallback =
	new ILayoutResultCallback.Stub() {
	@Override
	public void onLayoutStarted(ICancellationSignal cancellationSignal) {
	synchronized (mLock) {
	mCancellationSignal = cancellationSignal;
	if (isCancelled()) {
	cancelSignalQuietlyLocked();
	}
	}
	}

	@Override
	public void onLayoutFinished(PrintDocumentInfo info, boolean changed) {
	synchronized (mLock) {
	mCancellationSignal = null;
	mCompleted = true;
	mLock.notifyAll();
	}
	mCallback.onLayoutFinished(info, changed);
	}

	@Override
	public void onLayoutFailed(CharSequence error) {
	synchronized (mLock) {
	mCancellationSignal = null;
	mCompleted = true;
	mLock.notifyAll();
	}
	Slog.e(LOG_TAG, "Error laying out print document: " + error);
	mCallback.onLayoutFailed(error);
	}
	};

	private ICancellationSignal mCancellationSignal;

	private boolean mCompleted;

	public LayoutAsyncTask(PrintAttributes oldAttributes, PrintAttributes newAttributes,
	LayoutResultCallback callback, Bundle metadata) {
	mOldAttributes = oldAttributes;
	mNewAttributes = newAttributes;
	mCallback = callback;
	mMetadata = metadata;
	}

	@Override
	public void cancel() {
	synchronized (mLock) {
	throwIfCancelledLocked();
	cancelSignalQuietlyLocked();
	}
	super.cancel();
	}

	@Override
	protected Void doInBackground(Void... params) {
	synchronized (mLock) {
	if (mState != STATE_START_COMPLETED
	&& mState != STATE_LAYOUT_COMPLETED
	&& mState != STATE_WRITE_COMPLETED) {
	throw new IllegalStateException("Invalid state: " + mState);
	}
	}
	try {
	mRemoteInterface.layout(mOldAttributes, mNewAttributes,
	mILayoutResultCallback, mMetadata);
	synchronized (mLock) {
	while (true) {
	if (isCancelled()) {
	mState = STATE_INITIALIZED;
	mTaskQueue.remove(this);
	break;
	}
	if (mCompleted) {
	mState = STATE_LAYOUT_COMPLETED;
	mTaskQueue.remove(this);
	break;
	}
	try {
	mLock.wait();
	} catch (InterruptedException ie) {
	/* ignore */
	}
	}
	}
	} catch (RemoteException re) {
	Slog.e(LOG_TAG, "Error calling layout", re);
	mState = STATE_INITIALIZED;
	}
	return null;
	}

	private void cancelSignalQuietlyLocked() {
	if (mCancellationSignal != null) {
	try {
	mCancellationSignal.cancel();
	} catch (RemoteException re) {
	Slog.e(LOG_TAG, "Error cancelling layout", re);
	}
	}
	}

	private void throwIfCancelledLocked() {
	if (isCancelled()) {
	throw new IllegalStateException("Already cancelled");
	}
	}
	}

	private final class WriteAsyncTask extends QueuedAsyncTask {

	private final List<PageRange> mPages;

	private final WriteResultCallback mCallback;

	private final IWriteResultCallback mIWriteResultCallback =
	new IWriteResultCallback.Stub() {
	@Override
	public void onWriteStarted(ICancellationSignal cancellationSignal) {
	synchronized (mLock) {
	mCancellationSignal = cancellationSignal;
	if (isCancelled()) {
	cancelSignalQuietlyLocked();
	}
	}
	}

	@Override
	public void onWriteFinished(List<PageRange> pages) {
	synchronized (mLock) {
	mCancellationSignal = null;
	mCompleted = true;
	mLock.notifyAll();
	}
	mCallback.onWriteFinished(pages);
	}

	@Override
	public void onWriteFailed(CharSequence error) {
	synchronized (mLock) {
	mCancellationSignal = null;
	mCompleted = true;
	mLock.notifyAll();
	}
	Slog.e(LOG_TAG, "Error writing print document: " + error);
	mCallback.onWriteFailed(error);
	}
	};

	private ICancellationSignal mCancellationSignal;

	private boolean mCompleted;

	private Thread mWriteThread;

	public WriteAsyncTask(List<PageRange> pages, WriteResultCallback callback) {
	mPages = pages;
	mCallback = callback;
	}

	@Override
	public void cancel() {
	synchronized (mLock) {
	throwIfCancelledLocked();
	cancelSignalQuietlyLocked();
	mWriteThread.interrupt();
	}
	super.cancel();
	}

	@Override
	protected Void doInBackground(Void... params) {
	if (DEBUG) {
	Log.i(LOG_TAG, "print()");
	}
	synchronized (mLock) {
	if (mState != STATE_LAYOUT_COMPLETED) {
	throw new IllegalStateException("Invalid state: " + mState);
	}
	}
	InputStream in = null;
	OutputStream out = null;
	ParcelFileDescriptor source = null;
	ParcelFileDescriptor sink = null;
	synchronized (mLock) {
	mWriteThread = Thread.currentThread();
	}
	try {
	ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe();
	source = pipe[0];
	sink = pipe[1];

	in = new FileInputStream(source.getFileDescriptor());
	out = new FileOutputStream(mFile);

	// Async call to initiate the other process writing the data.
	mRemoteInterface.write(mPages, sink, mIWriteResultCallback);

	// Close the source. It is now held by the client.
	sink.close();
	sink = null;

	final byte[] buffer = new byte[8192];
	while (true) {
	if (Thread.currentThread().isInterrupted()) {
	Thread.currentThread().interrupt();
	break;
	}
	final int readByteCount = in.read(buffer);
	if (readByteCount < 0) {
	break;
	}
	out.write(buffer, 0, readByteCount);
	}
	synchronized (mLock) {
	while (true) {
	if (isCancelled()) {
	mState = STATE_INITIALIZED;
	mTaskQueue.remove(this);
	break;
	}
	if (mCompleted) {
	mState = STATE_WRITE_COMPLETED;
	mTaskQueue.remove(this);
	break;
	}
	try {
	mLock.wait();
	} catch (InterruptedException ie) {
	/* ignore */
	}
	}
	}
	} catch (RemoteException re) {
	Slog.e(LOG_TAG, "Error writing print document", re);
	mState = STATE_INITIALIZED;
	} catch (IOException ioe) {
	Slog.e(LOG_TAG, "Error writing print document", ioe);
	mState = STATE_INITIALIZED;
	} finally {
	IoUtils.closeQuietly(in);
	IoUtils.closeQuietly(out);
	IoUtils.closeQuietly(sink);
	IoUtils.closeQuietly(source);
	}
	return null;
	}

	private void cancelSignalQuietlyLocked() {
	if (mCancellationSignal != null) {
	try {
	mCancellationSignal.cancel();
	} catch (RemoteException re) {
	Slog.e(LOG_TAG, "Error cancelling layout", re);
	}
	}
	}

	private void throwIfCancelledLocked() {
	if (isCancelled()) {
	throw new IllegalStateException("Already cancelled");
	}
	}
	}
	}