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 const int DataShareSwitchState::TELEPHONY_ERR_LOCAL_PTR_NULL = 1;
31 const int DataShareSwitchState::TELEPHONY_ERR_DATABASE_READ_FAIL = 2;
32 const int DataShareSwitchState::TELEPHONY_ERR_DATABASE_WRITE_FAIL = 3;
33 const int DataShareSwitchState::COW_COUNT_NULL = 4;
34 constexpr const char *SETTINGS_DATASHARE_URI =
35 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
36 constexpr const char *SETTINGS_DATASHARE_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
37 constexpr const char *SETTINGS_DATA_COLUMN_KEYWORD = "KEYWORD";
38 constexpr const char *SETTINGS_DATA_COLUMN_VALUE = "VALUE";
39
LocationSubscriber(const EventFwk::CommonEventSubscribeInfo & subscriberInfo)40 LocationSubscriber::LocationSubscriber(const EventFwk::CommonEventSubscribeInfo &subscriberInfo)
41 : EventFwk::CommonEventSubscriber(subscriberInfo) {}
42
Subscriber(void)43 bool LocationSubscriber::Subscriber(void)
44 {
45 if (LocationSubscriber::subscriber_ == nullptr) {
46 EventFwk::MatchingSkills matchingSkills;
47 matchingSkills.AddEvent(LocationSubscriber::SWITCH_STATE_CHANGE_EVENTS);
48 EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills);
49 subscribeInfo.SetPermission("ohos.permission.ATTEST_KEY");
50 LocationSubscriber::subscriber_ = std::make_shared<LocationSubscriber>(subscribeInfo);
51 EventFwk::CommonEventManager::SubscribeCommonEvent(LocationSubscriber::subscriber_);
52 }
53 TELEPHONY_LOGI("create SubscribeCommonEvent LocationSubscriber");
54 return true;
55 }
56
OnReceiveEvent(const EventFwk::CommonEventData & eventData)57 void LocationSubscriber::OnReceiveEvent(const EventFwk::CommonEventData &eventData)
58 {
59 const AAFwk::Want &want = eventData.GetWant();
60 std::string action = want.GetAction();
61 std::string switchState = want.GetStringParam(LocationSubscriber::SWITCH_STATE);
62
63 if (action == LocationSubscriber::SWITCH_STATE_CHANGE_EVENTS) {
64 auto engine = MyLocationEngine::GetInstance();
65 if (engine == nullptr) {
66 TELEPHONY_LOGI("engine == nullptr LocationSubscriber");
67 return;
68 }
69 if (switchState == LocationSubscriber::SWITCH_STATE_START) {
70 TELEPHONY_LOGI("start location LocationSubscriber");
71 engine->SetValue();
72 engine->RegisterLocationChange();
73 engine->RegisterSwitchCallback();
74 };
75 if (switchState == LocationSubscriber::SWITCH_STATE_STOP) {
76 TELEPHONY_LOGI("stop location LocationSubscriber");
77 engine->UnregisterLocationChange();
78 engine->UnRegisterSwitchCallback();
79 engine->OnInit();
80 };
81 };
82 }
83
DataShareSwitchState()84 DataShareSwitchState::DataShareSwitchState()
85 {
86 datashareHelper_ = CreateDataShareHelper(OHOS::DEVICE_STANDBY_SERVICE_SYSTEM_ABILITY_ID);
87 }
88
CreateDataShareHelper(int systemAbilityId)89 std::shared_ptr<DataShare::DataShareHelper> DataShareSwitchState::CreateDataShareHelper(int systemAbilityId)
90 {
91 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
92 if (saManager == nullptr) {
93 TELEPHONY_LOGE("DataShareSwitchState failed.");
94 return nullptr;
95 }
96 sptr<IRemoteObject> remote = saManager->GetSystemAbility(systemAbilityId);
97 if (remote == nullptr) {
98 TELEPHONY_LOGE("DataShareSwitchState Service Failed.");
99 return nullptr;
100 }
101 return DataShare::DataShareHelper::Creator(remote, SETTINGS_DATASHARE_URI, SETTINGS_DATASHARE_EXT_URI);
102 }
103
QueryData(Uri & uri,const std::string & key,std::string & value)104 int32_t DataShareSwitchState::QueryData(Uri& uri, const std::string& key, std::string& value)
105 {
106 if (datashareHelper_ == nullptr) {
107 TELEPHONY_LOGE("DataShareSwitchState query error, datashareHelper_ is nullptr");
108 return DataShareSwitchState::TELEPHONY_ERR_LOCAL_PTR_NULL;
109 }
110 std::vector<std::string> columns;
111 DataShare::DataSharePredicates predicates;
112 predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
113 auto result = datashareHelper_->Query(uri, predicates, columns);
114 if (result == nullptr) {
115 TELEPHONY_LOGE("DataShareSwitchState query error, result is nullptr");
116 return DataShareSwitchState::TELEPHONY_ERR_LOCAL_PTR_NULL;
117 }
118
119 int rowCount = 0;
120 result->GetRowCount(rowCount);
121 if (rowCount == 0) {
122 TELEPHONY_LOGI("DataShareSwitchState query success, but rowCount is 0");
123 return DataShareSwitchState::COW_COUNT_NULL;
124 }
125
126 if (result->GoToFirstRow() != DataShare::E_OK) {
127 TELEPHONY_LOGE("DataShareSwitchState query error, go to first row error");
128 result->Close();
129 return DataShareSwitchState::TELEPHONY_ERR_DATABASE_READ_FAIL;
130 }
131 int columnIndex = 0;
132 result->GetColumnIndex(SETTINGS_DATA_COLUMN_VALUE, columnIndex);
133 result->GetString(columnIndex, value);
134 result->Close();
135 datashareHelper_->Release();
136 TELEPHONY_LOGI("DataShareSwitchState query success");
137 return DataShareSwitchState::TELEPHONY_SUCCESS;
138 }
139
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)140 void LocationSystemAbilityListener::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
141 {
142 static int firstboot = 0;
143 TELEPHONY_LOGI("location service are add LocationSubscriber systemID = %{public}d", systemAbilityId);
144 if (!CheckInputSysAbilityId(systemAbilityId)) {
145 TELEPHONY_LOGE("added SA is invalid! LocationSubscriber");
146 return;
147 }
148 if (systemAbilityId != OHOS::DEVICE_STANDBY_SERVICE_SYSTEM_ABILITY_ID &&
149 systemAbilityId != OHOS::LOCATION_LOCATOR_SA_ID &&
150 systemAbilityId != OHOS::LOCATION_NOPOWER_LOCATING_SA_ID) {
151 TELEPHONY_LOGI("location service are add LocationSubscriber systemID = %{public}d", systemAbilityId);
152 return;
153 }
154 if (!GetSystemAbility(OHOS::DEVICE_STANDBY_SERVICE_SYSTEM_ABILITY_ID)) return;
155 if (!GetSystemAbility(OHOS::LOCATION_LOCATOR_SA_ID)) return;
156 if (!GetSystemAbility(OHOS::LOCATION_NOPOWER_LOCATING_SA_ID)) return;
157 if (firstboot == 0) {
158 MyLocationEngine::BootComplete();
159 firstboot++;
160 TELEPHONY_LOGI("first boot LocationSubscriber");
161 }
162 }
163
GetSystemAbility(int32_t systemAbilityId)164 bool LocationSystemAbilityListener::GetSystemAbility(int32_t systemAbilityId)
165 {
166 sptr<ISystemAbilityManager> sysAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
167 if (sysAbilityMgr == nullptr) {
168 TELEPHONY_LOGE("system ability manager is nullptr. LocationSubscriber");
169 return false;
170 }
171 sptr<IRemoteObject> remote = sysAbilityMgr->GetSystemAbility(systemAbilityId);
172 if (remote == nullptr) {
173 TELEPHONY_LOGE("check systemAbilityId return is nullptr. LocationSubscriber %{public}d", systemAbilityId);
174 return false;
175 }
176 TELEPHONY_LOGE("check systemAbilityId return is not nullptr. LocationSubscriber %{public}d", systemAbilityId);
177 return true;
178 }
179
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)180 void LocationSystemAbilityListener::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
181 {
182 TELEPHONY_LOGI("location service are remove LocationSubscriber systemID = %{public}d", systemAbilityId);
183 GetSystemAbility(OHOS::DEVICE_STANDBY_SERVICE_SYSTEM_ABILITY_ID);
184 GetSystemAbility(OHOS::LOCATION_LOCATOR_SA_ID);
185 GetSystemAbility(OHOS::LOCATION_NOPOWER_LOCATING_SA_ID);
186 }
187
SystemAbilitySubscriber()188 bool LocationSystemAbilityListener::SystemAbilitySubscriber()
189 {
190 statusChangeListener_ = new (std::nothrow) LocationSystemAbilityListener();
191 if (statusChangeListener_ == nullptr) {
192 TELEPHONY_LOGI("failed to create statusChangeListener LocationSubscriber");
193 return false;
194 }
195 auto managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
196 if (managerPtr == nullptr) {
197 TELEPHONY_LOGE("get system ability manager error LocationSubscriber");
198 return false;
199 }
200 int32_t ret1 = managerPtr->SubscribeSystemAbility(OHOS::DEVICE_STANDBY_SERVICE_SYSTEM_ABILITY_ID,
201 statusChangeListener_);
202 if (ret1 != TELEPHONY_SUCCESS) {
203 TELEPHONY_LOGE("failed to subscribe 1914 service SA!");
204 }
205 TELEPHONY_LOGE("success to subscribe 1914 service SA! LocationSubscriber");
206 int32_t ret2 = managerPtr->SubscribeSystemAbility(OHOS::LOCATION_LOCATOR_SA_ID, statusChangeListener_);
207 if (ret2 != TELEPHONY_SUCCESS) {
208 TELEPHONY_LOGE("failed to subscribe 2802 service SA!");
209 }
210 TELEPHONY_LOGE("success to subscribe 2802 service SA! LocationSubscriber");
211 int32_t ret3 = managerPtr->SubscribeSystemAbility(OHOS::LOCATION_NOPOWER_LOCATING_SA_ID, statusChangeListener_);
212 if (ret3 != TELEPHONY_SUCCESS) {
213 TELEPHONY_LOGE("failed to subscribe 2805 service SA!");
214 }
215 TELEPHONY_LOGE("success to subscribe 2805 service SA! LocationSubscriber");
216 return true;
217 }
218 } // namespace Telephony
219 } // namespace OHOS