1 /*
2 * Copyright (c) 2021-2022 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 "data_ability_operation.h"
17
18 #include "data_ability_predicates.h"
19 #include "hilog_wrapper.h"
20 #include "values_bucket.h"
21
22 namespace OHOS {
23 namespace AppExecFwk {
DataAbilityOperation(const std::shared_ptr<DataAbilityOperation> & dataAbilityOperation,const std::shared_ptr<Uri> & withUri)24 DataAbilityOperation::DataAbilityOperation(
25 const std::shared_ptr<DataAbilityOperation> &dataAbilityOperation, const std::shared_ptr<Uri> &withUri)
26 {
27 uri_ = withUri;
28 if (dataAbilityOperation != nullptr) {
29 type_ = dataAbilityOperation->type_;
30 valuesBucket_ = dataAbilityOperation->valuesBucket_;
31 expectedCount_ = dataAbilityOperation->expectedCount_;
32 dataAbilityPredicates_ = dataAbilityOperation->dataAbilityPredicates_;
33 valuesBucketReferences_ = dataAbilityOperation->valuesBucketReferences_;
34 dataAbilityPredicatesBackReferences_ = dataAbilityOperation->dataAbilityPredicatesBackReferences_;
35 interrupted_ = dataAbilityOperation->interrupted_;
36 } else {
37 type_ = 0;
38 expectedCount_ = 0;
39 valuesBucket_ = std::make_shared<NativeRdb::ValuesBucket>();
40 dataAbilityPredicates_ = std::make_shared<NativeRdb::DataAbilityPredicates>();
41 valuesBucketReferences_ = std::make_shared<NativeRdb::ValuesBucket>();
42 dataAbilityPredicatesBackReferences_.clear();
43 interrupted_ = false;
44 }
45 }
DataAbilityOperation(Parcel & in)46 DataAbilityOperation::DataAbilityOperation(Parcel &in)
47 {
48 ReadFromParcel(in);
49 }
DataAbilityOperation(const std::shared_ptr<DataAbilityOperationBuilder> & builder)50 DataAbilityOperation::DataAbilityOperation(const std::shared_ptr<DataAbilityOperationBuilder> &builder)
51 {
52 if (builder != nullptr) {
53 type_ = builder->type_;
54 uri_ = builder->uri_;
55 valuesBucket_ = builder->valuesBucket_;
56 expectedCount_ = builder->expectedCount_;
57 dataAbilityPredicates_ = builder->dataAbilityPredicates_;
58 valuesBucketReferences_ = builder->valuesBucketReferences_;
59 dataAbilityPredicatesBackReferences_ = builder->dataAbilityPredicatesBackReferences_;
60 interrupted_ = builder->interrupted_;
61 }
62 }
63
DataAbilityOperation()64 DataAbilityOperation::DataAbilityOperation()
65 {
66 type_ = 0;
67 uri_ = nullptr;
68 expectedCount_ = 0;
69 valuesBucket_ = std::make_shared<NativeRdb::ValuesBucket>();
70 dataAbilityPredicates_ = std::make_shared<NativeRdb::DataAbilityPredicates>();
71 valuesBucketReferences_ = std::make_shared<NativeRdb::ValuesBucket>();
72 dataAbilityPredicatesBackReferences_.clear();
73 interrupted_ = false;
74 }
75
~DataAbilityOperation()76 DataAbilityOperation::~DataAbilityOperation()
77 {
78 dataAbilityPredicatesBackReferences_.clear();
79 }
80
operator ==(const DataAbilityOperation & other) const81 bool DataAbilityOperation::operator==(const DataAbilityOperation &other) const
82 {
83 if (type_ != other.type_) {
84 return false;
85 }
86 if ((uri_ != nullptr) && (other.uri_ != nullptr) && (uri_->ToString() != other.uri_->ToString())) {
87 return false;
88 }
89 if (expectedCount_ != other.expectedCount_) {
90 return false;
91 }
92 if (valuesBucket_ != other.valuesBucket_) {
93 return false;
94 }
95 if (dataAbilityPredicates_ != other.dataAbilityPredicates_) {
96 return false;
97 }
98 if (valuesBucketReferences_ != other.valuesBucketReferences_) {
99 return false;
100 }
101 size_t backReferencesCount = dataAbilityPredicatesBackReferences_.size();
102 size_t otherBackReferencesCount = other.dataAbilityPredicatesBackReferences_.size();
103 if (backReferencesCount != otherBackReferencesCount) {
104 return false;
105 }
106
107 std::map<int, int>::const_iterator it = dataAbilityPredicatesBackReferences_.begin();
108 while (it != dataAbilityPredicatesBackReferences_.end()) {
109 std::map<int, int>::const_iterator otherIt = other.dataAbilityPredicatesBackReferences_.find(it->first);
110 if (otherIt != other.dataAbilityPredicatesBackReferences_.end()) {
111 if (otherIt->second != it->second) {
112 return false;
113 }
114 } else {
115 return false;
116 }
117 it++;
118 }
119
120 if (interrupted_ != other.interrupted_) {
121 return false;
122 }
123 return true;
124 }
125
operator =(const DataAbilityOperation & other)126 DataAbilityOperation &DataAbilityOperation::operator=(const DataAbilityOperation &other)
127 {
128 if (this != &other) {
129 type_ = other.type_;
130 uri_ = other.uri_;
131 expectedCount_ = other.expectedCount_;
132 valuesBucket_ = other.valuesBucket_;
133 dataAbilityPredicates_ = other.dataAbilityPredicates_;
134 valuesBucketReferences_ = other.valuesBucketReferences_;
135 dataAbilityPredicatesBackReferences_ = other.dataAbilityPredicatesBackReferences_;
136 interrupted_ = other.interrupted_;
137 }
138 return *this;
139 }
140
NewInsertBuilder(const std::shared_ptr<Uri> & uri)141 std::shared_ptr<DataAbilityOperationBuilder> DataAbilityOperation::NewInsertBuilder(const std::shared_ptr<Uri> &uri)
142 {
143 HILOG_DEBUG("DataAbilityOperation::NewInsertBuilder start");
144 if (uri == nullptr) {
145 HILOG_ERROR("DataAbilityOperation::NewInsertBuilder uri is nullptr");
146 return nullptr;
147 }
148 std::shared_ptr<DataAbilityOperationBuilder> builder =
149 std::make_shared<DataAbilityOperationBuilder>(TYPE_INSERT, uri);
150 HILOG_DEBUG("DataAbilityOperation::NewInsertBuilder end");
151 return builder;
152 }
153
NewUpdateBuilder(const std::shared_ptr<Uri> & uri)154 std::shared_ptr<DataAbilityOperationBuilder> DataAbilityOperation::NewUpdateBuilder(const std::shared_ptr<Uri> &uri)
155 {
156 HILOG_DEBUG("DataAbilityOperation::NewUpdateBuilder start");
157 if (uri == nullptr) {
158 HILOG_ERROR("DataAbilityOperation::NewUpdateBuilder uri is nullptr");
159 return nullptr;
160 }
161 std::shared_ptr<DataAbilityOperationBuilder> builder =
162 std::make_shared<DataAbilityOperationBuilder>(TYPE_UPDATE, uri);
163 HILOG_DEBUG("DataAbilityOperation::NewUpdateBuilder end");
164 return builder;
165 }
166
NewDeleteBuilder(const std::shared_ptr<Uri> & uri)167 std::shared_ptr<DataAbilityOperationBuilder> DataAbilityOperation::NewDeleteBuilder(const std::shared_ptr<Uri> &uri)
168 {
169 HILOG_DEBUG("DataAbilityOperation::NewDeleteBuilder start");
170 if (uri == nullptr) {
171 HILOG_ERROR("DataAbilityOperation::NewDeleteBuilder uri is nullptr");
172 return nullptr;
173 }
174 std::shared_ptr<DataAbilityOperationBuilder> builder =
175 std::make_shared<DataAbilityOperationBuilder>(TYPE_DELETE, uri);
176 HILOG_DEBUG("DataAbilityOperation::NewDeleteBuilder end");
177 return builder;
178 }
179
NewAssertBuilder(const std::shared_ptr<Uri> & uri)180 std::shared_ptr<DataAbilityOperationBuilder> DataAbilityOperation::NewAssertBuilder(const std::shared_ptr<Uri> &uri)
181 {
182 HILOG_DEBUG("DataAbilityOperation::NewAssertBuilder start");
183 if (uri == nullptr) {
184 HILOG_ERROR("DataAbilityOperation::NewAssertBuilder uri is nullptr");
185 return nullptr;
186 }
187 std::shared_ptr<DataAbilityOperationBuilder> builder =
188 std::make_shared<DataAbilityOperationBuilder>(TYPE_ASSERT, uri);
189 HILOG_DEBUG("DataAbilityOperation::NewAssertBuilder end");
190 return builder;
191 }
192
GetType() const193 int DataAbilityOperation::GetType() const
194 {
195 HILOG_DEBUG("DataAbilityOperation::GetType");
196 return type_;
197 }
198
GetUri() const199 std::shared_ptr<Uri> DataAbilityOperation::GetUri() const
200 {
201 HILOG_DEBUG("DataAbilityOperation::GetUri");
202 return uri_;
203 }
204
GetValuesBucket() const205 std::shared_ptr<NativeRdb::ValuesBucket> DataAbilityOperation::GetValuesBucket() const
206 {
207 HILOG_DEBUG("DataAbilityOperation::GetValuesBucket");
208 return valuesBucket_;
209 }
210
GetExpectedCount() const211 int DataAbilityOperation::GetExpectedCount() const
212 {
213 HILOG_DEBUG("DataAbilityOperation::GetExpectedCount");
214 return expectedCount_;
215 }
216
GetDataAbilityPredicates() const217 std::shared_ptr<NativeRdb::DataAbilityPredicates> DataAbilityOperation::GetDataAbilityPredicates() const
218 {
219 HILOG_DEBUG("DataAbilityOperation::GetDataAbilityPredicates");
220 return dataAbilityPredicates_;
221 }
222
GetValuesBucketReferences() const223 std::shared_ptr<NativeRdb::ValuesBucket> DataAbilityOperation::GetValuesBucketReferences() const
224 {
225 HILOG_DEBUG("DataAbilityOperation::GetValuesBucketReferences");
226 return valuesBucketReferences_;
227 }
GetDataAbilityPredicatesBackReferences() const228 std::map<int, int> DataAbilityOperation::GetDataAbilityPredicatesBackReferences() const
229 {
230 HILOG_DEBUG("DataAbilityOperation::GetDataAbilityPredicatesBackReferences");
231 return dataAbilityPredicatesBackReferences_;
232 }
IsInsertOperation() const233 bool DataAbilityOperation::IsInsertOperation() const
234 {
235 HILOG_DEBUG("DataAbilityOperation::IsInsertOperation: %{public}d", type_ == TYPE_INSERT);
236 return type_ == TYPE_INSERT;
237 }
IsUpdateOperation() const238 bool DataAbilityOperation::IsUpdateOperation() const
239 {
240 HILOG_DEBUG("DataAbilityOperation::IsUpdateOperation: %{public}d", type_ == TYPE_UPDATE);
241 return type_ == TYPE_UPDATE;
242 }
IsDeleteOperation() const243 bool DataAbilityOperation::IsDeleteOperation() const
244 {
245 HILOG_DEBUG("DataAbilityOperation::IsDeleteOperation: %{public}d", type_ == TYPE_DELETE);
246 return type_ == TYPE_DELETE;
247 }
IsAssertOperation() const248 bool DataAbilityOperation::IsAssertOperation() const
249 {
250 HILOG_DEBUG("DataAbilityOperation::IsAssertOperation: %{public}d", type_ == TYPE_ASSERT);
251 return type_ == TYPE_ASSERT;
252 }
IsInterruptionAllowed() const253 bool DataAbilityOperation::IsInterruptionAllowed() const
254 {
255 HILOG_DEBUG("DataAbilityOperation::IsInterruptionAllowed: %{public}d", interrupted_);
256 return interrupted_;
257 }
Marshalling(Parcel & out) const258 bool DataAbilityOperation::Marshalling(Parcel &out) const
259 {
260 HILOG_DEBUG("DataAbilityOperation::Marshalling start");
261 if (!out.WriteInt32(type_)) {
262 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(type_) error");
263 return false;
264 }
265 if (!out.WriteInt32(expectedCount_)) {
266 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
267 return false;
268 }
269
270 if (!out.WriteBool(interrupted_)) {
271 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
272 return false;
273 }
274
275 if (uri_ != nullptr) {
276 if (!out.WriteInt32(VALUE_OBJECT)) {
277 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
278 return false;
279 }
280
281 if (!out.WriteParcelable(uri_.get())) {
282 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
283 return false;
284 }
285 } else {
286 if (!out.WriteInt32(VALUE_NULL)) {
287 return false;
288 }
289 }
290
291 if (valuesBucket_ != nullptr) {
292 if (!out.WriteInt32(VALUE_OBJECT)) {
293 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
294 return false;
295 }
296
297 if (!out.WriteParcelable(valuesBucket_.get())) {
298 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
299 return false;
300 }
301 } else {
302 if (!out.WriteInt32(VALUE_NULL)) {
303 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
304 return false;
305 }
306 }
307
308 if (dataAbilityPredicates_ != nullptr) {
309 if (!out.WriteInt32(VALUE_OBJECT)) {
310 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
311 return false;
312 }
313 if (!out.WriteParcelable(dataAbilityPredicates_.get())) {
314 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
315 return false;
316 }
317 } else {
318 if (!out.WriteInt32(VALUE_NULL)) {
319 return false;
320 }
321 }
322
323 if (valuesBucketReferences_ != nullptr) {
324 if (!out.WriteInt32(VALUE_OBJECT)) {
325 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
326 return false;
327 }
328 if (!out.WriteParcelable(valuesBucketReferences_.get())) {
329 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
330 return false;
331 }
332 } else {
333 if (!out.WriteInt32(VALUE_NULL)) {
334 return false;
335 }
336 }
337
338 int referenceSize = 0;
339 if (!dataAbilityPredicatesBackReferences_.empty()) {
340 referenceSize = (int)dataAbilityPredicatesBackReferences_.size();
341 if (!out.WriteInt32(referenceSize)) {
342 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
343 return false;
344 }
345 if (referenceSize >= REFERENCE_THRESHOLD) {
346 HILOG_INFO("DataAbilityOperation::Marshalling referenceSize >= REFERENCE_THRESHOLD");
347 return true;
348 }
349 for (auto it = dataAbilityPredicatesBackReferences_.begin(); it != dataAbilityPredicatesBackReferences_.end();
350 it++) {
351 if (!out.WriteInt32(it->first)) {
352 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
353 return false;
354 }
355 if (!out.WriteInt32(it->second)) {
356 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
357 return false;
358 }
359 }
360 } else {
361 HILOG_DEBUG("DataAbilityOperation::Marshalling dataAbilityPredicatesBackReferences_ is empty");
362 if (!out.WriteInt32(referenceSize)) {
363 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
364 return false;
365 }
366 }
367
368 HILOG_DEBUG("DataAbilityOperation::Marshalling end");
369 return true;
370 }
Unmarshalling(Parcel & in)371 DataAbilityOperation *DataAbilityOperation::Unmarshalling(Parcel &in)
372 {
373 HILOG_DEBUG("DataAbilityOperation::Unmarshalling start");
374 DataAbilityOperation *dataAbilityOperation = new (std::nothrow) DataAbilityOperation();
375 if (dataAbilityOperation != nullptr && !dataAbilityOperation->ReadFromParcel(in)) {
376 HILOG_ERROR("DataAbilityOperation::Unmarshalling dataAbilityOperation error");
377 delete dataAbilityOperation;
378 dataAbilityOperation = nullptr;
379 }
380 HILOG_DEBUG("DataAbilityOperation::Unmarshalling end");
381 return dataAbilityOperation;
382 }
ReadFromParcel(Parcel & in)383 bool DataAbilityOperation::ReadFromParcel(Parcel &in)
384 {
385 HILOG_DEBUG("DataAbilityOperation::ReadFromParcel start");
386 if (!in.ReadInt32(type_)) {
387 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(type_) error");
388 return false;
389 }
390 if (!in.ReadInt32(expectedCount_)) {
391 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(empty) error");
392 return false;
393 }
394 interrupted_ = in.ReadBool();
395
396 int empty = VALUE_NULL;
397 if (!in.ReadInt32(empty)) {
398 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(empty) error");
399 return false;
400 }
401 if (empty == VALUE_OBJECT) {
402 uri_.reset(in.ReadParcelable<Uri>());
403 } else {
404 uri_.reset();
405 }
406
407 empty = VALUE_NULL;
408 if (!in.ReadInt32(empty)) {
409 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(empty) error");
410 return false;
411 }
412 HILOG_DEBUG("DataAbilityOperation::ReadFromParcel empty is %{public}s",
413 empty == VALUE_OBJECT ? "VALUE_OBJECT" : "VALUE_NULL");
414 if (empty == VALUE_OBJECT) {
415 valuesBucket_.reset(in.ReadParcelable<NativeRdb::ValuesBucket>());
416 } else {
417 valuesBucket_.reset();
418 }
419
420 empty = VALUE_NULL;
421 if (!in.ReadInt32(empty)) {
422 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(empty) error");
423 return false;
424 }
425 HILOG_DEBUG("DataAbilityOperation::ReadFromParcel empty is %{public}s",
426 empty == VALUE_OBJECT ? "VALUE_OBJECT" : "VALUE_NULL");
427 if (empty == VALUE_OBJECT) {
428 dataAbilityPredicates_.reset(in.ReadParcelable<NativeRdb::DataAbilityPredicates>());
429 } else {
430 dataAbilityPredicates_.reset();
431 }
432
433 empty = VALUE_NULL;
434 if (!in.ReadInt32(empty)) {
435 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(empty) error");
436 return false;
437 }
438 HILOG_DEBUG("DataAbilityOperation::ReadFromParcel empty is %{public}s",
439 (empty == VALUE_OBJECT) ? "VALUE_OBJECT" : "VALUE_NULL");
440 if (empty == VALUE_OBJECT) {
441 valuesBucketReferences_.reset(in.ReadParcelable<NativeRdb::ValuesBucket>());
442 } else {
443 valuesBucketReferences_.reset();
444 }
445
446 int referenceSize = 0;
447 if (!in.ReadInt32(referenceSize)) {
448 HILOG_ERROR("DataAbilityOperation::ReadFromParcel end");
449 return false;
450 }
451 if (referenceSize >= REFERENCE_THRESHOLD) {
452 HILOG_INFO("DataAbilityOperation::ReadFromParcel referenceSize:%{public}d >= REFERENCE_THRESHOLD:%{public}d",
453 referenceSize, REFERENCE_THRESHOLD);
454 return true;
455 }
456
457 for (int i = 0; i < REFERENCE_THRESHOLD && i < referenceSize; ++i) {
458 int first = 0;
459 int second = 0;
460 if (!in.ReadInt32(first)) {
461 HILOG_ERROR("DataAbilityOperation::ReadFromParcel end");
462 return false;
463 }
464 if (!in.ReadInt32(second)) {
465 HILOG_ERROR("DataAbilityOperation::ReadFromParcel end");
466 return false;
467 }
468 dataAbilityPredicatesBackReferences_.insert(std::make_pair(first, second));
469 }
470
471 HILOG_DEBUG("DataAbilityOperation::ReadFromParcel end");
472 return true;
473 }
CreateFromParcel(Parcel & in)474 std::shared_ptr<DataAbilityOperation> DataAbilityOperation::CreateFromParcel(Parcel &in)
475 {
476 HILOG_DEBUG("DataAbilityOperation::CreateFromParcel start");
477 std::shared_ptr<DataAbilityOperation> operation = std::make_shared<DataAbilityOperation>(in);
478 HILOG_DEBUG("DataAbilityOperation::CreateFromParcel end");
479 return operation;
480 }
PutMap(Parcel & in)481 void DataAbilityOperation::PutMap(Parcel &in)
482 {
483 HILOG_DEBUG("DataAbilityOperation::PutMap start");
484 int count = in.ReadInt32();
485 if (count > 0 && count < REFERENCE_THRESHOLD) {
486 for (int i = 0; i < count; ++i) {
487 dataAbilityPredicatesBackReferences_.insert(std::make_pair(in.ReadInt32(), in.ReadInt32()));
488 }
489 }
490 HILOG_DEBUG("DataAbilityOperation::PutMap end");
491 }
492 } // namespace AppExecFwk
493 } // namespace OHOS
494