1 /*
2  * Copyright (C) 2023-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 permissions and
13  * limitations under the License.
14  */
15 
16 #include "call_earthquake_alarm_subscriber.h"
17 
18 using namespace OHOS::AAFwk;
19 namespace OHOS {
20 namespace Telephony {
21 const std::string LocationSubscriber::SWITCH_STATE_CHANGE_EVENTS = "usual.event.EMERGENCY_WARNINGS_SWITCH_STATE_CHANGE";
22 const std::string LocationSubscriber::SWITCH_STATE_START = "true";
23 const std::string LocationSubscriber::SWITCH_STATE_STOP = "false";
24 const std::string LocationSubscriber::SWITCH_STATE = "switchState";
25 const std::string LocationSubscriber::SWITCH_STATE_KEY = "auto_send_earthquake_alarm_switch";
26 std::shared_ptr<LocationSubscriber> LocationSubscriber::subscriber_ = nullptr;
27 sptr<ISystemAbilityStatusChange> LocationSystemAbilityListener::statusChangeListener_ = nullptr;
28 const int DataShareSwitchState::INVALID_VALUE = -1;
29 const int DataShareSwitchState::TELEPHONY_SUCCESS = 0;
30 constexpr const char *SETTINGS_DATASHARE_URI =
31     "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
32 constexpr const char *SETTINGS_DATASHARE_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
33 constexpr const char *SETTINGS_DATA_COLUMN_KEYWORD = "KEYWORD";
34 constexpr const char *SETTINGS_DATA_COLUMN_VALUE = "VALUE";
35 
LocationSubscriber(const EventFwk::CommonEventSubscribeInfo & subscriberInfo)36 LocationSubscriber::LocationSubscriber(const EventFwk::CommonEventSubscribeInfo &subscriberInfo)
37     : EventFwk::CommonEventSubscriber(subscriberInfo) {}
38 
Subscriber(void)39 bool LocationSubscriber::Subscriber(void)
40 {
41     if (LocationSubscriber::subscriber_ == nullptr) {
42         EventFwk::MatchingSkills matchingSkills;
43         matchingSkills.AddEvent(LocationSubscriber::SWITCH_STATE_CHANGE_EVENTS);
44         EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills);
45         subscribeInfo.SetPermission("ohos.permission.ATTEST_KEY");
46         LocationSubscriber::subscriber_ = std::make_shared<LocationSubscriber>(subscribeInfo);
47         EventFwk::CommonEventManager::SubscribeCommonEvent(LocationSubscriber::subscriber_);
48     }
49     TELEPHONY_LOGI("create subscribe commonEvent");
50     return true;
51 }
52 
OnReceiveEvent(const EventFwk::CommonEventData & eventData)53 void LocationSubscriber::OnReceiveEvent(const EventFwk::CommonEventData &eventData)
54 {
55     const AAFwk::Want &want = eventData.GetWant();
56     std::string action = want.GetAction();
57     std::string switchState = want.GetStringParam(LocationSubscriber::SWITCH_STATE);
58 
59     if (action == LocationSubscriber::SWITCH_STATE_CHANGE_EVENTS) {
60         if (switchState == LocationSubscriber::SWITCH_STATE_START) {
61             TELEPHONY_LOGI("start location listen");
62             MyLocationEngine::GetInstance()->SetValue();
63             MyLocationEngine::GetInstance()->RegisterLocationChange();
64             MyLocationEngine::GetInstance()->RegisterSwitchCallback();
65         };
66         if (switchState == LocationSubscriber::SWITCH_STATE_STOP) {
67             TELEPHONY_LOGI("stop location listen");
68             MyLocationEngine::GetInstance()->UnregisterLocationChange();
69             MyLocationEngine::GetInstance()->UnRegisterSwitchCallback();
70             MyLocationEngine::GetInstance()->OnInit();
71         };
72     };
73 }
74 
DataShareSwitchState()75 DataShareSwitchState::DataShareSwitchState()
76 {
77     datashareHelper_ = CreateDataShareHelper(OHOS::TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
78 }
79 
CreateDataShareHelper(int systemAbilityId)80 std::shared_ptr<DataShare::DataShareHelper> DataShareSwitchState::CreateDataShareHelper(int systemAbilityId)
81 {
82     sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
83     if (saManager == nullptr) {
84         TELEPHONY_LOGE("get SA manager failed");
85         return nullptr;
86     }
87     sptr<IRemoteObject> remote = saManager->GetSystemAbility(systemAbilityId);
88     if (remote == nullptr) {
89         TELEPHONY_LOGE("get SA failed");
90         return nullptr;
91     }
92     return DataShare::DataShareHelper::Creator(remote, SETTINGS_DATASHARE_URI, SETTINGS_DATASHARE_EXT_URI);
93 }
94 
QueryData(Uri & uri,const std::string & key,std::string & value)95 int32_t DataShareSwitchState::QueryData(Uri& uri, const std::string& key, std::string& value)
96 {
97     if (datashareHelper_ == nullptr) {
98         TELEPHONY_LOGE("query error, datashareHelper_ is nullptr");
99         return INVALID_VALUE;
100     }
101     std::vector<std::string> columns;
102     DataShare::DataSharePredicates predicates;
103     predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
104     auto result = datashareHelper_->Query(uri, predicates, columns);
105     datashareHelper_->Release();
106     if (result == nullptr) {
107         TELEPHONY_LOGE("query error, result is nullptr");
108         return INVALID_VALUE;
109     }
110     int rowCount = 0;
111     result->GetRowCount(rowCount);
112     if (rowCount == 0) {
113         TELEPHONY_LOGI("query success, but rowCount is 0");
114         result->Close();
115         return INVALID_VALUE;
116     }
117     if (result->GoToFirstRow() != DataShare::E_OK) {
118         TELEPHONY_LOGE("query error, go to first row error");
119         result->Close();
120         return INVALID_VALUE;
121     }
122     int columnIndex = 0;
123     result->GetColumnIndex(SETTINGS_DATA_COLUMN_VALUE, columnIndex);
124     result->GetString(columnIndex, value);
125     result->Close();
126     TELEPHONY_LOGI("query success");
127     return TELEPHONY_SUCCESS;
128 }
129 
RegisterListenSettingsKey(std::string key,bool isReg,sptr<AAFwk::IDataAbilityObserver> callback)130 bool DataShareSwitchState::RegisterListenSettingsKey(std::string key, bool isReg,
131     sptr<AAFwk::IDataAbilityObserver> callback)
132 {
133     if (datashareHelper_ == nullptr) {
134         TELEPHONY_LOGE("datashareHelper is nullptr");
135         return false;
136     }
137     if (callback == nullptr) {
138         TELEPHONY_LOGE("callback is nullptr");
139         return false;
140     }
141     std::string uri = DEFAULT_URI + key;
142     if (isReg) {
143         TELEPHONY_LOGI("register listen %{public}s finish", key.c_str());
144         datashareHelper_->RegisterObserver(OHOS::Uri(uri), callback);
145     } else {
146         TELEPHONY_LOGI("unregister listen %{public}s finish", key.c_str());
147         datashareHelper_->UnregisterObserver(OHOS::Uri(uri), callback);
148     }
149     datashareHelper_->Release();
150     return true;
151 }
152 
153 std::map<int32_t, bool> LocationSystemAbilityListener::systemAbilityStatus = {
154     {OHOS::DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, false},
155     {OHOS::LOCATION_LOCATOR_SA_ID, false},
156     {OHOS::LOCATION_NOPOWER_LOCATING_SA_ID, false}
157 };
158 
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)159 void LocationSystemAbilityListener::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
160 {
161     std::lock_guard<std::mutex> lock(mutex_);
162     if (startService) {
163         TELEPHONY_LOGE("service alredy started");
164         return;
165     }
166     if (systemAbilityId != OHOS::DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID &&
167         systemAbilityId != OHOS::LOCATION_LOCATOR_SA_ID &&
168         systemAbilityId != OHOS::LOCATION_NOPOWER_LOCATING_SA_ID) {
169         TELEPHONY_LOGE("add other SA failed, id = %{public}d", systemAbilityId);
170         return;
171     };
172     TELEPHONY_LOGI("added SA success, id = %{public}d", systemAbilityId);
173     systemAbilityStatus[systemAbilityId] = GetSystemAbility(systemAbilityId);
174     for (auto& systemId : systemAbilityStatus) {
175         if (!systemId.second) {
176             TELEPHONY_LOGE("SA id %{public}d, status is false", systemId.first);
177             return;
178         }
179     }
180     startService = true;
181     std::string stateValue = MyLocationEngine::INITIAL_FIRST_VALUE;
182     auto alarmSwitchState = MyLocationEngine::IsSwitchOn(LocationSubscriber::SWITCH_STATE_KEY, stateValue);
183     if (stateValue == MyLocationEngine::INITIAL_FIRST_VALUE) {
184         TELEPHONY_LOGI("start OOBE complete");
185         MyLocationEngine::OOBEComplete();
186     } else {
187         TELEPHONY_LOGI("start boot complete");
188         MyLocationEngine::BootComplete(alarmSwitchState);
189     }
190     SystemAbilitySubscriber();
191     statusChangeListener_ = nullptr;
192 }
193 
GetSystemAbility(int32_t systemAbilityId)194 bool LocationSystemAbilityListener::GetSystemAbility(int32_t systemAbilityId)
195 {
196     sptr<ISystemAbilityManager> sysAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
197     if (sysAbilityMgr == nullptr) {
198         TELEPHONY_LOGE("SA manager is nullptr");
199         return false;
200     }
201     sptr<IRemoteObject> remote = sysAbilityMgr->GetSystemAbility(systemAbilityId);
202     if (remote == nullptr) {
203         TELEPHONY_LOGE("get SA %{public}d failed", systemAbilityId);
204         return false;
205     }
206     TELEPHONY_LOGI("get SA %{public}d success", systemAbilityId);
207     return true;
208 }
209 
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)210 void LocationSystemAbilityListener::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
211 {
212     TELEPHONY_LOGI("remove SA %{public}d", systemAbilityId);
213 }
214 
SystemAbilitySubscriber()215 bool LocationSystemAbilityListener::SystemAbilitySubscriber()
216 {
217     if (statusChangeListener_ == nullptr) {
218         statusChangeListener_ = sptr<LocationSystemAbilityListener>::MakeSptr();
219     }
220     auto managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
221     if (managerPtr == nullptr) {
222         TELEPHONY_LOGE("get SA manager error");
223         return false;
224     }
225     int32_t ret = -1;
226     for (auto& systemId : systemAbilityStatus) {
227         if (!systemId.second) {
228             ret = managerPtr->SubscribeSystemAbility(systemId.first, statusChangeListener_);
229         } else {
230             ret = managerPtr->UnSubscribeSystemAbility(systemId.first, statusChangeListener_);
231         }
232         std::string isSub = systemId.second ? "unsubscribe" : "subscribe";
233         TELEPHONY_LOGI("%{public}s SA %{public}d ret code is %{public}d", isSub.c_str(), systemId.first, ret);
234     }
235     return true;
236 }
237 
238 } // namespace Telephony
239 } // namespace OHOS