1  /*
2   * Copyright (c) 2022-2023 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 "continuation_result.h"
17  
18  #include <cstddef>
19  #include <iosfwd>
20  #include <new>
21  #include <vector>
22  
23  #include "base/continuationmgr_log.h"
24  #include "string_ex.h"
25  
26  namespace OHOS {
27  namespace DistributedSchedule {
28  namespace {
29  const std::string TAG = "ContinuationResult";
30  constexpr int32_t VALUE_NULL = -1; // no object in parcel
31  constexpr int32_t VALUE_OBJECT = 1; // object exist in parcel
32  }
33  
ReadFromParcel(Parcel & parcel)34  bool ContinuationResult::ReadFromParcel(Parcel &parcel)
35  {
36      SetDeviceId(Str16ToStr8(parcel.ReadString16()));
37      SetDeviceType(Str16ToStr8(parcel.ReadString16()));
38      SetDeviceName(Str16ToStr8(parcel.ReadString16()));
39      return true;
40  }
41  
Unmarshalling(Parcel & parcel)42  ContinuationResult *ContinuationResult::Unmarshalling(Parcel &parcel)
43  {
44      ContinuationResult *continuationResult = new (std::nothrow) ContinuationResult();
45      if (continuationResult == nullptr) {
46          return nullptr;
47      }
48  
49      if (!continuationResult->ReadFromParcel(parcel)) {
50          delete continuationResult;
51          continuationResult = nullptr;
52      }
53  
54      return continuationResult;
55  }
56  
Marshalling(Parcel & parcel) const57  bool ContinuationResult::Marshalling(Parcel &parcel) const
58  {
59      parcel.WriteString16(Str8ToStr16(GetDeviceId()));
60      parcel.WriteString16(Str8ToStr16(GetDeviceType()));
61      parcel.WriteString16(Str8ToStr16(GetDeviceName()));
62      return true;
63  }
64  
SetDeviceId(std::string deviceId)65  void ContinuationResult::SetDeviceId(std::string deviceId)
66  {
67      deviceId_ = deviceId;
68  }
69  
GetDeviceId() const70  std::string ContinuationResult::GetDeviceId() const
71  {
72      return deviceId_;
73  }
74  
SetDeviceType(std::string deviceType)75  void ContinuationResult::SetDeviceType(std::string deviceType)
76  {
77      deviceType_ = deviceType;
78  }
79  
GetDeviceType() const80  std::string ContinuationResult::GetDeviceType() const
81  {
82      return deviceType_;
83  }
84  
SetDeviceName(std::string deviceName)85  void ContinuationResult::SetDeviceName(std::string deviceName)
86  {
87      deviceName_ = deviceName;
88  }
89  
GetDeviceName() const90  std::string ContinuationResult::GetDeviceName() const
91  {
92      return deviceName_;
93  }
94  
ReadContinuationResultsFromParcel(Parcel & parcel,std::vector<ContinuationResult> & continuationResults)95  bool ContinuationResult::ReadContinuationResultsFromParcel(Parcel& parcel,
96      std::vector<ContinuationResult>& continuationResults)
97  {
98      continuationResults.clear();
99      int32_t empty = parcel.ReadInt32();
100      if (empty == VALUE_OBJECT) {
101          int32_t len = parcel.ReadInt32();
102          HILOGD("read size: %{public}d", len);
103          if (len < 0) {
104              HILOGE("size Unmarshalling failed");
105              return false;
106          }
107          size_t size = static_cast<size_t>(len);
108          if ((size > parcel.GetReadableBytes()) || (continuationResults.max_size() < size)) {
109              HILOGE("size convert failed, size = %{public}zu", size);
110              return false;
111          }
112          for (size_t i = 0; i < size; i++) {
113              ContinuationResult* continuationResult = parcel.ReadParcelable<ContinuationResult>();
114              if (continuationResult == nullptr) {
115                  HILOGE("ContinuationResult Unmarshalling failed");
116                  return false;
117              }
118              continuationResults.emplace_back(*continuationResult);
119              delete continuationResult;
120          }
121      }
122      return true;
123  }
124  
WriteContinuationResultsToParcel(Parcel & parcel,const std::vector<ContinuationResult> & continuationResults)125  bool ContinuationResult::WriteContinuationResultsToParcel(Parcel& parcel,
126      const std::vector<ContinuationResult>& continuationResults)
127  {
128      size_t size = continuationResults.size();
129      if (size == 0) {
130          return parcel.WriteInt32(VALUE_NULL);
131      }
132      if (!parcel.WriteInt32(VALUE_OBJECT)) {
133          return false;
134      }
135      if (!parcel.WriteInt32(static_cast<int32_t>(size))) {
136          return false;
137      }
138      for (auto& continuationResult : continuationResults) {
139          if (!parcel.WriteParcelable(&continuationResult)) {
140              return false;
141          }
142      }
143      return true;
144  }
145  }  // namespace DistributedSchedule
146  }  // namespace OHOS