1 /*
2 * Copyright (C) 2024 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 Sensitives and
13 * limitations under the License.
14 */
15
16 #include <vector>
17 #include <map>
18 #include "medialibrary_app_uri_sensitive_operations.h"
19 #include "medialibrary_unistore_manager.h"
20 #include "medialibrary_rdbstore.h"
21 #include "medialibrary_rdb_utils.h"
22 #include "media_column.h"
23 #include "datashare_predicates.h"
24 #include "rdb_utils.h"
25 #include "media_file_uri.h"
26 #include "medialibrary_asset_operations.h"
27 #include "medialibrary_rdb_transaction.h"
28 #include "media_file_utils.h"
29 #include "medialibrary_appstate_observer.h"
30 #include "datashare_predicates_objects.h"
31
32 using namespace OHOS::DataShare;
33 using namespace std;
34 using namespace OHOS::NativeRdb;
35 using namespace OHOS::RdbDataShareAdapter;
36
37 namespace OHOS {
38 namespace Media {
39
40 const int MediaLibraryAppUriSensitiveOperations::ERROR = -1;
41 const int MediaLibraryAppUriSensitiveOperations::SUCCEED = 0;
42 const int MediaLibraryAppUriSensitiveOperations::ALREADY_EXIST = 1;
43 const int MediaLibraryAppUriSensitiveOperations::NO_DATA_EXIST = 0;
44
HandleInsertOperation(MediaLibraryCommand & cmd)45 int32_t MediaLibraryAppUriSensitiveOperations::HandleInsertOperation(MediaLibraryCommand &cmd)
46 {
47 MEDIA_INFO_LOG("insert appUriSensitive begin");
48 // sensitiveType from param
49 int sensitiveTypeParam = -1;
50 if (!GetIntFromValuesBucket(cmd.GetValueBucket(), AppUriSensitiveColumn::HIDE_SENSITIVE_TYPE,
51 sensitiveTypeParam)) {
52 return ERROR;
53 }
54 if (!IsValidSensitiveType(sensitiveTypeParam)) {
55 return ERROR;
56 }
57
58 // query sensitive data before insert
59 int queryFlag = ERROR;
60 shared_ptr<ResultSet> resultSet = QueryNewData(cmd.GetValueBucket(), queryFlag);
61 // Update the sensitiveType
62 if (queryFlag > 0) {
63 return UpdateSensitiveType(resultSet, sensitiveTypeParam);
64 }
65 if (queryFlag < 0) {
66 return ERROR;
67 }
68
69 // delete the temporary Sensitive when the app dies
70 MedialibraryAppStateObserverManager::GetInstance().SubscribeAppState();
71
72 auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
73 if (rdbStore == nullptr) {
74 MEDIA_ERR_LOG("get rdbStore error");
75 return ERROR;
76 }
77 // insert data
78 int64_t outRowId = -1;
79 cmd.GetValueBucket().PutLong(AppUriSensitiveColumn::DATE_MODIFIED,
80 MediaFileUtils::UTCTimeMilliSeconds());
81
82 int permissionTypeParam = -1;
83 if (!GetIntFromValuesBucket(cmd.GetValueBucket(), AppUriPermissionColumn::PERMISSION_TYPE,
84 permissionTypeParam)) {
85 return ERROR;
86 }
87 cmd.GetValueBucket().Delete(AppUriPermissionColumn::PERMISSION_TYPE);
88 cmd.SetTableName(AppUriSensitiveColumn::APP_URI_SENSITIVE_TABLE);
89
90 int32_t errCode = rdbStore->Insert(cmd, outRowId);
91 if (errCode != NativeRdb::E_OK) {
92 MEDIA_ERR_LOG("insert into db error, errCode=%{public}d", errCode);
93 return ERROR;
94 }
95 cmd.GetValueBucket().PutInt(AppUriPermissionColumn::PERMISSION_TYPE,
96 permissionTypeParam);
97 MEDIA_INFO_LOG("insert appUriSensitive ok");
98 return SUCCEED;
99 }
100
BeForceSensitive(MediaLibraryCommand & cmd,const std::vector<DataShare::DataShareValuesBucket> & values)101 bool MediaLibraryAppUriSensitiveOperations::BeForceSensitive(MediaLibraryCommand &cmd,
102 const std::vector<DataShare::DataShareValuesBucket> &values)
103 {
104 bool hasForce = false;
105 for (auto it = values.begin(); it != values.end(); it++) {
106 ValuesBucket value = RdbUtils::ToValuesBucket(*it);
107 int beForce = -1;
108 if (!GetIntFromValuesBucket(value, AppUriSensitiveColumn::IS_FORCE_SENSITIVE,
109 beForce)) {
110 continue;
111 }
112 if (beForce > 0) {
113 hasForce = true;
114 break;
115 }
116 }
117 return hasForce;
118 }
119
BatchInsert(MediaLibraryCommand & cmd,const std::vector<DataShare::DataShareValuesBucket> & values)120 int32_t MediaLibraryAppUriSensitiveOperations::BatchInsert(
121 MediaLibraryCommand &cmd, const std::vector<DataShare::DataShareValuesBucket> &values)
122 {
123 MEDIA_INFO_LOG("batch insert begin");
124 std::vector<ValuesBucket> insertVector;
125 for (auto it = values.begin(); it != values.end(); it++) {
126 ValuesBucket value = RdbUtils::ToValuesBucket(*it);
127 int queryFlag = -1;
128 std::shared_ptr<OHOS::NativeRdb::ResultSet> resultSet = QueryNewData(value, queryFlag);
129 if (queryFlag < 0) {
130 return ERROR;
131 }
132 // sensitiveType from param
133 int sensitiveTypeParam = -1;
134 if (!GetIntFromValuesBucket(value, AppUriSensitiveColumn::HIDE_SENSITIVE_TYPE,
135 sensitiveTypeParam)) {
136 return ERROR;
137 }
138
139 value.Delete(AppUriPermissionColumn::PERMISSION_TYPE);
140
141 if (queryFlag == 0) {
142 // delete the temporary sensitive when the app dies
143 MedialibraryAppStateObserverManager::GetInstance().SubscribeAppState();
144 value.PutLong(AppUriSensitiveColumn::DATE_MODIFIED, MediaFileUtils::UTCTimeMilliSeconds());
145 insertVector.push_back(value);
146 } else if (UpdateSensitiveTypeAndForceHideSensitive(resultSet, sensitiveTypeParam, value) == ERROR) {
147 return ERROR;
148 }
149 }
150 if (!insertVector.empty()) {
151 int64_t outRowId = -1;
152 int32_t ret = MediaLibraryRdbStore::BatchInsert(outRowId, AppUriSensitiveColumn::APP_URI_SENSITIVE_TABLE,
153 insertVector);
154 if (ret != NativeRdb::E_OK) {
155 MEDIA_ERR_LOG("batch insert err=%{public}d", ret);
156 return ERROR;
157 }
158 }
159 MEDIA_INFO_LOG("batch insert ok");
160 return SUCCEED;
161 }
162
DeleteOperation(NativeRdb::RdbPredicates & predicates)163 int32_t MediaLibraryAppUriSensitiveOperations::DeleteOperation(NativeRdb::RdbPredicates &predicates)
164 {
165 MEDIA_INFO_LOG("delete begin");
166 int deleteRow = MediaLibraryRdbStore::Delete(predicates);
167 MEDIA_INFO_LOG("deleted row=%{public}d", deleteRow);
168 return deleteRow < 0 ? ERROR : SUCCEED;
169 }
170
QueryOperation(DataShare::DataSharePredicates & predicates,std::vector<std::string> & fetchColumns)171 std::shared_ptr<OHOS::NativeRdb::ResultSet> MediaLibraryAppUriSensitiveOperations::QueryOperation(
172 DataShare::DataSharePredicates &predicates, std::vector<std::string> &fetchColumns)
173 {
174 RdbPredicates rdbPredicates = RdbUtils::ToPredicates(predicates,
175 AppUriSensitiveColumn::APP_URI_SENSITIVE_TABLE);
176 std::shared_ptr<OHOS::NativeRdb::ResultSet> resultSet =
177 MediaLibraryRdbStore::QueryWithFilter(rdbPredicates, fetchColumns);
178 if (resultSet == nullptr) {
179 return nullptr;
180 }
181 int32_t numRows = 0;
182 resultSet->GetRowCount(numRows);
183 if (numRows == 0) {
184 return nullptr;
185 }
186 resultSet->GoToFirstRow();
187 return resultSet;
188 }
189
QueryNewData(OHOS::NativeRdb::ValuesBucket & valueBucket,int & resultFlag)190 std::shared_ptr<OHOS::NativeRdb::ResultSet> MediaLibraryAppUriSensitiveOperations::QueryNewData(
191 OHOS::NativeRdb::ValuesBucket &valueBucket, int &resultFlag)
192 {
193 // target tokenId
194 int64_t targetTokenId;
195 ValueObject valueObject;
196 if (valueBucket.GetObject(AppUriSensitiveColumn::TARGET_TOKENID, valueObject)) {
197 valueObject.GetLong(targetTokenId);
198 }
199
200 // parse fileId
201 int fileId = -1;
202 if (!GetIntFromValuesBucket(valueBucket, AppUriSensitiveColumn::FILE_ID, fileId)) {
203 resultFlag = ERROR;
204 return nullptr;
205 }
206
207 // parse uriType
208 int uriType = -1;
209 if (!GetIntFromValuesBucket(valueBucket, AppUriSensitiveColumn::URI_TYPE, uriType)) {
210 resultFlag = ERROR;
211 return nullptr;
212 }
213
214 OHOS::DataShare::DataSharePredicates sensitivePredicates;
215 sensitivePredicates.And()->EqualTo(AppUriSensitiveColumn::FILE_ID, fileId);
216 sensitivePredicates.And()->EqualTo(AppUriSensitiveColumn::URI_TYPE, uriType);
217 sensitivePredicates.And()->EqualTo(AppUriSensitiveColumn::TARGET_TOKENID, targetTokenId);
218 vector<string> fetchColumns;
219 fetchColumns.push_back(AppUriSensitiveColumn::ID);
220 fetchColumns.push_back(AppUriSensitiveColumn::HIDE_SENSITIVE_TYPE);
221
222 shared_ptr<ResultSet> resultSet = QueryOperation(sensitivePredicates, fetchColumns);
223 resultFlag = (resultSet == nullptr ? NO_DATA_EXIST : ALREADY_EXIST);
224 return resultSet;
225 }
226
GetIntFromValuesBucket(OHOS::NativeRdb::ValuesBucket & valueBucket,const std::string & column,int & result)227 bool MediaLibraryAppUriSensitiveOperations::GetIntFromValuesBucket(
228 OHOS::NativeRdb::ValuesBucket &valueBucket, const std::string &column, int &result)
229 {
230 ValueObject valueObject;
231 bool ret = valueBucket.GetObject(column, valueObject);
232 if (!ret) {
233 MEDIA_ERR_LOG("valueBucket param without %{public}s", column.c_str());
234 return false;
235 }
236 result = valueObject;
237 return true;
238 }
239
UpdateSensitiveType(shared_ptr<ResultSet> & resultSetDB,int & sensitiveTypeParam)240 int MediaLibraryAppUriSensitiveOperations::UpdateSensitiveType(shared_ptr<ResultSet> &resultSetDB,
241 int &sensitiveTypeParam)
242 {
243 // delete the temporary Sensitive when the app dies
244 MedialibraryAppStateObserverManager::GetInstance().SubscribeAppState();
245
246 // update sensitive type
247 ValuesBucket updateVB;
248 updateVB.PutInt(AppUriSensitiveColumn::HIDE_SENSITIVE_TYPE, sensitiveTypeParam);
249 updateVB.PutLong(AppUriSensitiveColumn::DATE_MODIFIED, MediaFileUtils::UTCTimeMilliSeconds());
250 int32_t idDB = MediaLibraryRdbStore::GetInt(resultSetDB, AppUriSensitiveColumn::ID);
251
252 RdbPredicates updateRdbPredicates(AppUriSensitiveColumn::APP_URI_SENSITIVE_TABLE);
253 updateRdbPredicates.EqualTo(AppUriSensitiveColumn::ID, idDB);
254 int32_t updateRows = MediaLibraryRdbStore::UpdateWithDateTime(updateVB, updateRdbPredicates);
255 if (updateRows < 1) {
256 MEDIA_ERR_LOG("upgrade SensitiveType error,idDB=%{public}d", idDB);
257 return ERROR;
258 }
259 MEDIA_INFO_LOG("update ok,Rows=%{public}d", updateRows);
260 return SUCCEED;
261 }
262
UpdateSensitiveTypeAndForceHideSensitive(shared_ptr<ResultSet> & resultSetDB,int & sensitiveTypeParam,OHOS::NativeRdb::ValuesBucket & valueBucket)263 int MediaLibraryAppUriSensitiveOperations::UpdateSensitiveTypeAndForceHideSensitive(shared_ptr<ResultSet> &resultSetDB,
264 int &sensitiveTypeParam, OHOS::NativeRdb::ValuesBucket &valueBucket)
265 {
266 // get force value
267 int isForce = -1;
268 bool hasSetForce = GetIntFromValuesBucket(valueBucket, AppUriSensitiveColumn::IS_FORCE_SENSITIVE,
269 isForce);
270 // delete the temporary Sensitive when the app dies
271 MedialibraryAppStateObserverManager::GetInstance().SubscribeAppState();
272
273 // update is_force_hideSensitive value
274 ValuesBucket updateVB;
275 updateVB.PutInt(AppUriSensitiveColumn::HIDE_SENSITIVE_TYPE, sensitiveTypeParam);
276 updateVB.PutLong(AppUriSensitiveColumn::DATE_MODIFIED, MediaFileUtils::UTCTimeMilliSeconds());
277 if (hasSetForce && isForce > 0) {
278 updateVB.PutInt(AppUriSensitiveColumn::IS_FORCE_SENSITIVE, 1);
279 }
280 int32_t idDB = MediaLibraryRdbStore::GetInt(resultSetDB, AppUriSensitiveColumn::ID);
281
282 RdbPredicates updateRdbPredicates(AppUriSensitiveColumn::APP_URI_SENSITIVE_TABLE);
283 updateRdbPredicates.EqualTo(AppUriSensitiveColumn::ID, idDB);
284 int32_t updateRows = MediaLibraryRdbStore::UpdateWithDateTime(updateVB, updateRdbPredicates);
285 if (updateRows < 1) {
286 MEDIA_ERR_LOG("upgrade SensitiveType error,idDB=%{public}d", idDB);
287 return ERROR;
288 }
289 MEDIA_INFO_LOG("update ok,Rows=%{public}d", updateRows);
290 return SUCCEED;
291 }
292
IsValidSensitiveType(int & sensitiveType)293 bool MediaLibraryAppUriSensitiveOperations::IsValidSensitiveType(int &sensitiveType)
294 {
295 bool isValid = AppUriSensitiveColumn::SENSITIVE_TYPES_ALL.find(sensitiveType)
296 != AppUriSensitiveColumn::SENSITIVE_TYPES_ALL.end();
297 if (!isValid) {
298 MEDIA_ERR_LOG("invalid SensitiveType=%{public}d", sensitiveType);
299 }
300 return isValid;
301 }
302 } // namespace Media
303 } // namespace OHOS