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
34namespace OHOS {
35using AppExecFwk::AbilityLoader;
36using AppExecFwk::Ability;
37namespace Telephony {
38static const std::map<std::string, GlobalParamsUriType> g_globalParamsTypeMap = {
39    {"/globalparams/num_matchs", GlobalParamsUriType::NUMBER_MATCHS},
40    {"/globalparams/ecc_data", GlobalParamsUriType::ECC_LIST},
41};
42
43GlobalParamsAbility::GlobalParamsAbility() : DataShareExtAbility() {}
44
45GlobalParamsAbility::~GlobalParamsAbility() {}
46
47GlobalParamsAbility* GlobalParamsAbility::Create()
48{
49    DATA_STORAGE_LOGD("GlobalParamsAbility::Create begin.");
50    auto self = new GlobalParamsAbility();
51    self->DoInit();
52    return self;
53}
54
55void 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
85sptr<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
100void GlobalParamsAbility::OnStart(const AppExecFwk::Want &want)
101{
102    DATA_STORAGE_LOGI("GlobalParamsAbility::OnStart");
103    Extension::OnStart(want);
104    DoInit();
105}
106
107int32_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
120std::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
167int 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
183int 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
197bool 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
210std::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
217int 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
225GlobalParamsUriType 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
246OHOS::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