1 /*
2 * Copyright (C) 2021 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 "napi_telephony_observer.h"
17 #include "event_listener_manager.h"
18 #include "telephony_callback_event_id.h"
19 #include "telephony_log_wrapper.h"
20 #include "update_infos.h"
21
22 namespace OHOS {
23 namespace Telephony {
OnCallStateUpdated(int32_t slotId,int32_t callState,const std::u16string & phoneNumber)24 void NapiTelephonyObserver::OnCallStateUpdated(int32_t slotId, int32_t callState, const std::u16string &phoneNumber)
25 {
26 TELEPHONY_LOGI("OnCallStateUpdated slotId = %{public}d, callState = %{public}d", slotId, callState);
27 std::unique_ptr<CallStateUpdateInfo> callStateInfo =
28 std::make_unique<CallStateUpdateInfo>(slotId, callState, phoneNumber);
29 EventListenerManager::SendEvent(ToUint32t(TelephonyCallbackEventId::EVENT_ON_CALL_STATE_UPDATE), callStateInfo);
30 }
31
OnSignalInfoUpdated(int32_t slotId,const std::vector<sptr<SignalInformation>> & signalInfoList)32 void NapiTelephonyObserver::OnSignalInfoUpdated(
33 int32_t slotId, const std::vector<sptr<SignalInformation>> &signalInfoList)
34 {
35 TELEPHONY_LOGI("OnSignalInfoUpdated slotId = %{public}d, signalInfoList.size = %{public}zu", slotId,
36 signalInfoList.size());
37 std::unique_ptr<SignalUpdateInfo> infoList = std::make_unique<SignalUpdateInfo>(slotId, signalInfoList);
38 if (infoList == nullptr) {
39 TELEPHONY_LOGE("SignalUpdateInfo is nullptr!");
40 }
41 EventListenerManager::SendEvent(ToUint32t(TelephonyCallbackEventId::EVENT_ON_SIGNAL_INFO_UPDATE), infoList);
42 }
43
OnNetworkStateUpdated(int32_t slotId,const sptr<NetworkState> & networkState)44 void NapiTelephonyObserver::OnNetworkStateUpdated(int32_t slotId, const sptr<NetworkState> &networkState)
45 {
46 TELEPHONY_LOGI(
47 "OnNetworkStateUpdated slotId = %{public}d, networkState = %{public}d", slotId, networkState == nullptr);
48 std::unique_ptr<NetworkStateUpdateInfo> networkStateUpdateInfo =
49 std::make_unique<NetworkStateUpdateInfo>(slotId, networkState);
50 if (networkStateUpdateInfo == nullptr) {
51 TELEPHONY_LOGE("NetworkStateUpdateInfo is nullptr!");
52 }
53 EventListenerManager::SendEvent(
54 ToUint32t(TelephonyCallbackEventId::EVENT_ON_NETWORK_STATE_UPDATE), networkStateUpdateInfo);
55 }
56
OnSimStateUpdated(int32_t slotId,CardType type,SimState state,LockReason reason)57 void NapiTelephonyObserver::OnSimStateUpdated(
58 int32_t slotId, CardType type, SimState state, LockReason reason)
59 {
60 TELEPHONY_LOGI("OnSimStateUpdated slotId = %{public}d, simState = %{public}d", slotId, state);
61 std::unique_ptr<SimStateUpdateInfo> simStateUpdateInfo =
62 std::make_unique<SimStateUpdateInfo>(slotId, type, state, reason);
63 if (simStateUpdateInfo == nullptr) {
64 TELEPHONY_LOGE("SimStateUpdateInfo is nullptr!");
65 }
66 EventListenerManager::SendEvent(
67 ToUint32t(TelephonyCallbackEventId::EVENT_ON_SIM_STATE_UPDATE), simStateUpdateInfo);
68 }
69
OnCellInfoUpdated(int32_t slotId,const std::vector<sptr<CellInformation>> & vec)70 void NapiTelephonyObserver::OnCellInfoUpdated(int32_t slotId, const std::vector<sptr<CellInformation>> &vec)
71 {
72 TELEPHONY_LOGI("OnCellInfoUpdated slotId = %{public}d, cell info size = %{public}zu", slotId, vec.size());
73 std::unique_ptr<CellInfomationUpdate> cellInfo = std::make_unique<CellInfomationUpdate>(slotId, vec);
74 if (cellInfo == nullptr) {
75 TELEPHONY_LOGE("CellInfomationUpdate is nullptr!");
76 }
77 EventListenerManager::SendEvent(ToUint32t(TelephonyCallbackEventId::EVENT_ON_CELL_INFOMATION_UPDATE), cellInfo);
78 }
79
OnCellularDataConnectStateUpdated(int32_t slotId,int32_t dataState,int32_t networkType)80 void NapiTelephonyObserver::OnCellularDataConnectStateUpdated(
81 int32_t slotId, int32_t dataState, int32_t networkType)
82 {
83 TELEPHONY_LOGI(
84 "OnCellularDataConnectStateUpdated slotId=%{public}d, dataState=%{public}d, networkType="
85 "%{public}d",
86 slotId, dataState, networkType);
87 std::unique_ptr<CellularDataConnectState> cellularDataConnectState =
88 std::make_unique<CellularDataConnectState>(slotId, dataState, networkType);
89 if (cellularDataConnectState == nullptr) {
90 TELEPHONY_LOGE("OnCellularDataConnectStateUpdated cellularDataConnectState is nullptr!");
91 }
92 EventListenerManager::SendEvent(
93 ToUint32t(TelephonyCallbackEventId::EVENT_ON_CELLULAR_DATA_CONNECTION_UPDATE), cellularDataConnectState);
94 }
95
OnCellularDataFlowUpdated(int32_t slotId,int32_t dataFlowType)96 void NapiTelephonyObserver::OnCellularDataFlowUpdated(int32_t slotId, int32_t dataFlowType)
97 {
98 TELEPHONY_LOGI(
99 "OnCellularDataFlowUpdated slotId = %{public}d, dataFlowType = %{public}d", slotId, dataFlowType);
100 std::unique_ptr<CellularDataFlowUpdate> cellularDataFlowUpdateInfo =
101 std::make_unique<CellularDataFlowUpdate>(slotId, dataFlowType);
102 if (cellularDataFlowUpdateInfo == nullptr) {
103 TELEPHONY_LOGE("CellularDataFlowUpdate is nullptr!");
104 }
105 EventListenerManager::SendEvent(
106 ToUint32t(TelephonyCallbackEventId::EVENT_ON_CELLULAR_DATA_FLOW_UPDATE), cellularDataFlowUpdateInfo);
107 }
108 } // namespace Telephony
109 } // namespace OHOS