1 /*
2  * Copyright (c) 2022-2023 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 "policy_observer_wrapper.h"
17 
18 #include "constant.h"
19 #include "module_template.h"
20 #include "napi_constant.h"
21 #include "net_manager_constants.h"
22 #include "net_policy_client.h"
23 #include "net_policy_constants.h"
24 
25 namespace OHOS {
26 namespace NetManagerStandard {
27 constexpr const int DELETE_SIZE = 1;
PolicyObserverWrapper()28 PolicyObserverWrapper::PolicyObserverWrapper()
29     : observer_(new NetPolicyCallbackObserver()), manager_(new EventManager()), registed_(false)
30 {
31 }
32 
~PolicyObserverWrapper()33 PolicyObserverWrapper::~PolicyObserverWrapper()
34 {
35     if (manager_ != nullptr) {
36         delete manager_;
37     }
38 }
39 
On(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events,bool asyncCallback)40 napi_value PolicyObserverWrapper::On(napi_env env, napi_callback_info info,
41                                      const std::initializer_list<std::string> &events, bool asyncCallback)
42 {
43     size_t paramsCount = MAX_PARAM_NUM;
44     napi_value params[MAX_PARAM_NUM] = {nullptr};
45     NAPI_CALL(env, napi_get_cb_info(env, info, &paramsCount, params, nullptr, nullptr));
46     if (paramsCount != PARAM_OPTIONS_AND_CALLBACK || NapiUtils::GetValueType(env, params[ARG_INDEX_0]) != napi_string ||
47         NapiUtils::GetValueType(env, params[ARG_INDEX_1]) != napi_function) {
48         NETMANAGER_BASE_LOGE("on off once interface para: [string, function]");
49         napi_throw_error(env, std::to_string(NETMANAGER_ERR_PARAMETER_ERROR).c_str(), "Parameter error");
50         return NapiUtils::GetUndefined(env);
51     }
52 
53     const auto event = NapiUtils::GetStringFromValueUtf8(env, params[ARG_INDEX_0]);
54     if (std::find(events.begin(), events.end(), event) == events.end()) {
55         NETMANAGER_BASE_LOGE("no find event");
56         return NapiUtils::GetUndefined(env);
57     }
58     if (!registed_) {
59         int32_t ret = NetPolicyClient::GetInstance().RegisterNetPolicyCallback(observer_);
60         NETMANAGER_BASE_LOGI("ret = [%{public}d]", ret);
61         registed_ = (ret == NETMANAGER_SUCCESS);
62         if (!registed_) {
63             NETMANAGER_BASE_LOGE("register callback error");
64             NetBaseErrorCodeConvertor convertor;
65             std::string errorMsg = convertor.ConvertErrorCode(ret);
66             napi_throw_error(env, std::to_string(ret).c_str(), errorMsg.c_str());
67         } else {
68             manager_->AddListener(env, event, params[ARG_INDEX_1], false, asyncCallback);
69         }
70     } else {
71         int32_t ret = NetPolicyClient::GetInstance().CheckPermission();
72         if (ret != NETMANAGER_SUCCESS) {
73             NETMANAGER_BASE_LOGE("register callback error");
74             NetBaseErrorCodeConvertor convertor;
75             std::string errorMsg = convertor.ConvertErrorCode(ret);
76             napi_throw_error(env, std::to_string(ret).c_str(), errorMsg.c_str());
77         } else {
78             manager_->AddListener(env, event, params[ARG_INDEX_1], false, asyncCallback);
79         }
80     }
81     return NapiUtils::GetUndefined(env);
82 }
83 
Off(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events,bool asyncCallback)84 napi_value PolicyObserverWrapper::Off(napi_env env, napi_callback_info info,
85                                       const std::initializer_list<std::string> &events, bool asyncCallback)
86 {
87     napi_value thisVal = nullptr;
88     size_t paramsCount = MAX_PARAM_NUM;
89     napi_value params[MAX_PARAM_NUM] = {nullptr};
90     NAPI_CALL(env, napi_get_cb_info(env, info, &paramsCount, params, &thisVal, nullptr));
91 
92     if (!(paramsCount != PARAM_JUST_OPTIONS || paramsCount != PARAM_OPTIONS_AND_CALLBACK) ||
93         NapiUtils::GetValueType(env, params[ARG_INDEX_0]) != napi_string) {
94         NETMANAGER_BASE_LOGE("on off once interface para: [string, function?]");
95         napi_throw_error(env, std::to_string(NETMANAGER_ERR_PARAMETER_ERROR).c_str(), "Parameter error");
96         return NapiUtils::GetUndefined(env);
97     }
98 
99     if (paramsCount == PARAM_OPTIONS_AND_CALLBACK &&
100         NapiUtils::GetValueType(env, params[ARG_INDEX_1]) != napi_function) {
101         NETMANAGER_BASE_LOGE("on off once interface para: [string, function]");
102         return NapiUtils::GetUndefined(env);
103     }
104 
105     std::string event = NapiUtils::GetStringFromValueUtf8(env, params[ARG_INDEX_0]);
106     if (std::find(events.begin(), events.end(), event) == events.end()) {
107         return NapiUtils::GetUndefined(env);
108     }
109 
110     if (manager_->GetListenerListNum() > DELETE_SIZE) {
111         int32_t ret = NetPolicyClient::GetInstance().CheckPermission();
112         if (ret != NETMANAGER_SUCCESS) {
113             NETMANAGER_BASE_LOGE("unregister ret = %{public}d", ret);
114             NetBaseErrorCodeConvertor convertor;
115             std::string errorMsg = convertor.ConvertErrorCode(ret);
116             napi_throw_error(env, std::to_string(ret).c_str(), errorMsg.c_str());
117             return NapiUtils::GetUndefined(env);
118         }
119         DeleteListener(paramsCount, params, event);
120         return NapiUtils::GetUndefined(env);
121     }
122     if (manager_->GetListenerListNum() <= DELETE_SIZE) {
123         auto ret = NetPolicyClient::GetInstance().UnregisterNetPolicyCallback(observer_);
124         if (ret != NETMANAGER_SUCCESS) {
125             NETMANAGER_BASE_LOGE("unregister ret = %{public}d", ret);
126             NetBaseErrorCodeConvertor convertor;
127             std::string errorMsg = convertor.ConvertErrorCode(ret);
128             napi_throw_error(env, std::to_string(ret).c_str(), errorMsg.c_str());
129         } else {
130             DeleteListener(paramsCount, params, event);
131             registed_ = false;
132         }
133     }
134     return NapiUtils::GetUndefined(env);
135 }
136 
DeleteListener(size_t paramsCount,napi_value * params,std::string event)137 void PolicyObserverWrapper::DeleteListener(size_t paramsCount, napi_value *params, std::string event)
138 {
139     if (paramsCount == PARAM_OPTIONS_AND_CALLBACK) {
140         manager_->DeleteListener(event, params[ARG_INDEX_1]);
141     } else {
142         manager_->DeleteListener(event);
143     }
144 }
145 
146 } // namespace NetManagerStandard
147 } // namespace OHOS
148