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 if (callStateInfo == nullptr) {
30 TELEPHONY_LOGE("callStateInfo is nullptr!");
31 return;
32 }
33 EventListenerManager::SendEvent(ToUint32t(TelephonyCallbackEventId::EVENT_ON_CALL_STATE_UPDATE), callStateInfo);
34 }
35
OnSignalInfoUpdated(int32_t slotId,const std::vector<sptr<SignalInformation>> & signalInfoList)36 void NapiTelephonyObserver::OnSignalInfoUpdated(
37 int32_t slotId, const std::vector<sptr<SignalInformation>> &signalInfoList)
38 {
39 TELEPHONY_LOGI("OnSignalInfoUpdated slotId = %{public}d, signalInfoList.size = %{public}zu", slotId,
40 signalInfoList.size());
41 std::unique_ptr<SignalUpdateInfo> infoList = std::make_unique<SignalUpdateInfo>(slotId, signalInfoList);
42 if (infoList == nullptr) {
43 TELEPHONY_LOGE("SignalUpdateInfo is nullptr!");
44 return;
45 }
46 EventListenerManager::SendEvent(ToUint32t(TelephonyCallbackEventId::EVENT_ON_SIGNAL_INFO_UPDATE), infoList);
47 }
48
OnNetworkStateUpdated(int32_t slotId,const sptr<NetworkState> & networkState)49 void NapiTelephonyObserver::OnNetworkStateUpdated(int32_t slotId, const sptr<NetworkState> &networkState)
50 {
51 TELEPHONY_LOGI(
52 "OnNetworkStateUpdated slotId = %{public}d, networkState = %{public}d", slotId, networkState == nullptr);
53 std::unique_ptr<NetworkStateUpdateInfo> networkStateUpdateInfo =
54 std::make_unique<NetworkStateUpdateInfo>(slotId, networkState);
55 if (networkStateUpdateInfo == nullptr) {
56 TELEPHONY_LOGE("NetworkStateUpdateInfo is nullptr!");
57 return;
58 }
59 EventListenerManager::SendEvent(
60 ToUint32t(TelephonyCallbackEventId::EVENT_ON_NETWORK_STATE_UPDATE), networkStateUpdateInfo);
61 }
62
OnSimStateUpdated(int32_t slotId,CardType type,SimState state,LockReason reason)63 void NapiTelephonyObserver::OnSimStateUpdated(
64 int32_t slotId, CardType type, SimState state, LockReason reason)
65 {
66 TELEPHONY_LOGI("OnSimStateUpdated slotId = %{public}d, simState = %{public}d", slotId, state);
67 std::unique_ptr<SimStateUpdateInfo> simStateUpdateInfo =
68 std::make_unique<SimStateUpdateInfo>(slotId, type, state, reason);
69 if (simStateUpdateInfo == nullptr) {
70 TELEPHONY_LOGE("SimStateUpdateInfo is nullptr!");
71 return;
72 }
73 EventListenerManager::SendEvent(
74 ToUint32t(TelephonyCallbackEventId::EVENT_ON_SIM_STATE_UPDATE), simStateUpdateInfo);
75 }
76
OnCellInfoUpdated(int32_t slotId,const std::vector<sptr<CellInformation>> & vec)77 void NapiTelephonyObserver::OnCellInfoUpdated(int32_t slotId, const std::vector<sptr<CellInformation>> &vec)
78 {
79 TELEPHONY_LOGI("OnCellInfoUpdated slotId = %{public}d, cell info size = %{public}zu", slotId, vec.size());
80 std::unique_ptr<CellInfomationUpdate> cellInfo = std::make_unique<CellInfomationUpdate>(slotId, vec);
81 if (cellInfo == nullptr) {
82 TELEPHONY_LOGE("CellInfomationUpdate is nullptr!");
83 return;
84 }
85 EventListenerManager::SendEvent(ToUint32t(TelephonyCallbackEventId::EVENT_ON_CELL_INFOMATION_UPDATE), cellInfo);
86 }
87
OnCellularDataConnectStateUpdated(int32_t slotId,int32_t dataState,int32_t networkType)88 void NapiTelephonyObserver::OnCellularDataConnectStateUpdated(
89 int32_t slotId, int32_t dataState, int32_t networkType)
90 {
91 TELEPHONY_LOGI(
92 "OnCellularDataConnectStateUpdated slotId=%{public}d, dataState=%{public}d, networkType="
93 "%{public}d",
94 slotId, dataState, networkType);
95 std::unique_ptr<CellularDataConnectState> cellularDataConnectState =
96 std::make_unique<CellularDataConnectState>(slotId, dataState, networkType);
97 if (cellularDataConnectState == nullptr) {
98 TELEPHONY_LOGE("OnCellularDataConnectStateUpdated cellularDataConnectState is nullptr!");
99 return;
100 }
101 EventListenerManager::SendEvent(
102 ToUint32t(TelephonyCallbackEventId::EVENT_ON_CELLULAR_DATA_CONNECTION_UPDATE), cellularDataConnectState);
103 }
104
OnCellularDataFlowUpdated(int32_t slotId,int32_t dataFlowType)105 void NapiTelephonyObserver::OnCellularDataFlowUpdated(int32_t slotId, int32_t dataFlowType)
106 {
107 TELEPHONY_LOGI(
108 "OnCellularDataFlowUpdated slotId = %{public}d, dataFlowType = %{public}d", slotId, dataFlowType);
109 std::unique_ptr<CellularDataFlowUpdate> cellularDataFlowUpdateInfo =
110 std::make_unique<CellularDataFlowUpdate>(slotId, dataFlowType);
111 if (cellularDataFlowUpdateInfo == nullptr) {
112 TELEPHONY_LOGE("CellularDataFlowUpdate is nullptr!");
113 return;
114 }
115 EventListenerManager::SendEvent(
116 ToUint32t(TelephonyCallbackEventId::EVENT_ON_CELLULAR_DATA_FLOW_UPDATE), cellularDataFlowUpdateInfo);
117 }
118 } // namespace Telephony
119 } // namespace OHOS
120