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 "metadata/store_meta_data.h"
17
18 #include "metadata/auto_launch_meta_data.h"
19 #include "metadata/secret_key_meta_data.h"
20 #include "metadata/store_debug_info.h"
21 #include "metadata/store_meta_data_local.h"
22 #include "metadata/strategy_meta_data.h"
23 #include "utils/anonymous.h"
24 #include "utils/constant.h"
25 namespace OHOS {
26 namespace DistributedData {
27 constexpr uint32_t StoreMetaData::CURRENT_VERSION;
28 constexpr uint32_t StoreMetaData::FIELD_CHANGED_TAG;
29 constexpr const char *StoreMetaData::KEY_PREFIX;
Marshal(json & node) const30 bool StoreMetaData::Marshal(json &node) const
31 {
32 SetValue(node[GET_NAME(version)], version);
33 SetValue(node[GET_NAME(isAutoSync)], isAutoSync);
34 SetValue(node[GET_NAME(isBackup)], isBackup);
35 SetValue(node[GET_NAME(isEncrypt)], isEncrypt);
36 SetValue(node[GET_NAME(isManualClean)], isManualClean);
37 SetValue(node[GET_NAME(isDirty)], isDirty);
38 SetValue(node[GET_NAME(isSearchable)], isSearchable);
39 SetValue(node[GET_NAME(isNeedCompress)], isNeedCompress);
40 SetValue(node[GET_NAME(storeType)], storeType);
41 SetValue(node[GET_NAME(securityLevel)], securityLevel);
42 SetValue(node[GET_NAME(area)], area);
43 SetValue(node[GET_NAME(uid)], uid);
44 SetValue(node[GET_NAME(tokenId)], tokenId);
45 SetValue(node[GET_NAME(instanceId)], instanceId);
46 SetValue(node[GET_NAME(appId)], appId);
47 SetValue(node[GET_NAME(appType)], appType);
48 SetValue(node[GET_NAME(bundleName)], bundleName);
49 SetValue(node[GET_NAME(hapName)], hapName);
50 SetValue(node[GET_NAME(dataDir)], dataDir);
51 SetValue(node[GET_NAME(deviceId)], deviceId);
52 SetValue(node[GET_NAME(schema)], schema);
53 SetValue(node[GET_NAME(storeId)], storeId);
54 SetValue(node[GET_NAME(user)], user);
55 SetValue(node[GET_NAME(account)], account);
56 SetValue(node[GET_NAME(dataType)], dataType);
57 SetValue(node[GET_NAME(enableCloud)], enableCloud);
58 SetValue(node[GET_NAME(cloudAutoSync)], cloudAutoSync);
59 SetValue(node[GET_NAME(asyncDownloadAsset)], asyncDownloadAsset);
60 // compatible with the versions which lower than VERSION_TAG_0000
61 SetValue(node[GET_NAME(kvStoreType)], storeType);
62 SetValue(node[GET_NAME(deviceAccountID)], user);
63 SetValue(node[GET_NAME(userId)], account);
64 SetValue(node[GET_NAME(UID)], uid);
65 SetValue(node[GET_NAME(customDir)], customDir);
66 SetValue(node[GET_NAME(authType)], authType);
67 SetValue(node[GET_NAME(haMode)], haMode);
68 return true;
69 }
70
Unmarshal(const json & node)71 bool StoreMetaData::Unmarshal(const json &node)
72 {
73 GetValue(node, GET_NAME(version), version);
74 GetValue(node, GET_NAME(isAutoSync), isAutoSync);
75 GetValue(node, GET_NAME(isBackup), isBackup);
76 GetValue(node, GET_NAME(isDirty), isDirty);
77 GetValue(node, GET_NAME(isEncrypt), isEncrypt);
78 GetValue(node, GET_NAME(isManualClean), isManualClean);
79 GetValue(node, GET_NAME(isSearchable), isSearchable);
80 GetValue(node, GET_NAME(isNeedCompress), isNeedCompress);
81 GetValue(node, GET_NAME(storeType), storeType);
82 GetValue(node, GET_NAME(securityLevel), securityLevel);
83 GetValue(node, GET_NAME(area), area);
84 GetValue(node, GET_NAME(uid), uid);
85 GetValue(node, GET_NAME(tokenId), tokenId);
86 GetValue(node, GET_NAME(instanceId), instanceId);
87 GetValue(node, GET_NAME(appId), appId);
88 GetValue(node, GET_NAME(appType), appType);
89 GetValue(node, GET_NAME(bundleName), bundleName);
90 GetValue(node, GET_NAME(hapName), hapName);
91 GetValue(node, GET_NAME(dataDir), dataDir);
92 GetValue(node, GET_NAME(deviceId), deviceId);
93 GetValue(node, GET_NAME(schema), schema);
94 GetValue(node, GET_NAME(storeId), storeId);
95 GetValue(node, GET_NAME(user), user);
96 GetValue(node, GET_NAME(account), account);
97 GetValue(node, GET_NAME(dataType), dataType);
98 GetValue(node, GET_NAME(enableCloud), enableCloud);
99 GetValue(node, GET_NAME(cloudAutoSync), cloudAutoSync);
100 GetValue(node, GET_NAME(asyncDownloadAsset), asyncDownloadAsset);
101 // compatible with the older versions
102 if (version < FIELD_CHANGED_TAG) {
103 GetValue(node, GET_NAME(kvStoreType), storeType);
104 GetValue(node, GET_NAME(UID), uid);
105 GetValue(node, GET_NAME(deviceAccountID), user);
106 GetValue(node, GET_NAME(userId), account);
107 }
108 GetValue(node, GET_NAME(customDir), customDir);
109 GetValue(node, GET_NAME(authType), authType);
110 GetValue(node, GET_NAME(haMode), haMode);
111 return true;
112 }
113
StoreMetaData()114 StoreMetaData::StoreMetaData()
115 {
116 }
117
~StoreMetaData()118 StoreMetaData::~StoreMetaData()
119 {
120 }
121
StoreMetaData(const std::string & userId,const std::string & appId,const std::string & storeId)122 StoreMetaData::StoreMetaData(const std::string &userId, const std::string &appId, const std::string &storeId)
123 : appId(appId), storeId(storeId), user(userId)
124 {
125 }
126
StoreMetaData(const StoreInfo & storeInfo)127 StoreMetaData::StoreMetaData(const StoreInfo &storeInfo)
128 : instanceId(storeInfo.instanceId), bundleName(storeInfo.bundleName), storeId(storeInfo.storeName),
129 user(std::to_string(storeInfo.user))
130 {
131 }
132
operator ==(const StoreMetaData & metaData) const133 bool StoreMetaData::operator==(const StoreMetaData &metaData) const
134 {
135 if (Constant::NotEqual(isAutoSync, metaData.isAutoSync) || Constant::NotEqual(isBackup, metaData.isBackup) ||
136 Constant::NotEqual(isDirty, metaData.isDirty) || Constant::NotEqual(isEncrypt, metaData.isEncrypt) ||
137 Constant::NotEqual(isSearchable, metaData.isSearchable) ||
138 Constant::NotEqual(isNeedCompress, metaData.isNeedCompress) ||
139 Constant::NotEqual(enableCloud, metaData.enableCloud) ||
140 Constant::NotEqual(cloudAutoSync, metaData.cloudAutoSync) ||
141 Constant::NotEqual(isManualClean, metaData.isManualClean)) {
142 return false;
143 }
144 return (version == metaData.version && storeType == metaData.storeType && dataType == metaData.dataType &&
145 securityLevel == metaData.securityLevel && area == metaData.area && uid == metaData.uid &&
146 tokenId == metaData.tokenId && instanceId == metaData.instanceId && appId == metaData.appId &&
147 appType == metaData.appType && bundleName == metaData.bundleName && dataDir == metaData.dataDir &&
148 storeId == metaData.storeId && user == metaData.user && deviceId == metaData.deviceId &&
149 account == metaData.account && authType == metaData.authType && haMode == metaData.haMode);
150 }
151
operator !=(const StoreMetaData & metaData) const152 bool StoreMetaData::operator!=(const StoreMetaData &metaData) const
153 {
154 return !(*this == metaData);
155 }
156
GetKey() const157 std::string StoreMetaData::GetKey() const
158 {
159 if (instanceId == 0) {
160 return GetKey({ deviceId, user, "default", bundleName, storeId });
161 }
162 return GetKey({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
163 }
164
GetKeyLocal() const165 std::string StoreMetaData::GetKeyLocal() const
166 {
167 if (instanceId == 0) {
168 return StoreMetaDataLocal::GetKey({ deviceId, user, "default", bundleName, storeId });
169 }
170 return StoreMetaDataLocal::GetKey({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
171 }
172
GetSecretKey() const173 std::string StoreMetaData::GetSecretKey() const
174 {
175 if (version < UUID_CHANGED_TAG) {
176 return SecretKeyMetaData::GetKey({ user, "default", bundleName, storeId });
177 }
178 return SecretKeyMetaData::GetKey({ user, "default", bundleName, storeId, std::to_string(instanceId) });
179 }
180
GetBackupSecretKey() const181 std::string StoreMetaData::GetBackupSecretKey() const
182 {
183 if (version < UUID_CHANGED_TAG) {
184 return SecretKeyMetaData::GetBackupKey({ user, "default", bundleName, storeId });
185 }
186 return SecretKeyMetaData::GetBackupKey({ user, "default", bundleName, storeId, std::to_string(instanceId) });
187 }
188
GetAutoLaunchKey() const189 std::string StoreMetaData::GetAutoLaunchKey() const
190 {
191 return AutoLaunchMetaData::GetPrefix({ deviceId, user, "default", bundleName, storeId });
192 }
193
GetDebugInfoKey() const194 std::string StoreMetaData::GetDebugInfoKey() const
195 {
196 return StoreDebugInfo::GetPrefix({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
197 }
198
GetDfxInfoKey() const199 std::string StoreMetaData::GetDfxInfoKey() const
200 {
201 return StoreDfxInfo::GetPrefix({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
202 }
203
GetStoreAlias() const204 std::string StoreMetaData::GetStoreAlias() const
205 {
206 return Anonymous::Change(storeId);
207 }
208
GetStrategyKey() const209 std::string StoreMetaData::GetStrategyKey() const
210 {
211 if (instanceId == 0) {
212 return StrategyMeta::GetPrefix({ deviceId, user, "default", bundleName, storeId });
213 }
214 return StrategyMeta::GetPrefix({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
215 }
216
GetKey(const std::initializer_list<std::string> & fields)217 std::string StoreMetaData::GetKey(const std::initializer_list<std::string> &fields)
218 {
219 std::string prefix = KEY_PREFIX;
220 for (const auto &field : fields) {
221 prefix.append(Constant::KEY_SEPARATOR).append(field);
222 }
223 return prefix;
224 }
225
GetPrefix(const std::initializer_list<std::string> & fields)226 std::string StoreMetaData::GetPrefix(const std::initializer_list<std::string> &fields)
227 {
228 return GetKey(fields).append(Constant::KEY_SEPARATOR);
229 }
230
GetStoreInfo() const231 StoreInfo StoreMetaData::GetStoreInfo() const
232 {
233 StoreInfo info;
234 info.instanceId = instanceId;
235 info.bundleName = bundleName;
236 info.storeName = storeId;
237 info.user = atoi(user.c_str());
238 return info;
239 }
240
GetCloneSecretKey() const241 std::string StoreMetaData::GetCloneSecretKey() const
242 {
243 return SecretKeyMetaData::GetCloneKey({ user, "default", bundleName, storeId, std::to_string(instanceId) });
244 }
245 } // namespace DistributedData
246 } // namespace OHOS