1 /*
2 * Copyright (c) 2021 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
352 if (!out.WriteInt32(it->first)) {
353 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
354 return false;
355 }
356 if (!out.WriteInt32(it->second)) {
357 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
358 return false;
359 }
360 }
361 } else {
362 HILOG_DEBUG("DataAbilityOperation::Marshalling dataAbilityPredicatesBackReferences_ is empty");
363 if (!out.WriteInt32(referenceSize)) {
364 HILOG_ERROR("DataAbilityOperation::Marshalling WriteInt32(VALUE_OBJECT) error");
365 return false;
366 }
367 }
368
369 HILOG_DEBUG("DataAbilityOperation::Marshalling end");
370 return true;
371 }
Unmarshalling(Parcel & in)372 DataAbilityOperation *DataAbilityOperation::Unmarshalling(Parcel &in)
373 {
374 HILOG_DEBUG("DataAbilityOperation::Unmarshalling start");
375 DataAbilityOperation *dataAbilityOperation = new (std::nothrow) DataAbilityOperation();
376 if (dataAbilityOperation != nullptr && !dataAbilityOperation->ReadFromParcel(in)) {
377 HILOG_ERROR("DataAbilityOperation::Unmarshalling dataAbilityOperation error");
378 delete dataAbilityOperation;
379 dataAbilityOperation = nullptr;
380 }
381 HILOG_DEBUG("DataAbilityOperation::Unmarshalling end");
382 return dataAbilityOperation;
383 }
ReadFromParcel(Parcel & in)384 bool DataAbilityOperation::ReadFromParcel(Parcel &in)
385 {
386 HILOG_DEBUG("DataAbilityOperation::ReadFromParcel start");
387 if (!in.ReadInt32(type_)) {
388 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(type_) error");
389 return false;
390 }
391 if (!in.ReadInt32(expectedCount_)) {
392 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(empty) error");
393 return false;
394 }
395 interrupted_ = in.ReadBool();
396
397 int empty = VALUE_NULL;
398 if (!in.ReadInt32(empty)) {
399 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(empty) error");
400 return false;
401 }
402 if (empty == VALUE_OBJECT) {
403 uri_.reset(in.ReadParcelable<Uri>());
404 } else {
405 uri_.reset();
406 }
407
408 empty = VALUE_NULL;
409 if (!in.ReadInt32(empty)) {
410 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(empty) error");
411 return false;
412 }
413 HILOG_DEBUG("DataAbilityOperation::ReadFromParcel empty is %{public}s",
414 empty == VALUE_OBJECT ? "VALUE_OBJECT" : "VALUE_NULL");
415 if (empty == VALUE_OBJECT) {
416 valuesBucket_.reset(in.ReadParcelable<NativeRdb::ValuesBucket>());
417 } else {
418 valuesBucket_.reset();
419 }
420
421 empty = VALUE_NULL;
422 if (!in.ReadInt32(empty)) {
423 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(empty) error");
424 return false;
425 }
426 HILOG_DEBUG("DataAbilityOperation::ReadFromParcel empty is %{public}s",
427 empty == VALUE_OBJECT ? "VALUE_OBJECT" : "VALUE_NULL");
428 if (empty == VALUE_OBJECT) {
429 dataAbilityPredicates_.reset(in.ReadParcelable<NativeRdb::DataAbilityPredicates>());
430 } else {
431 dataAbilityPredicates_.reset();
432 }
433
434 empty = VALUE_NULL;
435 if (!in.ReadInt32(empty)) {
436 HILOG_ERROR("DataAbilityOperation::ReadFromParcel ReadInt32(empty) error");
437 return false;
438 }
439 HILOG_DEBUG("DataAbilityOperation::ReadFromParcel empty is %{public}s",
440 (empty == VALUE_OBJECT) ? "VALUE_OBJECT" : "VALUE_NULL");
441 if (empty == VALUE_OBJECT) {
442 valuesBucketReferences_.reset(in.ReadParcelable<NativeRdb::ValuesBucket>());
443 } else {
444 valuesBucketReferences_.reset();
445 }
446
447 int referenceSize = 0;
448 if (!in.ReadInt32(referenceSize)) {
449 HILOG_ERROR("DataAbilityOperation::ReadFromParcel end");
450 return false;
451 }
452 if (referenceSize >= REFERENCE_THRESHOLD) {
453 HILOG_INFO("DataAbilityOperation::ReadFromParcel referenceSize:%{public}d >= REFERENCE_THRESHOLD:%{public}d",
454 referenceSize, REFERENCE_THRESHOLD);
455 return true;
456 }
457
458 for (int i = 0; i < REFERENCE_THRESHOLD && i < referenceSize; ++i) {
459 int first = 0;
460 int second = 0;
461 if (!in.ReadInt32(first)) {
462 HILOG_ERROR("DataAbilityOperation::ReadFromParcel end");
463 return false;
464 }
465 if (!in.ReadInt32(second)) {
466 HILOG_ERROR("DataAbilityOperation::ReadFromParcel end");
467 return false;
468 }
469 dataAbilityPredicatesBackReferences_.insert(std::make_pair(first, second));
470 }
471
472 HILOG_DEBUG("DataAbilityOperation::ReadFromParcel end");
473 return true;
474 }
CreateFromParcel(Parcel & in)475 std::shared_ptr<DataAbilityOperation> DataAbilityOperation::CreateFromParcel(Parcel &in)
476 {
477 HILOG_DEBUG("DataAbilityOperation::CreateFromParcel start");
478 std::shared_ptr<DataAbilityOperation> operation = std::make_shared<DataAbilityOperation>(in);
479 HILOG_DEBUG("DataAbilityOperation::CreateFromParcel end");
480 return operation;
481 }
PutMap(Parcel & in)482 void DataAbilityOperation::PutMap(Parcel &in)
483 {
484 HILOG_DEBUG("DataAbilityOperation::PutMap start");
485 int count = in.ReadInt32();
486 if (count > 0 && count < REFERENCE_THRESHOLD) {
487 for (int i = 0; i < count; ++i) {
488 dataAbilityPredicatesBackReferences_.insert(std::make_pair(in.ReadInt32(), in.ReadInt32()));
489 }
490 }
491 HILOG_DEBUG("DataAbilityOperation::PutMap end");
492 }
493 } // namespace AppExecFwk
494 } // namespace OHOS