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