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 <cstdint>
17 #include <string_view>
18 
19 #include <napi/native_api.h>
20 #include <napi/native_common.h>
21 
22 #include "constant.h"
23 #include "module_template.h"
24 #include "napi_utils.h"
25 #include "net_manager_ext_constants.h"
26 #include "netmanager_ext_log.h"
27 #include "netshare_async_work.h"
28 #include "netshare_exec.h"
29 #include "netshare_issharing_context.h"
30 #include "netshare_observer_wrapper.h"
31 #include "netshare_startsharing_context.h"
32 #include "networkshare_constants.h"
33 
34 namespace OHOS {
35 namespace NetManagerStandard {
36 namespace {
37 // module name
38 constexpr const char *SHARE_MODULE_NAME = "net.sharing";
39 
40 // name of functions
41 constexpr const char *FUNCTION_IS_SHARING_SUPPORTED = "isSharingSupported";
42 constexpr const char *FUNCTION_IS_SHARING = "isSharing";
43 constexpr const char *FUNCTION_START_SHARING = "startSharing";
44 constexpr const char *FUNCTION_STOP_SHARING = "stopSharing";
45 constexpr const char *FUNCTION_GET_SHARING_IFACES = "getSharingIfaces";
46 constexpr const char *FUNCTION_GET_SHARING_STATE = "getSharingState";
47 constexpr const char *FUNCTION_GET_SHARABLE_REGEXES = "getSharableRegexes";
48 constexpr const char *FUNCTION_GET_STATS_RX_BYTES = "getStatsRxBytes";
49 constexpr const char *FUNCTION_GET_STATS_TX_BYTES = "getStatsTxBytes";
50 constexpr const char *FUNCTION_GET_STATS_TOTAL_BYTES = "getStatsTotalBytes";
51 constexpr const char *FUNCTION_ON = "on";
52 constexpr const char *FUNCTION_OFF = "off";
53 
54 // enum SharingIfaceState
55 constexpr const char *INTERFACE_SHARING_IFACE_STATE = "SharingIfaceState";
56 constexpr const char *SHARING_NIC_SERVING = "SHARING_NIC_SERVING";
57 constexpr const char *SHARING_NIC_CAN_SERVER = "SHARING_NIC_CAN_SERVER";
58 constexpr const char *SHARING_NIC_ERROR = "SHARING_NIC_ERROR";
59 
60 // enum SharingIfaceType
61 constexpr const char *INTERFACE_SHARING_IFACE_TYPE = "SharingIfaceType";
62 constexpr const char *SHARING_WIFI = "SHARING_WIFI";
63 constexpr const char *SHARING_USB = "SHARING_USB";
64 constexpr const char *SHARING_BLUETOOTH = "SHARING_BLUETOOTH";
65 } // namespace
66 
IsSharingSupported(napi_env env,napi_callback_info info)67 napi_value IsSharingSupported(napi_env env, napi_callback_info info)
68 {
69     return ModuleTemplate::Interface<IsSharingSupportedContext>(env, info, FUNCTION_IS_SHARING_SUPPORTED, nullptr,
70                                                                 NetShareAsyncWork::ExecIsSharingSupported,
71                                                                 NetShareAsyncWork::IsSharingSupportedCallback);
72 }
73 
IsSharing(napi_env env,napi_callback_info info)74 napi_value IsSharing(napi_env env, napi_callback_info info)
75 {
76     return ModuleTemplate::Interface<NetShareIsSharingContext>(env, info, FUNCTION_IS_SHARING, nullptr,
77                                                                NetShareAsyncWork::ExecIsSharing,
78                                                                NetShareAsyncWork::IsSharingCallback);
79 }
80 
StartSharing(napi_env env,napi_callback_info info)81 napi_value StartSharing(napi_env env, napi_callback_info info)
82 {
83     return ModuleTemplate::Interface<NetShareStartSharingContext>(env, info, FUNCTION_START_SHARING, nullptr,
84                                                                   NetShareAsyncWork::ExecStartSharing,
85                                                                   NetShareAsyncWork::StartSharingCallback);
86 }
87 
StopSharing(napi_env env,napi_callback_info info)88 napi_value StopSharing(napi_env env, napi_callback_info info)
89 {
90     return ModuleTemplate::Interface<StopSharingContext>(env, info, FUNCTION_STOP_SHARING, nullptr,
91                                                          NetShareAsyncWork::ExecStopSharing,
92                                                          NetShareAsyncWork::StopSharingCallback);
93 }
94 
GetSharingIfaces(napi_env env,napi_callback_info info)95 napi_value GetSharingIfaces(napi_env env, napi_callback_info info)
96 {
97     return ModuleTemplate::Interface<GetSharingIfacesContext>(env, info, FUNCTION_GET_SHARING_IFACES, nullptr,
98                                                               NetShareAsyncWork::ExecGetSharingIfaces,
99                                                               NetShareAsyncWork::GetSharingIfacesCallback);
100 }
101 
GetSharingState(napi_env env,napi_callback_info info)102 napi_value GetSharingState(napi_env env, napi_callback_info info)
103 {
104     return ModuleTemplate::Interface<GetSharingStateContext>(env, info, FUNCTION_GET_SHARING_STATE, nullptr,
105                                                              NetShareAsyncWork::ExecGetSharingState,
106                                                              NetShareAsyncWork::GetSharingStateCallback);
107 }
108 
GetSharableRegexes(napi_env env,napi_callback_info info)109 napi_value GetSharableRegexes(napi_env env, napi_callback_info info)
110 {
111     return ModuleTemplate::Interface<GetSharableRegexesContext>(env, info, FUNCTION_GET_SHARABLE_REGEXES, nullptr,
112                                                                 NetShareAsyncWork::ExecGetSharableRegexes,
113                                                                 NetShareAsyncWork::GetSharableRegexesCallback);
114 }
115 
GetStatsRxBytes(napi_env env,napi_callback_info info)116 napi_value GetStatsRxBytes(napi_env env, napi_callback_info info)
117 {
118     return ModuleTemplate::Interface<GetStatsRxBytesContext>(env, info, FUNCTION_GET_STATS_RX_BYTES, nullptr,
119                                                              NetShareAsyncWork::ExecGetStatsRxBytes,
120                                                              NetShareAsyncWork::GetStatsRxBytesCallback);
121 }
122 
GetStatsTxBytes(napi_env env,napi_callback_info info)123 napi_value GetStatsTxBytes(napi_env env, napi_callback_info info)
124 {
125     return ModuleTemplate::Interface<GetStatsTxBytesContext>(env, info, FUNCTION_GET_STATS_TX_BYTES, nullptr,
126                                                              NetShareAsyncWork::ExecGetStatsTxBytes,
127                                                              NetShareAsyncWork::GetStatsTxBytesCallback);
128 }
129 
GetStatsTotalBytes(napi_env env,napi_callback_info info)130 napi_value GetStatsTotalBytes(napi_env env, napi_callback_info info)
131 {
132     return ModuleTemplate::Interface<GetStatsTotalBytesContext>(env, info, FUNCTION_GET_STATS_TOTAL_BYTES, nullptr,
133                                                                 NetShareAsyncWork::ExecGetStatsTotalBytes,
134                                                                 NetShareAsyncWork::GetStatsTotalBytesCallback);
135 }
136 
On(napi_env env,napi_callback_info info)137 napi_value On(napi_env env, napi_callback_info info)
138 {
139     std::initializer_list<std::string_view> events = {EVENT_SHARE_STATE_CHANGE, EVENT_IFACE_SHARE_STATE_CHANGE,
140                                                       EVENT_SHARE_UPSTREAM_CHANGE};
141     return DelayedSingleton<NetShareObserverWrapper>::GetInstance()->On(env, info, events, false);
142 }
143 
Off(napi_env env,napi_callback_info info)144 napi_value Off(napi_env env, napi_callback_info info)
145 {
146     std::initializer_list<std::string_view> events = {EVENT_SHARE_STATE_CHANGE, EVENT_IFACE_SHARE_STATE_CHANGE,
147                                                       EVENT_SHARE_UPSTREAM_CHANGE};
148     return DelayedSingleton<NetShareObserverWrapper>::GetInstance()->Off(env, info, events, false);
149 }
150 
InitProperties(napi_env env,napi_value & exports)151 void InitProperties(napi_env env, napi_value &exports)
152 {
153     std::initializer_list<napi_property_descriptor> sharingIfaceState = {
154         DECLARE_NAPI_STATIC_PROPERTY(
155             SHARING_NIC_SERVING,
156             NapiUtils::CreateUint32(env, static_cast<uint32_t>(SharingIfaceState::SHARING_NIC_SERVING))),
157         DECLARE_NAPI_STATIC_PROPERTY(
158             SHARING_NIC_CAN_SERVER,
159             NapiUtils::CreateUint32(env, static_cast<uint32_t>(SharingIfaceState::SHARING_NIC_CAN_SERVER))),
160         DECLARE_NAPI_STATIC_PROPERTY(
161             SHARING_NIC_ERROR,
162             NapiUtils::CreateUint32(env, static_cast<uint32_t>(SharingIfaceState::SHARING_NIC_ERROR))),
163     };
164     napi_value ifaceState = NapiUtils::CreateObject(env);
165     NapiUtils::DefineProperties(env, ifaceState, sharingIfaceState);
166     NapiUtils::SetNamedProperty(env, exports, INTERFACE_SHARING_IFACE_STATE, ifaceState);
167 
168     std::initializer_list<napi_property_descriptor> sharingIfaceType = {
169         DECLARE_NAPI_STATIC_PROPERTY(
170             SHARING_WIFI, NapiUtils::CreateUint32(env, static_cast<uint32_t>(SharingIfaceType::SHARING_WIFI))),
171         DECLARE_NAPI_STATIC_PROPERTY(
172             SHARING_USB, NapiUtils::CreateUint32(env, static_cast<uint32_t>(SharingIfaceType::SHARING_USB))),
173         DECLARE_NAPI_STATIC_PROPERTY(
174             SHARING_BLUETOOTH,
175             NapiUtils::CreateUint32(env, static_cast<uint32_t>(SharingIfaceType::SHARING_BLUETOOTH))),
176     };
177     napi_value ifaceType = NapiUtils::CreateObject(env);
178     NapiUtils::DefineProperties(env, ifaceType, sharingIfaceType);
179     NapiUtils::SetNamedProperty(env, exports, INTERFACE_SHARING_IFACE_TYPE, ifaceType);
180 }
181 
InitNetShareModule(napi_env env,napi_value exports)182 napi_value InitNetShareModule(napi_env env, napi_value exports)
183 {
184     InitProperties(env, exports);
185 
186     NapiUtils::DefineProperties(env, exports,
187                                 {
188                                     DECLARE_NAPI_FUNCTION(FUNCTION_IS_SHARING_SUPPORTED, IsSharingSupported),
189                                     DECLARE_NAPI_FUNCTION(FUNCTION_IS_SHARING, IsSharing),
190                                     DECLARE_NAPI_FUNCTION(FUNCTION_START_SHARING, StartSharing),
191                                     DECLARE_NAPI_FUNCTION(FUNCTION_STOP_SHARING, StopSharing),
192                                     DECLARE_NAPI_FUNCTION(FUNCTION_GET_SHARING_IFACES, GetSharingIfaces),
193                                     DECLARE_NAPI_FUNCTION(FUNCTION_GET_SHARING_STATE, GetSharingState),
194                                     DECLARE_NAPI_FUNCTION(FUNCTION_GET_SHARABLE_REGEXES, GetSharableRegexes),
195                                     DECLARE_NAPI_FUNCTION(FUNCTION_GET_STATS_RX_BYTES, GetStatsRxBytes),
196                                     DECLARE_NAPI_FUNCTION(FUNCTION_GET_STATS_TX_BYTES, GetStatsTxBytes),
197                                     DECLARE_NAPI_FUNCTION(FUNCTION_GET_STATS_TOTAL_BYTES, GetStatsTotalBytes),
198                                     DECLARE_NAPI_FUNCTION(FUNCTION_ON, On),
199                                     DECLARE_NAPI_FUNCTION(FUNCTION_OFF, Off),
200                                 });
201     NapiUtils::SetEnvValid(env);
202     napi_add_env_cleanup_hook(env, NapiUtils::HookForEnvCleanup, env);
203     return exports;
204 }
205 
206 static napi_module g_netshareModule = {
207     .nm_version = 1,
208     .nm_flags = 0,
209     .nm_filename = nullptr,
210     .nm_register_func = InitNetShareModule,
211     .nm_modname = SHARE_MODULE_NAME,
212     .nm_priv = nullptr,
213     .reserved = {nullptr},
214 };
215 
RegisterNetShareModule(void)216 extern "C" __attribute__((constructor)) void RegisterNetShareModule(void)
217 {
218     napi_module_register(&g_netshareModule);
219 }
220 } // namespace NetManagerStandard
221 } // namespace OHOS
222