1 /*
2  * Copyright (C) 2021-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 "telephony_state_registry_service.h"
17 
18 #include <sstream>
19 #include <thread>
20 
21 #include "common_event_manager.h"
22 #include "common_event_support.h"
23 #include "iservice_registry.h"
24 #include "state_registry_errors.h"
25 #include "string_ex.h"
26 #include "system_ability.h"
27 #include "system_ability_definition.h"
28 #include "telephony_permission.h"
29 #include "telephony_state_manager.h"
30 #include "telephony_state_registry_dump_helper.h"
31 #include "telephony_types.h"
32 #include "telephony_ext_wrapper.h"
33 
34 namespace OHOS {
35 namespace Telephony {
36 using namespace OHOS::EventFwk;
37 bool g_registerResult =
38     SystemAbility::MakeAndRegisterAbility(DelayedSingleton<TelephonyStateRegistryService>::GetInstance().get());
39 
TelephonyStateRegistryService()40 TelephonyStateRegistryService::TelephonyStateRegistryService()
41     : SystemAbility(TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID, true)
42 {
43     slotSize_ = SIM_SLOT_COUNT;
44 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_VSIM
45     if (SIM_SLOT_COUNT == DUAL_SLOT_COUNT && VSIM_MODEM_COUNT == MAX_SLOT_COUNT) {
46         slotSize_ = MAX_SLOT_COUNT;
47     }
48 #endif
49     TELEPHONY_LOGI("TelephonyStateRegistryService SystemAbility create, slotSize_: %{public}d", slotSize_);
50     for (int32_t i = 0; i < slotSize_; i++) {
51         callState_[i] = static_cast<int32_t>(CallStatus::CALL_STATUS_UNKNOWN);
52     }
53 
54     // slotSize_ == 0 means wifionly product.
55     if (slotSize_ == 0) {
56         callState_[0] = static_cast<int32_t>(CallStatus::CALL_STATUS_UNKNOWN);
57     }
58     callState_[-1] = static_cast<int32_t>(CallStatus::CALL_STATUS_UNKNOWN);
59 }
60 
~TelephonyStateRegistryService()61 TelephonyStateRegistryService::~TelephonyStateRegistryService()
62 {
63     stateRecords_.clear();
64     callState_.clear();
65     callIncomingNumber_.clear();
66     signalInfos_.clear();
67     searchNetworkState_.clear();
68 }
69 
OnStart()70 void TelephonyStateRegistryService::OnStart()
71 {
72     bindStartTime_ =
73         std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
74             .count();
75     std::lock_guard<std::mutex> guard(lock_);
76     if (state_ == ServiceRunningState::STATE_RUNNING) {
77         TELEPHONY_LOGE("Leave, FAILED, already running");
78         return;
79     }
80     state_ = ServiceRunningState::STATE_RUNNING;
81     bool ret = SystemAbility::Publish(DelayedSingleton<TelephonyStateRegistryService>::GetInstance().get());
82     if (!ret) {
83         TELEPHONY_LOGE("Leave, Failed to publish TelephonyStateRegistryService");
84     }
85 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
86     TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
87 #endif
88     TELEPHONY_LOGI("TelephonyStateRegistryService start success.");
89     bindEndTime_ =
90         std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
91             .count();
92     std::thread task([&]() {
93         if (IsCommonEventServiceAbilityExist()) {
94             for (int32_t i = 0; i < slotSize_; i++) {
95                 TELEPHONY_LOGI("TelephonyStateRegistryService send disconnected call state.");
96                 SendCallStateChanged(i, static_cast<int32_t>(CallStatus::CALL_STATUS_DISCONNECTED));
97             }
98         }
99     });
100     pthread_setname_np(task.native_handle(), "state_registry_task");
101     task.detach();
102 }
103 
OnStop()104 void TelephonyStateRegistryService::OnStop()
105 {
106     TELEPHONY_LOGI("TelephonyStateRegistryService OnStop ");
107     std::lock_guard<std::mutex> guard(lock_);
108     state_ = ServiceRunningState::STATE_STOPPED;
109 }
110 
Finalize()111 void TelephonyStateRegistryService::Finalize()
112 {
113     TELEPHONY_LOGI("TelephonyStateRegistryService Finalize");
114 }
115 
OnDump()116 void TelephonyStateRegistryService::OnDump() {}
117 
UpdateCellularDataConnectState( int32_t slotId, int32_t dataState, int32_t networkType)118 int32_t TelephonyStateRegistryService::UpdateCellularDataConnectState(
119     int32_t slotId, int32_t dataState, int32_t networkType)
120 {
121     if (!VerifySlotId(slotId)) {
122         TELEPHONY_LOGE("UpdateCellularDataConnectState##VerifySlotId failed ##slotId = %{public}d", slotId);
123         return TELEPHONY_STATE_REGISTRY_SLODID_ERROR;
124     }
125     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
126         TELEPHONY_LOGE("Check permission failed.");
127         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
128     }
129     std::lock_guard<std::mutex> guard(lock_);
130     cellularDataConnectionState_[slotId] = dataState;
131     cellularDataConnectionNetworkType_[slotId] = networkType;
132     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
133     for (size_t i = 0; i < stateRecords_.size(); i++) {
134         TelephonyStateRegistryRecord record = stateRecords_[i];
135         if (record.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE) &&
136             (record.slotId_ == slotId) && record.telephonyObserver_ != nullptr) {
137             if (TELEPHONY_EXT_WRAPPER.onCellularDataConnectStateUpdated_ != nullptr) {
138                 int32_t networkTypeExt = networkType;
139                 TELEPHONY_EXT_WRAPPER.onCellularDataConnectStateUpdated_(slotId, record, networkTypeExt);
140                 record.telephonyObserver_->OnCellularDataConnectStateUpdated(slotId, dataState, networkTypeExt);
141             } else {
142                 record.telephonyObserver_->OnCellularDataConnectStateUpdated(slotId, dataState, networkType);
143             }
144             result = TELEPHONY_SUCCESS;
145         }
146     }
147     SendCellularDataConnectStateChanged(slotId, dataState, networkType);
148     return result;
149 }
150 
UpdateCellularDataFlow(int32_t slotId, int32_t flowData)151 int32_t TelephonyStateRegistryService::UpdateCellularDataFlow(int32_t slotId, int32_t flowData)
152 {
153     if (!VerifySlotId(slotId)) {
154         TELEPHONY_LOGE("UpdateCellularDataFlow##VerifySlotId failed ##slotId = %{public}d", slotId);
155         return TELEPHONY_STATE_REGISTRY_SLODID_ERROR;
156     }
157     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
158         TELEPHONY_LOGE("Check permission failed.");
159         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
160     }
161     std::lock_guard<std::mutex> guard(lock_);
162     cellularDataFlow_[slotId] = flowData;
163     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
164     for (size_t i = 0; i < stateRecords_.size(); i++) {
165         TelephonyStateRegistryRecord record = stateRecords_[i];
166         if (record.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW) &&
167             (record.slotId_ == slotId) && record.telephonyObserver_ != nullptr) {
168             record.telephonyObserver_->OnCellularDataFlowUpdated(slotId, flowData);
169             result = TELEPHONY_SUCCESS;
170         }
171     }
172     return result;
173 }
174 
UpdateCallState(int32_t callState, const std::u16string &number)175 int32_t TelephonyStateRegistryService::UpdateCallState(int32_t callState, const std::u16string &number)
176 {
177     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
178         TELEPHONY_LOGE("Check permission failed.");
179         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
180     }
181     std::lock_guard<std::mutex> guard(lock_);
182     // -1 means observe all slot
183     callState_[-1] = callState;
184     callIncomingNumber_[-1] = number;
185     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
186     for (size_t i = 0; i < stateRecords_.size(); i++) {
187         TelephonyStateRegistryRecord record = stateRecords_[i];
188         if (record.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE) &&
189             (record.slotId_ == -1) && record.telephonyObserver_ != nullptr) {
190             std::u16string phoneNumber;
191             if (record.IsCanReadCallHistory()) {
192                 phoneNumber = number;
193             } else {
194                 phoneNumber = Str8ToStr16("");
195             }
196             record.telephonyObserver_->OnCallStateUpdated(record.slotId_, callState, phoneNumber);
197             result = TELEPHONY_SUCCESS;
198         }
199     }
200     SendCallStateChanged(-1, callState);
201     SendCallStateChangedAsUserMultiplePermission(-1, callState, number);
202     return result;
203 }
204 
UpdateCallStateForSlotId( int32_t slotId, int32_t callState, const std::u16string &number)205 int32_t TelephonyStateRegistryService::UpdateCallStateForSlotId(
206     int32_t slotId, int32_t callState, const std::u16string &number)
207 {
208     if (!VerifySlotId(slotId)) {
209         TELEPHONY_LOGE("UpdateCallState##VerifySlotId failed ##slotId = %{public}d", slotId);
210         return TELEPHONY_STATE_REGISTRY_SLODID_ERROR;
211     }
212     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
213         TELEPHONY_LOGE("Check permission failed.");
214         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
215     }
216     std::lock_guard<std::mutex> guard(lock_);
217     callState_[slotId] = callState;
218     callIncomingNumber_[slotId] = number;
219     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
220     for (size_t i = 0; i < stateRecords_.size(); i++) {
221         TelephonyStateRegistryRecord record = stateRecords_[i];
222         if (record.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE) &&
223             (record.slotId_ == slotId) && record.telephonyObserver_ != nullptr) {
224             std::u16string phoneNumber = GetCallIncomingNumberForSlotId(record, slotId);
225             record.telephonyObserver_->OnCallStateUpdated(slotId, callState, phoneNumber);
226             result = TELEPHONY_SUCCESS;
227         }
228     }
229     SendCallStateChanged(slotId, callState);
230     SendCallStateChangedAsUserMultiplePermission(slotId, callState, number);
231     return result;
232 }
233 
UpdateSimState(int32_t slotId, CardType type, SimState state, LockReason reason)234 int32_t TelephonyStateRegistryService::UpdateSimState(int32_t slotId, CardType type, SimState state, LockReason reason)
235 {
236     if (!VerifySlotId(slotId)) {
237         TELEPHONY_LOGE("UpdateSimState##VerifySlotId failed ##slotId = %{public}d", slotId);
238         return TELEPHONY_STATE_REGISTRY_SLODID_ERROR;
239     }
240     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
241         TELEPHONY_LOGE("Check permission failed.");
242         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
243     }
244     std::lock_guard<std::mutex> guard(lock_);
245     simState_[slotId] = state;
246     simReason_[slotId] = reason;
247     cardType_[slotId] = type;
248     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
249     for (size_t i = 0; i < stateRecords_.size(); i++) {
250         TelephonyStateRegistryRecord record = stateRecords_[i];
251         if (record.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE) &&
252             (record.slotId_ == slotId) && record.telephonyObserver_ != nullptr) {
253             record.telephonyObserver_->OnSimStateUpdated(slotId, type, state, reason);
254             result = TELEPHONY_SUCCESS;
255         }
256     }
257     SendSimStateChanged(slotId, type, state, reason);
258     return result;
259 }
260 
UpdateSignalInfo(int32_t slotId, const std::vector<sptr<SignalInformation>> &vec)261 int32_t TelephonyStateRegistryService::UpdateSignalInfo(int32_t slotId, const std::vector<sptr<SignalInformation>> &vec)
262 {
263     if (!VerifySlotId(slotId)) {
264         TELEPHONY_LOGE("UpdateSignalInfo##VerifySlotId failed ##slotId = %{public}d", slotId);
265         return TELEPHONY_STATE_REGISTRY_SLODID_ERROR;
266     }
267     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
268         TELEPHONY_LOGE("Check permission failed.");
269         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
270     }
271     std::lock_guard<std::mutex> guard(lock_);
272     signalInfos_[slotId] = vec;
273     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
274     for (size_t i = 0; i < stateRecords_.size(); i++) {
275         TelephonyStateRegistryRecord record = stateRecords_[i];
276         if (record.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS) &&
277             (record.slotId_ == slotId) && record.telephonyObserver_ != nullptr) {
278             if (TELEPHONY_EXT_WRAPPER.onSignalInfoUpdated_ != nullptr) {
279                 std::vector<sptr<SignalInformation>> vecExt = vec;
280                 TELEPHONY_EXT_WRAPPER.onSignalInfoUpdated_(slotId, record, vecExt, vec);
281                 record.telephonyObserver_->OnSignalInfoUpdated(slotId, vecExt);
282             } else {
283                 record.telephonyObserver_->OnSignalInfoUpdated(slotId, vec);
284             }
285             result = TELEPHONY_SUCCESS;
286         }
287     }
288     SendSignalInfoChanged(slotId, vec);
289     return result;
290 }
291 
UpdateCellInfo(int32_t slotId, const std::vector<sptr<CellInformation>> &vec)292 int32_t TelephonyStateRegistryService::UpdateCellInfo(int32_t slotId, const std::vector<sptr<CellInformation>> &vec)
293 {
294     if (!VerifySlotId(slotId)) {
295         TELEPHONY_LOGE("UpdateCellInfo##VerifySlotId failed ##slotId = %{public}d", slotId);
296         return TELEPHONY_STATE_REGISTRY_SLODID_ERROR;
297     }
298     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE) ||
299         !TelephonyPermission::CheckPermission(Permission::CELL_LOCATION)) {
300         TELEPHONY_LOGE("Check permission failed.");
301         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
302     }
303     std::lock_guard<std::mutex> guard(lock_);
304     cellInfos_[slotId] = vec;
305     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
306     for (size_t i = 0; i < stateRecords_.size(); i++) {
307         TelephonyStateRegistryRecord record = stateRecords_[i];
308         if (record.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO) && record.slotId_ == slotId) {
309             if (record.telephonyObserver_ == nullptr) {
310                 TELEPHONY_LOGE("record.telephonyObserver_ is nullptr");
311                 return TELEPHONY_ERR_LOCAL_PTR_NULL;
312             }
313             if (TELEPHONY_EXT_WRAPPER.onCellInfoUpdated_ != nullptr) {
314                 std::vector<sptr<CellInformation>> vecExt = vec;
315                 TELEPHONY_EXT_WRAPPER.onCellInfoUpdated_(slotId, record, vecExt, vec);
316                 record.telephonyObserver_->OnCellInfoUpdated(slotId, vecExt);
317             } else {
318                 record.telephonyObserver_->OnCellInfoUpdated(slotId, vec);
319             }
320             result = TELEPHONY_SUCCESS;
321         }
322     }
323     return result;
324 }
325 
UpdateNetworkState(int32_t slotId, const sptr<NetworkState> &networkState)326 int32_t TelephonyStateRegistryService::UpdateNetworkState(int32_t slotId, const sptr<NetworkState> &networkState)
327 {
328     if (!VerifySlotId(slotId)) {
329         TELEPHONY_LOGE("UpdateNetworkState##VerifySlotId failed ##slotId = %{public}d", slotId);
330         return TELEPHONY_STATE_REGISTRY_SLODID_ERROR;
331     }
332     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
333         TELEPHONY_LOGE("Check permission failed.");
334         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
335     }
336     std::lock_guard<std::mutex> guard(lock_);
337     searchNetworkState_[slotId] = networkState;
338     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
339     for (size_t i = 0; i < stateRecords_.size(); i++) {
340         TelephonyStateRegistryRecord r = stateRecords_[i];
341         if (r.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE) && (r.slotId_ == slotId) &&
342             r.telephonyObserver_ != nullptr) {
343             if (TELEPHONY_EXT_WRAPPER.onNetworkStateUpdated_ != nullptr) {
344                 sptr<NetworkState> networkStateExt = new NetworkState();
345                 MessageParcel data;
346                 networkState->Marshalling(data);
347                 networkStateExt->ReadFromParcel(data);
348                 TELEPHONY_EXT_WRAPPER.onNetworkStateUpdated_(slotId, r, networkStateExt, networkState);
349                 r.telephonyObserver_->OnNetworkStateUpdated(slotId, networkStateExt);
350             } else {
351                 r.telephonyObserver_->OnNetworkStateUpdated(slotId, networkState);
352             }
353             result = TELEPHONY_SUCCESS;
354         }
355     }
356     SendNetworkStateChanged(slotId, networkState);
357     TELEPHONY_LOGI("TelephonyStateRegistryService::UpdateNetworkState end");
358     return result;
359 }
360 
UpdateCfuIndicator(int32_t slotId, bool cfuResult)361 int32_t TelephonyStateRegistryService::UpdateCfuIndicator(int32_t slotId, bool cfuResult)
362 {
363     if (!VerifySlotId(slotId)) {
364         TELEPHONY_LOGE("UpdateCfuIndicator##VerifySlotId failed ##slotId = %{public}d", slotId);
365         return TELEPHONY_STATE_REGISTRY_SLODID_ERROR;
366     }
367     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
368         TELEPHONY_LOGE("Check permission failed.");
369         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
370     }
371     std::lock_guard<std::mutex> guard(lock_);
372     cfuResult_[slotId] = cfuResult;
373     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
374     for (size_t i = 0; i < stateRecords_.size(); i++) {
375         TelephonyStateRegistryRecord record = stateRecords_[i];
376         if (record.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR) &&
377             (record.slotId_ == slotId) && record.telephonyObserver_ != nullptr) {
378             record.telephonyObserver_->OnCfuIndicatorUpdated(slotId, cfuResult);
379             result = TELEPHONY_SUCCESS;
380         }
381     }
382     TELEPHONY_LOGI("TelephonyStateRegistryService::UpdateCfuIndicator end");
383     return result;
384 }
385 
UpdateIccAccount()386 int32_t TelephonyStateRegistryService::UpdateIccAccount()
387 {
388     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
389         TELEPHONY_LOGE("Check permission failed.");
390         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
391     }
392     std::lock_guard<std::mutex> guard(lock_);
393     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
394     for (size_t i = 0; i < stateRecords_.size(); i++) {
395         TelephonyStateRegistryRecord record = stateRecords_[i];
396         if (record.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_ICC_ACCOUNT) &&
397             (record.telephonyObserver_ != nullptr)) {
398             record.telephonyObserver_->OnIccAccountUpdated();
399             result = TELEPHONY_SUCCESS;
400         }
401     }
402     TELEPHONY_LOGI("TelephonyStateRegistryService::UpdateIccAccount end");
403     return result;
404 }
405 
UpdateVoiceMailMsgIndicator(int32_t slotId, bool voiceMailMsgResult)406 int32_t TelephonyStateRegistryService::UpdateVoiceMailMsgIndicator(int32_t slotId, bool voiceMailMsgResult)
407 {
408     if (!VerifySlotId(slotId)) {
409         TELEPHONY_LOGE("UpdateVoiceMailMsgIndicator##VerifySlotId failed ##slotId = %{public}d", slotId);
410         return TELEPHONY_STATE_REGISTRY_SLODID_ERROR;
411     }
412     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
413         TELEPHONY_LOGE("Check permission failed.");
414         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
415     }
416     std::lock_guard<std::mutex> guard(lock_);
417     voiceMailMsgResult_[slotId] = voiceMailMsgResult;
418     int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
419     for (size_t i = 0; i < stateRecords_.size(); i++) {
420         TelephonyStateRegistryRecord record = stateRecords_[i];
421         if (record.IsExistStateListener(TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR) &&
422             (record.slotId_ == slotId) && record.telephonyObserver_ != nullptr) {
423             record.telephonyObserver_->OnVoiceMailMsgIndicatorUpdated(slotId, voiceMailMsgResult);
424             result = TELEPHONY_SUCCESS;
425         }
426     }
427     TELEPHONY_LOGI("TelephonyStateRegistryService::UpdateVoiceMailMsgIndicator end");
428     return result;
429 }
430 
CheckCallerIsSystemApp(uint32_t mask)431 bool TelephonyStateRegistryService::CheckCallerIsSystemApp(uint32_t mask)
432 {
433     if ((mask & TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO) != 0) {
434         if (!TelephonyPermission::CheckCallerIsSystemApp()) {
435             TELEPHONY_LOGE("The listening event is cellInfoChange. Non-system applications use system APIs!");
436             return false;
437         }
438     }
439     if ((mask & TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR) != 0) {
440         if (!TelephonyPermission::CheckCallerIsSystemApp()) {
441             TELEPHONY_LOGE("The listening event is cfuIndicatorChange. Non-system applications use system APIs!");
442             return false;
443         }
444     }
445     if ((mask & TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR) != 0) {
446         if (!TelephonyPermission::CheckCallerIsSystemApp()) {
447             TELEPHONY_LOGE(
448                 "The listening event is voiceMailMsgIndicatorChange. Non-system applications use system APIs!");
449             return false;
450         }
451     }
452     return true;
453 }
454 
RegisterStateChange( const sptr<TelephonyObserverBroker> &telephonyObserver, int32_t slotId, uint32_t mask, const std::string &bundleName, bool isUpdate, pid_t pid, int32_t uid, int32_t tokenId)455 int32_t TelephonyStateRegistryService::RegisterStateChange(
456     const sptr<TelephonyObserverBroker> &telephonyObserver, int32_t slotId,
457     uint32_t mask, const std::string &bundleName, bool isUpdate, pid_t pid, int32_t uid, int32_t tokenId)
458 {
459     if (!CheckCallerIsSystemApp(mask)) {
460         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
461     }
462     if (!CheckPermission(mask)) {
463         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
464     }
465     std::lock_guard<std::mutex> guard(lock_);
466     bool isExist = false;
467     TelephonyStateRegistryRecord record;
468     for (size_t i = 0; i < stateRecords_.size(); i++) {
469         record = stateRecords_[i];
470         if (record.slotId_ == slotId && record.mask_ == mask && record.tokenId_ == tokenId && record.pid_ == pid) {
471             isExist = true;
472             break;
473         }
474     }
475 
476     if (!isExist) {
477         record.pid_ = pid;
478         record.uid_ = uid;
479         record.slotId_ = slotId;
480         record.mask_ = mask;
481         record.bundleName_ = bundleName;
482         record.tokenId_ = tokenId;
483         record.telephonyObserver_ = telephonyObserver;
484         stateRecords_.push_back(record);
485     }
486 
487     if (isUpdate) {
488         UpdateData(record);
489     }
490     TELEPHONY_LOGD("[slot%{public}d] Register successfully, callback list size is %{public}zu", slotId,
491         stateRecords_.size());
492     return TELEPHONY_SUCCESS;
493 }
494 
UnregisterStateChange(int32_t slotId, uint32_t mask, int32_t tokenId, pid_t pid)495 int32_t TelephonyStateRegistryService::UnregisterStateChange(int32_t slotId, uint32_t mask, int32_t tokenId, pid_t pid)
496 {
497     if (!CheckCallerIsSystemApp(mask)) {
498         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
499     }
500     if (!CheckPermission(mask)) {
501         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
502     }
503     std::lock_guard<std::mutex> guard(lock_);
504     int32_t result = TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST;
505     std::vector<TelephonyStateRegistryRecord>::iterator it;
506     for (it = stateRecords_.begin(); it != stateRecords_.end(); ++it) {
507         if (it->slotId_ == slotId && it->mask_ == mask && it->tokenId_ == tokenId && it->pid_ == pid) {
508             stateRecords_.erase(it);
509             result = TELEPHONY_SUCCESS;
510             break;
511         }
512     }
513     TELEPHONY_LOGD("[slot%{public}d] Unregister successfully, callback list size is %{public}zu", slotId,
514         stateRecords_.size());
515     return result;
516 }
517 
CheckPermission(uint32_t mask)518 bool TelephonyStateRegistryService::CheckPermission(uint32_t mask)
519 {
520     if ((mask & TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE) != 0) {
521         if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
522             TELEPHONY_LOGE("Check permission failed,"
523                 "you must declare ohos.permission.GET_NETWORK_INFO permission for network state");
524             return false;
525         }
526     }
527     if ((mask & TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO) != 0) {
528         if (!TelephonyPermission::CheckPermission(Permission::CELL_LOCATION)) {
529             TELEPHONY_LOGE("Check permission failed,"
530                 "you must declare ohos.permission.LOCATION permission for cell info");
531             return false;
532         }
533     }
534     return true;
535 }
536 
VerifySlotId(int slotId)537 bool TelephonyStateRegistryService::VerifySlotId(int slotId)
538 {
539     return slotId >= 0 && slotId < slotSize_;
540 }
541 
GetCallIncomingNumberForSlotId( TelephonyStateRegistryRecord record, int32_t slotId)542 std::u16string TelephonyStateRegistryService::GetCallIncomingNumberForSlotId(
543     TelephonyStateRegistryRecord record, int32_t slotId)
544 {
545     if (record.IsCanReadCallHistory()) {
546         return callIncomingNumber_[slotId];
547     } else {
548         return Str8ToStr16("");
549     }
550 }
551 
UpdateData(const TelephonyStateRegistryRecord &record)552 void TelephonyStateRegistryService::UpdateData(const TelephonyStateRegistryRecord &record)
553 {
554     if (record.telephonyObserver_ == nullptr) {
555         TELEPHONY_LOGE("record.telephonyObserver_ is nullptr");
556         return;
557     }
558     if ((record.mask_ & TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE) != 0) {
559         std::u16string phoneNumber = GetCallIncomingNumberForSlotId(record, record.slotId_);
560         TELEPHONY_LOGI("RegisterStateChange##Notify-OBSERVER_MASK_CALL_STATE");
561         record.telephonyObserver_->OnCallStateUpdated(record.slotId_, callState_[record.slotId_], phoneNumber);
562     }
563     if ((record.mask_ & TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS) != 0) {
564         TELEPHONY_LOGI("RegisterStateChange##Notify-OBSERVER_MASK_SIGNAL_STRENGTHS");
565         record.telephonyObserver_->OnSignalInfoUpdated(record.slotId_, signalInfos_[record.slotId_]);
566     }
567     if ((record.mask_ & TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE) != 0) {
568         TELEPHONY_LOGI("RegisterStateChange##Notify-OBSERVER_MASK_NETWORK_STATE");
569         record.telephonyObserver_->OnNetworkStateUpdated(record.slotId_, searchNetworkState_[record.slotId_]);
570     }
571     if ((record.mask_ & TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO) != 0) {
572         TELEPHONY_LOGI("RegisterStateChange##Notify-OBSERVER_MASK_CELL_INFO");
573         record.telephonyObserver_->OnCellInfoUpdated(record.slotId_, cellInfos_[record.slotId_]);
574     }
575     if ((record.mask_ & TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE) != 0) {
576         record.telephonyObserver_->OnSimStateUpdated(
577             record.slotId_, cardType_[record.slotId_], simState_[record.slotId_], simReason_[record.slotId_]);
578     }
579     if ((record.mask_ & TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE) != 0) {
580         TELEPHONY_LOGI("RegisterStateChange##Notify-OBSERVER_MASK_DATA_CONNECTION_STATE");
581         record.telephonyObserver_->OnCellularDataConnectStateUpdated(record.slotId_,
582             cellularDataConnectionState_[record.slotId_], cellularDataConnectionNetworkType_[record.slotId_]);
583     }
584     if ((record.mask_ & TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW) != 0) {
585         TELEPHONY_LOGI("RegisterStateChange##Notify-OBSERVER_MASK_DATA_FLOW");
586         record.telephonyObserver_->OnCellularDataFlowUpdated(record.slotId_, cellularDataFlow_[record.slotId_]);
587     }
588     if ((record.mask_ & TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR) != 0) {
589         TELEPHONY_LOGI("RegisterStateChange##Notify-OBSERVER_MASK_CFU_INDICATOR");
590         record.telephonyObserver_->OnCfuIndicatorUpdated(record.slotId_, cfuResult_[record.slotId_]);
591     }
592     if ((record.mask_ & TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR) != 0) {
593         TELEPHONY_LOGI("RegisterStateChange##Notify-OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR");
594         record.telephonyObserver_->OnVoiceMailMsgIndicatorUpdated(record.slotId_, voiceMailMsgResult_[record.slotId_]);
595     }
596     if ((record.mask_ & TelephonyObserverBroker::OBSERVER_MASK_ICC_ACCOUNT) != 0) {
597         TELEPHONY_LOGI("RegisterStateChange##Notify-OBSERVER_MASK_ICC_ACCOUNT");
598         record.telephonyObserver_->OnIccAccountUpdated();
599     }
600 }
601 
PublishCommonEvent( const AAFwk::Want &want, int eventCode, const std::string &eventData)602 bool TelephonyStateRegistryService::PublishCommonEvent(
603     const AAFwk::Want &want, int eventCode, const std::string &eventData)
604 {
605     EventFwk::CommonEventData data;
606     data.SetWant(want);
607     data.SetCode(eventCode);
608     data.SetData(eventData);
609     EventFwk::CommonEventPublishInfo publishInfo;
610     publishInfo.SetOrdered(false);
611     if (want.GetAction() == EventFwk::CommonEventSupport::COMMON_EVENT_NETWORK_STATE_CHANGED) {
612         std::vector<std::string> permissions;
613         permissions.emplace_back(Permission::GET_NETWORK_INFO);
614         publishInfo.SetSubscriberPermissions(permissions);
615     }
616     bool publishResult = EventFwk::CommonEventManager::PublishCommonEvent(data, publishInfo, nullptr);
617     TELEPHONY_LOGI("PublishCommonEvent end###publishResult = %{public}d\n", publishResult);
618     return publishResult;
619 }
620 
SendCallStateChanged(int32_t slotId, int32_t state)621 void TelephonyStateRegistryService::SendCallStateChanged(int32_t slotId, int32_t state)
622 {
623     AAFwk::Want want;
624     want.SetParam("slotId", slotId);
625     want.SetParam("state", state);
626     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
627 
628     EventFwk::CommonEventData data;
629     data.SetWant(want);
630     EventFwk::CommonEventPublishInfo publishInfo;
631     publishInfo.SetOrdered(false);
632     std::vector<std::string> callPermissions;
633     callPermissions.emplace_back(Permission::GET_TELEPHONY_STATE);
634     publishInfo.SetSubscriberPermissions(callPermissions);
635     bool publishResult = EventFwk::CommonEventManager::PublishCommonEvent(data, publishInfo, nullptr);
636     if (!publishResult) {
637         TELEPHONY_LOGE("SendCallStateChanged PublishBroadcastEvent result fail");
638     }
639 }
640 
SendCallStateChangedAsUserMultiplePermission( int32_t slotId, int32_t state, const std::u16string &number)641 void TelephonyStateRegistryService::SendCallStateChangedAsUserMultiplePermission(
642     int32_t slotId, int32_t state, const std::u16string &number)
643 {
644     AAFwk::Want want;
645     want.SetParam("slotId", slotId);
646     want.SetParam("state", state);
647     want.SetParam("number", Str16ToStr8(number));
648     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
649 
650     EventFwk::CommonEventData data;
651     data.SetWant(want);
652     EventFwk::CommonEventPublishInfo publishInfo;
653     publishInfo.SetOrdered(false);
654     std::vector<std::string> callPermissions;
655     callPermissions.emplace_back(Permission::GET_TELEPHONY_STATE);
656     callPermissions.emplace_back(Permission::READ_CALL_LOG);
657     publishInfo.SetSubscriberPermissions(callPermissions);
658     bool publishResult = EventFwk::CommonEventManager::PublishCommonEvent(data, publishInfo, nullptr);
659     if (!publishResult) {
660         TELEPHONY_LOGE("SendCallStateChangedAsUserMultiplePermission PublishBroadcastEvent result fail");
661     }
662 }
663 
SendCellularDataConnectStateChanged( int32_t slotId, int32_t dataState, int32_t networkType)664 void TelephonyStateRegistryService::SendCellularDataConnectStateChanged(
665     int32_t slotId, int32_t dataState, int32_t networkType)
666 {
667     AAFwk::Want want;
668     want.SetParam("slotId", slotId);
669     want.SetParam("dataState", dataState);
670     want.SetParam("networkType", networkType);
671     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CELLULAR_DATA_STATE_CHANGED);
672     int32_t eventCode = 1;
673     std::string eventData("connectStateChanged");
674     PublishCommonEvent(want, eventCode, eventData);
675 }
676 
SendSimStateChanged( int32_t slotId, CardType type, SimState state, LockReason reason)677 void TelephonyStateRegistryService::SendSimStateChanged(
678     int32_t slotId, CardType type, SimState state, LockReason reason)
679 {
680     AAFwk::Want want;
681     want.SetParam("slotId", slotId);
682     want.SetParam("cardType", static_cast<int32_t>(type));
683     want.SetParam("reason", static_cast<int32_t>(reason));
684     want.SetParam("state", static_cast<int32_t>(state));
685     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_STATE_CHANGED);
686     int32_t eventCode = 1;
687     std::string eventData("simStateChanged");
688     PublishCommonEvent(want, eventCode, eventData);
689 }
690 
SendSignalInfoChanged( int32_t slotId, const std::vector<sptr<SignalInformation>> &vec)691 void TelephonyStateRegistryService::SendSignalInfoChanged(
692     int32_t slotId, const std::vector<sptr<SignalInformation>> &vec)
693 {
694     AAFwk::Want want;
695     want.SetParam("slotId", slotId);
696     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIGNAL_INFO_CHANGED);
697     std::vector<std::string> contentStr;
698     if (TELEPHONY_EXT_WRAPPER.sendSignalInfoChanged_ != nullptr) {
699         TELEPHONY_EXT_WRAPPER.sendSignalInfoChanged_(slotId, vec);
700     }
701     for (size_t i = 0; i < vec.size(); i++) {
702         sptr<SignalInformation> signal = vec[i];
703         if (signal != nullptr) {
704             contentStr.push_back(signal->ToString());
705         }
706     }
707     want.SetParam("signalInfos", contentStr);
708     int32_t eventCode = 1;
709     std::string eventData("signalInfoChanged");
710     PublishCommonEvent(want, eventCode, eventData);
711 }
712 
SendNetworkStateChanged(int32_t slotId, const sptr<NetworkState> &networkState)713 void TelephonyStateRegistryService::SendNetworkStateChanged(int32_t slotId, const sptr<NetworkState> &networkState)
714 {
715     AAFwk::Want want;
716     want.SetParam("slotId", slotId);
717     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_NETWORK_STATE_CHANGED);
718     int32_t eventCode = 1;
719     if (TELEPHONY_EXT_WRAPPER.sendNetworkStateChanged_ != nullptr) {
720         TELEPHONY_EXT_WRAPPER.sendNetworkStateChanged_(slotId, networkState);
721     }
722     if (networkState != nullptr) {
723         want.SetParam("networkState", networkState->ToString());
724     }
725     std::string eventData("networkStateChanged");
726     PublishCommonEvent(want, eventCode, eventData);
727 }
728 
Dump(std::int32_t fd, const std::vector<std::u16string> &args)729 int TelephonyStateRegistryService::Dump(std::int32_t fd, const std::vector<std::u16string> &args)
730 {
731     if (fd < 0) {
732         TELEPHONY_LOGE("dump fd invalid");
733         return TELEPHONY_ERR_FAIL;
734     }
735     std::vector<std::string> argsInStr;
736     for (const auto &arg : args) {
737         TELEPHONY_LOGI("Dump args: %{public}s", Str16ToStr8(arg).c_str());
738         argsInStr.emplace_back(Str16ToStr8(arg));
739     }
740     std::string result;
741     TelephonyStateRegistryDumpHelper dumpHelper;
742     std::lock_guard<std::mutex> guard(lock_);
743     if (dumpHelper.Dump(argsInStr, stateRecords_, result)) {
744         std::int32_t ret = dprintf(fd, "%s", result.c_str());
745         if (ret < 0) {
746             TELEPHONY_LOGE("dprintf to dump fd failed");
747             return TELEPHONY_ERR_FAIL;
748         }
749         return TELEPHONY_SUCCESS;
750     }
751     TELEPHONY_LOGW("dumpHelper failed");
752     return TELEPHONY_ERR_FAIL;
753 }
754 
GetBindStartTime()755 std::string TelephonyStateRegistryService::GetBindStartTime()
756 {
757     std::ostringstream oss;
758     oss << bindStartTime_;
759     return oss.str();
760 }
761 
GetBindEndTime()762 std::string TelephonyStateRegistryService::GetBindEndTime()
763 {
764     std::ostringstream oss;
765     oss << bindEndTime_;
766     return oss.str();
767 }
768 
GetBindSpendTime()769 std::string TelephonyStateRegistryService::GetBindSpendTime()
770 {
771     std::ostringstream oss;
772     oss << (bindEndTime_ - bindStartTime_);
773     return oss.str();
774 }
775 
GetServiceRunningState()776 int32_t TelephonyStateRegistryService::GetServiceRunningState()
777 {
778     return static_cast<int32_t>(state_);
779 }
780 
GetSimState(int32_t slotId)781 int32_t TelephonyStateRegistryService::GetSimState(int32_t slotId)
782 {
783     std::map<int32_t, SimState>::iterator it;
784     int32_t result = TELEPHONY_ERROR;
785     for (it = simState_.begin(); it != simState_.end(); ++it) {
786         if (it->first == slotId) {
787             result = static_cast<int32_t>(it->second);
788             TELEPHONY_LOGI("CallState = %{public}d", result);
789             break;
790         }
791     }
792     return result;
793 }
794 
GetCallState(int32_t slotId)795 int32_t TelephonyStateRegistryService::GetCallState(int32_t slotId)
796 {
797     std::map<int32_t, int32_t>::iterator it;
798     int32_t result = TELEPHONY_ERROR;
799     for (it = callState_.begin(); it != callState_.end(); ++it) {
800         if (it->first == slotId) {
801             result = it->second;
802             break;
803         }
804     }
805     return result;
806 }
807 
GetCardType(int32_t slotId)808 int32_t TelephonyStateRegistryService::GetCardType(int32_t slotId)
809 {
810     std::map<int32_t, CardType>::iterator it;
811     int32_t result = TELEPHONY_ERROR;
812     for (it = cardType_.begin(); it != cardType_.end(); ++it) {
813         if (it->first == slotId) {
814             result = static_cast<int32_t>(it->second);
815             break;
816         }
817     }
818     return result;
819 }
820 
GetCellularDataConnectionState(int32_t slotId)821 int32_t TelephonyStateRegistryService::GetCellularDataConnectionState(int32_t slotId)
822 {
823     std::map<int32_t, int32_t>::iterator it;
824     int32_t result = TELEPHONY_ERROR;
825     for (it = cellularDataConnectionState_.begin(); it != cellularDataConnectionState_.end(); ++it) {
826         if (it->first == slotId) {
827             result = it->second;
828             break;
829         }
830     }
831     return result;
832 }
833 
GetCellularDataFlow(int32_t slotId)834 int32_t TelephonyStateRegistryService::GetCellularDataFlow(int32_t slotId)
835 {
836     std::map<int32_t, int32_t>::iterator it;
837     int32_t result = TELEPHONY_ERROR;
838     for (it = cellularDataFlow_.begin(); it != cellularDataFlow_.end(); ++it) {
839         if (it->first == slotId) {
840             result = it->second;
841             break;
842         }
843     }
844     return result;
845 }
846 
GetCellularDataConnectionNetworkType(int32_t slotId)847 int32_t TelephonyStateRegistryService::GetCellularDataConnectionNetworkType(int32_t slotId)
848 {
849     std::map<int32_t, int32_t>::iterator it;
850     int32_t result = TELEPHONY_ERROR;
851     for (it = cellularDataConnectionNetworkType_.begin(); it != cellularDataConnectionNetworkType_.end(); ++it) {
852         if (it->first == slotId) {
853             result = it->second;
854             break;
855         }
856     }
857     return result;
858 }
859 
GetLockReason(int32_t slotId)860 int32_t TelephonyStateRegistryService::GetLockReason(int32_t slotId)
861 {
862     std::map<int32_t, LockReason>::iterator it;
863     int32_t result = TELEPHONY_ERROR;
864     for (it = simReason_.begin(); it != simReason_.end(); ++it) {
865         if (it->first == slotId) {
866             result = static_cast<int32_t>(it->second);
867             break;
868         }
869     }
870     return result;
871 }
872 
IsCommonEventServiceAbilityExist()873 bool TelephonyStateRegistryService::IsCommonEventServiceAbilityExist() __attribute__((no_sanitize("cfi")))
874 {
875     sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
876     if (sm == nullptr) {
877         TELEPHONY_LOGE("IsCommonEventServiceAbilityExist Get ISystemAbilityManager failed, no SystemAbilityManager");
878         return false;
879     }
880     sptr<IRemoteObject> remote = sm->CheckSystemAbility(COMMON_EVENT_SERVICE_ID);
881     if (remote == nullptr) {
882         TELEPHONY_LOGE("No CesServiceAbility");
883         return false;
884     }
885     return true;
886 }
887 } // namespace Telephony
888 } // namespace OHOS
889