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 #define MLOG_TAG "Distributed"
16
17 #include "medialibrary_device_operations.h"
18 #include "media_file_utils.h"
19 #include "media_log.h"
20 #include "medialibrary_errno.h"
21 #include "result_set_utils.h"
22
23 using namespace std;
24 using namespace OHOS::NativeRdb;
25
26 namespace OHOS {
27 namespace Media {
28 static const int64_t AGING_DEVICE_INTERVAL = 14 * 24 * 60 * 60LL;
29
InsertDeviceInfo(const std::shared_ptr<NativeRdb::RdbStore> & rdbStore,const OHOS::Media::MediaLibraryDeviceInfo & deviceInfo,const std::string & bundleName)30 bool MediaLibraryDeviceOperations::InsertDeviceInfo(const std::shared_ptr<NativeRdb::RdbStore> &rdbStore,
31 const OHOS::Media::MediaLibraryDeviceInfo &deviceInfo, const std::string &bundleName)
32 {
33 if (rdbStore == nullptr) {
34 MEDIA_ERR_LOG("rdbstore is nullptr");
35 return false;
36 }
37 unique_ptr<AbsSharedResultSet> queryResultSet;
38 std::vector<std::string> columns;
39 AbsRdbPredicates absPredDevice(DEVICE_TABLE);
40 absPredDevice.EqualTo(DEVICE_DB_UDID, deviceInfo.deviceUdid);
41 queryResultSet = rdbStore->Query(absPredDevice, columns);
42
43 auto count = 0;
44 auto ret = queryResultSet->GetRowCount(count);
45 MEDIA_INFO_LOG("MediaLibraryDeviceOperations::InsertDeviceInfo ret = %{public}d, count = %{public}d", ret, count);
46 if (ret == NativeRdb::E_OK) {
47 if (count > 0) {
48 // 更新数据库
49 ValuesBucket valuesBucket;
50 valuesBucket.PutString(DEVICE_DB_UDID, deviceInfo.deviceUdid);
51 valuesBucket.PutString(DEVICE_DB_NETWORK_ID, deviceInfo.networkId);
52 valuesBucket.PutInt(DEVICE_DB_SYNC_STATUS, 0);
53 valuesBucket.PutLong(DEVICE_DB_DATE_MODIFIED, 0);
54 return MediaLibraryDeviceDb::UpdateDeviceInfo(valuesBucket, rdbStore) == E_SUCCESS;
55 } else {
56 // 插入数据库
57 ValuesBucket valuesBucket;
58 valuesBucket.PutString(DEVICE_DB_UDID, deviceInfo.deviceUdid);
59 valuesBucket.PutString(DEVICE_DB_NETWORK_ID, deviceInfo.networkId);
60 valuesBucket.PutString(DEVICE_DB_NAME, deviceInfo.deviceName);
61 valuesBucket.PutString(DEVICE_DB_IP, std::string());
62 valuesBucket.PutString(DEVICE_DB_SELF_ID, deviceInfo.selfId);
63 valuesBucket.PutInt(DEVICE_DB_TYPE, (int32_t) deviceInfo.deviceTypeId);
64 valuesBucket.PutString(DEVICE_DB_PREPATH, std::string());
65 int64_t now = MediaFileUtils::UTCTimeSeconds();
66 valuesBucket.PutLong(DEVICE_DB_DATE_ADDED, now);
67 return MediaLibraryDeviceDb::InsertDeviceInfo(valuesBucket, rdbStore) >= 0;
68 }
69 }
70 return false;
71 }
72
UpdateDeviceInfo(const std::shared_ptr<NativeRdb::RdbStore> & rdbStore,const OHOS::Media::MediaLibraryDeviceInfo & deviceInfo,const std::string & bundleName)73 bool MediaLibraryDeviceOperations::UpdateDeviceInfo(const std::shared_ptr<NativeRdb::RdbStore> &rdbStore,
74 const OHOS::Media::MediaLibraryDeviceInfo &deviceInfo, const std::string &bundleName)
75 {
76 unique_ptr<AbsSharedResultSet> queryResultSet;
77 std::vector<std::string> columns;
78 AbsRdbPredicates absPredDevice(DEVICE_TABLE);
79 absPredDevice.EqualTo(DEVICE_DB_UDID, deviceInfo.deviceUdid);
80 MEDIA_INFO_LOG("MediaLibraryDeviceOperations::UpdateDeviceInfo dev id = %{private}s",
81 deviceInfo.deviceUdid.c_str());
82 queryResultSet = rdbStore->Query(absPredDevice, columns);
83
84 auto count = 0;
85 auto ret = queryResultSet->GetRowCount(count);
86 if (ret == NativeRdb::E_OK) {
87 if (count > 0) {
88 // 更新数据库
89 ValuesBucket valuesBucket;
90 valuesBucket.PutString(DEVICE_DB_UDID, deviceInfo.deviceUdid);
91 valuesBucket.PutString(DEVICE_DB_NETWORK_ID, deviceInfo.networkId);
92 int idx = -1;
93 ret = queryResultSet->GoToFirstRow();
94 if (ret != NativeRdb::E_OK) {
95 return false;
96 }
97
98 ret = queryResultSet->GetColumnIndex(DEVICE_DB_DATE_MODIFIED, idx);
99 if (ret != NativeRdb::E_OK) {
100 return false;
101 }
102
103 int64_t modifiedTime = 0;
104 queryResultSet->GetLong(idx, modifiedTime);
105 if (modifiedTime == 0) {
106 int64_t now = MediaFileUtils::UTCTimeSeconds();
107 valuesBucket.PutLong(DEVICE_DB_DATE_MODIFIED, now);
108 }
109 return MediaLibraryDeviceDb::UpdateDeviceInfo(valuesBucket, rdbStore) == E_SUCCESS;
110 }
111 }
112 return false;
113 }
114
DeleteDeviceInfo(const std::shared_ptr<NativeRdb::RdbStore> & rdbStore,const std::string & udid)115 bool MediaLibraryDeviceOperations::DeleteDeviceInfo(const std::shared_ptr<NativeRdb::RdbStore> &rdbStore,
116 const std::string &udid)
117 {
118 return MediaLibraryDeviceDb::DeleteDeviceInfo(udid, rdbStore);
119 }
120
UpdateSyncStatus(const std::shared_ptr<NativeRdb::RdbStore> & rdbStore,const std::string & udid,int32_t syncStatus)121 bool MediaLibraryDeviceOperations::UpdateSyncStatus(const std::shared_ptr<NativeRdb::RdbStore> &rdbStore,
122 const std::string &udid, int32_t syncStatus)
123 {
124 unique_ptr<AbsSharedResultSet> queryResultSet;
125 std::vector<std::string> columns;
126 AbsRdbPredicates absPredDevice(DEVICE_TABLE);
127
128 absPredDevice.EqualTo(DEVICE_DB_UDID, udid);
129 queryResultSet = rdbStore->Query(absPredDevice, columns);
130
131 auto count = 0;
132 auto ret = queryResultSet->GetRowCount(count);
133 if (ret == NativeRdb::E_OK) {
134 if (count > 0) {
135 // 更新数据库
136 ValuesBucket valuesBucket;
137 valuesBucket.PutString(DEVICE_DB_UDID, udid);
138 valuesBucket.PutInt(DEVICE_DB_SYNC_STATUS, syncStatus);
139 MEDIA_INFO_LOG("MediaLibraryDeviceOperations::UpdateSyncStatus");
140 return MediaLibraryDeviceDb::UpdateDeviceInfo(valuesBucket, rdbStore) == E_SUCCESS;
141 }
142 }
143 return false;
144 }
145
GetSyncStatusById(const std::shared_ptr<NativeRdb::RdbStore> & rdbStore,const std::string & udid,int32_t & syncStatus)146 bool MediaLibraryDeviceOperations::GetSyncStatusById(const std::shared_ptr<NativeRdb::RdbStore> &rdbStore,
147 const std::string &udid,
148 int32_t &syncStatus)
149 {
150 unique_ptr<AbsSharedResultSet> queryResultSet;
151 std::vector<std::string> columns;
152 AbsRdbPredicates absPredDevice(DEVICE_TABLE);
153
154 absPredDevice.EqualTo(DEVICE_DB_UDID, udid);
155 queryResultSet = rdbStore->Query(absPredDevice, columns);
156 if (queryResultSet == nullptr) {
157 return false;
158 }
159
160 if (queryResultSet->GoToNextRow() == NativeRdb::E_OK) {
161 int32_t columnIndexId;
162 queryResultSet->GetColumnIndex(DEVICE_DB_SYNC_STATUS, columnIndexId);
163 queryResultSet->GetInt(columnIndexId, syncStatus);
164 }
165 MEDIA_INFO_LOG("MediaLibraryDeviceOperations::GetSyncStatusById syncStatus = %{public}d", syncStatus);
166 return true;
167 }
168
QueryDeviceTable(const std::shared_ptr<NativeRdb::RdbStore> & rdbStore,std::map<std::string,std::set<int>> & excludeMap)169 bool MediaLibraryDeviceOperations::QueryDeviceTable(const std::shared_ptr<NativeRdb::RdbStore> &rdbStore,
170 std::map<std::string, std::set<int>> &excludeMap)
171 {
172 const int SHORT_UDID_LEN = 8;
173 unique_ptr<AbsSharedResultSet> queryResultSet;
174 std::vector<std::string> columns;
175 AbsRdbPredicates absPredDevice(DEVICE_TABLE);
176 queryResultSet = rdbStore->Query(absPredDevice, columns);
177 if (queryResultSet == nullptr) {
178 MEDIA_ERR_LOG("MediaLibraryDeviceOperations::QueryDeviceTable fail");
179 return false;
180 }
181
182 if (queryResultSet->GoToNextRow() == NativeRdb::E_OK) {
183 int32_t columnIndexId;
184 std::string selfId;
185 queryResultSet->GetColumnIndex(DEVICE_DB_SELF_ID, columnIndexId);
186 queryResultSet->GetString(columnIndexId, selfId);
187 if (selfId.length() > SHORT_UDID_LEN) {
188 std::string shortUdid = selfId.substr(0, SHORT_UDID_LEN);
189 std::string randNumber = selfId.substr(SHORT_UDID_LEN);
190 if (!randNumber.empty()) {
191 auto &data = excludeMap[shortUdid];
192 data.insert(atoi(randNumber.c_str()));
193 }
194 }
195 }
196 return true;
197 }
198
GetAllDeviceData(const std::shared_ptr<NativeRdb::RdbStore> & rdbStore,vector<MediaLibraryDeviceInfo> & outDeviceList)199 bool MediaLibraryDeviceOperations::GetAllDeviceData(
200 const std::shared_ptr<NativeRdb::RdbStore> &rdbStore,
201 vector<MediaLibraryDeviceInfo> &outDeviceList)
202 {
203 shared_ptr<AbsSharedResultSet> queryResultSet;
204 std::vector<std::string> columns;
205 AbsRdbPredicates absPredDevice(DEVICE_TABLE);
206 queryResultSet = rdbStore->Query(absPredDevice, columns);
207 if (queryResultSet == nullptr) {
208 MEDIA_ERR_LOG("MediaLibraryDeviceOperations::GetAllDeviceData fail");
209 return false;
210 }
211
212 while (queryResultSet->GoToNextRow() == NativeRdb::E_OK) {
213 MediaLibraryDeviceInfo deviceInfo;
214 deviceInfo.networkId = get<string>(ResultSetUtils::GetValFromColumn(DEVICE_DB_NETWORK_ID, queryResultSet,
215 TYPE_STRING));
216 deviceInfo.deviceTypeId = static_cast<DistributedHardware::DmDeviceType>(get<int32_t>(
217 ResultSetUtils::GetValFromColumn(DEVICE_DB_TYPE, queryResultSet, TYPE_INT32)));
218 deviceInfo.deviceUdid = get<string>(ResultSetUtils::GetValFromColumn(DEVICE_DB_UDID, queryResultSet,
219 TYPE_STRING));
220 deviceInfo.selfId = get<string>(ResultSetUtils::GetValFromColumn(DEVICE_DB_SELF_ID, queryResultSet,
221 TYPE_STRING));
222 outDeviceList.push_back(deviceInfo);
223 }
224 return true;
225 }
226
GetAgingDeviceData(const shared_ptr<RdbStore> & rdbStore,vector<MediaLibraryDeviceInfo> & outDeviceList)227 bool MediaLibraryDeviceOperations::GetAgingDeviceData(
228 const shared_ptr<RdbStore> &rdbStore, vector<MediaLibraryDeviceInfo> &outDeviceList)
229 {
230 vector<string> columns;
231 int64_t agingTime = MediaFileUtils::UTCTimeSeconds() - AGING_DEVICE_INTERVAL;
232
233 MEDIA_INFO_LOG("GetAgingDeviceData less than %{public}" PRId64, agingTime);
234 AbsRdbPredicates absPredevice(DEVICE_TABLE);
235 absPredevice.GreaterThan(DEVICE_DB_DATE_MODIFIED, to_string(0))->And()->
236 LessThan(DEVICE_DB_DATE_MODIFIED, to_string(agingTime));
237 shared_ptr<AbsSharedResultSet> queryResultSet = rdbStore->Query(absPredevice, columns);
238 if (queryResultSet == nullptr) {
239 MEDIA_ERR_LOG("GetAgingDeviceData fail");
240 return false;
241 }
242 auto ret = queryResultSet->GoToFirstRow();
243 if (ret != NativeRdb::E_OK) {
244 MEDIA_ERR_LOG("Failed to fetch first record, ret = %{public}d", ret);
245 return false;
246 }
247
248 MediaLibraryDeviceInfo deviceInfo;
249 do {
250 deviceInfo.networkId = get<string>(ResultSetUtils::GetValFromColumn(DEVICE_DB_NETWORK_ID, queryResultSet,
251 TYPE_STRING));
252 deviceInfo.deviceTypeId = (DistributedHardware::DmDeviceType)(get<int32_t>(ResultSetUtils::GetValFromColumn(
253 DEVICE_DB_TYPE, queryResultSet, TYPE_INT32)));
254 deviceInfo.deviceUdid = get<string>(ResultSetUtils::GetValFromColumn(DEVICE_DB_UDID, queryResultSet,
255 TYPE_STRING));
256 deviceInfo.selfId = get<string>(ResultSetUtils::GetValFromColumn(DEVICE_DB_SELF_ID, queryResultSet,
257 TYPE_STRING));
258 outDeviceList.push_back(deviceInfo);
259 } while (queryResultSet->GoToNextRow() == NativeRdb::E_OK);
260
261 MEDIA_ERR_LOG("GetAgingDeviceData OUT, deviceSize = %{public}d", static_cast<int>(outDeviceList.size()));
262 return true;
263 }
264
GetAllDeviceUdid(const shared_ptr<RdbStore> & rdbStore,vector<string> & deviceUdids)265 bool MediaLibraryDeviceOperations::GetAllDeviceUdid(const shared_ptr<RdbStore> &rdbStore,
266 vector<string> &deviceUdids)
267 {
268 vector<string> columns;
269 AbsRdbPredicates absPreDevice(DEVICE_TABLE);
270 shared_ptr<AbsSharedResultSet> queryResultSet = rdbStore->Query(absPreDevice, columns);
271 if (queryResultSet == nullptr) {
272 MEDIA_ERR_LOG("MediaLibraryDeviceOperations::GetAllDeviceUdid fail");
273 return false;
274 }
275 auto ret = queryResultSet->GoToFirstRow();
276 if (ret != NativeRdb::E_OK) {
277 return true;
278 }
279 do {
280 string udid = get<string>(ResultSetUtils::GetValFromColumn(DEVICE_DB_UDID, queryResultSet,
281 TYPE_STRING));
282 deviceUdids.push_back(udid);
283 } while (queryResultSet->GoToNextRow() == NativeRdb::E_OK);
284
285 MEDIA_DEBUG_LOG("MediaLibraryDeviceOperations::GetAllDeviceUdid OUT");
286 return true;
287 }
288 } // namespace Media
289 } // namespace OHOS
290