src/chrome/browser/autofill/android/personal_data_manager_android.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/autofill/android/personal_data_manager_android.h"
   6
   7 #include "base/android/jni_string.h"
   8 #include "base/format_macros.h"
   9 #include "base/prefs/pref_service.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/autofill/personal_data_manager_factory.h"
  13 #include "chrome/browser/browser_process.h"
  14 #include "chrome/browser/profiles/profile_manager.h"
  15 #include "chrome/common/pref_names.h"
  16 #include "components/autofill/core/browser/autofill_country.h"
  17 #include "components/autofill/core/browser/autofill_type.h"
  18 #include "components/autofill/core/browser/field_types.h"
  19 #include "components/autofill/core/browser/personal_data_manager.h"
  20 #include "jni/PersonalDataManager_jni.h"
  21
  22 using base::android::ConvertJavaStringToUTF8;
  23 using base::android::ConvertUTF16ToJavaString;
  24 using base::android::ConvertUTF8ToJavaString;
  25 using base::android::ScopedJavaLocalRef;
  26
  27 namespace autofill {
  28 namespace {
  29
  30 Profile* GetDefaultProfile() {
  31   return g_browser_process->profile_manager()->GetDefaultProfile();
  32 }
  33
  34 PrefService* GetPrefs() {
  35   return GetDefaultProfile()->GetOriginalProfile()->GetPrefs();
  36 }
  37
  38 ScopedJavaLocalRef<jobject> CreateJavaProfileFromNative(
  39     JNIEnv* env,
  40     const AutofillProfile& profile) {
  41   return Java_AutofillProfile_create(
  42       env,
  43       ConvertUTF8ToJavaString(env, profile.guid()).obj(),
  44       ConvertUTF8ToJavaString(env, profile.origin()).obj(),
  45       ConvertUTF16ToJavaString(env, profile.GetRawInfo(NAME_FULL)).obj(),
  46       ConvertUTF16ToJavaString(env, profile.GetRawInfo(COMPANY_NAME)).obj(),
  47       ConvertUTF16ToJavaString(
  48           env,
  49           profile.GetRawInfo(ADDRESS_HOME_LINE1)).obj(),
  50       ConvertUTF16ToJavaString(
  51           env,
  52           profile.GetRawInfo(ADDRESS_HOME_LINE2)).obj(),
  53       ConvertUTF16ToJavaString(
  54           env,
  55           profile.GetRawInfo(ADDRESS_HOME_CITY)).obj(),
  56       ConvertUTF16ToJavaString(
  57           env,
  58           profile.GetRawInfo(ADDRESS_HOME_STATE)).obj(),
  59       ConvertUTF16ToJavaString(
  60           env,
  61           profile.GetRawInfo(ADDRESS_HOME_ZIP)).obj(),
  62       ConvertUTF16ToJavaString(
  63           env,
  64           profile.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY),
  65                           g_browser_process->GetApplicationLocale())).obj(),
  66       ConvertUTF16ToJavaString(
  67           env,
  68           profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER)).obj(),
  69       ConvertUTF16ToJavaString(env, profile.GetRawInfo(EMAIL_ADDRESS)).obj());
  70 }
  71
  72 void PopulateNativeProfileFromJava(
  73     const jobject& jprofile,
  74     JNIEnv* env,
  75     AutofillProfile* profile) {
  76   profile->set_origin(
  77       ConvertJavaStringToUTF8(
  78           Java_AutofillProfile_getOrigin(env, jprofile)));
  79   profile->SetRawInfo(
  80       NAME_FULL,
  81       ConvertJavaStringToUTF16(
  82           Java_AutofillProfile_getFullName(env, jprofile)));
  83   profile->SetRawInfo(
  84       COMPANY_NAME,
  85       ConvertJavaStringToUTF16(
  86           Java_AutofillProfile_getCompanyName(env, jprofile)));
  87   profile->SetRawInfo(
  88       ADDRESS_HOME_LINE1,
  89       ConvertJavaStringToUTF16(
  90           Java_AutofillProfile_getAddressLine1(env, jprofile)));
  91   profile->SetRawInfo(
  92       ADDRESS_HOME_LINE2,
  93       ConvertJavaStringToUTF16(
  94           Java_AutofillProfile_getAddressLine2(env, jprofile)));
  95   profile->SetRawInfo(
  96       ADDRESS_HOME_CITY,
  97       ConvertJavaStringToUTF16(
  98           Java_AutofillProfile_getCity(env, jprofile)));
  99   profile->SetRawInfo(
 100       ADDRESS_HOME_STATE,
 101       ConvertJavaStringToUTF16(
 102           Java_AutofillProfile_getState(env, jprofile)));
 103   profile->SetRawInfo(
 104       ADDRESS_HOME_ZIP,
 105       ConvertJavaStringToUTF16(
 106           Java_AutofillProfile_getZip(env, jprofile)));
 107   profile->SetInfo(
 108       AutofillType(ADDRESS_HOME_COUNTRY),
 109       ConvertJavaStringToUTF16(
 110           Java_AutofillProfile_getCountry(env, jprofile)),
 111       g_browser_process->GetApplicationLocale());
 112   profile->SetRawInfo(
 113       PHONE_HOME_WHOLE_NUMBER,
 114       ConvertJavaStringToUTF16(
 115           Java_AutofillProfile_getPhoneNumber(env, jprofile)));
 116   profile->SetRawInfo(
 117       EMAIL_ADDRESS,
 118       ConvertJavaStringToUTF16(
 119           Java_AutofillProfile_getEmailAddress(env, jprofile)));
 120 }
 121
 122 ScopedJavaLocalRef<jobject> CreateJavaCreditCardFromNative(
 123     JNIEnv* env,
 124     const CreditCard& card) {
 125   return Java_CreditCard_create(
 126       env,
 127       ConvertUTF8ToJavaString(env, card.guid()).obj(),
 128       ConvertUTF8ToJavaString(env, card.origin()).obj(),
 129       ConvertUTF16ToJavaString(env, card.GetRawInfo(CREDIT_CARD_NAME)).obj(),
 130       ConvertUTF16ToJavaString(env, card.GetRawInfo(CREDIT_CARD_NUMBER)).obj(),
 131       ConvertUTF16ToJavaString(env, card.ObfuscatedNumber()).obj(),
 132       ConvertUTF16ToJavaString(
 133           env,
 134           card.GetRawInfo(CREDIT_CARD_EXP_MONTH)).obj(),
 135       ConvertUTF16ToJavaString(
 136           env,
 137           card.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR)).obj());
 138 }
 139
 140 void PopulateNativeCreditCardFromJava(
 141     const jobject& jcard,
 142     JNIEnv* env,
 143     CreditCard* card) {
 144   card->set_origin(
 145       ConvertJavaStringToUTF8(Java_CreditCard_getOrigin(env, jcard)));
 146   card->SetRawInfo(
 147       CREDIT_CARD_NAME,
 148       ConvertJavaStringToUTF16(Java_CreditCard_getName(env, jcard)));
 149   card->SetRawInfo(
 150       CREDIT_CARD_NUMBER,
 151       ConvertJavaStringToUTF16(Java_CreditCard_getNumber(env, jcard)));
 152   card->SetRawInfo(
 153       CREDIT_CARD_EXP_MONTH,
 154       ConvertJavaStringToUTF16(Java_CreditCard_getMonth(env, jcard)));
 155   card->SetRawInfo(
 156       CREDIT_CARD_EXP_4_DIGIT_YEAR,
 157       ConvertJavaStringToUTF16(Java_CreditCard_getYear(env, jcard)));
 158 }
 159
 160 }  // namespace
 161
 162 PersonalDataManagerAndroid::PersonalDataManagerAndroid(JNIEnv* env,
 163                                                        jobject obj)
 164     : weak_java_obj_(env, obj),
 165       personal_data_manager_(
 166           PersonalDataManagerFactory::GetForProfile(GetDefaultProfile())) {
 167   personal_data_manager_->AddObserver(this);
 168 }
 169
 170 PersonalDataManagerAndroid::~PersonalDataManagerAndroid() {
 171   personal_data_manager_->RemoveObserver(this);
 172 }
 173
 174 jint PersonalDataManagerAndroid::GetProfileCount(JNIEnv* unused_env,
 175                                                  jobject unused_obj) {
 176   return personal_data_manager_->GetProfiles().size();
 177 }
 178
 179 ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::GetProfileByIndex(
 180     JNIEnv* env,
 181     jobject unused_obj,
 182     jint index) {
 183   const std::vector<AutofillProfile*>& profiles =
 184       personal_data_manager_->GetProfiles();
 185   size_t index_size_t = static_cast<size_t>(index);
 186   DCHECK_LT(index_size_t, profiles.size());
 187   return CreateJavaProfileFromNative(env, *profiles[index_size_t]);
 188 }
 189
 190 ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::GetProfileByGUID(
 191     JNIEnv* env,
 192     jobject unused_obj,
 193     jstring jguid) {
 194   AutofillProfile* profile = personal_data_manager_->GetProfileByGUID(
 195       ConvertJavaStringToUTF8(env, jguid));
 196   if (!profile)
 197     return ScopedJavaLocalRef<jobject>();
 198
 199   return CreateJavaProfileFromNative(env, *profile);
 200 }
 201
 202 ScopedJavaLocalRef<jstring> PersonalDataManagerAndroid::SetProfile(
 203     JNIEnv* env,
 204     jobject unused_obj,
 205     jobject jprofile) {
 206   std::string guid = ConvertJavaStringToUTF8(
 207       env,
 208       Java_AutofillProfile_getGUID(env, jprofile).obj());
 209
 210   AutofillProfile profile;
 211   PopulateNativeProfileFromJava(jprofile, env, &profile);
 212
 213   if (guid.empty()) {
 214     personal_data_manager_->AddProfile(profile);
 215   } else {
 216     profile.set_guid(guid);
 217     personal_data_manager_->UpdateProfile(profile);
 218   }
 219
 220   return ConvertUTF8ToJavaString(env, profile.guid());
 221 }
 222
 223 jint PersonalDataManagerAndroid::GetCreditCardCount(JNIEnv* unused_env,
 224                                                     jobject unused_obj) {
 225   return personal_data_manager_->GetCreditCards().size();
 226 }
 227
 228 ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::GetCreditCardByIndex(
 229     JNIEnv* env,
 230     jobject unused_obj,
 231     jint index) {
 232   const std::vector<CreditCard*>& credit_cards =
 233       personal_data_manager_->GetCreditCards();
 234   size_t index_size_t = static_cast<size_t>(index);
 235   DCHECK_LT(index_size_t, credit_cards.size());
 236   return CreateJavaCreditCardFromNative(env, *credit_cards[index_size_t]);
 237 }
 238
 239 ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::GetCreditCardByGUID(
 240     JNIEnv* env,
 241     jobject unused_obj,
 242     jstring jguid) {
 243   CreditCard* card = personal_data_manager_->GetCreditCardByGUID(
 244           ConvertJavaStringToUTF8(env, jguid));
 245   if (!card)
 246     return ScopedJavaLocalRef<jobject>();
 247
 248   return CreateJavaCreditCardFromNative(env, *card);
 249 }
 250
 251 ScopedJavaLocalRef<jstring> PersonalDataManagerAndroid::SetCreditCard(
 252     JNIEnv* env,
 253     jobject unused_obj,
 254     jobject jcard) {
 255   std::string guid = ConvertJavaStringToUTF8(
 256        env,
 257        Java_CreditCard_getGUID(env, jcard).obj());
 258
 259   CreditCard card;
 260   PopulateNativeCreditCardFromJava(jcard, env, &card);
 261
 262   if (guid.empty()) {
 263     personal_data_manager_->AddCreditCard(card);
 264   } else {
 265     card.set_guid(guid);
 266     personal_data_manager_->UpdateCreditCard(card);
 267   }
 268   return ConvertUTF8ToJavaString(env, card.guid());
 269 }
 270
 271 void PersonalDataManagerAndroid::RemoveByGUID(JNIEnv* env,
 272                                               jobject unused_obj,
 273                                               jstring jguid) {
 274   personal_data_manager_->RemoveByGUID(ConvertJavaStringToUTF8(env, jguid));
 275 }
 276
 277 void PersonalDataManagerAndroid::OnPersonalDataChanged() {
 278   JNIEnv* env = base::android::AttachCurrentThread();
 279   if (weak_java_obj_.get(env).is_null())
 280     return;
 281
 282   Java_PersonalDataManager_personalDataChanged(env,
 283                                                weak_java_obj_.get(env).obj());
 284 }
 285
 286 // static
 287 bool PersonalDataManagerAndroid::Register(JNIEnv* env) {
 288   return RegisterNativesImpl(env);
 289 }
 290
 291 // Returns whether the Autofill feature is enabled.
 292 static jboolean IsAutofillEnabled(JNIEnv* env, jclass clazz) {
 293   return GetPrefs()->GetBoolean(autofill::prefs::kAutofillEnabled);
 294 }
 295
 296 // Enables or disables the Autofill feature.
 297 static void SetAutofillEnabled(JNIEnv* env, jclass clazz, jboolean enable) {
 298   GetPrefs()->SetBoolean(autofill::prefs::kAutofillEnabled, enable);
 299 }
 300
 301 // Returns whether Autofill feature is managed.
 302 static jboolean IsAutofillManaged(JNIEnv* env, jclass clazz) {
 303   return GetPrefs()->IsManagedPreference(autofill::prefs::kAutofillEnabled);
 304 }
 305
 306 // Returns an ISO 3166-1-alpha-2 country code for a |jcountry_name| using
 307 // the application locale, or an empty string.
 308 static jstring ToCountryCode(JNIEnv* env, jclass clazz, jstring jcountry_name) {
 309   return ConvertUTF8ToJavaString(
 310       env,
 311       AutofillCountry::GetCountryCode(
 312           base::android::ConvertJavaStringToUTF16(env, jcountry_name),
 313           g_browser_process->GetApplicationLocale())).Release();
 314 }
 315
 316 static jint Init(JNIEnv* env, jobject obj) {
 317   PersonalDataManagerAndroid* personal_data_manager_android =
 318       new PersonalDataManagerAndroid(env, obj);
 319   return reinterpret_cast<jint>(personal_data_manager_android);
 320 }
 321
 322 }  // namespace autofill