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 "network_type.h"
17
18 #include "network_search_manager.h"
19 #include "telephony_errors.h"
20 #include "telephony_log_wrapper.h"
21 #include "telephony_ext_wrapper.h"
22
23 namespace OHOS {
24 namespace Telephony {
NetworkType(const std::weak_ptr<NetworkSearchManager> & networkSearchManager,int32_t slotId)25 NetworkType::NetworkType(const std::weak_ptr<NetworkSearchManager> &networkSearchManager, int32_t slotId)
26 : networkSearchManager_(networkSearchManager), slotId_(slotId)
27 {}
28
ProcessGetPreferredNetwork(const AppExecFwk::InnerEvent::Pointer & event) const29 void NetworkType::ProcessGetPreferredNetwork(const AppExecFwk::InnerEvent::Pointer &event) const
30 {
31 if (event == nullptr) {
32 TELEPHONY_LOGE("NetworkType::ProcessGetPreferredNetwork event is nullptr");
33 return;
34 }
35 std::shared_ptr<PreferredNetworkTypeInfo> preferredNetworkInfo =
36 event->GetSharedObject<PreferredNetworkTypeInfo>();
37 if (TELEPHONY_EXT_WRAPPER.getPreferredNetworkExt_ != nullptr && preferredNetworkInfo != nullptr) {
38 TELEPHONY_EXT_WRAPPER.getPreferredNetworkExt_(preferredNetworkInfo->preferredNetworkType);
39 }
40 std::shared_ptr<HRilRadioResponseInfo> responseInfo = event->GetSharedObject<HRilRadioResponseInfo>();
41 if (preferredNetworkInfo == nullptr && responseInfo == nullptr) {
42 TELEPHONY_LOGE("NetworkType::ProcessGetPreferredNetwork object is nullptr\n");
43 return;
44 }
45 MessageParcel data;
46 int64_t index = -1;
47 if (!WriteGetPreferredNetworkInfo(preferredNetworkInfo, responseInfo, data, index)) {
48 return;
49 }
50 std::shared_ptr<NetworkSearchCallbackInfo> callbackInfo = NetworkUtils::FindNetworkSearchCallback(index);
51 if (callbackInfo != nullptr) {
52 sptr<INetworkSearchCallback> callback = callbackInfo->networkSearchItem_;
53 if (callback != nullptr) {
54 callback->OnNetworkSearchCallback(
55 INetworkSearchCallback::NetworkSearchCallback::GET_PREFERRED_NETWORK_MODE_RESULT, data);
56 TELEPHONY_LOGI("NetworkType::ProcessGetPreferredNetwork callback success");
57 }
58 NetworkUtils::RemoveCallbackFromMap(index);
59 } else {
60 TELEPHONY_LOGI("NetworkType::ProcessGetPreferredNetwork has no callbackInfo");
61 }
62 }
63
ProcessSetPreferredNetwork(const AppExecFwk::InnerEvent::Pointer & event) const64 void NetworkType::ProcessSetPreferredNetwork(const AppExecFwk::InnerEvent::Pointer &event) const
65 {
66 if (event == nullptr) {
67 TELEPHONY_LOGE("NetworkType::ProcessSetPreferredNetwork event is nullptr");
68 return;
69 }
70 std::shared_ptr<NetworkSearchManager> networkSearchManager = networkSearchManager_.lock();
71 if (networkSearchManager == nullptr) {
72 TELEPHONY_LOGE("NetworkType::ProcessSetPreferredNetwork networkSearchManager is nullptr");
73 return;
74 }
75 std::shared_ptr<HRilRadioResponseInfo> responseInfo = event->GetSharedObject<HRilRadioResponseInfo>();
76 if (responseInfo == nullptr) {
77 TELEPHONY_LOGE("NetworkType::ProcessSetPreferredNetwork responseInfo is nullptr");
78 return;
79 }
80
81 bool success = responseInfo->error == HRilErrType::NONE;
82 if (success) {
83 int32_t networkMode = 0;
84 networkSearchManager->GetCachePreferredNetworkValue(slotId_, networkMode);
85 if (networkMode >= static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_AUTO) &&
86 networkMode < static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_MAX_VALUE)) {
87 networkSearchManager->SavePreferredNetworkValue(slotId_, networkMode);
88 }
89 }
90 int64_t index = responseInfo->flag;
91 std::shared_ptr<NetworkSearchCallbackInfo> callbackInfo = NetworkUtils::FindNetworkSearchCallback(index);
92 if (callbackInfo == nullptr) {
93 TELEPHONY_LOGE("NetworkType::ProcessSetPreferredNetwork callbackInfo is nullptr slotId:%{public}d", slotId_);
94 return;
95 }
96 sptr<INetworkSearchCallback> callback = callbackInfo->networkSearchItem_;
97 if (callback == nullptr) {
98 TELEPHONY_LOGE("NetworkType::ProcessSetPreferredNetwork callback is nullptr slotId:%{public}d", slotId_);
99 return;
100 }
101 MessageParcel data;
102 data.WriteInterfaceToken(INetworkSearchCallback::GetDescriptor());
103 if (!data.WriteBool(success) ||
104 !data.WriteInt32(success ? TELEPHONY_SUCCESS : (int32_t)responseInfo->error)) {
105 TELEPHONY_LOGE("NetworkType::ProcessSetPreferredNetwork write date fail slotId:%{public}d", slotId_);
106 return;
107 }
108 callback->OnNetworkSearchCallback(
109 INetworkSearchCallback::NetworkSearchCallback::SET_PREFERRED_NETWORK_MODE_RESULT, data);
110 NetworkUtils::RemoveCallbackFromMap(index);
111 }
112
WriteGetPreferredNetworkInfo(std::shared_ptr<PreferredNetworkTypeInfo> & preferredNetworkInfo,std::shared_ptr<HRilRadioResponseInfo> & responseInfo,MessageParcel & data,int64_t & index) const113 bool NetworkType::WriteGetPreferredNetworkInfo(std::shared_ptr<PreferredNetworkTypeInfo> &preferredNetworkInfo,
114 std::shared_ptr<HRilRadioResponseInfo> &responseInfo, MessageParcel &data, int64_t &index) const
115 {
116 std::shared_ptr<NetworkSearchManager> networkSearchManager = networkSearchManager_.lock();
117 if (networkSearchManager == nullptr) {
118 TELEPHONY_LOGE("NetworkType::ProcessGetPreferredNetwork networkSearchManager is nullptr\n");
119 return false;
120 }
121 int32_t networkMode = -1;
122 if (!data.WriteInterfaceToken(INetworkSearchCallback::GetDescriptor())) {
123 TELEPHONY_LOGE("NetworkType::ProcessGetPreferredNetwork WriteInterfaceToken failed");
124 return false;
125 }
126 if (preferredNetworkInfo != nullptr) {
127 networkMode = preferredNetworkInfo->preferredNetworkType;
128 index = preferredNetworkInfo->flag;
129 networkSearchManager->SavePreferredNetworkValue(slotId_, networkMode);
130 if (!data.WriteInt32(networkMode) || !data.WriteInt32(TELEPHONY_SUCCESS)) {
131 TELEPHONY_LOGE("NetworkType::ProcessGetPreferredNetwork WriteInt32 networkMode is false");
132 return false;
133 }
134 } else if (responseInfo != nullptr) {
135 TELEPHONY_LOGE("NetworkType::ProcessGetPreferredNetwork error code is %{public}d", responseInfo->error);
136 index = responseInfo->flag;
137 if (!data.WriteInt32(networkMode) && !data.WriteInt32(static_cast<int32_t>(responseInfo->error))) {
138 TELEPHONY_LOGE("NetworkType::ProcessGetPreferredNetwork WriteInt32 networkMode is false");
139 return false;
140 }
141 }
142 return true;
143 }
144 } // namespace Telephony
145 } // namespace OHOS
146