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 "global_params_ability.h"
17
18 #include "ability_context.h"
19 #include "ability_loader.h"
20 #include "abs_rdb_predicates.h"
21 #include "abs_shared_result_set.h"
22 #include "data_storage_errors.h"
23 #include "data_storage_log_wrapper.h"
24 #include "datashare_ext_ability.h"
25 #include "datashare_predicates.h"
26 #include "new"
27 #include "global_params_data.h"
28 #include "permission_util.h"
29 #include "rdb_errno.h"
30 #include "rdb_utils.h"
31 #include "telephony_datashare_stub_impl.h"
32 #include "uri.h"
33
34 namespace OHOS {
35 using AppExecFwk::AbilityLoader;
36 using AppExecFwk::Ability;
37 namespace Telephony {
38 static const std::map<std::string, GlobalParamsUriType> g_globalParamsTypeMap = {
39 {"/globalparams/num_matchs", GlobalParamsUriType::NUMBER_MATCHS},
40 {"/globalparams/ecc_data", GlobalParamsUriType::ECC_LIST},
41 };
42
GlobalParamsAbility()43 GlobalParamsAbility::GlobalParamsAbility() : DataShareExtAbility() {}
44
~GlobalParamsAbility()45 GlobalParamsAbility::~GlobalParamsAbility() {}
46
Create()47 GlobalParamsAbility* GlobalParamsAbility::Create()
48 {
49 DATA_STORAGE_LOGD("GlobalParamsAbility::Create begin.");
50 auto self = new GlobalParamsAbility();
51 self->DoInit();
52 return self;
53 }
54
DoInit()55 void GlobalParamsAbility::DoInit()
56 {
57 if (initDatabaseDir_ && initRdbStore_) {
58 DATA_STORAGE_LOGI("DoInit has done.");
59 return;
60 }
61 auto abilityContext = AbilityRuntime::Context::GetApplicationContext();
62 if (abilityContext == nullptr) {
63 DATA_STORAGE_LOGE("abilityContext is nullptr.");
64 return;
65 }
66 // switch database dir to el1 for init before unlock
67 abilityContext->SwitchArea(0);
68 std::string path = abilityContext->GetDatabaseDir();
69 if (!path.empty()) {
70 initDatabaseDir_ = true;
71 path.append("/");
72 helper_.UpdateDbPath(path);
73 if (helper_.Init() == NativeRdb::E_OK) {
74 initRdbStore_ = true;
75 } else {
76 DATA_STORAGE_LOGE("DoInit rdb init fail!");
77 initRdbStore_ = false;
78 }
79 } else {
80 DATA_STORAGE_LOGE("path is empty");
81 initDatabaseDir_ = false;
82 }
83 }
84
OnConnect(const AAFwk::Want & want)85 sptr<IRemoteObject> GlobalParamsAbility::OnConnect(const AAFwk::Want &want)
86 {
87 DATA_STORAGE_LOGI("GlobalParamsAbility %{public}s begin.", __func__);
88 Extension::OnConnect(want);
89 sptr<DataShare::TelephonyDataShareStubImpl> remoteObject =
90 new (std::nothrow) DataShare::TelephonyDataShareStubImpl();
91 if (remoteObject == nullptr) {
92 DATA_STORAGE_LOGE("%{public}s No memory allocated for DataShareStubImpl", __func__);
93 return nullptr;
94 }
95 remoteObject->SetGlobalParamsAbility(std::static_pointer_cast<GlobalParamsAbility>(shared_from_this()));
96 DATA_STORAGE_LOGI("GlobalParamsAbility %{public}s end.", __func__);
97 return remoteObject->AsObject();
98 }
99
OnStart(const AppExecFwk::Want & want)100 void GlobalParamsAbility::OnStart(const AppExecFwk::Want &want)
101 {
102 DATA_STORAGE_LOGI("GlobalParamsAbility::OnStart");
103 Extension::OnStart(want);
104 DoInit();
105 }
106
Insert(const Uri & uri,const DataShare::DataShareValuesBucket & value)107 int32_t GlobalParamsAbility::Insert(const Uri &uri, const DataShare::DataShareValuesBucket &value)
108 {
109 if (!PermissionUtil::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
110 DATA_STORAGE_LOGE("Permission denied!");
111 return DATA_STORAGE_ERR_PERMISSION_ERR;
112 }
113 if (!IsInitOk()) {
114 return DATA_STORAGE_ERROR;
115 }
116 DATA_STORAGE_LOGE("GlobalParamsAbility::The insert capability is not supported.");
117 return DATA_STORAGE_ERROR;
118 }
119
Query(const Uri & uri,const DataShare::DataSharePredicates & predicates,std::vector<std::string> & columns,DataShare::DatashareBusinessError & businessError)120 std::shared_ptr<DataShare::DataShareResultSet> GlobalParamsAbility::Query(const Uri &uri,
121 const DataShare::DataSharePredicates &predicates, std::vector<std::string> &columns,
122 DataShare::DatashareBusinessError &businessError)
123 {
124 if (!PermissionUtil::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
125 DATA_STORAGE_LOGE("Permission denied!");
126 return nullptr;
127 }
128 std::shared_ptr<DataShare::DataShareResultSet> sharedPtrResult = nullptr;
129 if (!IsInitOk()) {
130 return nullptr;
131 }
132 Uri tempUri = uri;
133 GlobalParamsUriType globalParamsUriType = ParseUriType(tempUri);
134 NativeRdb::AbsRdbPredicates *absRdbPredicates = nullptr;
135 switch (globalParamsUriType) {
136 case GlobalParamsUriType::NUMBER_MATCHS: {
137 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_NUMBER_MATCH);
138 break;
139 }
140 case GlobalParamsUriType::ECC_LIST: {
141 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_ECC_DATA);
142 break;
143 }
144 default:
145 DATA_STORAGE_LOGE("GlobalParamsAbility::Query failed##uri = %{public}s", uri.ToString().c_str());
146 break;
147 }
148 if (absRdbPredicates != nullptr) {
149 NativeRdb::RdbPredicates rdbPredicates = ConvertPredicates(absRdbPredicates->GetTableName(), predicates);
150 auto result = helper_.Query(rdbPredicates, columns);
151 if (result == nullptr) {
152 DATA_STORAGE_LOGE("GlobalParamsAbility::Query NativeRdb::ResultSet is null!");
153 delete absRdbPredicates;
154 absRdbPredicates = nullptr;
155 return nullptr;
156 }
157 auto queryResultSet = RdbDataShareAdapter::RdbUtils::ToResultSetBridge(result);
158 sharedPtrResult = std::make_shared<DataShare::DataShareResultSet>(queryResultSet);
159 delete absRdbPredicates;
160 absRdbPredicates = nullptr;
161 } else {
162 DATA_STORAGE_LOGE("GlobalParamsAbility::Query##uri = %{public}s", uri.ToString().c_str());
163 }
164 return sharedPtrResult;
165 }
166
Update(const Uri & uri,const DataShare::DataSharePredicates & predicates,const DataShare::DataShareValuesBucket & value)167 int GlobalParamsAbility::Update(
168 const Uri &uri, const DataShare::DataSharePredicates &predicates,
169 const DataShare::DataShareValuesBucket &value)
170 {
171 if (!PermissionUtil::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
172 DATA_STORAGE_LOGE("Permission denied!");
173 return DATA_STORAGE_ERR_PERMISSION_ERR;
174 }
175 int result = DATA_STORAGE_ERROR;
176 if (!IsInitOk()) {
177 return result;
178 }
179 DATA_STORAGE_LOGE("GlobalParamsAbility::The update capability is not supported.");
180 return result;
181 }
182
Delete(const Uri & uri,const DataShare::DataSharePredicates & predicates)183 int GlobalParamsAbility::Delete(const Uri &uri, const DataShare::DataSharePredicates &predicates)
184 {
185 if (!PermissionUtil::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
186 DATA_STORAGE_LOGE("Permission denied!");
187 return DATA_STORAGE_ERR_PERMISSION_ERR;
188 }
189 int result = DATA_STORAGE_ERROR;
190 if (!IsInitOk()) {
191 return result;
192 }
193 DATA_STORAGE_LOGE("GlobalParamsAbility::The delete capability is not supported.");
194 return result;
195 }
196
IsInitOk()197 bool GlobalParamsAbility::IsInitOk()
198 {
199 if (!initDatabaseDir_) {
200 DATA_STORAGE_LOGE("GlobalParamsAbility::IsInitOk initDatabaseDir_ failed!");
201 return false;
202 }
203 if (!initRdbStore_) {
204 DATA_STORAGE_LOGE("GlobalParamsAbility::IsInitOk initRdbStore_ failed!");
205 return false;
206 }
207 return true;
208 }
209
GetType(const Uri & uri)210 std::string GlobalParamsAbility::GetType(const Uri &uri)
211 {
212 DATA_STORAGE_LOGI("GlobalParamsAbility::GetType##uri = %{public}s", uri.ToString().c_str());
213 std::string retval(uri.ToString());
214 return retval;
215 }
216
OpenFile(const Uri & uri,const std::string & mode)217 int GlobalParamsAbility::OpenFile(const Uri &uri, const std::string &mode)
218 {
219 DATA_STORAGE_LOGI("GlobalParamsAbility::OpenFile##uri = %{public}s", uri.ToString().c_str());
220 Uri tempUri = uri;
221 GlobalParamsUriType globalParamsUriType = ParseUriType(tempUri);
222 return static_cast<int>(globalParamsUriType);
223 }
224
ParseUriType(Uri & uri)225 GlobalParamsUriType GlobalParamsAbility::ParseUriType(Uri &uri)
226 {
227 DATA_STORAGE_LOGD("GlobalParamsAbility::ParseUriType start");
228 GlobalParamsUriType globalParamsUriType = GlobalParamsUriType::UNKNOW;
229 std::string uriPath = uri.ToString();
230 if (!uriPath.empty()) {
231 helper_.ReplaceAllStr(uriPath, ":///", "://");
232 Uri tempUri(uriPath);
233 std::string path = tempUri.GetPath();
234 if (!path.empty() && !g_globalParamsTypeMap.empty()) {
235 auto it = g_globalParamsTypeMap.find(path);
236 if (it != g_globalParamsTypeMap.end()) {
237 globalParamsUriType = it->second;
238 DATA_STORAGE_LOGD(
239 "GlobalParamsAbility::ParseUriType##globalParamsUriType = %{public}d", globalParamsUriType);
240 }
241 }
242 }
243 return globalParamsUriType;
244 }
245
ConvertPredicates(const std::string & tableName,const DataShare::DataSharePredicates & predicates)246 OHOS::NativeRdb::RdbPredicates GlobalParamsAbility::ConvertPredicates(
247 const std::string &tableName, const DataShare::DataSharePredicates &predicates)
248 {
249 OHOS::NativeRdb::RdbPredicates res = RdbDataShareAdapter::RdbUtils::ToPredicates(predicates, tableName);
250 return res;
251 }
252 } // namespace Telephony
253 } // namespace OHOS
254