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 "telephony_state_registry_stub.h"
17
18 #include "ipc_skeleton.h"
19 #include "string_ex.h"
20
21 #include "sim_state_type.h"
22 #include "state_registry_errors.h"
23 #include "telephony_permission.h"
24
25 namespace OHOS {
26 namespace Telephony {
TelephonyStateRegistryStub()27 TelephonyStateRegistryStub::TelephonyStateRegistryStub()
28 {
29 memberFuncMap_[StateNotifyCode::CELL_INFO] = &TelephonyStateRegistryStub::OnUpdateCellInfo;
30 memberFuncMap_[StateNotifyCode::SIM_STATE] = &TelephonyStateRegistryStub::OnUpdateSimState;
31 memberFuncMap_[StateNotifyCode::SIGNAL_INFO] = &TelephonyStateRegistryStub::OnUpdateSignalInfo;
32 memberFuncMap_[StateNotifyCode::NET_WORK_STATE] = &TelephonyStateRegistryStub::OnUpdateNetworkState;
33 memberFuncMap_[StateNotifyCode::CALL_STATE] = &TelephonyStateRegistryStub::OnUpdateCallState;
34 memberFuncMap_[StateNotifyCode::CALL_STATE_FOR_ID] = &TelephonyStateRegistryStub::OnUpdateCallStateForSlotId;
35 memberFuncMap_[StateNotifyCode::CELLULAR_DATA_STATE] =
36 &TelephonyStateRegistryStub::OnUpdateCellularDataConnectState;
37 memberFuncMap_[StateNotifyCode::CELLULAR_DATA_FLOW] = &TelephonyStateRegistryStub::OnUpdateCellularDataFlow;
38 memberFuncMap_[StateNotifyCode::ADD_OBSERVER] = &TelephonyStateRegistryStub::OnRegisterStateChange;
39 memberFuncMap_[StateNotifyCode::REMOVE_OBSERVER] = &TelephonyStateRegistryStub::OnUnregisterStateChange;
40 }
41
~TelephonyStateRegistryStub()42 TelephonyStateRegistryStub::~TelephonyStateRegistryStub()
43 {
44 memberFuncMap_.clear();
45 }
46
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)47 int32_t TelephonyStateRegistryStub::OnRemoteRequest(
48 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
49 {
50 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnRemoteRequest start##code = %{public}u\n", code);
51 std::u16string myToken = TelephonyStateRegistryStub::GetDescriptor();
52 std::u16string remoteToken = data.ReadInterfaceToken();
53 if (myToken != remoteToken) {
54 TELEPHONY_LOGE("TelephonyStateRegistryStub::OnRemoteRequest end##descriptor checked fail");
55 return TELEPHONY_ERR_DESCRIPTOR_MISMATCH;
56 }
57 auto itFunc = memberFuncMap_.find(static_cast<StateNotifyCode>(code));
58 if (itFunc != memberFuncMap_.end()) {
59 auto memberFunc = itFunc->second;
60 if (memberFunc != nullptr) {
61 return (this->*memberFunc)(data, reply);
62 }
63 }
64 int ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
65 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnRemoteRequest end##ret=%{public}d\n", ret);
66 return ret;
67 }
68
OnUpdateCallState(MessageParcel & data,MessageParcel & reply)69 int32_t TelephonyStateRegistryStub::OnUpdateCallState(MessageParcel &data, MessageParcel &reply)
70 {
71 int32_t slotId = data.ReadInt32();
72 int32_t callState = data.ReadInt32();
73 std::u16string phoneNumber = data.ReadString16();
74 int32_t ret = UpdateCallState(slotId, callState, phoneNumber);
75 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnUpdateCallState end##ret=%{public}d\n", ret);
76 reply.WriteInt32(ret);
77 return ret;
78 }
79
OnUpdateSimState(MessageParcel & data,MessageParcel & reply)80 int32_t TelephonyStateRegistryStub::OnUpdateSimState(MessageParcel &data, MessageParcel &reply)
81 {
82 int32_t slotId = data.ReadInt32();
83 CardType type = static_cast<CardType>(data.ReadInt32());
84 SimState state = static_cast<SimState>(data.ReadInt32());
85 LockReason reason = static_cast<LockReason>(data.ReadInt32());
86 int32_t ret = UpdateSimState(slotId, type, state, reason);
87 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnUpdateSimState end##ret=%{public}d\n", ret);
88 reply.WriteInt32(ret);
89 return ret;
90 }
91
OnUpdateCallStateForSlotId(MessageParcel & data,MessageParcel & reply)92 int32_t TelephonyStateRegistryStub::OnUpdateCallStateForSlotId(MessageParcel &data, MessageParcel &reply)
93 {
94 int32_t slotId = data.ReadInt32();
95 int32_t callId = data.ReadInt32();
96 int32_t callState = data.ReadInt32();
97 std::u16string incomingNumber = data.ReadString16();
98 int32_t ret = UpdateCallStateForSlotId(slotId, callId, callState, incomingNumber);
99 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnUpdateCallStateForSlotId end##ret=%{public}d\n", ret);
100 reply.WriteInt32(ret);
101 return ret;
102 }
103
OnUpdateCellularDataConnectState(MessageParcel & data,MessageParcel & reply)104 int32_t TelephonyStateRegistryStub::OnUpdateCellularDataConnectState(MessageParcel &data, MessageParcel &reply)
105 {
106 int32_t slotId = data.ReadInt32();
107 int32_t dataState = data.ReadInt32();
108 int32_t networkType = data.ReadInt32();
109 int32_t ret = UpdateCellularDataConnectState(slotId, dataState, networkType);
110 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnUpdateCellularDataConnectState end##ret=%{public}d\n", ret);
111 reply.WriteInt32(ret);
112 return ret;
113 }
114
OnUpdateCellularDataFlow(MessageParcel & data,MessageParcel & reply)115 int32_t TelephonyStateRegistryStub::OnUpdateCellularDataFlow(MessageParcel &data, MessageParcel &reply)
116 {
117 int32_t slotId = data.ReadInt32();
118 int32_t flowData = data.ReadInt32();
119 int32_t ret = UpdateCellularDataFlow(slotId, flowData);
120 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnUpdateCellularDataFlow end##ret=%{public}d\n", ret);
121 reply.WriteInt32(ret);
122 return ret;
123 }
124
OnUpdateSignalInfo(MessageParcel & data,MessageParcel & reply)125 int32_t TelephonyStateRegistryStub::OnUpdateSignalInfo(MessageParcel &data, MessageParcel &reply)
126 {
127 int32_t ret = TELEPHONY_SUCCESS;
128 int32_t slotId = data.ReadInt32();
129 int32_t size = data.ReadInt32();
130 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnUpdateSignalInfo size=%{public}d\n", size);
131 size = ((size > SignalInformation::MAX_SIGNAL_NUM) ? 0 : size);
132 if (size <= 0) {
133 ret = TELEPHONY_ERR_FAIL;
134 TELEPHONY_LOGE("TelephonyStateRegistryStub::OnUpdateSignalInfo size <= 0\n");
135 return ret;
136 }
137 std::vector<sptr<SignalInformation>> result;
138 parseSignalInfos(data, size, result);
139 ret = UpdateSignalInfo(slotId, result);
140 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnUpdateSignalInfo end##ret=%{public}d\n", ret);
141 reply.WriteInt32(ret);
142 return ret;
143 }
144
parseSignalInfos(MessageParcel & data,const int32_t size,std::vector<sptr<SignalInformation>> & result)145 void TelephonyStateRegistryStub::parseSignalInfos(
146 MessageParcel &data, const int32_t size, std::vector<sptr<SignalInformation>> &result)
147 {
148 SignalInformation::NetworkType type;
149 for (int i = 0; i < size; ++i) {
150 type = static_cast<SignalInformation::NetworkType>(data.ReadInt32());
151 switch (type) {
152 case SignalInformation::NetworkType::GSM: {
153 TELEPHONY_LOGI("TelephonyStateRegistryStub::parseSignalInfos NetworkType::GSM\n");
154 std::unique_ptr<GsmSignalInformation> signal = std::make_unique<GsmSignalInformation>();
155 if (signal != nullptr) {
156 signal->ReadFromParcel(data);
157 result.emplace_back(signal.release());
158 }
159 break;
160 }
161 case SignalInformation::NetworkType::CDMA: {
162 TELEPHONY_LOGI("TelephonyStateRegistryStub::parseSignalInfos NetworkType::CDMA\n");
163 std::unique_ptr<CdmaSignalInformation> signal = std::make_unique<CdmaSignalInformation>();
164 if (signal != nullptr) {
165 signal->ReadFromParcel(data);
166 result.emplace_back(signal.release());
167 }
168 break;
169 }
170 case SignalInformation::NetworkType::LTE: {
171 TELEPHONY_LOGI("TelephonyStateRegistryStub::parseSignalInfos NetworkType::LTE\n");
172 std::unique_ptr<LteSignalInformation> signal = std::make_unique<LteSignalInformation>();
173 if (signal != nullptr) {
174 signal->ReadFromParcel(data);
175 result.emplace_back(signal.release());
176 }
177 break;
178 }
179 case SignalInformation::NetworkType::WCDMA: {
180 TELEPHONY_LOGI("TelephonyStateRegistryStub::UpdateSignalInfoInner NetworkType::Wcdma\n");
181 std::unique_ptr<WcdmaSignalInformation> signal = std::make_unique<WcdmaSignalInformation>();
182 if (signal != nullptr) {
183 signal->ReadFromParcel(data);
184 result.emplace_back(signal.release());
185 }
186 break;
187 }
188 default:
189 break;
190 }
191 }
192 }
193
OnUpdateCellInfo(MessageParcel & data,MessageParcel & reply)194 int32_t TelephonyStateRegistryStub::OnUpdateCellInfo(MessageParcel &data, MessageParcel &reply)
195 {
196 int32_t ret = TELEPHONY_SUCCESS;
197 int32_t slotId = data.ReadInt32();
198 int32_t size = data.ReadInt32();
199 TELEPHONY_LOGI("TelephonyStateRegistryStub OnUpdateCellInfo:size=%{public}d\n", size);
200 size = ((size > CellInformation::MAX_CELL_NUM) ? 0 : size);
201 if (size <= 0) {
202 ret = TELEPHONY_ERR_FAIL;
203 TELEPHONY_LOGE("TelephonyStateRegistryStub the size less than or equal to 0!\n");
204 return ret;
205 }
206 std::vector<sptr<CellInformation>> cells;
207 CellInformation::CellType type;
208 for (int i = 0; i < size; ++i) {
209 type = static_cast<CellInformation::CellType>(data.ReadInt32());
210 switch (type) {
211 case CellInformation::CellType::CELL_TYPE_GSM: {
212 std::unique_ptr<GsmCellInformation> cell = std::make_unique<GsmCellInformation>();
213 if (cell != nullptr) {
214 cell->ReadFromParcel(data);
215 cells.emplace_back(cell.release());
216 }
217 break;
218 }
219 case CellInformation::CellType::CELL_TYPE_LTE: {
220 std::unique_ptr<LteCellInformation> cell = std::make_unique<LteCellInformation>();
221 if (cell != nullptr) {
222 cell->ReadFromParcel(data);
223 cells.emplace_back(cell.release());
224 }
225 break;
226 }
227 default:
228 break;
229 }
230 }
231 ret = UpdateCellInfo(slotId, cells);
232 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnUpdateCellInfo end##ret=%{public}d\n", ret);
233 reply.WriteInt32(ret);
234 return ret;
235 }
236
OnUpdateNetworkState(MessageParcel & data,MessageParcel & reply)237 int32_t TelephonyStateRegistryStub::OnUpdateNetworkState(MessageParcel &data, MessageParcel &reply)
238 {
239 int32_t ret = TELEPHONY_SUCCESS;
240 int32_t slotId = data.ReadInt32();
241 sptr<NetworkState> result = NetworkState::Unmarshalling(data);
242 if (result == nullptr) {
243 TELEPHONY_LOGE("TelephonyStateRegistryStub::OnUpdateNetworkState GetNetworkStatus is null\n");
244 ret = TELEPHONY_ERR_FAIL;
245 return ret;
246 }
247 ret = UpdateNetworkState(slotId, result);
248 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnUpdateNetworkState end##ret=%{public}d\n", ret);
249 reply.WriteInt32(ret);
250 return ret;
251 }
252
OnRegisterStateChange(MessageParcel & data,MessageParcel & reply)253 int32_t TelephonyStateRegistryStub::OnRegisterStateChange(MessageParcel &data, MessageParcel &reply)
254 {
255 int32_t ret = TELEPHONY_SUCCESS;
256 int32_t slotId = data.ReadInt32();
257 int32_t mask = data.ReadInt32();
258 bool notifyNow = data.ReadBool();
259 sptr<TelephonyObserverBroker> callback = nullptr;
260 ret = ReadData(data, reply, callback);
261 if (ret != TELEPHONY_SUCCESS) {
262 reply.WriteInt32(ret);
263 TELEPHONY_LOGE("TelephonyStateRegistryStub::OnRegisterStateChange ReadData failed\n");
264 return ret;
265 }
266 ret = RegisterStateChange(callback, slotId, mask, notifyNow);
267 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnRegisterStateChange end##ret=%{public}d\n", ret);
268 reply.WriteInt32(ret);
269 return ret;
270 }
271
OnUnregisterStateChange(MessageParcel & data,MessageParcel & reply)272 int32_t TelephonyStateRegistryStub::OnUnregisterStateChange(MessageParcel &data, MessageParcel &reply)
273 {
274 int32_t slotId = data.ReadInt32();
275 int32_t mask = data.ReadInt32();
276 int32_t ret = UnregisterStateChange(slotId, mask);
277 TELEPHONY_LOGI("TelephonyStateRegistryStub::OnUnregisterStateChange end##ret=%{public}d\n", ret);
278 reply.WriteInt32(ret);
279 return ret;
280 }
281
ReadData(MessageParcel & data,MessageParcel & reply,sptr<TelephonyObserverBroker> & callback)282 int32_t TelephonyStateRegistryStub::ReadData(
283 MessageParcel &data, MessageParcel &reply, sptr<TelephonyObserverBroker> &callback)
284 {
285 int32_t result = TELEPHONY_SUCCESS;
286 sptr<IRemoteObject> remote = data.ReadRemoteObject();
287 if (remote == nullptr) {
288 TELEPHONY_LOGE("TelephonyStateRegistryStub::ReadData remote is nullptr.\n");
289 result = TELEPHONY_ERR_FAIL;
290 reply.WriteInt32(result);
291 return result;
292 }
293 callback = iface_cast<TelephonyObserverBroker>(remote);
294 if (callback == nullptr) {
295 TELEPHONY_LOGE("TelephonyStateRegistryStub::ReadData callback is nullptr.\n");
296 result = TELEPHONY_ERR_FAIL;
297 reply.WriteInt32(result);
298 return result;
299 }
300 return result;
301 }
302
RegisterStateChange(const sptr<TelephonyObserverBroker> & telephonyObserver,int32_t slotId,uint32_t mask,bool isUpdate)303 int32_t TelephonyStateRegistryStub::RegisterStateChange(const sptr<TelephonyObserverBroker> &telephonyObserver,
304 int32_t slotId, uint32_t mask, bool isUpdate)
305 {
306 int32_t uid = IPCSkeleton::GetCallingUid();
307 std::string bundleName = "";
308 TelephonyPermission::GetBundleNameByUid(uid, bundleName);
309 return RegisterStateChange(telephonyObserver, slotId, mask, bundleName, isUpdate, IPCSkeleton::GetCallingPid());
310 }
311
UnregisterStateChange(int32_t slotId,uint32_t mask)312 int32_t TelephonyStateRegistryStub::UnregisterStateChange(int32_t slotId, uint32_t mask)
313 {
314 return UnregisterStateChange(slotId, mask, IPCSkeleton::GetCallingPid());
315 }
316 } // namespace Telephony
317 } // namespace OHOS