1 /*
2  * Copyright (c) 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 "pkg_database.h"
17 #include "hilog_wrapper.h"
18 
19 namespace OHOS {
20 namespace ExternalDeviceManager {
21 std::shared_ptr<PkgDataBase> PkgDataBase::instance_ = nullptr;
22 
PkgDataBase()23 PkgDataBase::PkgDataBase()
24 {
25 }
26 
InitDB()27 bool PkgDataBase::InitDB()
28 {
29     std::string rightDatabaseName = PKG_DB_PATH + "pkg.db";
30     int32_t errCode = OHOS::NativeRdb::E_OK;
31     OHOS::NativeRdb::RdbStoreConfig config(rightDatabaseName);
32     config.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
33     PkgDataBaseCallBack sqliteOpenHelperCallback;
34     store_ = OHOS::NativeRdb::RdbHelper::GetRdbStore(config, DATABASE_OPEN_VERSION, sqliteOpenHelperCallback, errCode);
35     if (errCode != OHOS::NativeRdb::E_OK) {
36         EDM_LOGE(MODULE_PKG_MGR, "GetRdbStore errCode :%{public}d", errCode);
37         return false;
38     } else {
39         EDM_LOGE(MODULE_PKG_MGR, "GetRdbStore success :%{public}d", errCode);
40         return true;
41     }
42 }
43 
GetInstance()44 std::shared_ptr<PkgDataBase> PkgDataBase::GetInstance()
45 {
46     if (instance_ == nullptr) {
47         EDM_LOGE(MODULE_PKG_MGR, "PkgDataBase reset to new instance");
48         instance_.reset(new PkgDataBase());
49         return instance_;
50     }
51     return instance_;
52 }
53 
BeginTransaction()54 int32_t PkgDataBase::BeginTransaction()
55 {
56     if (store_ == nullptr) {
57         EDM_LOGE(MODULE_PKG_MGR, "BeginTransaction store_ is nullptr");
58         return PKG_RDB_NO_INIT;
59     }
60     int32_t ret = store_->BeginTransaction();
61     if (ret != OHOS::NativeRdb::E_OK) {
62         EDM_LOGE(MODULE_PKG_MGR, "BeginTransaction fail :%{public}d", ret);
63         return PKG_RDB_EXECUTE_FAILTURE;
64     }
65     return PKG_OK;
66 }
67 
Commit()68 int32_t PkgDataBase::Commit()
69 {
70     if (store_ == nullptr) {
71         EDM_LOGE(MODULE_PKG_MGR, "Commit store_ is nullptr");
72         return PKG_RDB_NO_INIT;
73     }
74     int32_t ret = store_->Commit();
75     if (ret != OHOS::NativeRdb::E_OK) {
76         EDM_LOGE(MODULE_PKG_MGR, "Commit fail :%{public}d", ret);
77         return PKG_RDB_EXECUTE_FAILTURE;
78     }
79     return PKG_OK;
80 }
81 
RollBack()82 int32_t PkgDataBase::RollBack()
83 {
84     if (store_ == nullptr) {
85         EDM_LOGE(MODULE_PKG_MGR, "RollBack store_ is nullptr");
86         return PKG_RDB_NO_INIT;
87     }
88     int32_t ret = store_->RollBack();
89     if (ret != OHOS::NativeRdb::E_OK) {
90         EDM_LOGE(MODULE_PKG_MGR, "RollBack fail :%{public}d", ret);
91         return PKG_RDB_EXECUTE_FAILTURE;
92     }
93     return PKG_OK;
94 }
95 
Insert(const OHOS::NativeRdb::ValuesBucket & insertValues)96 int64_t PkgDataBase::Insert(const OHOS::NativeRdb::ValuesBucket &insertValues)
97 {
98     if (store_ == nullptr) {
99         EDM_LOGE(MODULE_PKG_MGR, "Insert store_ is  nullptr");
100         return PKG_RDB_NO_INIT;
101     }
102     int64_t outRowId = 0;
103     int32_t ret = store_->Insert(outRowId, PKG_TABLE_NAME, insertValues);
104     EDM_LOGI(MODULE_PKG_MGR, "Insert id=%{public}" PRIu64 "", outRowId);
105     if (ret != OHOS::NativeRdb::E_OK) {
106         EDM_LOGE(MODULE_PKG_MGR, "Insert ret :%{public}d", ret);
107         return PKG_RDB_EXECUTE_FAILTURE;
108     }
109     return outRowId;
110 }
111 
Update(int32_t & changedRows,const OHOS::NativeRdb::ValuesBucket & values,const OHOS::NativeRdb::RdbPredicates & predicates)112 int32_t PkgDataBase::Update(
113     int32_t &changedRows, const OHOS::NativeRdb::ValuesBucket &values, const OHOS::NativeRdb::RdbPredicates &predicates)
114 {
115     if (store_ == nullptr) {
116         EDM_LOGE(MODULE_PKG_MGR, "Update(RdbPredicates) store_ is nullptr");
117         return PKG_RDB_NO_INIT;
118     }
119     int32_t ret = store_->Update(changedRows, values, predicates);
120     if (ret != OHOS::NativeRdb::E_OK) {
121         EDM_LOGE(MODULE_PKG_MGR, "Update(RdbPredicates) ret :%{public}d", ret);
122         return PKG_RDB_EXECUTE_FAILTURE;
123     }
124     return PKG_OK;
125 }
126 
Update(int32_t & changedRows,const OHOS::NativeRdb::ValuesBucket & values,const std::string & whereClause,const std::vector<std::string> & whereArgs)127 int32_t PkgDataBase::Update(int32_t &changedRows, const OHOS::NativeRdb::ValuesBucket &values,
128     const std::string &whereClause, const std::vector<std::string> &whereArgs)
129 {
130     if (store_ == nullptr) {
131         EDM_LOGE(MODULE_PKG_MGR, "Update(whereClause) store_ is nullptr");
132         return PKG_RDB_NO_INIT;
133     }
134     int32_t ret = store_->Update(changedRows, PKG_TABLE_NAME, values, whereClause, whereArgs);
135     if (ret != OHOS::NativeRdb::E_OK) {
136         EDM_LOGE(MODULE_PKG_MGR, "Update(whereClause) ret :%{public}d", ret);
137         return PKG_RDB_EXECUTE_FAILTURE;
138     }
139     return PKG_OK;
140 }
141 
Delete(int32_t & changedRows,const std::string & whereClause,const std::vector<std::string> & whereArgs)142 int32_t PkgDataBase::Delete(
143     int32_t &changedRows, const std::string &whereClause, const std::vector<std::string> &whereArgs)
144 {
145     if (store_ == nullptr) {
146         EDM_LOGE(MODULE_PKG_MGR, "Delete store_ is nullptr");
147         return PKG_RDB_NO_INIT;
148     }
149     int32_t ret = store_->Delete(changedRows, PKG_TABLE_NAME, whereClause, whereArgs);
150     if (ret != OHOS::NativeRdb::E_OK) {
151         EDM_LOGE(MODULE_PKG_MGR, "Delete(whereClause) ret :%{public}d", ret);
152         return PKG_RDB_EXECUTE_FAILTURE;
153     }
154     return PKG_OK;
155 }
156 
Query(const OHOS::NativeRdb::AbsRdbPredicates & predicates,const std::vector<std::string> & columns)157 std::shared_ptr<OHOS::NativeRdb::ResultSet> PkgDataBase::Query(
158     const OHOS::NativeRdb::AbsRdbPredicates &predicates, const std::vector<std::string> &columns)
159 {
160     if (store_ == nullptr) {
161         EDM_LOGE(MODULE_PKG_MGR, "Query(AbsRdbPredicates) store_ is nullptr");
162         return nullptr;
163     }
164     return store_->Query(predicates, columns);
165 }
166 
OnCreate(OHOS::NativeRdb::RdbStore & store)167 int32_t PkgDataBaseCallBack::OnCreate(OHOS::NativeRdb::RdbStore &store)
168 {
169     std::string sql = CREATE_PKG_TABLE;
170     int32_t ret = store.ExecuteSql(sql);
171     if (ret != OHOS::NativeRdb::E_OK) {
172         EDM_LOGE(MODULE_PKG_MGR, "OnCreate failed: %{public}d", ret);
173         return PKG_RDB_EXECUTE_FAILTURE;
174     }
175     EDM_LOGI(MODULE_PKG_MGR, "DB OnCreate Done: %{public}d", ret);
176     return PKG_OK;
177 }
178 
OnUpgrade(OHOS::NativeRdb::RdbStore & store,int32_t oldVersion,int32_t newVersion)179 int32_t PkgDataBaseCallBack::OnUpgrade(OHOS::NativeRdb::RdbStore &store, int32_t oldVersion, int32_t newVersion)
180 {
181     EDM_LOGI(MODULE_PKG_MGR, "DB OnUpgrade Enter");
182     (void)store;
183     (void)oldVersion;
184     (void)newVersion;
185     return PKG_OK;
186 }
187 
OnDowngrade(OHOS::NativeRdb::RdbStore & store,int32_t oldVersion,int32_t newVersion)188 int32_t PkgDataBaseCallBack::OnDowngrade(OHOS::NativeRdb::RdbStore &store, int32_t oldVersion, int32_t newVersion)
189 {
190     EDM_LOGI(MODULE_PKG_MGR, "DB OnDowngrade Enter");
191     (void)store;
192     (void)oldVersion;
193     (void)newVersion;
194     return PKG_OK;
195 }
196 } // namespace USB
197 } // namespace OHOS
198