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