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