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