src/com/android/apps/tag/record/VCardRecord.java - platform/packages/apps/Tag - Git at Google

 /*
  * Copyright (C) 2010 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.apps.tag.record;

 import com.android.apps.tag.R;
 import com.android.vcard.VCardConfig;
 import com.android.vcard.VCardEntry;
 import com.android.vcard.VCardEntryConstructor;
 import com.android.vcard.VCardEntryHandler;
 import com.android.vcard.VCardParser;
 import com.android.vcard.VCardParser_V21;
 import com.android.vcard.VCardParser_V30;
 import com.android.vcard.exception.VCardException;
 import com.android.vcard.exception.VCardVersionException;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.Lists;

 import android.app.Activity;
 import android.content.ActivityNotFoundException;
 import android.content.ContentUris;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.content.res.AssetFileDescriptor;
 import android.database.Cursor;
 import android.graphics.BitmapFactory;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
 import android.nfc.NdefRecord;
 import android.os.AsyncTask;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.provider.ContactsContract;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.ViewGroup;
 import android.widget.ImageView;
 import android.widget.TextView;

 import java.io.ByteArrayInputStream;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;

 /**
  * VCard Ndef Record object
  */
 public class VCardRecord extends ParsedNdefRecord implements OnClickListener {
     private static final String TAG = VCardRecord.class.getSimpleName();

     public static final String RECORD_TYPE = "vcard";

     private final byte[] mVCard;

     private VCardRecord(byte[] content) {
         mVCard = content;
     }

     @Override
     public View getView(Activity activity, LayoutInflater inflater, ViewGroup parent, int offset) {

         Uri uri = activity.getIntent().getData();
         uri = Uri.withAppendedPath(uri, Integer.toString(offset));
         uri = Uri.withAppendedPath(uri, "mime");

         // TODO: parse content and display something nicer.
         Intent intent = new Intent(Intent.ACTION_VIEW, uri);

         CharSequence template = activity.getResources().getText(R.string.import_vcard);
         String description = TextUtils.expandTemplate(template, getDisplayName()).toString();

         return RecordUtils.getViewsForIntent(activity, inflater, parent, this, intent, description);
     }

     @Override
     public String getSnippet(Context context, Locale locale) {
         CharSequence template = context.getResources().getText(R.string.vcard_title);
         return TextUtils.expandTemplate(template, getDisplayName()).toString();
     }

     public String getDisplayName() {
         try {
             ArrayList<VCardEntry> entries = getVCardEntries();
             if (!entries.isEmpty()) {
                 return entries.get(0).getDisplayName();
             }
         } catch (Exception e) {
         }

         return "vCard";
     }

     private ArrayList<VCardEntry> getVCardEntries() throws IOException, VCardException {
         final ArrayList<VCardEntry> entries = Lists.newArrayList();

         final int type = VCardConfig.VCARD_TYPE_UNKNOWN;
         final VCardEntryConstructor constructor = new VCardEntryConstructor(type);
         constructor.addEntryHandler(new VCardEntryHandler() {
             @Override public void onStart() {}
             @Override public void onEnd() {}

             @Override
             public void onEntryCreated(VCardEntry entry) {
                 entries.add(entry);
             }
         });

         VCardParser parser = new VCardParser_V21(type);
         try {
             parser.parse(new ByteArrayInputStream(mVCard), constructor);
         } catch (VCardVersionException e) {
             try {
                 parser = new VCardParser_V30(type);
                 parser.parse(new ByteArrayInputStream(mVCard), constructor);
             } finally {
             }
         }

         return entries;
     }

     private static Intent getPickContactIntent() {
         Intent intent = new Intent(Intent.ACTION_PICK);
         intent.setType(ContactsContract.Contacts.CONTENT_TYPE);
         return intent;
     }

     /**
      * Returns a view in a list of record types for adding new records to a message.
      */
     public static View getAddView(Context context, LayoutInflater inflater, ViewGroup parent) {
         ViewGroup root = (ViewGroup) inflater.inflate(
                 R.layout.tag_add_record_list_item, parent, false);

         Intent intent = getPickContactIntent();
         PackageManager pm = context.getPackageManager();
         List<ResolveInfo> activities = pm.queryIntentActivities(intent, 0);
         if (activities.isEmpty()) {
             return null;
         }

         ResolveInfo info = activities.get(0);
         ((ImageView) root.findViewById(R.id.image)).setImageDrawable(info.loadIcon(pm));
         ((TextView) root.findViewById(R.id.text)).setText(context.getString(R.string.contact));

         root.setTag(new VCardRecordEditInfo());
         return root;
     }

     @Override
     public RecordEditInfo getEditInfo(Activity host) {
         return new VCardRecordEditInfo(mVCard);
     }

     public static VCardRecord parse(NdefRecord record) {
         MimeRecord underlyingRecord = MimeRecord.parse(record);

         // TODO: Add support for other vcard mime types.
         Preconditions.checkArgument("text/x-vCard".equals(underlyingRecord.getMimeType()));
         return new VCardRecord(underlyingRecord.getContent());
     }

     public static NdefRecord newVCardRecord(byte[] data) {
         return MimeRecord.newMimeRecord("text/x-vCard", data);
     }

     @Override
     public void onClick(View view) {
         RecordUtils.ClickInfo info = (RecordUtils.ClickInfo) view.getTag();
         try {
             info.activity.startActivity(info.intent);
             info.activity.finish();
         } catch (ActivityNotFoundException e) {
             // The activity wansn't found for some reason. Don't crash, but don't do anything.
             Log.e(TAG, "Failed to launch activity for intent " + info.intent, e);
         }
     }

     public static boolean isVCard(NdefRecord record) {
         try {
             parse(record);
             return true;
         } catch (IllegalArgumentException e) {
             return false;
         }
     }

     public static VCardRecordEditInfo editInfoForUri(Uri vcardUri) {
         if (vcardUri.toString().startsWith(
                 ContactsContract.Contacts.CONTENT_VCARD_URI.toString())) {
             String lookupKey = vcardUri.getLastPathSegment();
             Uri lookupUri = Uri.withAppendedPath(
                     ContactsContract.Contacts.CONTENT_LOOKUP_URI, lookupKey);
             return new VCardRecord.VCardRecordEditInfo(lookupUri);
         }
         return null;
     }

     private static class VCardRecordEditInfo extends RecordEditInfo {
         /**
          * The lookup {@link Uri} if the data is to be pulled from the contact provider.
          * Can be null if {@link #mValue} is filled in by other means externally.
          * @see ContactsContract
          */
         private Uri mLookupUri;

         /**
          * The raw VCard bytes.
          */
         private byte[] mValue;

         private WeakReference<View> mActiveView = null;

         private String mCachedName = null;
         private Drawable mCachedPhoto = null;

         /**
          * Data
          */
         private static final class CacheData {
             public String mName;
             public Drawable mPhoto;
             public byte[] mVcard;
         }

         public VCardRecordEditInfo() {
             super(RECORD_TYPE);
         }

         public VCardRecordEditInfo(Uri lookupUri) {
             super(RECORD_TYPE);
             mLookupUri = lookupUri;
             mValue = null;
         }

         public VCardRecordEditInfo(byte[] value) {
             super(RECORD_TYPE);
             mLookupUri = null;
             mValue = Preconditions.checkNotNull(value);
         }

         protected VCardRecordEditInfo(Parcel parcel) {
             super(RECORD_TYPE);
             mLookupUri = parcel.readParcelable(null);
             int valueLength = parcel.readInt();
             if (valueLength > 0) {
                 mValue = new byte[valueLength];
                 parcel.readByteArray(mValue);
             }
         }

         @Override
         public Intent getPickIntent() {
             return getPickContactIntent();
         }

         private void extractValuesFromBytes(final Context context) {
             byte[] bytes = Preconditions.checkNotNull(mValue);

             final int type = VCardConfig.VCARD_TYPE_UNKNOWN;
             final VCardEntryConstructor constructor = new VCardEntryConstructor(type);
             constructor.addEntryHandler(new VCardEntryHandler() {
                 @Override public void onStart() {}
                 @Override public void onEnd() {}

                 @Override
                 public void onEntryCreated(VCardEntry entry) {
                     mCachedName = entry.getDisplayName();
                     List<VCardEntry.PhotoData> photoList = entry.getPhotoList();
                     if (photoList != null && !photoList.isEmpty()) {
                         byte[] rawData = photoList.get(0).photoBytes;
                         mCachedPhoto = new BitmapDrawable(
                                 context.getResources(),
                                 BitmapFactory.decodeByteArray(rawData, 0, rawData.length));
                     }
                     bindView();
                 }
             });

             VCardParser parser = new VCardParser_V21(type);
             try {
                 parser.parse(new ByteArrayInputStream(bytes), constructor);
             } catch (IOException e) {
             } catch (VCardException e) {
             }
         }

         private void fetchValuesFromProvider(final Context context) {
             if (mValue != null) {
                 bindView();
                 return;
             }

             new AsyncTask<Uri, Void, CacheData>() {
                 @Override
                 protected CacheData doInBackground(Uri... params) {
                     Cursor cursor = null;
                     long id;
                     String lookupKey = null;
                     Uri lookupUri = params[0];
                     CacheData result = new CacheData();
                     try {
                         String[] projection = {
                                 ContactsContract.Contacts._ID,
                                 ContactsContract.Contacts.LOOKUP_KEY,
                                 ContactsContract.Contacts.DISPLAY_NAME
                         };
                         cursor = context.getContentResolver().query(
                                 lookupUri, projection, null, null, null);
                         cursor.moveToFirst();
                         id = cursor.getLong(0);
                         lookupKey = cursor.getString(1);
                         result.mName = cursor.getString(2);

                     } finally {
                         if (cursor != null) {
                             cursor.close();
                             cursor = null;
                         }
                     }

                     if (lookupKey == null) {
                         // TODO: handle errors.
                         return null;
                     }

                     // Note: the lookup key should already encoded.
                     Uri vcardUri = Uri.withAppendedPath(
                             ContactsContract.Contacts.CONTENT_VCARD_URI,
                             lookupKey);

                     AssetFileDescriptor descriptor;
                     FileInputStream in = null;
                     try {
                         descriptor =  context.getContentResolver().openAssetFileDescriptor(
                                 vcardUri, "r");
                         result.mVcard = new byte[(int) descriptor.getLength()];

                         in = descriptor.createInputStream();
                         in.read(result.mVcard);
                         in.close();
                     } catch (FileNotFoundException e) {
                         return null;
                     } catch (IOException e) {
                         return null;
                     }

                     Uri contactUri = ContentUris.withAppendedId(
                             ContactsContract.Contacts.CONTENT_URI, id);
                     InputStream photoIn = ContactsContract.Contacts.openContactPhotoInputStream(
                             context.getContentResolver(), contactUri);
                     if (photoIn != null) {
                         result.mPhoto = Drawable.createFromStream(photoIn, contactUri.toString());
                     }
                     return result;
                 }

                 @Override
                 protected void onPostExecute(CacheData data) {
                     if (data == null) {
                         return;
                     }

                     mCachedName = data.mName;
                     mValue = data.mVcard;
                     mCachedPhoto = data.mPhoto;
                     bindView();
                 }
             }.execute(mLookupUri);
         }

         @Override
         public NdefRecord getValue() {
             return (mValue == null) ? null : VCardRecord.newVCardRecord(mValue);
         }

         @Override
         public void handlePickResult(Context context, Intent data) {
             mLookupUri = data.getData();
             mValue = null;
             mCachedName = null;
             mCachedPhoto = null;
         }

         private void bindView() {
             View view = (mActiveView == null) ? null : mActiveView.get();
             if (view == null) {
                 return;
             }

             if (mCachedPhoto != null) {
                 ((ImageView) view.findViewById(R.id.photo)).setImageDrawable(mCachedPhoto);
             }

             if (mCachedName != null) {
                 ((TextView) view.findViewById(R.id.display_name)).setText(mCachedName);
             }
         }

         @Override
         public View getEditView(
                 Activity activity, LayoutInflater inflater,
                 ViewGroup parent, EditCallbacks callbacks) {
             View result = buildEditView(
                     activity, inflater, R.layout.tag_edit_vcard, parent, callbacks);

             mActiveView = new WeakReference<View>(result);
             result.setOnClickListener(this);

             // Show default contact photo until the data loads.
             ((ImageView) result.findViewById(R.id.photo)).setImageDrawable(
                     activity.getResources().getDrawable(R.drawable.default_contact_photo));

             if (mLookupUri != null) {
                 fetchValuesFromProvider(activity);
             } else if (mValue != null) {
                 extractValuesFromBytes(activity);
             }
             return result;
         }

         @Override
         public void writeToParcel(Parcel out, int flags) {
             super.writeToParcel(out, flags);
             out.writeParcelable(mLookupUri, flags);
             out.writeInt(mValue == null ? 0 : mValue.length);
             out.writeByteArray(mValue);
         }

         @SuppressWarnings("unused")
         public static final Parcelable.Creator<VCardRecordEditInfo> CREATOR =
                 new Parcelable.Creator<VCardRecordEditInfo>() {
             @Override
             public VCardRecordEditInfo createFromParcel(Parcel in) {
                 return new VCardRecordEditInfo(in);
             }

             @Override
             public VCardRecordEditInfo[] newArray(int size) {
                 return new VCardRecordEditInfo[size];
             }
         };

         @Override
         public int describeContents() {
             return 0;
         }

         @Override
         public void onClick(View target) {
             if (this == target.getTag()) {
                 mCallbacks.startPickForRecord(this, getPickIntent());
             } else {
                 super.onClick(target);
             }
         }
     }
 }
	/*
	* Copyright (C) 2010 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.apps.tag.record;

	import com.android.apps.tag.R;
	import com.android.vcard.VCardConfig;
	import com.android.vcard.VCardEntry;
	import com.android.vcard.VCardEntryConstructor;
	import com.android.vcard.VCardEntryHandler;
	import com.android.vcard.VCardParser;
	import com.android.vcard.VCardParser_V21;
	import com.android.vcard.VCardParser_V30;
	import com.android.vcard.exception.VCardException;
	import com.android.vcard.exception.VCardVersionException;
	import com.google.common.base.Preconditions;
	import com.google.common.collect.Lists;

	import android.app.Activity;
	import android.content.ActivityNotFoundException;
	import android.content.ContentUris;
	import android.content.Context;
	import android.content.Intent;
	import android.content.pm.PackageManager;
	import android.content.pm.ResolveInfo;
	import android.content.res.AssetFileDescriptor;
	import android.database.Cursor;
	import android.graphics.BitmapFactory;
	import android.graphics.drawable.BitmapDrawable;
	import android.graphics.drawable.Drawable;
	import android.net.Uri;
	import android.nfc.NdefRecord;
	import android.os.AsyncTask;
	import android.os.Parcel;
	import android.os.Parcelable;
	import android.provider.ContactsContract;
	import android.text.TextUtils;
	import android.util.Log;
	import android.view.LayoutInflater;
	import android.view.View;
	import android.view.View.OnClickListener;
	import android.view.ViewGroup;
	import android.widget.ImageView;
	import android.widget.TextView;

	import java.io.ByteArrayInputStream;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.InputStream;
	import java.lang.ref.WeakReference;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Locale;

	/**
	* VCard Ndef Record object
	*/
	public class VCardRecord extends ParsedNdefRecord implements OnClickListener {
	private static final String TAG = VCardRecord.class.getSimpleName();

	public static final String RECORD_TYPE = "vcard";

	private final byte[] mVCard;

	private VCardRecord(byte[] content) {
	mVCard = content;
	}

	@Override
	public View getView(Activity activity, LayoutInflater inflater, ViewGroup parent, int offset) {

	Uri uri = activity.getIntent().getData();
	uri = Uri.withAppendedPath(uri, Integer.toString(offset));
	uri = Uri.withAppendedPath(uri, "mime");

	// TODO: parse content and display something nicer.
	Intent intent = new Intent(Intent.ACTION_VIEW, uri);

	CharSequence template = activity.getResources().getText(R.string.import_vcard);
	String description = TextUtils.expandTemplate(template, getDisplayName()).toString();

	return RecordUtils.getViewsForIntent(activity, inflater, parent, this, intent, description);
	}

	@Override
	public String getSnippet(Context context, Locale locale) {
	CharSequence template = context.getResources().getText(R.string.vcard_title);
	return TextUtils.expandTemplate(template, getDisplayName()).toString();
	}

	public String getDisplayName() {
	try {
	ArrayList<VCardEntry> entries = getVCardEntries();
	if (!entries.isEmpty()) {
	return entries.get(0).getDisplayName();
	}
	} catch (Exception e) {
	}

	return "vCard";
	}

	private ArrayList<VCardEntry> getVCardEntries() throws IOException, VCardException {
	final ArrayList<VCardEntry> entries = Lists.newArrayList();

	final int type = VCardConfig.VCARD_TYPE_UNKNOWN;
	final VCardEntryConstructor constructor = new VCardEntryConstructor(type);
	constructor.addEntryHandler(new VCardEntryHandler() {
	@Override public void onStart() {}
	@Override public void onEnd() {}

	@Override
	public void onEntryCreated(VCardEntry entry) {
	entries.add(entry);
	}
	});

	VCardParser parser = new VCardParser_V21(type);
	try {
	parser.parse(new ByteArrayInputStream(mVCard), constructor);
	} catch (VCardVersionException e) {
	try {
	parser = new VCardParser_V30(type);
	parser.parse(new ByteArrayInputStream(mVCard), constructor);
	} finally {
	}
	}

	return entries;
	}

	private static Intent getPickContactIntent() {
	Intent intent = new Intent(Intent.ACTION_PICK);
	intent.setType(ContactsContract.Contacts.CONTENT_TYPE);
	return intent;
	}

	/**
	* Returns a view in a list of record types for adding new records to a message.
	*/
	public static View getAddView(Context context, LayoutInflater inflater, ViewGroup parent) {
	ViewGroup root = (ViewGroup) inflater.inflate(
	R.layout.tag_add_record_list_item, parent, false);

	Intent intent = getPickContactIntent();
	PackageManager pm = context.getPackageManager();
	List<ResolveInfo> activities = pm.queryIntentActivities(intent, 0);
	if (activities.isEmpty()) {
	return null;
	}

	ResolveInfo info = activities.get(0);
	((ImageView) root.findViewById(R.id.image)).setImageDrawable(info.loadIcon(pm));
	((TextView) root.findViewById(R.id.text)).setText(context.getString(R.string.contact));

	root.setTag(new VCardRecordEditInfo());
	return root;
	}

	@Override
	public RecordEditInfo getEditInfo(Activity host) {
	return new VCardRecordEditInfo(mVCard);
	}

	public static VCardRecord parse(NdefRecord record) {
	MimeRecord underlyingRecord = MimeRecord.parse(record);

	// TODO: Add support for other vcard mime types.
	Preconditions.checkArgument("text/x-vCard".equals(underlyingRecord.getMimeType()));
	return new VCardRecord(underlyingRecord.getContent());
	}

	public static NdefRecord newVCardRecord(byte[] data) {
	return MimeRecord.newMimeRecord("text/x-vCard", data);
	}

	@Override
	public void onClick(View view) {
	RecordUtils.ClickInfo info = (RecordUtils.ClickInfo) view.getTag();
	try {
	info.activity.startActivity(info.intent);
	info.activity.finish();
	} catch (ActivityNotFoundException e) {
	// The activity wansn't found for some reason. Don't crash, but don't do anything.
	Log.e(TAG, "Failed to launch activity for intent " + info.intent, e);
	}
	}

	public static boolean isVCard(NdefRecord record) {
	try {
	parse(record);
	return true;
	} catch (IllegalArgumentException e) {
	return false;
	}
	}

	public static VCardRecordEditInfo editInfoForUri(Uri vcardUri) {
	if (vcardUri.toString().startsWith(
	ContactsContract.Contacts.CONTENT_VCARD_URI.toString())) {
	String lookupKey = vcardUri.getLastPathSegment();
	Uri lookupUri = Uri.withAppendedPath(
	ContactsContract.Contacts.CONTENT_LOOKUP_URI, lookupKey);
	return new VCardRecord.VCardRecordEditInfo(lookupUri);
	}
	return null;
	}

	private static class VCardRecordEditInfo extends RecordEditInfo {
	/**
	* The lookup {@link Uri} if the data is to be pulled from the contact provider.
	* Can be null if {@link #mValue} is filled in by other means externally.
	* @see ContactsContract
	*/
	private Uri mLookupUri;

	/**
	* The raw VCard bytes.
	*/
	private byte[] mValue;

	private WeakReference<View> mActiveView = null;

	private String mCachedName = null;
	private Drawable mCachedPhoto = null;

	/**
	* Data
	*/
	private static final class CacheData {
	public String mName;
	public Drawable mPhoto;
	public byte[] mVcard;
	}

	public VCardRecordEditInfo() {
	super(RECORD_TYPE);
	}

	public VCardRecordEditInfo(Uri lookupUri) {
	super(RECORD_TYPE);
	mLookupUri = lookupUri;
	mValue = null;
	}

	public VCardRecordEditInfo(byte[] value) {
	super(RECORD_TYPE);
	mLookupUri = null;
	mValue = Preconditions.checkNotNull(value);
	}

	protected VCardRecordEditInfo(Parcel parcel) {
	super(RECORD_TYPE);
	mLookupUri = parcel.readParcelable(null);
	int valueLength = parcel.readInt();
	if (valueLength > 0) {
	mValue = new byte[valueLength];
	parcel.readByteArray(mValue);
	}
	}

	@Override
	public Intent getPickIntent() {
	return getPickContactIntent();
	}

	private void extractValuesFromBytes(final Context context) {
	byte[] bytes = Preconditions.checkNotNull(mValue);

	final int type = VCardConfig.VCARD_TYPE_UNKNOWN;
	final VCardEntryConstructor constructor = new VCardEntryConstructor(type);
	constructor.addEntryHandler(new VCardEntryHandler() {
	@Override public void onStart() {}
	@Override public void onEnd() {}

	@Override
	public void onEntryCreated(VCardEntry entry) {
	mCachedName = entry.getDisplayName();
	List<VCardEntry.PhotoData> photoList = entry.getPhotoList();
	if (photoList != null && !photoList.isEmpty()) {
	byte[] rawData = photoList.get(0).photoBytes;
	mCachedPhoto = new BitmapDrawable(
	context.getResources(),
	BitmapFactory.decodeByteArray(rawData, 0, rawData.length));
	}
	bindView();
	}
	});

	VCardParser parser = new VCardParser_V21(type);
	try {
	parser.parse(new ByteArrayInputStream(bytes), constructor);
	} catch (IOException e) {
	} catch (VCardException e) {
	}
	}

	private void fetchValuesFromProvider(final Context context) {
	if (mValue != null) {
	bindView();
	return;
	}

	new AsyncTask<Uri, Void, CacheData>() {
	@Override
	protected CacheData doInBackground(Uri... params) {
	Cursor cursor = null;
	long id;
	String lookupKey = null;
	Uri lookupUri = params[0];
	CacheData result = new CacheData();
	try {
	String[] projection = {
	ContactsContract.Contacts._ID,
	ContactsContract.Contacts.LOOKUP_KEY,
	ContactsContract.Contacts.DISPLAY_NAME
	};
	cursor = context.getContentResolver().query(
	lookupUri, projection, null, null, null);
	cursor.moveToFirst();
	id = cursor.getLong(0);
	lookupKey = cursor.getString(1);
	result.mName = cursor.getString(2);

	} finally {
	if (cursor != null) {
	cursor.close();
	cursor = null;
	}
	}

	if (lookupKey == null) {
	// TODO: handle errors.
	return null;
	}

	// Note: the lookup key should already encoded.
	Uri vcardUri = Uri.withAppendedPath(
	ContactsContract.Contacts.CONTENT_VCARD_URI,
	lookupKey);

	AssetFileDescriptor descriptor;
	FileInputStream in = null;
	try {
	descriptor = context.getContentResolver().openAssetFileDescriptor(
	vcardUri, "r");
	result.mVcard = new byte[(int) descriptor.getLength()];

	in = descriptor.createInputStream();
	in.read(result.mVcard);
	in.close();
	} catch (FileNotFoundException e) {
	return null;
	} catch (IOException e) {
	return null;
	}

	Uri contactUri = ContentUris.withAppendedId(
	ContactsContract.Contacts.CONTENT_URI, id);
	InputStream photoIn = ContactsContract.Contacts.openContactPhotoInputStream(
	context.getContentResolver(), contactUri);
	if (photoIn != null) {
	result.mPhoto = Drawable.createFromStream(photoIn, contactUri.toString());
	}
	return result;
	}

	@Override
	protected void onPostExecute(CacheData data) {
	if (data == null) {
	return;
	}

	mCachedName = data.mName;
	mValue = data.mVcard;
	mCachedPhoto = data.mPhoto;
	bindView();
	}
	}.execute(mLookupUri);
	}

	@Override
	public NdefRecord getValue() {
	return (mValue == null) ? null : VCardRecord.newVCardRecord(mValue);
	}

	@Override
	public void handlePickResult(Context context, Intent data) {
	mLookupUri = data.getData();
	mValue = null;
	mCachedName = null;
	mCachedPhoto = null;
	}

	private void bindView() {
	View view = (mActiveView == null) ? null : mActiveView.get();
	if (view == null) {
	return;
	}

	if (mCachedPhoto != null) {
	((ImageView) view.findViewById(R.id.photo)).setImageDrawable(mCachedPhoto);
	}

	if (mCachedName != null) {
	((TextView) view.findViewById(R.id.display_name)).setText(mCachedName);
	}
	}

	@Override
	public View getEditView(
	Activity activity, LayoutInflater inflater,
	ViewGroup parent, EditCallbacks callbacks) {
	View result = buildEditView(
	activity, inflater, R.layout.tag_edit_vcard, parent, callbacks);

	mActiveView = new WeakReference<View>(result);
	result.setOnClickListener(this);

	// Show default contact photo until the data loads.
	((ImageView) result.findViewById(R.id.photo)).setImageDrawable(
	activity.getResources().getDrawable(R.drawable.default_contact_photo));

	if (mLookupUri != null) {
	fetchValuesFromProvider(activity);
	} else if (mValue != null) {
	extractValuesFromBytes(activity);
	}
	return result;
	}

	@Override
	public void writeToParcel(Parcel out, int flags) {
	super.writeToParcel(out, flags);
	out.writeParcelable(mLookupUri, flags);
	out.writeInt(mValue == null ? 0 : mValue.length);
	out.writeByteArray(mValue);
	}

	@SuppressWarnings("unused")
	public static final Parcelable.Creator<VCardRecordEditInfo> CREATOR =
	new Parcelable.Creator<VCardRecordEditInfo>() {
	@Override
	public VCardRecordEditInfo createFromParcel(Parcel in) {
	return new VCardRecordEditInfo(in);
	}

	@Override
	public VCardRecordEditInfo[] newArray(int size) {
	return new VCardRecordEditInfo[size];
	}
	};

	@Override
	public int describeContents() {
	return 0;
	}

	@Override
	public void onClick(View target) {
	if (this == target.getTag()) {
	mCallbacks.startPickForRecord(this, getPickIntent());
	} else {
	super.onClick(target);
	}
	}
	}
	}