car-apps-common/src/com/android/car/apps/common/BitmapWorkerTask.java - platform/packages/apps/Car/libs - Git at Google

 /*
  * Copyright (C) 2016 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.car.apps.common;

 import android.accounts.Account;
 import android.accounts.AccountManager;
 import android.content.Context;
 import android.content.Intent.ShortcutIconResource;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.res.Resources;
 import android.content.res.Resources.NotFoundException;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Canvas;
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.util.Log;
 import android.util.TypedValue;
 import android.widget.ImageView;

 import java.io.BufferedInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.ref.WeakReference;
 import java.net.HttpURLConnection;
 import java.net.URL;

 /**
  * AsyncTask which loads a bitmap.
  * <p>
  * The source of this can be another package (via a resource), a URI (content provider), or
  * a file path.
  *
  * @see BitmapWorkerOptions
  * @hide
  */
 public class BitmapWorkerTask extends AsyncTask<BitmapWorkerOptions, Void, Bitmap> {

     private static final String TAG = "BitmapWorker";
     private static final String GOOGLE_ACCOUNT_TYPE = "com.google";

     private static final boolean DEBUG = false;

     private static final int SOCKET_TIMEOUT = 10000;
     private static final int READ_TIMEOUT = 10000;

     private final WeakReference<ImageView> mImageView;
     // a flag for if the bitmap is scaled from original source
     protected boolean mScaled;

     public BitmapWorkerTask(ImageView imageView) {
         mImageView = new WeakReference<ImageView>(imageView);
         mScaled = false;
     }

     @Override
     protected Bitmap doInBackground(BitmapWorkerOptions... params) {

         return retrieveBitmap(params[0]);
     }

     protected Bitmap retrieveBitmap(BitmapWorkerOptions workerOptions) {
         try {
             if (workerOptions.getIconResource() != null) {
                 return getBitmapFromResource(workerOptions.getContext(),
                         workerOptions.getIconResource(),
                         workerOptions);
             } else if (workerOptions.getResourceUri() != null) {
                 if (UriUtils.isAndroidResourceUri(workerOptions.getResourceUri())
                         || UriUtils.isShortcutIconResourceUri(workerOptions.getResourceUri())) {
                     // Make an icon resource from this.
                     return getBitmapFromResource(workerOptions.getContext(),
                             UriUtils.getIconResource(workerOptions.getResourceUri()),
                             workerOptions);
                 } else if (UriUtils.isWebUri(workerOptions.getResourceUri())) {
                         return getBitmapFromHttp(workerOptions);
                 } else if (UriUtils.isContentUri(workerOptions.getResourceUri())) {
                     return getBitmapFromContent(workerOptions);
                 } else if (UriUtils.isAccountImageUri(workerOptions.getResourceUri())) {
                     return getAccountImage(workerOptions);
                 } else {
                     Log.e(TAG, "Error loading bitmap - unknown resource URI! "
                             + workerOptions.getResourceUri());
                 }
             } else {
                 Log.e(TAG, "Error loading bitmap - no source!");
             }
         } catch (IOException e) {
             Log.e(TAG, "Error loading url " + workerOptions.getResourceUri(), e);
             return null;
         } catch (RuntimeException e) {
             Log.e(TAG, "Critical Error loading url " + workerOptions.getResourceUri(), e);
             return null;
         }

         return null;
     }

     @Override
     protected void onPostExecute(Bitmap bitmap) {
         if (mImageView != null) {
             final ImageView imageView = mImageView.get();
             if (imageView != null) {
                 imageView.setImageBitmap(bitmap);
             }
         }
     }

     private Bitmap getBitmapFromResource(Context context, ShortcutIconResource iconResource,
             BitmapWorkerOptions outputOptions) throws IOException {
         if (DEBUG) {
             Log.d(TAG, "Loading " + iconResource.toString());
         }
         try {
             Object drawable = loadDrawable(context, iconResource);
             if (drawable instanceof InputStream) {
                 // Most of these are bitmaps, so resize properly.
                 return decodeBitmap((InputStream) drawable, outputOptions);
             } else if (drawable instanceof Drawable){
                 return createIconBitmap((Drawable) drawable, outputOptions);
             } else {
                 Log.w(TAG, "getBitmapFromResource failed, unrecognized resource: " + drawable);
                 return null;
             }
         } catch (NameNotFoundException e) {
             Log.w(TAG, "Could not load package: " + iconResource.packageName + "! NameNotFound");
             return null;
         } catch (NotFoundException e) {
             Log.w(TAG, "Could not load resource: " + iconResource.resourceName + "! NotFound");
             return null;
         }
     }

     public final boolean isScaled() {
         return mScaled;
     }

     private Bitmap decodeBitmap(InputStream in, BitmapWorkerOptions options)
             throws IOException {
         CachedInputStream bufferedStream = null;
         BitmapFactory.Options bitmapOptions = null;
         try {
             bufferedStream = new CachedInputStream(in);
             // Let the bufferedStream be able to mark unlimited bytes up to full stream length.
             // The value that BitmapFactory uses (1024) is too small for detecting bounds
             bufferedStream.setOverrideMarkLimit(Integer.MAX_VALUE);
             bitmapOptions = new BitmapFactory.Options();
             bitmapOptions.inJustDecodeBounds = true;
             if (options.getBitmapConfig() != null) {
                 bitmapOptions.inPreferredConfig = options.getBitmapConfig();
             }
             bitmapOptions.inTempStorage = ByteArrayPool.get16KBPool().allocateChunk();
             bufferedStream.mark(Integer.MAX_VALUE);
             BitmapFactory.decodeStream(bufferedStream, null, bitmapOptions);

             float heightScale = (float) bitmapOptions.outHeight / options.getHeight();
             float widthScale = (float) bitmapOptions.outWidth / options.getWidth();
             // We take the smaller value because we will crop the result later.
             float scale = heightScale < widthScale ? heightScale : widthScale;

             bitmapOptions.inJustDecodeBounds = false;
             if (scale >= 4) {
                 // Sampling looks really, really bad. So sample part way and then smooth
                 // the result with bilinear interpolation.
                 bitmapOptions.inSampleSize = (int) scale / 2;
             }
             // Reset buffer to original position and disable the overrideMarkLimit
             bufferedStream.reset();
             bufferedStream.setOverrideMarkLimit(0);

             Bitmap bitmap = BitmapFactory.decodeStream(bufferedStream, null, bitmapOptions);
             // We need to check isCancelled() and throw away the result if we are cancelled because
             // if we're loading over HTTP, canceling an AsyncTask causes the HTTP library to throw
             // an exception, which the bitmap library then eats and returns a partially decoded
             // bitmap. This behavior no longer will happen in lmp-mr1.
             if (bitmap == null || isCancelled()) {
                 return null;
             }

             Bitmap result = bitmap;
             if (options.getWidth() < bitmap.getWidth()
                     || options.getHeight() < bitmap.getHeight()) {
                 result = BitmapUtils.scaleBitmap(bitmap, options.getWidth(), options.getHeight());
                 mScaled = true;
             }

             if (result != bitmap) {
                 bitmap.recycle();
             }
             return result;

         } finally {
             if (bitmapOptions != null) {
                 ByteArrayPool.get16KBPool().releaseChunk(bitmapOptions.inTempStorage);
             }
             if (bufferedStream != null) {
                 bufferedStream.close();
             }
         }
     }

     private Bitmap getBitmapFromHttp(BitmapWorkerOptions options) throws IOException {
         URL url = new URL(options.getResourceUri().toString());
         if (DEBUG) {
             Log.d(TAG, "Loading " + url);
         }
         HttpURLConnection connection = null;
         try {
             connection = (HttpURLConnection) url.openConnection();
             connection.setConnectTimeout(SOCKET_TIMEOUT);
             connection.setReadTimeout(READ_TIMEOUT);
             InputStream in = new BufferedInputStream(connection.getInputStream());
             return decodeBitmap(in, options);
         } finally {
             if (DEBUG) {
                 Log.d(TAG, "loading done "+url);
             }
             if (connection != null) {
                 connection.disconnect();
             }
         }
     }

     private Bitmap getBitmapFromContent(BitmapWorkerOptions options) throws IOException {
         InputStream bitmapStream =
                 options.getContext().getContentResolver().openInputStream(options.getResourceUri());
         if (bitmapStream != null) {
             return decodeBitmap(bitmapStream, options);
         } else {
             Log.w(TAG, "Content provider returned a null InputStream when trying to " +
                     "open resource.");
             return null;
         }
     }

     /**
      * load drawable for non-bitmap resource or InputStream for bitmap resource without
      * caching Bitmap in Resources.  So that caller can maintain a different caching
      * storage with less memory used.
      * @return  either {@link Drawable} for xml and ColorDrawable <br>
      *          or {@link InputStream} for Bitmap resource
      */
     private static Object loadDrawable(Context context, ShortcutIconResource r)
             throws NameNotFoundException {
         Resources resources = context.getPackageManager()
                 .getResourcesForApplication(r.packageName);
         if (resources == null) {
             return null;
         }
         resources.updateConfiguration(context.getResources().getConfiguration(),
                 context.getResources().getDisplayMetrics());
         final int id = resources.getIdentifier(r.resourceName, null, null);
         if (id == 0) {
             Log.e(TAG, "Couldn't get resource " + r.resourceName + " in resources of "
                     + r.packageName);
             return null;
         }
         TypedValue value = new TypedValue();
         resources.getValue(id, value, true);
         if ((value.type == TypedValue.TYPE_STRING && value.string.toString().endsWith(".xml")) || (
                 value.type >= TypedValue.TYPE_FIRST_COLOR_INT
                 && value.type <= TypedValue.TYPE_LAST_COLOR_INT)) {
             return resources.getDrawable(id);
         }
         return resources.openRawResource(id, value);
     }

     private static Bitmap createIconBitmap(Drawable drawable, BitmapWorkerOptions workerOptions) {
         // Some drawables have an intrinsic width and height of -1. In that case
         // size it to our output.
         int width = drawable.getIntrinsicWidth();
         if (width == -1) {
             width = workerOptions.getWidth();
         }
         int height = drawable.getIntrinsicHeight();
         if (height == -1) {
             height = workerOptions.getHeight();
         }
         Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
         Canvas canvas = new Canvas(bitmap);
         drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
         drawable.draw(canvas);
         return bitmap;
     }

     public static Drawable getDrawable(Context context, ShortcutIconResource iconResource)
             throws NameNotFoundException {
         Resources resources =
                 context.getPackageManager().getResourcesForApplication(iconResource.packageName);
         if (resources == null) {
             return null;
         }
         resources.updateConfiguration(context.getResources().getConfiguration(),
                 context.getResources().getDisplayMetrics());
         int id = resources.getIdentifier(iconResource.resourceName, null, null);
         if (id == 0) {
             throw new NameNotFoundException();
         }

         return resources.getDrawable(id);
     }

     @SuppressWarnings("deprecation")
     private Bitmap getAccountImage(BitmapWorkerOptions options) {
         String accountName = UriUtils.getAccountName(options.getResourceUri());
         Context context = options.getContext();

         if (accountName != null && context != null) {
             Account thisAccount = null;
             for (Account account : AccountManager.get(context).
                     getAccountsByType(GOOGLE_ACCOUNT_TYPE)) {
                 if (account.name.equals(accountName)) {
                     thisAccount = account;
                     break;
                 }
             }
             if (thisAccount != null) {
                 String picUriString = AccountImageHelper.getAccountPictureUri(context, thisAccount);
                 if (picUriString != null) {
                     BitmapWorkerOptions.Builder optionBuilder =
                             new BitmapWorkerOptions.Builder(context)
                             .width(options.getWidth())
                                     .height(options.getHeight())
                                     .cacheFlag(options.getCacheFlag())
                                     .bitmapConfig(options.getBitmapConfig())
                                     .resource(Uri.parse(picUriString));
                     return BitmapDownloader.getInstance(context)
                             .loadBitmapBlocking(optionBuilder.build());
                 }
                 return null;
             }
         }
         return null;
     }
 }
	/*
	* Copyright (C) 2016 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.car.apps.common;

	import android.accounts.Account;
	import android.accounts.AccountManager;
	import android.content.Context;
	import android.content.Intent.ShortcutIconResource;
	import android.content.pm.PackageManager.NameNotFoundException;
	import android.content.res.Resources;
	import android.content.res.Resources.NotFoundException;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.graphics.Canvas;
	import android.graphics.drawable.Drawable;
	import android.net.Uri;
	import android.os.AsyncTask;
	import android.util.Log;
	import android.util.TypedValue;
	import android.widget.ImageView;

	import java.io.BufferedInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.lang.ref.WeakReference;
	import java.net.HttpURLConnection;
	import java.net.URL;

	/**
	* AsyncTask which loads a bitmap.
	* <p>
	* The source of this can be another package (via a resource), a URI (content provider), or
	* a file path.
	*
	* @see BitmapWorkerOptions
	* @hide
	*/
	public class BitmapWorkerTask extends AsyncTask<BitmapWorkerOptions, Void, Bitmap> {

	private static final String TAG = "BitmapWorker";
	private static final String GOOGLE_ACCOUNT_TYPE = "com.google";

	private static final boolean DEBUG = false;

	private static final int SOCKET_TIMEOUT = 10000;
	private static final int READ_TIMEOUT = 10000;

	private final WeakReference<ImageView> mImageView;
	// a flag for if the bitmap is scaled from original source
	protected boolean mScaled;

	public BitmapWorkerTask(ImageView imageView) {
	mImageView = new WeakReference<ImageView>(imageView);
	mScaled = false;
	}

	@Override
	protected Bitmap doInBackground(BitmapWorkerOptions... params) {

	return retrieveBitmap(params[0]);
	}

	protected Bitmap retrieveBitmap(BitmapWorkerOptions workerOptions) {
	try {
	if (workerOptions.getIconResource() != null) {
	return getBitmapFromResource(workerOptions.getContext(),
	workerOptions.getIconResource(),
	workerOptions);
	} else if (workerOptions.getResourceUri() != null) {
	if (UriUtils.isAndroidResourceUri(workerOptions.getResourceUri())
	\|\| UriUtils.isShortcutIconResourceUri(workerOptions.getResourceUri())) {
	// Make an icon resource from this.
	return getBitmapFromResource(workerOptions.getContext(),
	UriUtils.getIconResource(workerOptions.getResourceUri()),
	workerOptions);
	} else if (UriUtils.isWebUri(workerOptions.getResourceUri())) {
	return getBitmapFromHttp(workerOptions);
	} else if (UriUtils.isContentUri(workerOptions.getResourceUri())) {
	return getBitmapFromContent(workerOptions);
	} else if (UriUtils.isAccountImageUri(workerOptions.getResourceUri())) {
	return getAccountImage(workerOptions);
	} else {
	Log.e(TAG, "Error loading bitmap - unknown resource URI! "
	+ workerOptions.getResourceUri());
	}
	} else {
	Log.e(TAG, "Error loading bitmap - no source!");
	}
	} catch (IOException e) {
	Log.e(TAG, "Error loading url " + workerOptions.getResourceUri(), e);
	return null;
	} catch (RuntimeException e) {
	Log.e(TAG, "Critical Error loading url " + workerOptions.getResourceUri(), e);
	return null;
	}

	return null;
	}

	@Override
	protected void onPostExecute(Bitmap bitmap) {
	if (mImageView != null) {
	final ImageView imageView = mImageView.get();
	if (imageView != null) {
	imageView.setImageBitmap(bitmap);
	}
	}
	}

	private Bitmap getBitmapFromResource(Context context, ShortcutIconResource iconResource,
	BitmapWorkerOptions outputOptions) throws IOException {
	if (DEBUG) {
	Log.d(TAG, "Loading " + iconResource.toString());
	}
	try {
	Object drawable = loadDrawable(context, iconResource);
	if (drawable instanceof InputStream) {
	// Most of these are bitmaps, so resize properly.
	return decodeBitmap((InputStream) drawable, outputOptions);
	} else if (drawable instanceof Drawable){
	return createIconBitmap((Drawable) drawable, outputOptions);
	} else {
	Log.w(TAG, "getBitmapFromResource failed, unrecognized resource: " + drawable);
	return null;
	}
	} catch (NameNotFoundException e) {
	Log.w(TAG, "Could not load package: " + iconResource.packageName + "! NameNotFound");
	return null;
	} catch (NotFoundException e) {
	Log.w(TAG, "Could not load resource: " + iconResource.resourceName + "! NotFound");
	return null;
	}
	}

	public final boolean isScaled() {
	return mScaled;
	}

	private Bitmap decodeBitmap(InputStream in, BitmapWorkerOptions options)
	throws IOException {
	CachedInputStream bufferedStream = null;
	BitmapFactory.Options bitmapOptions = null;
	try {
	bufferedStream = new CachedInputStream(in);
	// Let the bufferedStream be able to mark unlimited bytes up to full stream length.
	// The value that BitmapFactory uses (1024) is too small for detecting bounds
	bufferedStream.setOverrideMarkLimit(Integer.MAX_VALUE);
	bitmapOptions = new BitmapFactory.Options();
	bitmapOptions.inJustDecodeBounds = true;
	if (options.getBitmapConfig() != null) {
	bitmapOptions.inPreferredConfig = options.getBitmapConfig();
	}
	bitmapOptions.inTempStorage = ByteArrayPool.get16KBPool().allocateChunk();
	bufferedStream.mark(Integer.MAX_VALUE);
	BitmapFactory.decodeStream(bufferedStream, null, bitmapOptions);

	float heightScale = (float) bitmapOptions.outHeight / options.getHeight();
	float widthScale = (float) bitmapOptions.outWidth / options.getWidth();
	// We take the smaller value because we will crop the result later.
	float scale = heightScale < widthScale ? heightScale : widthScale;

	bitmapOptions.inJustDecodeBounds = false;
	if (scale >= 4) {
	// Sampling looks really, really bad. So sample part way and then smooth
	// the result with bilinear interpolation.
	bitmapOptions.inSampleSize = (int) scale / 2;
	}
	// Reset buffer to original position and disable the overrideMarkLimit
	bufferedStream.reset();
	bufferedStream.setOverrideMarkLimit(0);

	Bitmap bitmap = BitmapFactory.decodeStream(bufferedStream, null, bitmapOptions);
	// We need to check isCancelled() and throw away the result if we are cancelled because
	// if we're loading over HTTP, canceling an AsyncTask causes the HTTP library to throw
	// an exception, which the bitmap library then eats and returns a partially decoded
	// bitmap. This behavior no longer will happen in lmp-mr1.
	if (bitmap == null \|\| isCancelled()) {
	return null;
	}

	Bitmap result = bitmap;
	if (options.getWidth() < bitmap.getWidth()
	\|\| options.getHeight() < bitmap.getHeight()) {
	result = BitmapUtils.scaleBitmap(bitmap, options.getWidth(), options.getHeight());
	mScaled = true;
	}

	if (result != bitmap) {
	bitmap.recycle();
	}
	return result;

	} finally {
	if (bitmapOptions != null) {
	ByteArrayPool.get16KBPool().releaseChunk(bitmapOptions.inTempStorage);
	}
	if (bufferedStream != null) {
	bufferedStream.close();
	}
	}
	}

	private Bitmap getBitmapFromHttp(BitmapWorkerOptions options) throws IOException {
	URL url = new URL(options.getResourceUri().toString());
	if (DEBUG) {
	Log.d(TAG, "Loading " + url);
	}
	HttpURLConnection connection = null;
	try {
	connection = (HttpURLConnection) url.openConnection();
	connection.setConnectTimeout(SOCKET_TIMEOUT);
	connection.setReadTimeout(READ_TIMEOUT);
	InputStream in = new BufferedInputStream(connection.getInputStream());
	return decodeBitmap(in, options);
	} finally {
	if (DEBUG) {
	Log.d(TAG, "loading done "+url);
	}
	if (connection != null) {
	connection.disconnect();
	}
	}
	}

	private Bitmap getBitmapFromContent(BitmapWorkerOptions options) throws IOException {
	InputStream bitmapStream =
	options.getContext().getContentResolver().openInputStream(options.getResourceUri());
	if (bitmapStream != null) {
	return decodeBitmap(bitmapStream, options);
	} else {
	Log.w(TAG, "Content provider returned a null InputStream when trying to " +
	"open resource.");
	return null;
	}
	}

	/**
	* load drawable for non-bitmap resource or InputStream for bitmap resource without
	* caching Bitmap in Resources. So that caller can maintain a different caching
	* storage with less memory used.
	* @return either {@link Drawable} for xml and ColorDrawable <br>
	* or {@link InputStream} for Bitmap resource
	*/
	private static Object loadDrawable(Context context, ShortcutIconResource r)
	throws NameNotFoundException {
	Resources resources = context.getPackageManager()
	.getResourcesForApplication(r.packageName);
	if (resources == null) {
	return null;
	}
	resources.updateConfiguration(context.getResources().getConfiguration(),
	context.getResources().getDisplayMetrics());
	final int id = resources.getIdentifier(r.resourceName, null, null);
	if (id == 0) {
	Log.e(TAG, "Couldn't get resource " + r.resourceName + " in resources of "
	+ r.packageName);
	return null;
	}
	TypedValue value = new TypedValue();
	resources.getValue(id, value, true);
	if ((value.type == TypedValue.TYPE_STRING && value.string.toString().endsWith(".xml")) \|\| (
	value.type >= TypedValue.TYPE_FIRST_COLOR_INT
	&& value.type <= TypedValue.TYPE_LAST_COLOR_INT)) {
	return resources.getDrawable(id);
	}
	return resources.openRawResource(id, value);
	}

	private static Bitmap createIconBitmap(Drawable drawable, BitmapWorkerOptions workerOptions) {
	// Some drawables have an intrinsic width and height of -1. In that case
	// size it to our output.
	int width = drawable.getIntrinsicWidth();
	if (width == -1) {
	width = workerOptions.getWidth();
	}
	int height = drawable.getIntrinsicHeight();
	if (height == -1) {
	height = workerOptions.getHeight();
	}
	Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
	Canvas canvas = new Canvas(bitmap);
	drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
	drawable.draw(canvas);
	return bitmap;
	}

	public static Drawable getDrawable(Context context, ShortcutIconResource iconResource)
	throws NameNotFoundException {
	Resources resources =
	context.getPackageManager().getResourcesForApplication(iconResource.packageName);
	if (resources == null) {
	return null;
	}
	resources.updateConfiguration(context.getResources().getConfiguration(),
	context.getResources().getDisplayMetrics());
	int id = resources.getIdentifier(iconResource.resourceName, null, null);
	if (id == 0) {
	throw new NameNotFoundException();
	}

	return resources.getDrawable(id);
	}

	@SuppressWarnings("deprecation")
	private Bitmap getAccountImage(BitmapWorkerOptions options) {
	String accountName = UriUtils.getAccountName(options.getResourceUri());
	Context context = options.getContext();

	if (accountName != null && context != null) {
	Account thisAccount = null;
	for (Account account : AccountManager.get(context).
	getAccountsByType(GOOGLE_ACCOUNT_TYPE)) {
	if (account.name.equals(accountName)) {
	thisAccount = account;
	break;
	}
	}
	if (thisAccount != null) {
	String picUriString = AccountImageHelper.getAccountPictureUri(context, thisAccount);
	if (picUriString != null) {
	BitmapWorkerOptions.Builder optionBuilder =
	new BitmapWorkerOptions.Builder(context)
	.width(options.getWidth())
	.height(options.getHeight())
	.cacheFlag(options.getCacheFlag())
	.bitmapConfig(options.getBitmapConfig())
	.resource(Uri.parse(picUriString));
	return BitmapDownloader.getInstance(context)
	.loadBitmapBlocking(optionBuilder.build());
	}
	return null;
	}
	}
	return null;
	}
	}