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 "common_event_publish_info.h"
17 #include "event_log_wrapper.h"
18 #include "string_ex.h"
19 #include <cstdint>
20
21 namespace OHOS {
22 namespace EventFwk {
23 namespace {
24 const int32_t SUBSCRIBER_UIDS_MAX_NUM = 3;
25 }
26
CommonEventPublishInfo()27 CommonEventPublishInfo::CommonEventPublishInfo() : sticky_(false), ordered_(false),
28 subscriberType_(UNINITIALIZATED_SUBSCRIBER_TYPE), rule_(ValidationRule::AND)
29 {
30 }
31
CommonEventPublishInfo(const CommonEventPublishInfo & commonEventPublishInfo)32 CommonEventPublishInfo::CommonEventPublishInfo(const CommonEventPublishInfo &commonEventPublishInfo)
33 {
34 sticky_ = commonEventPublishInfo.sticky_;
35 ordered_ = commonEventPublishInfo.ordered_;
36 bundleName_ = commonEventPublishInfo.bundleName_;
37 subscriberPermissions_ = commonEventPublishInfo.subscriberPermissions_;
38 subscriberUids_ = commonEventPublishInfo.subscriberUids_;
39 subscriberType_ = commonEventPublishInfo.subscriberType_;
40 rule_ = commonEventPublishInfo.rule_;
41 }
42
~CommonEventPublishInfo()43 CommonEventPublishInfo::~CommonEventPublishInfo()
44 {
45 }
46
SetSticky(bool sticky)47 void CommonEventPublishInfo::SetSticky(bool sticky)
48 {
49 sticky_ = sticky;
50 }
51
IsSticky() const52 bool CommonEventPublishInfo::IsSticky() const
53 {
54 return sticky_;
55 }
56
SetSubscriberPermissions(const std::vector<std::string> & subscriberPermissions)57 void CommonEventPublishInfo::SetSubscriberPermissions(const std::vector<std::string> &subscriberPermissions)
58 {
59 subscriberPermissions_ = subscriberPermissions;
60 }
61
GetSubscriberPermissions() const62 const std::vector<std::string> &CommonEventPublishInfo::GetSubscriberPermissions() const
63 {
64 return subscriberPermissions_;
65 }
66
SetOrdered(bool ordered)67 void CommonEventPublishInfo::SetOrdered(bool ordered)
68 {
69 ordered_ = ordered;
70 }
71
IsOrdered() const72 bool CommonEventPublishInfo::IsOrdered() const
73 {
74 return ordered_;
75 }
76
SetBundleName(const std::string & bundleName)77 void CommonEventPublishInfo::SetBundleName(const std::string &bundleName)
78 {
79 bundleName_ = bundleName;
80 }
81
GetBundleName() const82 std::string CommonEventPublishInfo::GetBundleName() const
83 {
84 return bundleName_;
85 }
86
SetSubscriberUid(const std::vector<int32_t> & subscriberUids)87 void CommonEventPublishInfo::SetSubscriberUid(const std::vector<int32_t> &subscriberUids)
88 {
89 if (subscriberUids.size() > SUBSCRIBER_UIDS_MAX_NUM) {
90 subscriberUids_ =
91 std::vector<int32_t>(subscriberUids.begin(), subscriberUids.begin() + SUBSCRIBER_UIDS_MAX_NUM);
92 return;
93 }
94 subscriberUids_ = subscriberUids;
95 }
96
GetSubscriberUid() const97 std::vector<int32_t> CommonEventPublishInfo::GetSubscriberUid() const
98 {
99 return subscriberUids_;
100 }
101
SetSubscriberType(const int32_t & subscriberType)102 void CommonEventPublishInfo::SetSubscriberType(const int32_t &subscriberType)
103 {
104 if (!isSubscriberType(subscriberType)) {
105 EVENT_LOGW("subscriberType in common event Publish Info is out of range, and has already"
106 "converted to default value ALL_SUBSCRIBER_TYPE = 0");
107 subscriberType_ = static_cast<int32_t>(SubscriberType::ALL_SUBSCRIBER_TYPE);
108 return;
109 }
110 subscriberType_ = subscriberType;
111 }
112
GetSubscriberType() const113 int32_t CommonEventPublishInfo::GetSubscriberType() const
114 {
115 return subscriberType_;
116 }
117
SetValidationRule(const ValidationRule & rule)118 void CommonEventPublishInfo::SetValidationRule(const ValidationRule &rule)
119 {
120 rule_ = rule;
121 }
122
GetValidationRule() const123 ValidationRule CommonEventPublishInfo::GetValidationRule() const
124 {
125 return rule_;
126 }
127
GetFilterSettings() const128 uint16_t CommonEventPublishInfo::GetFilterSettings() const
129 {
130 uint16_t filterSettings = 0;
131 if (subscriberType_ != UNINITIALIZATED_SUBSCRIBER_TYPE) {
132 filterSettings |= SUBSCRIBER_FILTER_SUBSCRIBER_TYPE_INDEX;
133 }
134 if (!bundleName_.empty()) {
135 filterSettings |= SUBSCRIBER_FILTER_BUNDLE_INDEX;
136 }
137 if (!subscriberPermissions_.empty()) {
138 filterSettings |= SUBSCRIBER_FILTER_PERMISSION_INDEX;
139 }
140 if (!subscriberUids_.empty()) {
141 filterSettings |= SUBSCRIBER_FILTER_SUBSCRIBER_UID_INDEX;
142 }
143 return filterSettings;
144 }
145
Marshalling(Parcel & parcel) const146 bool CommonEventPublishInfo::Marshalling(Parcel &parcel) const
147 {
148 EVENT_LOGD("enter");
149
150 // write subscriber permissions
151 std::vector<std::u16string> permissionVec_;
152 for (std::vector<std::string>::size_type i = 0; i < subscriberPermissions_.size(); ++i) {
153 permissionVec_.emplace_back(Str8ToStr16(subscriberPermissions_[i]));
154 }
155 if (!parcel.WriteString16Vector(permissionVec_)) {
156 EVENT_LOGE("common event Publish Info write permission failed");
157 return false;
158 }
159
160 // write ordered
161 if (!parcel.WriteBool(ordered_)) {
162 EVENT_LOGE("common event Publish Info write ordered failed");
163 return false;
164 }
165
166 // write sticky
167 if (!parcel.WriteBool(sticky_)) {
168 EVENT_LOGE("common event Publish Info write sticky failed");
169 return false;
170 }
171 // write bundleName
172 if (!parcel.WriteString16(Str8ToStr16(bundleName_))) {
173 EVENT_LOGE("common event Publish Info write bundleName failed");
174 return false;
175 }
176 // write subscriberUids
177 if (!parcel.WriteInt32Vector(subscriberUids_)) {
178 EVENT_LOGE("common event Publish Info write subscriberUids failed");
179 return false;
180 }
181
182 // write subscriberType
183 if (!parcel.WriteInt32(subscriberType_)) {
184 EVENT_LOGE("common event Publish Info write subscriberType failed");
185 return false;
186 }
187 // write rule_
188 if (!parcel.WriteInt32(static_cast<int32_t>(rule_))) {
189 EVENT_LOGE("common event Publish Info write rule failed");
190 return false;
191 }
192 return true;
193 }
194
isSubscriberType(int32_t subscriberType)195 bool CommonEventPublishInfo::isSubscriberType(int32_t subscriberType)
196 {
197 switch (subscriberType) {
198 case static_cast<int32_t>(SubscriberType::ALL_SUBSCRIBER_TYPE):
199 return true;
200 case static_cast<int32_t>(SubscriberType::SYSTEM_SUBSCRIBER_TYPE):
201 return true;
202 default:
203 return false;
204 }
205 }
206
ReadFromParcel(Parcel & parcel)207 bool CommonEventPublishInfo::ReadFromParcel(Parcel &parcel)
208 {
209 EVENT_LOGD("enter");
210
211 // read subscriber permissions
212 std::vector<std::u16string> permissionVec_;
213 if (!parcel.ReadString16Vector(&permissionVec_)) {
214 EVENT_LOGE("ReadFromParcel read permission error");
215 return false;
216 }
217 subscriberPermissions_.clear();
218 for (std::vector<std::u16string>::size_type i = 0; i < permissionVec_.size(); i++) {
219 subscriberPermissions_.emplace_back(Str16ToStr8(permissionVec_[i]));
220 }
221 // read ordered
222 ordered_ = parcel.ReadBool();
223 // read sticky
224 sticky_ = parcel.ReadBool();
225 // read bundleName
226 bundleName_ = Str16ToStr8(parcel.ReadString16());
227 // read subscriberUids
228 if (!parcel.ReadInt32Vector(&subscriberUids_)) {
229 EVENT_LOGE("ReadFromParcel read subscriberUids error");
230 return false;
231 }
232 // read subscriberType
233 subscriberType_ = parcel.ReadInt32();
234 int32_t rule = parcel.ReadInt32();
235 if (rule < static_cast<int32_t>(ValidationRule::AND) ||
236 rule > static_cast<int32_t>(ValidationRule::OR)) {
237 EVENT_LOGE("ReadFromParcel read rule error");
238 return false;
239 }
240 rule_ = static_cast<ValidationRule>(rule);
241 return true;
242 }
243
Unmarshalling(Parcel & parcel)244 CommonEventPublishInfo *CommonEventPublishInfo::Unmarshalling(Parcel &parcel)
245 {
246 CommonEventPublishInfo *commonEventPublishInfo = new (std::nothrow) CommonEventPublishInfo();
247
248 if (commonEventPublishInfo == nullptr) {
249 EVENT_LOGE("commonEventPublishInfo == nullptr");
250 return nullptr;
251 }
252
253 if (!commonEventPublishInfo->ReadFromParcel(parcel)) {
254 EVENT_LOGE("failed to ReadFromParcel");
255 delete commonEventPublishInfo;
256 commonEventPublishInfo = nullptr;
257 }
258
259 return commonEventPublishInfo;
260 }
261 } // namespace EventFwk
262 } // namespace OHOS