1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ability_runtime/cj_ability_context.h"
17 #include "data_share_predicates_impl.h"
18 #include "contacts.h"
19 #include "contacts_control.h"
20 #include "contacts_permission.h"
21 #include "datashare_helper.h"
22 #include "datashare_predicates.h"
23 #include "hilog_wrapper_api.h"
24 #include "native/ffi_remote_data.h"
25
26 using namespace OHOS;
27 using namespace OHOS::AbilityRuntime;
28 using namespace OHOS::ContactsFfi;
29 using namespace OHOS::DataShare;
30 using namespace OHOS::FFI;
31
32 namespace OHOS {
33 namespace ContactsFfi {
34
35 // works for contactId and holderId
IsInvalidId(int id)36 bool IsInvalidId(int id)
37 {
38 return id <= 0;
39 }
40
dsHelperFromContext(int64_t contextId)41 std::shared_ptr<DataShareHelper> dsHelperFromContext(int64_t contextId)
42 {
43 sptr<CJAbilityContext> context = FFIData::GetData<CJAbilityContext>(contextId);
44 return DataShareHelper::Creator(context->GetToken(), CONTACTS_DATA_URI);
45 }
46
CJaddContact(int64_t contextId,DataShareValuesBucket rawContact,std::vector<DataShareValuesBucket> contactData,int32_t * errCode)47 int64_t Contacts::CJaddContact(int64_t contextId, DataShareValuesBucket rawContact,
48 std::vector<DataShareValuesBucket> contactData, int32_t *errCode)
49 {
50 HILOG_INFO("CJaddContact data size = %{public}d", (int) contactData.size());
51
52 std::shared_ptr<DataShareHelper> dataShareHelper = dsHelperFromContext(contextId);
53 if (dataShareHelper == nullptr) {
54 HILOG_ERROR("CJaddContact Permission denied!");
55 *errCode = PERMISSION_ERROR;
56 return Contacts::INVALID_CONTACT_ID;
57 }
58
59 ContactsControl contactsControl;
60 int rawId = contactsControl.RawContactInsert(dataShareHelper, rawContact);
61
62 unsigned int size = contactData.size();
63 for (unsigned int i = 0; i < size; ++i) {
64 contactData[i].Put("raw_contact_id", rawId);
65 }
66
67 int code = contactsControl.ContactDataInsert(dataShareHelper, contactData);
68
69 dataShareHelper->Release();
70 dataShareHelper = nullptr;
71
72 *errCode = code;
73 if (code == SUCCESS) {
74 HILOG_INFO("CJaddContact returns id = %{public}d", rawId);
75 return rawId;
76 } else {
77 HILOG_ERROR("CJaddContact gets errCode = %{public}d and returns id = -1", code);
78 return Contacts::INVALID_CONTACT_ID;
79 }
80 }
81
CJdeleteContact(int64_t contextId,int64_t predicatesId,int32_t * errCode)82 void Contacts::CJdeleteContact(int64_t contextId, int64_t predicatesId, int32_t *errCode)
83 {
84 std::shared_ptr<DataShareHelper> dataShareHelper = dsHelperFromContext(contextId);
85 if (dataShareHelper == nullptr) {
86 HILOG_ERROR("CJdeleteContact Permission denied!");
87 *errCode = PERMISSION_ERROR;
88 return;
89 }
90
91 std::shared_ptr<DataSharePredicates> predicates =
92 FFIData::GetData<DataSharePredicatesImpl>(predicatesId)->GetPredicates();
93
94 ContactsControl contactsControl;
95 int code = contactsControl.ContactDelete(dataShareHelper, *predicates);
96
97 dataShareHelper->Release();
98 dataShareHelper = nullptr;
99
100 *errCode = code;
101 }
102
buildQueryDataPredicates(int64_t contactId)103 DataSharePredicates buildQueryDataPredicates(int64_t contactId)
104 {
105 DataSharePredicates predicates;
106 if (contactId != 0) {
107 std::vector<std::string> fields;
108 fields.push_back("raw_contact_id");
109 predicates.EqualTo("is_deleted", "0");
110 predicates.And();
111 predicates.EqualTo("contact_id", std::to_string(contactId));
112 predicates.GroupBy(fields);
113 }
114 return predicates;
115 }
116
GetRawIdByResultSet(const std::shared_ptr<DataShare::DataShareResultSet> & resultSet)117 int GetRawIdByResultSet(const std::shared_ptr<DataShare::DataShareResultSet> &resultSet)
118 {
119 if (resultSet == nullptr) {
120 return -1;
121 }
122 int resultSetNum = resultSet->GoToFirstRow();
123 int intValue = 0;
124 while (resultSetNum == OHOS::NativeRdb::E_OK) {
125 resultSet->GetInt(0, intValue);
126 resultSetNum = resultSet->GoToNextRow();
127 }
128 resultSet->Close();
129 return intValue;
130 }
131
CJupdateContact(int64_t contextId,int64_t contactId,std::vector<DataShareValuesBucket> contactData,int64_t predicatesId,int32_t * errCode)132 void Contacts::CJupdateContact(int64_t contextId, int64_t contactId, std::vector<DataShareValuesBucket> contactData,
133 int64_t predicatesId, int32_t *errCode)
134 {
135 std::shared_ptr<DataShareHelper> dataShareHelper = dsHelperFromContext(contextId);
136 if (dataShareHelper == nullptr) {
137 HILOG_ERROR("CJupdateContact Permission denied!");
138 *errCode = PERMISSION_ERROR;
139 return;
140 }
141 if (IsInvalidId(contactId)) {
142 HILOG_ERROR("CJupdateContact Parameter invalid! %{public}lld", static_cast<long long>(contactId));
143 *errCode = PARAMETER_ERROR;
144 return;
145 }
146
147 std::shared_ptr<DataSharePredicates> deletePredicates =
148 FFIData::GetData<DataSharePredicatesImpl>(predicatesId)->GetPredicates();
149 ContactsControl contactsControl;
150
151 // query raw_contact_id
152 std::vector<std::string> queryDataColumns;
153 queryDataColumns.push_back("raw_contact_id");
154 DataSharePredicates queryDataPredicates = buildQueryDataPredicates(contactId);
155
156 std::shared_ptr<DataShareResultSet> resultSet =
157 contactsControl.ContactQuery(dataShareHelper, queryDataColumns, queryDataPredicates);
158 int rawId = GetRawIdByResultSet(resultSet);
159 if (rawId <= 0) {
160 HILOG_ERROR("CJupdateContact contact rawId equals %{public}d", rawId);
161 *errCode = ERROR;
162
163 dataShareHelper->Release();
164 dataShareHelper = nullptr;
165
166 return;
167 }
168
169 unsigned int size = contactData.size();
170 for (unsigned int i = 0; i < size; ++i) {
171 contactData[i].Put("raw_contact_id", rawId);
172 }
173
174 deletePredicates->And();
175 deletePredicates->EqualTo("raw_contact_id", std::to_string(rawId));
176
177 int resultCode = contactsControl.ContactDataDelete(dataShareHelper, *(deletePredicates));
178 if (resultCode >= 0) {
179 resultCode = contactsControl.ContactDataInsert(dataShareHelper, contactData);
180 }
181
182 dataShareHelper->Release();
183 dataShareHelper = nullptr;
184
185 *errCode = resultCode;
186 }
187
buildIsLocalContactPredicates(int64_t id)188 DataSharePredicates buildIsLocalContactPredicates(int64_t id)
189 {
190 DataShare::DataSharePredicates predicates;
191 if (id != 0) {
192 predicates.EqualTo("is_deleted", "0");
193 predicates.And();
194 predicates.EqualTo("contact_id", std::to_string(id));
195 predicates.And();
196 predicates.EqualTo("account_type", "com.ohos.contacts");
197 predicates.And();
198 predicates.EqualTo("account_name", "phone");
199 }
200 return predicates;
201 }
202
CJisLocalContact(int64_t contextId,int64_t contactId,int32_t * errCode)203 bool Contacts::CJisLocalContact(int64_t contextId, int64_t contactId, int32_t *errCode)
204 {
205 ContactsTelephonyPermission permission;
206 if (!permission.CheckPermission(Permission::READ_CONTACTS)) {
207 HILOG_ERROR("CJisLocalContact Permission denied!");
208 *errCode = PERMISSION_ERROR;
209 return false;
210 }
211 if (IsInvalidId(contactId)) {
212 HILOG_ERROR("CJisLocalContact Parameter invalid! %{public}lld", static_cast<long long>(contactId));
213 *errCode = PARAMETER_ERROR;
214 return false;
215 }
216
217 std::shared_ptr<DataShareHelper> dataShareHelper = dsHelperFromContext(contextId);
218 if (dataShareHelper == nullptr) {
219 HILOG_ERROR("CJisLocalContact Permission denied!");
220 *errCode = PERMISSION_ERROR;
221 return false;
222 }
223
224 ContactsControl contactsControl;
225
226 DataSharePredicates predicates = buildIsLocalContactPredicates(contactId);
227 std::vector<std::string> columns;
228 std::shared_ptr<DataShareResultSet> resultSet = contactsControl.ContactQuery(dataShareHelper, columns, predicates);
229 if (resultSet == nullptr) {
230 return false;
231 }
232 int resultSetNum = resultSet->GoToFirstRow();
233 bool isLocal = resultSetNum == OHOS::NativeRdb::E_OK;
234
235 resultSet->Close();
236
237 dataShareHelper->Release();
238 dataShareHelper = nullptr;
239
240 return isLocal;
241 }
242
buildIsMyCardPredicates(int64_t id)243 DataSharePredicates buildIsMyCardPredicates(int64_t id)
244 {
245 DataShare::DataSharePredicates predicates;
246 if (id != 0) {
247 predicates.EqualTo("is_deleted", "0");
248 predicates.And();
249 predicates.EqualTo("contact_id", std::to_string(id));
250 }
251 return predicates;
252 }
253
CJisMyCard(int64_t contextId,int64_t contactId,int32_t * errCode)254 bool Contacts::CJisMyCard(int64_t contextId, int64_t contactId, int32_t *errCode)
255 {
256 ContactsTelephonyPermission permission;
257 if (!permission.CheckPermission(Permission::READ_CONTACTS)) {
258 HILOG_ERROR("CJisMyCard Permission denied!");
259 *errCode = PERMISSION_ERROR;
260 return false;
261 }
262 if (IsInvalidId(contactId)) {
263 HILOG_ERROR("CJisMyCard Parameter invalid! %{public}lld", static_cast<long long>(contactId));
264 *errCode = PARAMETER_ERROR;
265 return false;
266 }
267
268 std::shared_ptr<DataShareHelper> dataShareHelper = dsHelperFromContext(contextId);
269 if (dataShareHelper == nullptr) {
270 HILOG_ERROR("CJisMyCard Permission denied!");
271 *errCode = PERMISSION_ERROR;
272 return false;
273 }
274
275 ContactsControl contactsControl;
276
277 DataSharePredicates predicates = buildIsMyCardPredicates(contactId);
278 std::vector<std::string> columns;
279 std::shared_ptr<DataShareResultSet> resultSet = contactsControl.MyCardQuery(dataShareHelper, columns, predicates);
280 if (resultSet == nullptr) {
281 dataShareHelper->Release();
282 dataShareHelper = nullptr;
283
284 return false;
285 }
286 int resultSetNum = resultSet->GoToFirstRow();
287 bool isMyCard = resultSetNum == OHOS::NativeRdb::E_OK;
288
289 resultSet->Close();
290 dataShareHelper->Release();
291 dataShareHelper = nullptr;
292
293 return isMyCard;
294 }
295
CJqueryMyCard(int64_t contextId,int64_t predicatesId,int32_t * errCode)296 ContactsData* Contacts::CJqueryMyCard(int64_t contextId, int64_t predicatesId, int32_t *errCode)
297 {
298 ContactsTelephonyPermission permission;
299 if (!permission.CheckPermission(Permission::READ_CONTACTS)) {
300 HILOG_ERROR("CJqueryMyCard Permission denied!");
301 *errCode = PERMISSION_ERROR;
302 return nullptr;
303 }
304
305 std::shared_ptr<DataShareHelper> dataShareHelper = dsHelperFromContext(contextId);
306 if (dataShareHelper == nullptr) {
307 HILOG_ERROR("CJqueryMyCard Permission denied!");
308 *errCode = PERMISSION_ERROR;
309 return nullptr;
310 }
311
312 std::shared_ptr<DataSharePredicates> predicates =
313 FFIData::GetData<DataSharePredicatesImpl>(predicatesId)->GetPredicates();
314 ContactsControl contactsControl;
315
316 std::vector<std::string> columns;
317 std::shared_ptr<DataShareResultSet> resultSet = contactsControl.MyCardQuery(dataShareHelper, columns, *predicates);
318 ContactsData* contacts = parseResultSetForContacts(resultSet, errCode); // resultSet is closed inside
319
320 dataShareHelper->Release();
321 dataShareHelper = nullptr;
322
323 return contacts;
324 }
325
CJqueryGroups(int64_t contextId,int64_t predicatesId,int32_t * errCode)326 GroupsData* Contacts::CJqueryGroups(int64_t contextId, int64_t predicatesId, int32_t *errCode)
327 {
328 ContactsTelephonyPermission permission;
329 if (!permission.CheckPermission(Permission::READ_CONTACTS)) {
330 HILOG_ERROR("CJqueryGroups Permission denied!");
331 *errCode = PERMISSION_ERROR;
332 return nullptr;
333 }
334
335 std::shared_ptr<DataShareHelper> dataShareHelper = dsHelperFromContext(contextId);
336 if (dataShareHelper == nullptr) {
337 HILOG_ERROR("CJqueryGroups Permission denied!");
338 *errCode = PERMISSION_ERROR;
339 return nullptr;
340 }
341
342 std::shared_ptr<DataSharePredicates> predicates =
343 FFIData::GetData<DataSharePredicatesImpl>(predicatesId)->GetPredicates();
344 ContactsControl contactsControl;
345
346 std::vector<std::string> columns;
347 std::shared_ptr<DataShareResultSet> resultSet = contactsControl.GroupsQuery(dataShareHelper, columns, *predicates);
348 GroupsData* groups = parseResultSetForGroups(resultSet, errCode); // resultSet is closed inside
349
350 dataShareHelper->Release();
351 dataShareHelper = nullptr;
352
353 return groups;
354 }
355
CJqueryHolders(int64_t contextId,int32_t * errCode)356 HoldersData* Contacts::CJqueryHolders(int64_t contextId, int32_t *errCode)
357 {
358 ContactsTelephonyPermission permission;
359 if (!permission.CheckPermission(Permission::READ_CONTACTS)) {
360 HILOG_ERROR("CJqueryHolders Permission denied!");
361 *errCode = PERMISSION_ERROR;
362 return nullptr;
363 }
364
365 std::shared_ptr<DataShareHelper> dataShareHelper = dsHelperFromContext(contextId);
366 if (dataShareHelper == nullptr) {
367 HILOG_ERROR("CJqueryHolders Permission denied!");
368 *errCode = PERMISSION_ERROR;
369 return nullptr;
370 }
371
372 ContactsControl contactsControl;
373
374 DataSharePredicates predicates;
375 std::vector<std::string> columns;
376 std::shared_ptr<DataShareResultSet> resultSet = contactsControl.HolderQuery(dataShareHelper, columns, predicates);
377 HoldersData* holders = parseResultSetForHolders(resultSet, errCode); // resultSet is closed inside
378
379 dataShareHelper->Release();
380 dataShareHelper = nullptr;
381
382 return holders;
383 }
384
CJqueryContacts(int64_t contextId,int64_t predicatesId,int32_t * errCode)385 ContactsData* Contacts::CJqueryContacts(int64_t contextId, int64_t predicatesId, int32_t *errCode)
386 {
387 ContactsTelephonyPermission permission;
388 if (!permission.CheckPermission(Permission::READ_CONTACTS)) {
389 HILOG_ERROR("CJqueryContacts Permission denied!");
390 *errCode = PERMISSION_ERROR;
391 return nullptr;
392 }
393
394 std::shared_ptr<DataShareHelper> dataShareHelper = dsHelperFromContext(contextId);
395 if (dataShareHelper == nullptr) {
396 HILOG_ERROR("CJqueryContacts Permission denied!");
397 *errCode = PERMISSION_ERROR;
398 return nullptr;
399 }
400
401 std::shared_ptr<DataSharePredicates> predicates =
402 FFIData::GetData<DataSharePredicatesImpl>(predicatesId)->GetPredicates();
403 ContactsControl contactsControl;
404
405 std::vector<std::string> columns;
406 std::shared_ptr<DataShareResultSet> resultSet =
407 contactsControl.ContactQuery(dataShareHelper, columns, *predicates);
408 ContactsData* contacts = parseResultSetForContacts(resultSet, errCode); // resultSet is closed inside
409
410 dataShareHelper->Release();
411 dataShareHelper = nullptr;
412
413 return contacts;
414 }
415
416 } // namespace ContactsFfi
417 } // namespace OHOS
418