src/com/android/browser/AutofillHandler.java - platform/packages/apps/Browser - Git at Google


 /*
  * Copyright (C) 2011 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.browser;

 import android.content.Context;
 import android.content.SharedPreferences;
 import android.content.SharedPreferences.Editor;
 import android.database.Cursor;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Message;
 import android.preference.PreferenceManager;
 import android.provider.ContactsContract;
 import android.util.Log;
 import android.webkit.WebSettingsClassic.AutoFillProfile;

 import java.util.concurrent.CountDownLatch;

 public class AutofillHandler {

     private AutoFillProfile mAutoFillProfile;
     // Default to zero. In the case no profile is set up, the initial
     // value will come from the AutoFillSettingsFragment when the user
     // creates a profile. Otherwise, we'll read the ID of the last used
     // profile from the prefs db.
     private int mAutoFillActiveProfileId;
     private static final int NO_AUTOFILL_PROFILE_SET = 0;

     private CountDownLatch mLoaded = new CountDownLatch(1);
     private Context mContext;

     private static final String LOGTAG = "AutofillHandler";

     public AutofillHandler(Context context) {
         mContext = context.getApplicationContext();
     }

     /**
      * Load settings from the browser app's database. It is performed in
      * an AsyncTask as it involves plenty of slow disk IO.
      * NOTE: Strings used for the preferences must match those specified
      * in the various preference XML files.
      */
     public void asyncLoadFromDb() {
         // Run the initial settings load in an AsyncTask as it hits the
         // disk multiple times through SharedPreferences and SQLite. We
         // need to be certain though that this has completed before we start
         // to load pages though, so in the worst case we will block waiting
         // for it to finish in BrowserActivity.onCreate().
          new LoadFromDb().start();
     }

     private void waitForLoad() {
         try {
             mLoaded.await();
         } catch (InterruptedException e) {
             Log.w(LOGTAG, "Caught exception while waiting for AutofillProfile to load.");
         }
     }

     private class LoadFromDb extends Thread {

         @Override
         public void run() {
             // Note the lack of synchronization over mAutoFillActiveProfileId and
             // mAutoFillProfile here. This is because we control all other access
             // to these members through the public functions of this class, and they
             // all wait for this thread via the mLoaded CountDownLatch.

             SharedPreferences p = PreferenceManager.getDefaultSharedPreferences(mContext);

             // Read the last active AutoFill profile id.
             mAutoFillActiveProfileId = p.getInt(
                     PreferenceKeys.PREF_AUTOFILL_ACTIVE_PROFILE_ID,
                     mAutoFillActiveProfileId);

             // Load the autofill profile data from the database. We use a database separate
             // to the browser preference DB to make it easier to support multiple profiles
             // and switching between them. Note that this may block startup if this DB lookup
             // is extremely slow. We do this to ensure that if there's a profile set, the
             // user never sees the "setup Autofill" option.
             AutoFillProfileDatabase autoFillDb = AutoFillProfileDatabase.getInstance(mContext);
             Cursor c = autoFillDb.getProfile(mAutoFillActiveProfileId);

             if (c.getCount() > 0) {
                 c.moveToFirst();

                 String fullName = c.getString(c.getColumnIndex(
                         AutoFillProfileDatabase.Profiles.FULL_NAME));
                 String email = c.getString(c.getColumnIndex(
                         AutoFillProfileDatabase.Profiles.EMAIL_ADDRESS));
                 String company = c.getString(c.getColumnIndex(
                         AutoFillProfileDatabase.Profiles.COMPANY_NAME));
                 String addressLine1 = c.getString(c.getColumnIndex(
                         AutoFillProfileDatabase.Profiles.ADDRESS_LINE_1));
                 String addressLine2 = c.getString(c.getColumnIndex(
                         AutoFillProfileDatabase.Profiles.ADDRESS_LINE_2));
                 String city = c.getString(c.getColumnIndex(
                         AutoFillProfileDatabase.Profiles.CITY));
                 String state = c.getString(c.getColumnIndex(
                         AutoFillProfileDatabase.Profiles.STATE));
                 String zip = c.getString(c.getColumnIndex(
                         AutoFillProfileDatabase.Profiles.ZIP_CODE));
                 String country = c.getString(c.getColumnIndex(
                         AutoFillProfileDatabase.Profiles.COUNTRY));
                 String phone = c.getString(c.getColumnIndex(
                         AutoFillProfileDatabase.Profiles.PHONE_NUMBER));
                 mAutoFillProfile = new AutoFillProfile(mAutoFillActiveProfileId,
                         fullName, email, company, addressLine1, addressLine2, city,
                         state, zip, country, phone);
             }
             c.close();
             autoFillDb.close();

             // At this point we've loaded the profile if there was one, so let any thread
             // waiting on initialization continue.
             mLoaded.countDown();

             // Synchronization note: strictly speaking, it's possible that mAutoFillProfile
             // may get a value after we check below, but that's OK. This check is only an
             // optimisation, and we do a proper synchronized check further down when it comes
             // to actually setting the inferred profile.
             if (mAutoFillProfile == null) {
                 // We did not load a profile from disk. Try to infer one from the user's
                 // "me" contact.
                 final Uri profileUri = Uri.withAppendedPath(ContactsContract.Profile.CONTENT_URI,
                         ContactsContract.Contacts.Data.CONTENT_DIRECTORY);
                 String name = getContactField(profileUri,
                         ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME,
                         ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);
                 // Only attempt to read other data and set a profile if we could successfully
                 // get a name.
                 if (name != null) {
                     String email = getContactField(profileUri,
                             ContactsContract.CommonDataKinds.Email.ADDRESS,
                             ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE);
                     String phone = getContactField(profileUri,
                             ContactsContract.CommonDataKinds.Phone.NUMBER,
                             ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                     String company = getContactField(profileUri,
                             ContactsContract.CommonDataKinds.Organization.COMPANY,
                             ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE);

                     // Can't easily get structured postal address information (even using
                     // CommonDataKinds.StructuredPostal) so omit prepopulating that for now.
                     // When querying structured postal data, it often all comes back as a string
                     // inside the "street" field.

                     synchronized(AutofillHandler.this) {
                         // Only use this profile if one hasn't been set inbetween the
                         // inital import and this thread getting to this point.
                         if (mAutoFillProfile == null) {
                             setAutoFillProfile(new AutoFillProfile(1, name, email, company,
                                     null, null, null, null, null, null, phone), null);
                         }
                     }
                 }
             }
         }

         private String getContactField(Uri uri, String field, String itemType) {
             String result = null;

             Cursor c = mContext.getContentResolver().query(uri, new String[] { field },
                     ContactsContract.Data.MIMETYPE + "=?", new String[] { itemType }, null);

             if (c == null) {
                 return null;
             }

             try {
                 // Just use the first returned value if we get more than one.
                 if (c.moveToFirst()) {
                     result = c.getString(0);
                 }
             } finally {
                 c.close();
             }
             return result;
         }
     }

     public synchronized void setAutoFillProfile(AutoFillProfile profile, Message msg) {
         waitForLoad();
         int profileId = NO_AUTOFILL_PROFILE_SET;
         if (profile != null) {
             profileId = profile.getUniqueId();
             // Update the AutoFill DB with the new profile.
             new SaveProfileToDbTask(msg).execute(profile);
         } else {
             // Delete the current profile.
             if (mAutoFillProfile != null) {
                 new DeleteProfileFromDbTask(msg).execute(mAutoFillProfile.getUniqueId());
             }
         }
         // Make sure we set mAutoFillProfile before calling setActiveAutoFillProfileId
         // Calling setActiveAutoFillProfileId will trigger an update of WebViews
         // which will expect a new profile to be set
         mAutoFillProfile = profile;
         setActiveAutoFillProfileId(profileId);
     }

     public synchronized AutoFillProfile getAutoFillProfile() {
         waitForLoad();
         return mAutoFillProfile;
     }

     private synchronized void setActiveAutoFillProfileId(int activeProfileId) {
         mAutoFillActiveProfileId = activeProfileId;
         Editor ed = PreferenceManager.
             getDefaultSharedPreferences(mContext).edit();
         ed.putInt(PreferenceKeys.PREF_AUTOFILL_ACTIVE_PROFILE_ID, activeProfileId);
         ed.apply();
     }

     private abstract class AutoFillProfileDbTask<T> extends AsyncTask<T, Void, Void> {
         AutoFillProfileDatabase mAutoFillProfileDb;
         Message mCompleteMessage;

         public AutoFillProfileDbTask(Message msg) {
             mCompleteMessage = msg;
         }

         @Override
         protected void onPostExecute(Void result) {
             if (mCompleteMessage != null) {
                 mCompleteMessage.sendToTarget();
             }
             mAutoFillProfileDb.close();
         }

         @Override
         abstract protected Void doInBackground(T... values);
     }


     private class SaveProfileToDbTask extends AutoFillProfileDbTask<AutoFillProfile> {
         public SaveProfileToDbTask(Message msg) {
             super(msg);
         }

         @Override
         protected Void doInBackground(AutoFillProfile... values) {
             mAutoFillProfileDb = AutoFillProfileDatabase.getInstance(mContext);
             synchronized (AutofillHandler.this) {
                 assert mAutoFillActiveProfileId != NO_AUTOFILL_PROFILE_SET;
                 AutoFillProfile newProfile = values[0];
                 mAutoFillProfileDb.addOrUpdateProfile(mAutoFillActiveProfileId, newProfile);
             }
             return null;
         }
     }

     private class DeleteProfileFromDbTask extends AutoFillProfileDbTask<Integer> {
         public DeleteProfileFromDbTask(Message msg) {
             super(msg);
         }

         @Override
         protected Void doInBackground(Integer... values) {
             mAutoFillProfileDb = AutoFillProfileDatabase.getInstance(mContext);
             int id = values[0];
             assert  id > 0;
             mAutoFillProfileDb.dropProfile(id);
             return null;
         }
     }
 }

	/*
	* Copyright (C) 2011 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.browser;

	import android.content.Context;
	import android.content.SharedPreferences;
	import android.content.SharedPreferences.Editor;
	import android.database.Cursor;
	import android.net.Uri;
	import android.os.AsyncTask;
	import android.os.Message;
	import android.preference.PreferenceManager;
	import android.provider.ContactsContract;
	import android.util.Log;
	import android.webkit.WebSettingsClassic.AutoFillProfile;

	import java.util.concurrent.CountDownLatch;

	public class AutofillHandler {

	private AutoFillProfile mAutoFillProfile;
	// Default to zero. In the case no profile is set up, the initial
	// value will come from the AutoFillSettingsFragment when the user
	// creates a profile. Otherwise, we'll read the ID of the last used
	// profile from the prefs db.
	private int mAutoFillActiveProfileId;
	private static final int NO_AUTOFILL_PROFILE_SET = 0;

	private CountDownLatch mLoaded = new CountDownLatch(1);
	private Context mContext;

	private static final String LOGTAG = "AutofillHandler";

	public AutofillHandler(Context context) {
	mContext = context.getApplicationContext();
	}

	/**
	* Load settings from the browser app's database. It is performed in
	* an AsyncTask as it involves plenty of slow disk IO.
	* NOTE: Strings used for the preferences must match those specified
	* in the various preference XML files.
	*/
	public void asyncLoadFromDb() {
	// Run the initial settings load in an AsyncTask as it hits the
	// disk multiple times through SharedPreferences and SQLite. We
	// need to be certain though that this has completed before we start
	// to load pages though, so in the worst case we will block waiting
	// for it to finish in BrowserActivity.onCreate().
	new LoadFromDb().start();
	}

	private void waitForLoad() {
	try {
	mLoaded.await();
	} catch (InterruptedException e) {
	Log.w(LOGTAG, "Caught exception while waiting for AutofillProfile to load.");
	}
	}

	private class LoadFromDb extends Thread {

	@Override
	public void run() {
	// Note the lack of synchronization over mAutoFillActiveProfileId and
	// mAutoFillProfile here. This is because we control all other access
	// to these members through the public functions of this class, and they
	// all wait for this thread via the mLoaded CountDownLatch.

	SharedPreferences p = PreferenceManager.getDefaultSharedPreferences(mContext);

	// Read the last active AutoFill profile id.
	mAutoFillActiveProfileId = p.getInt(
	PreferenceKeys.PREF_AUTOFILL_ACTIVE_PROFILE_ID,
	mAutoFillActiveProfileId);

	// Load the autofill profile data from the database. We use a database separate
	// to the browser preference DB to make it easier to support multiple profiles
	// and switching between them. Note that this may block startup if this DB lookup
	// is extremely slow. We do this to ensure that if there's a profile set, the
	// user never sees the "setup Autofill" option.
	AutoFillProfileDatabase autoFillDb = AutoFillProfileDatabase.getInstance(mContext);
	Cursor c = autoFillDb.getProfile(mAutoFillActiveProfileId);

	if (c.getCount() > 0) {
	c.moveToFirst();

	String fullName = c.getString(c.getColumnIndex(
	AutoFillProfileDatabase.Profiles.FULL_NAME));
	String email = c.getString(c.getColumnIndex(
	AutoFillProfileDatabase.Profiles.EMAIL_ADDRESS));
	String company = c.getString(c.getColumnIndex(
	AutoFillProfileDatabase.Profiles.COMPANY_NAME));
	String addressLine1 = c.getString(c.getColumnIndex(
	AutoFillProfileDatabase.Profiles.ADDRESS_LINE_1));
	String addressLine2 = c.getString(c.getColumnIndex(
	AutoFillProfileDatabase.Profiles.ADDRESS_LINE_2));
	String city = c.getString(c.getColumnIndex(
	AutoFillProfileDatabase.Profiles.CITY));
	String state = c.getString(c.getColumnIndex(
	AutoFillProfileDatabase.Profiles.STATE));
	String zip = c.getString(c.getColumnIndex(
	AutoFillProfileDatabase.Profiles.ZIP_CODE));
	String country = c.getString(c.getColumnIndex(
	AutoFillProfileDatabase.Profiles.COUNTRY));
	String phone = c.getString(c.getColumnIndex(
	AutoFillProfileDatabase.Profiles.PHONE_NUMBER));
	mAutoFillProfile = new AutoFillProfile(mAutoFillActiveProfileId,
	fullName, email, company, addressLine1, addressLine2, city,
	state, zip, country, phone);
	}
	c.close();
	autoFillDb.close();

	// At this point we've loaded the profile if there was one, so let any thread
	// waiting on initialization continue.
	mLoaded.countDown();

	// Synchronization note: strictly speaking, it's possible that mAutoFillProfile
	// may get a value after we check below, but that's OK. This check is only an
	// optimisation, and we do a proper synchronized check further down when it comes
	// to actually setting the inferred profile.
	if (mAutoFillProfile == null) {
	// We did not load a profile from disk. Try to infer one from the user's
	// "me" contact.
	final Uri profileUri = Uri.withAppendedPath(ContactsContract.Profile.CONTENT_URI,
	ContactsContract.Contacts.Data.CONTENT_DIRECTORY);
	String name = getContactField(profileUri,
	ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME,
	ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);
	// Only attempt to read other data and set a profile if we could successfully
	// get a name.
	if (name != null) {
	String email = getContactField(profileUri,
	ContactsContract.CommonDataKinds.Email.ADDRESS,
	ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE);
	String phone = getContactField(profileUri,
	ContactsContract.CommonDataKinds.Phone.NUMBER,
	ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
	String company = getContactField(profileUri,
	ContactsContract.CommonDataKinds.Organization.COMPANY,
	ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE);

	// Can't easily get structured postal address information (even using
	// CommonDataKinds.StructuredPostal) so omit prepopulating that for now.
	// When querying structured postal data, it often all comes back as a string
	// inside the "street" field.

	synchronized(AutofillHandler.this) {
	// Only use this profile if one hasn't been set inbetween the
	// inital import and this thread getting to this point.
	if (mAutoFillProfile == null) {
	setAutoFillProfile(new AutoFillProfile(1, name, email, company,
	null, null, null, null, null, null, phone), null);
	}
	}
	}
	}
	}

	private String getContactField(Uri uri, String field, String itemType) {
	String result = null;

	Cursor c = mContext.getContentResolver().query(uri, new String[] { field },
	ContactsContract.Data.MIMETYPE + "=?", new String[] { itemType }, null);

	if (c == null) {
	return null;
	}

	try {
	// Just use the first returned value if we get more than one.
	if (c.moveToFirst()) {
	result = c.getString(0);
	}
	} finally {
	c.close();
	}
	return result;
	}
	}

	public synchronized void setAutoFillProfile(AutoFillProfile profile, Message msg) {
	waitForLoad();
	int profileId = NO_AUTOFILL_PROFILE_SET;
	if (profile != null) {
	profileId = profile.getUniqueId();
	// Update the AutoFill DB with the new profile.
	new SaveProfileToDbTask(msg).execute(profile);
	} else {
	// Delete the current profile.
	if (mAutoFillProfile != null) {
	new DeleteProfileFromDbTask(msg).execute(mAutoFillProfile.getUniqueId());
	}
	}
	// Make sure we set mAutoFillProfile before calling setActiveAutoFillProfileId
	// Calling setActiveAutoFillProfileId will trigger an update of WebViews
	// which will expect a new profile to be set
	mAutoFillProfile = profile;
	setActiveAutoFillProfileId(profileId);
	}

	public synchronized AutoFillProfile getAutoFillProfile() {
	waitForLoad();
	return mAutoFillProfile;
	}

	private synchronized void setActiveAutoFillProfileId(int activeProfileId) {
	mAutoFillActiveProfileId = activeProfileId;
	Editor ed = PreferenceManager.
	getDefaultSharedPreferences(mContext).edit();
	ed.putInt(PreferenceKeys.PREF_AUTOFILL_ACTIVE_PROFILE_ID, activeProfileId);
	ed.apply();
	}

	private abstract class AutoFillProfileDbTask<T> extends AsyncTask<T, Void, Void> {
	AutoFillProfileDatabase mAutoFillProfileDb;
	Message mCompleteMessage;

	public AutoFillProfileDbTask(Message msg) {
	mCompleteMessage = msg;
	}

	@Override
	protected void onPostExecute(Void result) {
	if (mCompleteMessage != null) {
	mCompleteMessage.sendToTarget();
	}
	mAutoFillProfileDb.close();
	}

	@Override
	abstract protected Void doInBackground(T... values);
	}


	private class SaveProfileToDbTask extends AutoFillProfileDbTask<AutoFillProfile> {
	public SaveProfileToDbTask(Message msg) {
	super(msg);
	}

	@Override
	protected Void doInBackground(AutoFillProfile... values) {
	mAutoFillProfileDb = AutoFillProfileDatabase.getInstance(mContext);
	synchronized (AutofillHandler.this) {
	assert mAutoFillActiveProfileId != NO_AUTOFILL_PROFILE_SET;
	AutoFillProfile newProfile = values[0];
	mAutoFillProfileDb.addOrUpdateProfile(mAutoFillActiveProfileId, newProfile);
	}
	return null;
	}
	}

	private class DeleteProfileFromDbTask extends AutoFillProfileDbTask<Integer> {
	public DeleteProfileFromDbTask(Message msg) {
	super(msg);
	}

	@Override
	protected Void doInBackground(Integer... values) {
	mAutoFillProfileDb = AutoFillProfileDatabase.getInstance(mContext);
	int id = values[0];
	assert id > 0;
	mAutoFillProfileDb.dropProfile(id);
	return null;
	}
	}
	}