packages/ExternalStorageProvider/src/com/android/externalstorage/TestDocumentsProvider.java - platform/frameworks/base - Git at Google

 /*
  * 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.externalstorage;

 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.pm.ProviderInfo;
 import android.content.res.AssetFileDescriptor;
 import android.database.Cursor;
 import android.database.MatrixCursor;
 import android.database.MatrixCursor.RowBuilder;
 import android.graphics.Bitmap;
 import android.graphics.Bitmap.CompressFormat;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Point;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.CancellationSignal;
 import android.os.CancellationSignal.OnCancelListener;
 import android.os.ParcelFileDescriptor;
 import android.os.SystemClock;
 import android.provider.DocumentsContract;
 import android.provider.DocumentsContract.Document;
 import android.provider.DocumentsContract.Root;
 import android.provider.DocumentsProvider;
 import android.util.Log;

 import libcore.io.IoUtils;
 import libcore.io.Streams;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.ref.WeakReference;

 public class TestDocumentsProvider extends DocumentsProvider {
     private static final String TAG = "TestDocuments";

     private static final boolean LAG = false;

     private static final boolean ROOTS_WEDGE = false;
     private static final boolean ROOTS_CRASH = false;
     private static final boolean ROOTS_REFRESH = false;

     private static final boolean DOCUMENT_CRASH = false;

     private static final boolean RECENT_WEDGE = false;

     private static final boolean CHILD_WEDGE = false;
     private static final boolean CHILD_CRASH = false;

     private static final boolean THUMB_HUNDREDS = false;
     private static final boolean THUMB_WEDGE = false;
     private static final boolean THUMB_CRASH = false;

     private static final String MY_ROOT_ID = "myRoot";
     private static final String MY_DOC_ID = "myDoc";
     private static final String MY_DOC_NULL = "myNull";

     private static final String[] DEFAULT_ROOT_PROJECTION = new String[] {
             Root.COLUMN_ROOT_ID, Root.COLUMN_FLAGS, Root.COLUMN_ICON,
             Root.COLUMN_TITLE, Root.COLUMN_SUMMARY, Root.COLUMN_DOCUMENT_ID,
             Root.COLUMN_AVAILABLE_BYTES,
     };

     private static final String[] DEFAULT_DOCUMENT_PROJECTION = new String[] {
             Document.COLUMN_DOCUMENT_ID, Document.COLUMN_MIME_TYPE, Document.COLUMN_DISPLAY_NAME,
             Document.COLUMN_LAST_MODIFIED, Document.COLUMN_FLAGS, Document.COLUMN_SIZE,
     };

     private static String[] resolveRootProjection(String[] projection) {
         return projection != null ? projection : DEFAULT_ROOT_PROJECTION;
     }

     private static String[] resolveDocumentProjection(String[] projection) {
         return projection != null ? projection : DEFAULT_DOCUMENT_PROJECTION;
     }

     private String mAuthority;

     @Override
     public void attachInfo(Context context, ProviderInfo info) {
         mAuthority = info.authority;
         super.attachInfo(context, info);
     }

     @Override
     public Cursor queryRoots(String[] projection) throws FileNotFoundException {
         Log.d(TAG, "Someone asked for our roots!");

         if (LAG) lagUntilCanceled(null);
         if (ROOTS_WEDGE) wedgeUntilCanceled(null);
         if (ROOTS_CRASH) System.exit(12);

         if (ROOTS_REFRESH) {
             new AsyncTask<Void, Void, Void>() {
                 @Override
                 protected Void doInBackground(Void... params) {
                     SystemClock.sleep(3000);
                     Log.d(TAG, "Notifying that something changed!!");
                     final Uri uri = DocumentsContract.buildRootsUri(mAuthority);
                     getContext().getContentResolver().notifyChange(uri, null, false);
                     return null;
                 }
             }.execute();
         }

         final MatrixCursor result = new MatrixCursor(resolveRootProjection(projection));
         final RowBuilder row = result.newRow();
         row.add(Root.COLUMN_ROOT_ID, MY_ROOT_ID);
         row.add(Root.COLUMN_FLAGS, Root.FLAG_SUPPORTS_RECENTS);
         row.add(Root.COLUMN_TITLE, "_Test title which is really long");
         row.add(Root.COLUMN_SUMMARY,
                 SystemClock.elapsedRealtime() + " summary which is also super long text");
         row.add(Root.COLUMN_DOCUMENT_ID, MY_DOC_ID);
         row.add(Root.COLUMN_AVAILABLE_BYTES, 1024);
         return result;
     }

     @Override
     public Cursor queryDocument(String documentId, String[] projection)
             throws FileNotFoundException {
         if (LAG) lagUntilCanceled(null);
         if (DOCUMENT_CRASH) System.exit(12);

         final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
         includeFile(result, documentId, 0);
         return result;
     }

     /**
      * Holds any outstanding or finished "network" fetching.
      */
     private WeakReference<CloudTask> mTask;

     private static class CloudTask implements Runnable {

         private final ContentResolver mResolver;
         private final Uri mNotifyUri;

         private volatile boolean mFinished;

         public CloudTask(ContentResolver resolver, Uri notifyUri) {
             mResolver = resolver;
             mNotifyUri = notifyUri;
         }

         @Override
         public void run() {
             // Pretend to do some network
             Log.d(TAG, hashCode() + ": pretending to do some network!");
             SystemClock.sleep(2000);
             Log.d(TAG, hashCode() + ": network done!");

             mFinished = true;

             // Tell anyone remotely they should requery
             mResolver.notifyChange(mNotifyUri, null, false);
         }

         public boolean includeIfFinished(MatrixCursor result) {
             Log.d(TAG, hashCode() + ": includeIfFinished() found " + mFinished);
             if (mFinished) {
                 includeFile(result, "_networkfile1", 0);
                 includeFile(result, "_networkfile2", 0);
                 includeFile(result, "_networkfile3", 0);
                 includeFile(result, "_networkfile4", 0);
                 includeFile(result, "_networkfile5", 0);
                 includeFile(result, "_networkfile6", 0);
                 return true;
             } else {
                 return false;
             }
         }
     }

     private static class CloudCursor extends MatrixCursor {
         public Object keepAlive;
         public final Bundle extras = new Bundle();

         public CloudCursor(String[] columnNames) {
             super(columnNames);
         }

         @Override
         public Bundle getExtras() {
             return extras;
         }
     }

     @Override
     public Cursor queryChildDocuments(
             String parentDocumentId, String[] projection, String sortOrder)
             throws FileNotFoundException {

         if (LAG) lagUntilCanceled(null);
         if (CHILD_WEDGE) SystemClock.sleep(Integer.MAX_VALUE);
         if (CHILD_CRASH) System.exit(12);

         final ContentResolver resolver = getContext().getContentResolver();
         final Uri notifyUri = DocumentsContract.buildDocumentUri(
                 "com.example.documents", parentDocumentId);

         CloudCursor result = new CloudCursor(resolveDocumentProjection(projection));
         result.setNotificationUri(resolver, notifyUri);

         // Always include local results
         includeFile(result, MY_DOC_NULL, 0);
         includeFile(result, "localfile1", 0);
         includeFile(result, "localfile2", Document.FLAG_SUPPORTS_THUMBNAIL);
         includeFile(result, "localfile3", 0);
         includeFile(result, "localfile4", 0);

         if (THUMB_HUNDREDS) {
             for (int i = 0; i < 256; i++) {
                 includeFile(result, "i maded u an picshure" + i, Document.FLAG_SUPPORTS_THUMBNAIL);
             }
         }

         synchronized (this) {
             // Try picking up an existing network fetch
             CloudTask task = mTask != null ? mTask.get() : null;
             if (task == null) {
                 Log.d(TAG, "No network task found; starting!");
                 task = new CloudTask(resolver, notifyUri);
                 mTask = new WeakReference<CloudTask>(task);
                 new Thread(task).start();

                 // Aggressively try freeing weak reference above
                 new Thread() {
                     @Override
                     public void run() {
                         while (mTask.get() != null) {
                             SystemClock.sleep(200);
                             System.gc();
                             System.runFinalization();
                         }
                         Log.d(TAG, "AHA! THE CLOUD TASK WAS GC'ED!");
                     }
                 }.start();
             }

             // Blend in cloud results if ready
             if (task.includeIfFinished(result)) {
                 result.extras.putString(DocumentsContract.EXTRA_INFO,
                         "Everything Went Better Than Expected and this message is quite "
                                 + "long and verbose and maybe even too long");
                 result.extras.putString(DocumentsContract.EXTRA_ERROR,
                         "But then again, maybe our server ran into an error, which means "
                                 + "we're going to have a bad time");
             } else {
                 result.extras.putBoolean(DocumentsContract.EXTRA_LOADING, true);
             }

             // Tie the network fetch to the cursor GC lifetime
             result.keepAlive = task;

             return result;
         }
     }

     @Override
     public Cursor queryRecentDocuments(String rootId, String[] projection)
             throws FileNotFoundException {

         if (LAG) lagUntilCanceled(null);
         if (RECENT_WEDGE) wedgeUntilCanceled(null);

         // Pretend to take a super long time to respond
         SystemClock.sleep(3000);

         final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
         includeFile(
                 result, "It was /worth/ the_wait for?the file:with the&incredibly long name", 0);
         return result;
     }

     @Override
     public ParcelFileDescriptor openDocument(String docId, String mode, CancellationSignal signal)
             throws FileNotFoundException {
         if (LAG) lagUntilCanceled(null);
         throw new FileNotFoundException();
     }

     @Override
     public AssetFileDescriptor openDocumentThumbnail(
             String docId, Point sizeHint, CancellationSignal signal) throws FileNotFoundException {

         if (LAG) lagUntilCanceled(signal);
         if (THUMB_WEDGE) wedgeUntilCanceled(signal);
         if (THUMB_CRASH) System.exit(12);

         final Bitmap bitmap = Bitmap.createBitmap(32, 32, Bitmap.Config.ARGB_8888);
         final Canvas canvas = new Canvas(bitmap);
         final Paint paint = new Paint();
         paint.setColor(Color.BLUE);
         canvas.drawColor(Color.RED);
         canvas.drawLine(0, 0, 32, 32, paint);

         final ByteArrayOutputStream bos = new ByteArrayOutputStream();
         bitmap.compress(CompressFormat.JPEG, 50, bos);

         final ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
         try {
             final ParcelFileDescriptor[] fds = ParcelFileDescriptor.createReliablePipe();
             new AsyncTask<Object, Object, Object>() {
                 @Override
                 protected Object doInBackground(Object... params) {
                     final FileOutputStream fos = new FileOutputStream(fds[1].getFileDescriptor());
                     try {
                         Streams.copy(bis, fos);
                     } catch (IOException e) {
                         throw new RuntimeException(e);
                     }
                     IoUtils.closeQuietly(fds[1]);
                     return null;
                 }
             }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
             return new AssetFileDescriptor(fds[0], 0, AssetFileDescriptor.UNKNOWN_LENGTH);
         } catch (IOException e) {
             throw new FileNotFoundException(e.getMessage());
         }
     }

     @Override
     public boolean onCreate() {
         return true;
     }

     private static void lagUntilCanceled(CancellationSignal signal) {
         waitForCancelOrTimeout(signal, 1500);
     }

     private static void wedgeUntilCanceled(CancellationSignal signal) {
         waitForCancelOrTimeout(signal, Integer.MAX_VALUE);
     }

     private static void waitForCancelOrTimeout(
             final CancellationSignal signal, long timeoutMillis) {
         if (signal != null) {
             final Thread blocked = Thread.currentThread();
             signal.setOnCancelListener(new OnCancelListener() {
                 @Override
                 public void onCancel() {
                     blocked.interrupt();
                 }
             });
             signal.throwIfCanceled();
         }

         try {
             Thread.sleep(timeoutMillis);
         } catch (InterruptedException e) {
         }

         if (signal != null) {
             signal.throwIfCanceled();
         }
     }

     private static void includeFile(MatrixCursor result, String docId, int flags) {
         final RowBuilder row = result.newRow();
         row.add(Document.COLUMN_DOCUMENT_ID, docId);
         row.add(Document.COLUMN_DISPLAY_NAME, docId);
         row.add(Document.COLUMN_LAST_MODIFIED, System.currentTimeMillis());
         row.add(Document.COLUMN_FLAGS, flags);

         if (MY_DOC_ID.equals(docId)) {
             row.add(Document.COLUMN_MIME_TYPE, Document.MIME_TYPE_DIR);
         } else if (MY_DOC_NULL.equals(docId)) {
             // No MIME type
         } else {
             row.add(Document.COLUMN_MIME_TYPE, "application/octet-stream");
         }
     }
 }
	/*
	* 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.externalstorage;

	import android.content.ContentResolver;
	import android.content.Context;
	import android.content.pm.ProviderInfo;
	import android.content.res.AssetFileDescriptor;
	import android.database.Cursor;
	import android.database.MatrixCursor;
	import android.database.MatrixCursor.RowBuilder;
	import android.graphics.Bitmap;
	import android.graphics.Bitmap.CompressFormat;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Paint;
	import android.graphics.Point;
	import android.net.Uri;
	import android.os.AsyncTask;
	import android.os.Bundle;
	import android.os.CancellationSignal;
	import android.os.CancellationSignal.OnCancelListener;
	import android.os.ParcelFileDescriptor;
	import android.os.SystemClock;
	import android.provider.DocumentsContract;
	import android.provider.DocumentsContract.Document;
	import android.provider.DocumentsContract.Root;
	import android.provider.DocumentsProvider;
	import android.util.Log;

	import libcore.io.IoUtils;
	import libcore.io.Streams;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.lang.ref.WeakReference;

	public class TestDocumentsProvider extends DocumentsProvider {
	private static final String TAG = "TestDocuments";

	private static final boolean LAG = false;

	private static final boolean ROOTS_WEDGE = false;
	private static final boolean ROOTS_CRASH = false;
	private static final boolean ROOTS_REFRESH = false;

	private static final boolean DOCUMENT_CRASH = false;

	private static final boolean RECENT_WEDGE = false;

	private static final boolean CHILD_WEDGE = false;
	private static final boolean CHILD_CRASH = false;

	private static final boolean THUMB_HUNDREDS = false;
	private static final boolean THUMB_WEDGE = false;
	private static final boolean THUMB_CRASH = false;

	private static final String MY_ROOT_ID = "myRoot";
	private static final String MY_DOC_ID = "myDoc";
	private static final String MY_DOC_NULL = "myNull";

	private static final String[] DEFAULT_ROOT_PROJECTION = new String[] {
	Root.COLUMN_ROOT_ID, Root.COLUMN_FLAGS, Root.COLUMN_ICON,
	Root.COLUMN_TITLE, Root.COLUMN_SUMMARY, Root.COLUMN_DOCUMENT_ID,
	Root.COLUMN_AVAILABLE_BYTES,
	};

	private static final String[] DEFAULT_DOCUMENT_PROJECTION = new String[] {
	Document.COLUMN_DOCUMENT_ID, Document.COLUMN_MIME_TYPE, Document.COLUMN_DISPLAY_NAME,
	Document.COLUMN_LAST_MODIFIED, Document.COLUMN_FLAGS, Document.COLUMN_SIZE,
	};

	private static String[] resolveRootProjection(String[] projection) {
	return projection != null ? projection : DEFAULT_ROOT_PROJECTION;
	}

	private static String[] resolveDocumentProjection(String[] projection) {
	return projection != null ? projection : DEFAULT_DOCUMENT_PROJECTION;
	}

	private String mAuthority;

	@Override
	public void attachInfo(Context context, ProviderInfo info) {
	mAuthority = info.authority;
	super.attachInfo(context, info);
	}

	@Override
	public Cursor queryRoots(String[] projection) throws FileNotFoundException {
	Log.d(TAG, "Someone asked for our roots!");

	if (LAG) lagUntilCanceled(null);
	if (ROOTS_WEDGE) wedgeUntilCanceled(null);
	if (ROOTS_CRASH) System.exit(12);

	if (ROOTS_REFRESH) {
	new AsyncTask<Void, Void, Void>() {
	@Override
	protected Void doInBackground(Void... params) {
	SystemClock.sleep(3000);
	Log.d(TAG, "Notifying that something changed!!");
	final Uri uri = DocumentsContract.buildRootsUri(mAuthority);
	getContext().getContentResolver().notifyChange(uri, null, false);
	return null;
	}
	}.execute();
	}

	final MatrixCursor result = new MatrixCursor(resolveRootProjection(projection));
	final RowBuilder row = result.newRow();
	row.add(Root.COLUMN_ROOT_ID, MY_ROOT_ID);
	row.add(Root.COLUMN_FLAGS, Root.FLAG_SUPPORTS_RECENTS);
	row.add(Root.COLUMN_TITLE, "_Test title which is really long");
	row.add(Root.COLUMN_SUMMARY,
	SystemClock.elapsedRealtime() + " summary which is also super long text");
	row.add(Root.COLUMN_DOCUMENT_ID, MY_DOC_ID);
	row.add(Root.COLUMN_AVAILABLE_BYTES, 1024);
	return result;
	}

	@Override
	public Cursor queryDocument(String documentId, String[] projection)
	throws FileNotFoundException {
	if (LAG) lagUntilCanceled(null);
	if (DOCUMENT_CRASH) System.exit(12);

	final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
	includeFile(result, documentId, 0);
	return result;
	}

	/**
	* Holds any outstanding or finished "network" fetching.
	*/
	private WeakReference<CloudTask> mTask;

	private static class CloudTask implements Runnable {

	private final ContentResolver mResolver;
	private final Uri mNotifyUri;

	private volatile boolean mFinished;

	public CloudTask(ContentResolver resolver, Uri notifyUri) {
	mResolver = resolver;
	mNotifyUri = notifyUri;
	}

	@Override
	public void run() {
	// Pretend to do some network
	Log.d(TAG, hashCode() + ": pretending to do some network!");
	SystemClock.sleep(2000);
	Log.d(TAG, hashCode() + ": network done!");

	mFinished = true;

	// Tell anyone remotely they should requery
	mResolver.notifyChange(mNotifyUri, null, false);
	}

	public boolean includeIfFinished(MatrixCursor result) {
	Log.d(TAG, hashCode() + ": includeIfFinished() found " + mFinished);
	if (mFinished) {
	includeFile(result, "_networkfile1", 0);
	includeFile(result, "_networkfile2", 0);
	includeFile(result, "_networkfile3", 0);
	includeFile(result, "_networkfile4", 0);
	includeFile(result, "_networkfile5", 0);
	includeFile(result, "_networkfile6", 0);
	return true;
	} else {
	return false;
	}
	}
	}

	private static class CloudCursor extends MatrixCursor {
	public Object keepAlive;
	public final Bundle extras = new Bundle();

	public CloudCursor(String[] columnNames) {
	super(columnNames);
	}

	@Override
	public Bundle getExtras() {
	return extras;
	}
	}

	@Override
	public Cursor queryChildDocuments(
	String parentDocumentId, String[] projection, String sortOrder)
	throws FileNotFoundException {

	if (LAG) lagUntilCanceled(null);
	if (CHILD_WEDGE) SystemClock.sleep(Integer.MAX_VALUE);
	if (CHILD_CRASH) System.exit(12);

	final ContentResolver resolver = getContext().getContentResolver();
	final Uri notifyUri = DocumentsContract.buildDocumentUri(
	"com.example.documents", parentDocumentId);

	CloudCursor result = new CloudCursor(resolveDocumentProjection(projection));
	result.setNotificationUri(resolver, notifyUri);

	// Always include local results
	includeFile(result, MY_DOC_NULL, 0);
	includeFile(result, "localfile1", 0);
	includeFile(result, "localfile2", Document.FLAG_SUPPORTS_THUMBNAIL);
	includeFile(result, "localfile3", 0);
	includeFile(result, "localfile4", 0);

	if (THUMB_HUNDREDS) {
	for (int i = 0; i < 256; i++) {
	includeFile(result, "i maded u an picshure" + i, Document.FLAG_SUPPORTS_THUMBNAIL);
	}
	}

	synchronized (this) {
	// Try picking up an existing network fetch
	CloudTask task = mTask != null ? mTask.get() : null;
	if (task == null) {
	Log.d(TAG, "No network task found; starting!");
	task = new CloudTask(resolver, notifyUri);
	mTask = new WeakReference<CloudTask>(task);
	new Thread(task).start();

	// Aggressively try freeing weak reference above
	new Thread() {
	@Override
	public void run() {
	while (mTask.get() != null) {
	SystemClock.sleep(200);
	System.gc();
	System.runFinalization();
	}
	Log.d(TAG, "AHA! THE CLOUD TASK WAS GC'ED!");
	}
	}.start();
	}

	// Blend in cloud results if ready
	if (task.includeIfFinished(result)) {
	result.extras.putString(DocumentsContract.EXTRA_INFO,
	"Everything Went Better Than Expected and this message is quite "
	+ "long and verbose and maybe even too long");
	result.extras.putString(DocumentsContract.EXTRA_ERROR,
	"But then again, maybe our server ran into an error, which means "
	+ "we're going to have a bad time");
	} else {
	result.extras.putBoolean(DocumentsContract.EXTRA_LOADING, true);
	}

	// Tie the network fetch to the cursor GC lifetime
	result.keepAlive = task;

	return result;
	}
	}

	@Override
	public Cursor queryRecentDocuments(String rootId, String[] projection)
	throws FileNotFoundException {

	if (LAG) lagUntilCanceled(null);
	if (RECENT_WEDGE) wedgeUntilCanceled(null);

	// Pretend to take a super long time to respond
	SystemClock.sleep(3000);

	final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
	includeFile(
	result, "It was /worth/ the_wait for?the file:with the&incredibly long name", 0);
	return result;
	}

	@Override
	public ParcelFileDescriptor openDocument(String docId, String mode, CancellationSignal signal)
	throws FileNotFoundException {
	if (LAG) lagUntilCanceled(null);
	throw new FileNotFoundException();
	}

	@Override
	public AssetFileDescriptor openDocumentThumbnail(
	String docId, Point sizeHint, CancellationSignal signal) throws FileNotFoundException {

	if (LAG) lagUntilCanceled(signal);
	if (THUMB_WEDGE) wedgeUntilCanceled(signal);
	if (THUMB_CRASH) System.exit(12);

	final Bitmap bitmap = Bitmap.createBitmap(32, 32, Bitmap.Config.ARGB_8888);
	final Canvas canvas = new Canvas(bitmap);
	final Paint paint = new Paint();
	paint.setColor(Color.BLUE);
	canvas.drawColor(Color.RED);
	canvas.drawLine(0, 0, 32, 32, paint);

	final ByteArrayOutputStream bos = new ByteArrayOutputStream();
	bitmap.compress(CompressFormat.JPEG, 50, bos);

	final ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
	try {
	final ParcelFileDescriptor[] fds = ParcelFileDescriptor.createReliablePipe();
	new AsyncTask<Object, Object, Object>() {
	@Override
	protected Object doInBackground(Object... params) {
	final FileOutputStream fos = new FileOutputStream(fds[1].getFileDescriptor());
	try {
	Streams.copy(bis, fos);
	} catch (IOException e) {
	throw new RuntimeException(e);
	}
	IoUtils.closeQuietly(fds[1]);
	return null;
	}
	}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
	return new AssetFileDescriptor(fds[0], 0, AssetFileDescriptor.UNKNOWN_LENGTH);
	} catch (IOException e) {
	throw new FileNotFoundException(e.getMessage());
	}
	}

	@Override
	public boolean onCreate() {
	return true;
	}

	private static void lagUntilCanceled(CancellationSignal signal) {
	waitForCancelOrTimeout(signal, 1500);
	}

	private static void wedgeUntilCanceled(CancellationSignal signal) {
	waitForCancelOrTimeout(signal, Integer.MAX_VALUE);
	}

	private static void waitForCancelOrTimeout(
	final CancellationSignal signal, long timeoutMillis) {
	if (signal != null) {
	final Thread blocked = Thread.currentThread();
	signal.setOnCancelListener(new OnCancelListener() {
	@Override
	public void onCancel() {
	blocked.interrupt();
	}
	});
	signal.throwIfCanceled();
	}

	try {
	Thread.sleep(timeoutMillis);
	} catch (InterruptedException e) {
	}

	if (signal != null) {
	signal.throwIfCanceled();
	}
	}

	private static void includeFile(MatrixCursor result, String docId, int flags) {
	final RowBuilder row = result.newRow();
	row.add(Document.COLUMN_DOCUMENT_ID, docId);
	row.add(Document.COLUMN_DISPLAY_NAME, docId);
	row.add(Document.COLUMN_LAST_MODIFIED, System.currentTimeMillis());
	row.add(Document.COLUMN_FLAGS, flags);

	if (MY_DOC_ID.equals(docId)) {
	row.add(Document.COLUMN_MIME_TYPE, Document.MIME_TYPE_DIR);
	} else if (MY_DOC_NULL.equals(docId)) {
	// No MIME type
	} else {
	row.add(Document.COLUMN_MIME_TYPE, "application/octet-stream");
	}
	}
	}