personal_data_manager_android.cc revision 4e180b6a0b4720a9b8e9e959a882386f690f08ff 
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
22using base::android::ConvertJavaStringToUTF8;
23using base::android::ConvertUTF16ToJavaString;
24using base::android::ConvertUTF8ToJavaString;
25using base::android::ScopedJavaLocalRef;
26
27namespace autofill {
28namespace {
29
30Profile* GetDefaultProfile() {
31  return g_browser_process->profile_manager()->GetDefaultProfile();
32}
33
34PrefService* GetPrefs() {
35  return GetDefaultProfile()->GetOriginalProfile()->GetPrefs();
36}
37
38ScopedJavaLocalRef<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
72void 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
122ScopedJavaLocalRef<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
140void 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
162PersonalDataManagerAndroid::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
170PersonalDataManagerAndroid::~PersonalDataManagerAndroid() {
171  personal_data_manager_->RemoveObserver(this);
172}
173
174jint PersonalDataManagerAndroid::GetProfileCount(JNIEnv* unused_env,
175                                                 jobject unused_obj) {
176  return personal_data_manager_->GetProfiles().size();
177}
178
179ScopedJavaLocalRef<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
190ScopedJavaLocalRef<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
202ScopedJavaLocalRef<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
223jint PersonalDataManagerAndroid::GetCreditCardCount(JNIEnv* unused_env,
224                                                    jobject unused_obj) {
225  return personal_data_manager_->GetCreditCards().size();
226}
227
228ScopedJavaLocalRef<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
239ScopedJavaLocalRef<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
251ScopedJavaLocalRef<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
271void PersonalDataManagerAndroid::RemoveByGUID(JNIEnv* env,
272                                              jobject unused_obj,
273                                              jstring jguid) {
274  personal_data_manager_->RemoveByGUID(ConvertJavaStringToUTF8(env, jguid));
275}
276
277void 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
287bool PersonalDataManagerAndroid::Register(JNIEnv* env) {
288  return RegisterNativesImpl(env);
289}
290
291// Returns whether the Autofill feature is enabled.
292static jboolean IsAutofillEnabled(JNIEnv* env, jclass clazz) {
293  return GetPrefs()->GetBoolean(autofill::prefs::kAutofillEnabled);
294}
295
296// Enables or disables the Autofill feature.
297static void SetAutofillEnabled(JNIEnv* env, jclass clazz, jboolean enable) {
298  GetPrefs()->SetBoolean(autofill::prefs::kAutofillEnabled, enable);
299}
300
301// Returns whether Autofill feature is managed.
302static 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.
308static 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
316static 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
323