personal_data_manager_android.cc revision 90dce4d38c5ff5333bea97d859d4e484e27edf0c 
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/stringprintf.h"
10#include "base/utf_string_conversions.h"
11#include "chrome/browser/autofill/personal_data_manager_factory.h"
12#include "chrome/browser/browser_process.h"
13#include "chrome/browser/profiles/profile_manager.h"
14#include "components/autofill/browser/field_types.h"
15#include "components/autofill/browser/personal_data_manager.h"
16#include "jni/PersonalDataManager_jni.h"
17
18using base::android::ConvertJavaStringToUTF8;
19using base::android::ConvertUTF16ToJavaString;
20using base::android::ConvertUTF8ToJavaString;
21using base::android::ScopedJavaLocalRef;
22
23namespace autofill {
24namespace {
25
26Profile* GetDefaultProfile() {
27  return g_browser_process->profile_manager()->GetDefaultProfile();
28}
29
30ScopedJavaLocalRef<jobject> CreateJavaProfileFromNative(
31    JNIEnv* env,
32    const AutofillProfile& profile) {
33  return Java_AutofillProfile_create(
34      env,
35      ConvertUTF8ToJavaString(env, profile.guid()).obj(),
36      ConvertUTF8ToJavaString(env, profile.origin()).obj(),
37      ConvertUTF16ToJavaString(env, profile.GetRawInfo(NAME_FULL)).obj(),
38      ConvertUTF16ToJavaString(env, profile.GetRawInfo(COMPANY_NAME)).obj(),
39      ConvertUTF16ToJavaString(
40          env,
41          profile.GetRawInfo(ADDRESS_HOME_LINE1)).obj(),
42      ConvertUTF16ToJavaString(
43          env,
44          profile.GetRawInfo(ADDRESS_HOME_LINE2)).obj(),
45      ConvertUTF16ToJavaString(
46          env,
47          profile.GetRawInfo(ADDRESS_HOME_CITY)).obj(),
48      ConvertUTF16ToJavaString(
49          env,
50          profile.GetRawInfo(ADDRESS_HOME_STATE)).obj(),
51      ConvertUTF16ToJavaString(
52          env,
53          profile.GetRawInfo(ADDRESS_HOME_ZIP)).obj(),
54      ConvertUTF16ToJavaString(
55          env,
56          profile.GetInfo(ADDRESS_HOME_COUNTRY,
57                          g_browser_process->GetApplicationLocale())).obj(),
58      ConvertUTF16ToJavaString(
59          env,
60          profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER)).obj(),
61      ConvertUTF16ToJavaString(env, profile.GetRawInfo(EMAIL_ADDRESS)).obj());
62}
63
64void PopulateNativeProfileFromJava(
65    const jobject& jprofile,
66    JNIEnv* env,
67    AutofillProfile* profile) {
68  profile->set_origin(
69      ConvertJavaStringToUTF8(
70          Java_AutofillProfile_getOrigin(env, jprofile)));
71  profile->SetRawInfo(
72      NAME_FULL,
73      ConvertJavaStringToUTF16(
74          Java_AutofillProfile_getFullName(env, jprofile)));
75  profile->SetRawInfo(
76      COMPANY_NAME,
77      ConvertJavaStringToUTF16(
78          Java_AutofillProfile_getCompanyName(env, jprofile)));
79  profile->SetRawInfo(
80      ADDRESS_HOME_LINE1,
81      ConvertJavaStringToUTF16(
82          Java_AutofillProfile_getAddressLine1(env, jprofile)));
83  profile->SetRawInfo(
84      ADDRESS_HOME_LINE2,
85      ConvertJavaStringToUTF16(
86          Java_AutofillProfile_getAddressLine2(env, jprofile)));
87  profile->SetRawInfo(
88      ADDRESS_HOME_CITY,
89      ConvertJavaStringToUTF16(
90          Java_AutofillProfile_getCity(env, jprofile)));
91  profile->SetRawInfo(
92      ADDRESS_HOME_STATE,
93      ConvertJavaStringToUTF16(
94          Java_AutofillProfile_getState(env, jprofile)));
95  profile->SetRawInfo(
96      ADDRESS_HOME_ZIP,
97      ConvertJavaStringToUTF16(
98          Java_AutofillProfile_getZip(env, jprofile)));
99  profile->SetInfo(
100      ADDRESS_HOME_COUNTRY,
101      ConvertJavaStringToUTF16(
102          Java_AutofillProfile_getCountry(env, jprofile)),
103      g_browser_process->GetApplicationLocale());
104  profile->SetRawInfo(
105      PHONE_HOME_WHOLE_NUMBER,
106      ConvertJavaStringToUTF16(
107          Java_AutofillProfile_getPhoneNumber(env, jprofile)));
108  profile->SetRawInfo(
109      EMAIL_ADDRESS,
110      ConvertJavaStringToUTF16(
111          Java_AutofillProfile_getEmailAddress(env, jprofile)));
112}
113
114ScopedJavaLocalRef<jobject> CreateJavaCreditCardFromNative(
115    JNIEnv* env,
116    const CreditCard& card) {
117  return Java_CreditCard_create(
118      env,
119      ConvertUTF8ToJavaString(env, card.guid()).obj(),
120      ConvertUTF8ToJavaString(env, card.origin()).obj(),
121      ConvertUTF16ToJavaString(env, card.GetRawInfo(CREDIT_CARD_NAME)).obj(),
122      ConvertUTF16ToJavaString(env, card.GetRawInfo(CREDIT_CARD_NUMBER)).obj(),
123      ConvertUTF16ToJavaString(env, card.ObfuscatedNumber()).obj(),
124      ConvertUTF16ToJavaString(
125          env,
126          card.GetRawInfo(CREDIT_CARD_EXP_MONTH)).obj(),
127      ConvertUTF16ToJavaString(
128          env,
129          card.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR)).obj());
130}
131
132void PopulateNativeCreditCardFromJava(
133    const jobject& jcard,
134    JNIEnv* env,
135    CreditCard* card) {
136  card->set_origin(
137      ConvertJavaStringToUTF8(Java_CreditCard_getOrigin(env, jcard)));
138  card->SetRawInfo(
139      CREDIT_CARD_NAME,
140      ConvertJavaStringToUTF16(Java_CreditCard_getName(env, jcard)));
141  card->SetRawInfo(
142      CREDIT_CARD_NUMBER,
143      ConvertJavaStringToUTF16(Java_CreditCard_getNumber(env, jcard)));
144  card->SetRawInfo(
145      CREDIT_CARD_EXP_MONTH,
146      ConvertJavaStringToUTF16(Java_CreditCard_getMonth(env, jcard)));
147  card->SetRawInfo(
148      CREDIT_CARD_EXP_4_DIGIT_YEAR,
149      ConvertJavaStringToUTF16(Java_CreditCard_getYear(env, jcard)));
150}
151
152}  // namespace
153
154PersonalDataManagerAndroid::PersonalDataManagerAndroid(JNIEnv* env,
155                                                       jobject obj)
156    : weak_java_obj_(env, obj),
157      personal_data_manager_(
158          PersonalDataManagerFactory::GetForProfile(GetDefaultProfile())) {
159  personal_data_manager_->AddObserver(this);
160}
161
162PersonalDataManagerAndroid::~PersonalDataManagerAndroid() {
163  personal_data_manager_->RemoveObserver(this);
164}
165
166
167jint PersonalDataManagerAndroid::GetProfileCount(JNIEnv* unused_env,
168                                                 jobject unused_obj) {
169  return personal_data_manager_->GetProfiles().size();
170}
171
172ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::GetProfileByIndex(
173    JNIEnv* env,
174    jobject unused_obj,
175    jint index) {
176  const std::vector<AutofillProfile*>& profiles =
177      personal_data_manager_->GetProfiles();
178  size_t index_size_t = static_cast<size_t>(index);
179  DCHECK_LT(index_size_t, profiles.size());
180  return CreateJavaProfileFromNative(env, *profiles[index_size_t]);
181}
182
183ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::GetProfileByGUID(
184    JNIEnv* env,
185    jobject unused_obj,
186    jstring jguid) {
187  AutofillProfile* profile = personal_data_manager_->GetProfileByGUID(
188      ConvertJavaStringToUTF8(env, jguid));
189  if (!profile)
190    return ScopedJavaLocalRef<jobject>();
191
192  return CreateJavaProfileFromNative(env, *profile);
193}
194
195ScopedJavaLocalRef<jstring> PersonalDataManagerAndroid::SetProfile(
196    JNIEnv* env,
197    jobject unused_obj,
198    jobject jprofile) {
199  std::string guid = ConvertJavaStringToUTF8(
200      env,
201      Java_AutofillProfile_getGUID(env, jprofile).obj());
202
203  AutofillProfile profile;
204  PopulateNativeProfileFromJava(jprofile, env, &profile);
205
206  if (guid.empty()) {
207    personal_data_manager_->AddProfile(profile);
208  } else {
209    profile.set_guid(guid);
210    personal_data_manager_->UpdateProfile(profile);
211  }
212
213  return ConvertUTF8ToJavaString(env, profile.guid());
214}
215
216
217jint PersonalDataManagerAndroid::GetCreditCardCount(JNIEnv* unused_env,
218                                                    jobject unused_obj) {
219  return personal_data_manager_->GetCreditCards().size();
220}
221
222ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::GetCreditCardByIndex(
223    JNIEnv* env,
224    jobject unused_obj,
225    jint index) {
226  const std::vector<CreditCard*>& credit_cards =
227      personal_data_manager_->GetCreditCards();
228  size_t index_size_t = static_cast<size_t>(index);
229  DCHECK_LT(index_size_t, credit_cards.size());
230  return CreateJavaCreditCardFromNative(env, *credit_cards[index_size_t]);
231}
232
233ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::GetCreditCardByGUID(
234    JNIEnv* env,
235    jobject unused_obj,
236    jstring jguid) {
237  CreditCard* card = personal_data_manager_->GetCreditCardByGUID(
238          ConvertJavaStringToUTF8(env, jguid));
239  if (!card)
240    return ScopedJavaLocalRef<jobject>();
241
242  return CreateJavaCreditCardFromNative(env, *card);
243}
244
245ScopedJavaLocalRef<jstring> PersonalDataManagerAndroid::SetCreditCard(
246    JNIEnv* env,
247    jobject unused_obj,
248    jobject jcard) {
249  std::string guid = ConvertJavaStringToUTF8(
250       env,
251       Java_CreditCard_getGUID(env, jcard).obj());
252
253  CreditCard card;
254  PopulateNativeCreditCardFromJava(jcard, env, &card);
255
256  if (guid.empty()) {
257    personal_data_manager_->AddCreditCard(card);
258  } else {
259    card.set_guid(guid);
260    personal_data_manager_->UpdateCreditCard(card);
261  }
262  return ConvertUTF8ToJavaString(env, card.guid());
263}
264
265void PersonalDataManagerAndroid::RemoveByGUID(JNIEnv* env,
266                                              jobject unused_obj,
267                                              jstring jguid) {
268  personal_data_manager_->RemoveByGUID(ConvertJavaStringToUTF8(env, jguid));
269}
270
271void PersonalDataManagerAndroid::OnPersonalDataChanged() {
272  JNIEnv* env = base::android::AttachCurrentThread();
273  if (weak_java_obj_.get(env).is_null())
274    return;
275
276  Java_PersonalDataManager_personalDataChanged(env,
277                                               weak_java_obj_.get(env).obj());
278}
279
280// static
281bool PersonalDataManagerAndroid::Register(JNIEnv* env) {
282  return RegisterNativesImpl(env);
283}
284
285static jint Init(JNIEnv* env, jobject obj) {
286  PersonalDataManagerAndroid* personal_data_manager_android =
287      new PersonalDataManagerAndroid(env, obj);
288  return reinterpret_cast<jint>(personal_data_manager_android);
289}
290
291}  // namespace autofill
292