1 /*
2 * Copyright (c) 2022 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 "netshare_exec.h"
17
18 #include "constant.h"
19 #include "napi_utils.h"
20 #include "net_manager_constants.h"
21 #include "net_manager_ext_constants.h"
22 #include "netmanager_ext_log.h"
23 #include "networkshare_client.h"
24 #include "networkshare_constants.h"
25
26 namespace OHOS {
27 namespace NetManagerStandard {
ExecIsSharingSupported(IsSharingSupportedContext * context)28 bool NetShareExec::ExecIsSharingSupported(IsSharingSupportedContext *context)
29 {
30 int32_t supported = NETWORKSHARE_IS_UNSUPPORTED;
31 int32_t result = DelayedSingleton<NetworkShareClient>::GetInstance()->IsSharingSupported(supported);
32 if (result != NETMANAGER_EXT_SUCCESS) {
33 context->SetErrorCode(result);
34 NETMANAGER_EXT_LOGE("ExecIsSharingSupported error, errorCode: %{public}d", result);
35 return false;
36 }
37 context->SetSharingSupported(supported);
38 return true;
39 }
40
IsSharingSupportedCallback(IsSharingSupportedContext * context)41 napi_value NetShareExec::IsSharingSupportedCallback(IsSharingSupportedContext *context)
42 {
43 return NapiUtils::GetBoolean(context->GetEnv(), static_cast<bool>(context->GetSharingSupported()));
44 }
45
ExecIsSharing(NetShareIsSharingContext * context)46 bool NetShareExec::ExecIsSharing(NetShareIsSharingContext *context)
47 {
48 int32_t sharingStatus = NETWORKSHARE_IS_UNSHARING;
49 int32_t result = DelayedSingleton<NetworkShareClient>::GetInstance()->IsSharing(sharingStatus);
50 if (result != NETMANAGER_EXT_SUCCESS) {
51 context->SetErrorCode(result);
52 NETMANAGER_EXT_LOGE("ExecIsSharing error, errorCode: %{public}d", result);
53 return false;
54 }
55 context->SetSharing(sharingStatus);
56 return true;
57 }
58
IsSharingCallback(NetShareIsSharingContext * context)59 napi_value NetShareExec::IsSharingCallback(NetShareIsSharingContext *context)
60 {
61 return NapiUtils::GetBoolean(context->GetEnv(), static_cast<bool>(context->GetSharing()));
62 }
63
ExecStartSharing(NetShareStartSharingContext * context)64 bool NetShareExec::ExecStartSharing(NetShareStartSharingContext *context)
65 {
66 SharingIfaceType ifaceType = static_cast<SharingIfaceType>(context->GetParam());
67 int32_t result = DelayedSingleton<NetworkShareClient>::GetInstance()->StartSharing(ifaceType);
68 if (result != NETMANAGER_EXT_SUCCESS) {
69 context->SetErrorCode(result);
70 NETMANAGER_EXT_LOGE("ExecStartSharing error, errorCode: %{public}d", result);
71 return false;
72 }
73 return true;
74 }
75
StartSharingCallback(NetShareStartSharingContext * context)76 napi_value NetShareExec::StartSharingCallback(NetShareStartSharingContext *context)
77 {
78 return NapiUtils::GetUndefined(context->GetEnv());
79 }
80
ExecStopSharing(StopSharingContext * context)81 bool NetShareExec::ExecStopSharing(StopSharingContext *context)
82 {
83 SharingIfaceType ifaceType = static_cast<SharingIfaceType>(context->GetParam());
84 int32_t result = DelayedSingleton<NetworkShareClient>::GetInstance()->StopSharing(ifaceType);
85 if (result != NETMANAGER_EXT_SUCCESS) {
86 context->SetErrorCode(result);
87 NETMANAGER_EXT_LOGE("ExecStopSharing error, errorCode: %{public}d", result);
88 return false;
89 }
90 return true;
91 }
92
StopSharingCallback(StopSharingContext * context)93 napi_value NetShareExec::StopSharingCallback(StopSharingContext *context)
94 {
95 return NapiUtils::GetUndefined(context->GetEnv());
96 }
97
ExecGetSharingIfaces(GetSharingIfacesContext * context)98 bool NetShareExec::ExecGetSharingIfaces(GetSharingIfacesContext *context)
99 {
100 SharingIfaceState ifaceState = static_cast<SharingIfaceState>(context->GetParam());
101 std::vector<std::string> ifaces;
102 int32_t result = DelayedSingleton<NetworkShareClient>::GetInstance()->GetSharingIfaces(ifaceState, ifaces);
103 if (result != NETMANAGER_EXT_SUCCESS) {
104 context->SetErrorCode(result);
105 NETMANAGER_EXT_LOGE("ExecGetSharingIfaces error, errorCode: %{public}d", result);
106 return false;
107 }
108 context->SetIface(ifaces);
109 return true;
110 }
111
GetSharingIfacesCallback(GetSharingIfacesContext * context)112 napi_value NetShareExec::GetSharingIfacesCallback(GetSharingIfacesContext *context)
113 {
114 napi_value ifacesArray = NapiUtils::CreateArray(context->GetEnv(), context->GetIfaces().size());
115 uint32_t index = 0;
116 for (auto iface : context->GetIfaces()) {
117 napi_value item = NapiUtils::CreateStringUtf8(context->GetEnv(), iface);
118 NapiUtils::SetArrayElement(context->GetEnv(), ifacesArray, index++, item);
119 }
120 return ifacesArray;
121 }
122
ExecGetSharingState(GetSharingStateContext * context)123 bool NetShareExec::ExecGetSharingState(GetSharingStateContext *context)
124 {
125 SharingIfaceType ifaceType = static_cast<SharingIfaceType>(context->GetParam());
126 SharingIfaceState ifaceState;
127
128 int32_t result = DelayedSingleton<NetworkShareClient>::GetInstance()->GetSharingState(ifaceType, ifaceState);
129 if (result != NETMANAGER_EXT_SUCCESS) {
130 context->SetErrorCode(result);
131 NETMANAGER_EXT_LOGE("ExecGetSharingState error, errorCode: %{public}d", result);
132 return false;
133 }
134 context->SetParam(static_cast<int32_t>(ifaceState));
135 return true;
136 }
137
GetSharingStateCallback(GetSharingStateContext * context)138 napi_value NetShareExec::GetSharingStateCallback(GetSharingStateContext *context)
139 {
140 return NapiUtils::CreateInt32(context->GetEnv(), context->GetParam());
141 }
142
ExecGetSharableRegexes(GetSharableRegexesContext * context)143 bool NetShareExec::ExecGetSharableRegexes(GetSharableRegexesContext *context)
144 {
145 SharingIfaceType ifaceType = static_cast<SharingIfaceType>(context->GetParam());
146 std::vector<std::string> ifaceRegexs;
147 int32_t result = DelayedSingleton<NetworkShareClient>::GetInstance()->GetSharableRegexs(ifaceType, ifaceRegexs);
148 if (result != NETMANAGER_EXT_SUCCESS) {
149 context->SetErrorCode(result);
150 NETMANAGER_EXT_LOGE("ExecGetSharableRegexes error, errorCode: %{public}d", result);
151 return false;
152 }
153 context->SetIface(ifaceRegexs);
154 return true;
155 }
156
GetSharableRegexesCallback(GetSharableRegexesContext * context)157 napi_value NetShareExec::GetSharableRegexesCallback(GetSharableRegexesContext *context)
158 {
159 napi_value ifacesArray = NapiUtils::CreateArray(context->GetEnv(), context->GetIfaces().size());
160 uint32_t index = 0;
161 for (auto iface : context->GetIfaces()) {
162 napi_value item = NapiUtils::CreateStringUtf8(context->GetEnv(), iface);
163 NapiUtils::SetArrayElement(context->GetEnv(), ifacesArray, index++, item);
164 }
165 return ifacesArray;
166 }
167
ExecGetStatsRxBytes(GetStatsRxBytesContext * context)168 bool NetShareExec::ExecGetStatsRxBytes(GetStatsRxBytesContext *context)
169 {
170 int32_t bytes = 0;
171 int32_t result = DelayedSingleton<NetworkShareClient>::GetInstance()->GetStatsRxBytes(bytes);
172 if (result != NETMANAGER_EXT_SUCCESS) {
173 context->SetErrorCode(result);
174 NETMANAGER_EXT_LOGE("ExecGetStatsRxBytes error, errorCode: %{public}d", result);
175 return false;
176 }
177 context->SetBytes32(bytes);
178 return true;
179 }
180
GetStatsRxBytesCallback(GetStatsRxBytesContext * context)181 napi_value NetShareExec::GetStatsRxBytesCallback(GetStatsRxBytesContext *context)
182 {
183 return NapiUtils::CreateInt32(context->GetEnv(), context->GetBytes32());
184 }
185
ExecGetStatsTxBytes(GetStatsTxBytesContext * context)186 bool NetShareExec::ExecGetStatsTxBytes(GetStatsTxBytesContext *context)
187 {
188 int32_t bytes = 0;
189 int32_t result = DelayedSingleton<NetworkShareClient>::GetInstance()->GetStatsTxBytes(bytes);
190 if (result != NETMANAGER_EXT_SUCCESS) {
191 context->SetErrorCode(result);
192 NETMANAGER_EXT_LOGE("ExecGetStatsTxBytes error, errorCode: %{public}d", result);
193 return false;
194 }
195 context->SetBytes32(bytes);
196 return true;
197 }
198
GetStatsTxBytesCallback(GetStatsTxBytesContext * context)199 napi_value NetShareExec::GetStatsTxBytesCallback(GetStatsTxBytesContext *context)
200 {
201 return NapiUtils::CreateInt32(context->GetEnv(), context->GetBytes32());
202 }
203
ExecGetStatsTotalBytes(GetStatsTotalBytesContext * context)204 bool NetShareExec::ExecGetStatsTotalBytes(GetStatsTotalBytesContext *context)
205 {
206 int32_t bytes = 0;
207 int32_t result = DelayedSingleton<NetworkShareClient>::GetInstance()->GetStatsTotalBytes(bytes);
208 if (result != NETMANAGER_EXT_SUCCESS) {
209 context->SetErrorCode(result);
210 NETMANAGER_EXT_LOGE("ExecGetStatsTotalBytes error, errorCode: %{public}d", result);
211 return false;
212 }
213 context->SetBytes32(bytes);
214 return true;
215 }
216
GetStatsTotalBytesCallback(GetStatsTotalBytesContext * context)217 napi_value NetShareExec::GetStatsTotalBytesCallback(GetStatsTotalBytesContext *context)
218 {
219 return NapiUtils::CreateInt32(context->GetEnv(), context->GetBytes32());
220 }
221 } // namespace NetManagerStandard
222 } // namespace OHOS
223