1 /*
2 * Copyright (c) 2023-2024 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 "net_factoryreset_callback.h"
17
18 #include "net_mgr_log_wrapper.h"
19 #include "cpp/queue.h"
20
21 namespace OHOS {
22 namespace NetManagerStandard {
23 constexpr int16_t LIMIT_CALLBACK_NUM = 200;
24
NetFactoryResetCallback()25 NetFactoryResetCallback::NetFactoryResetCallback()
26 {
27 factoryResetCallFfrtQueue_ = std::make_shared<ffrt::queue>("NetFactoryResetCall");
28 }
29
RegisterNetFactoryResetCallbackAsync(const sptr<INetFactoryResetCallback> & callback)30 int32_t NetFactoryResetCallback::RegisterNetFactoryResetCallbackAsync(const sptr<INetFactoryResetCallback> &callback)
31 {
32 if (callback == nullptr || callback->AsObject() == nullptr || callback->AsObject().GetRefPtr() == nullptr) {
33 NETMGR_LOG_E("The parameter callback is null");
34 return NETMANAGER_ERR_PARAMETER_ERROR;
35 }
36 int32_t ret = NETMANAGER_SUCCESS;
37 if (!factoryResetCallFfrtQueue_) {
38 NETMGR_LOG_E("FFRT Init Fail");
39 return NETMANAGER_ERR_PARAMETER_ERROR;
40 }
41 ffrt::task_handle ResetCallbackAsyncTask = factoryResetCallFfrtQueue_->submit_h([this, &callback, &ret]() {
42 ret = RegisterNetFactoryResetCallback(callback);
43 }, ffrt::task_attr().name("FfrtRegisterNetFactoryResetCallbackAsync"));
44 factoryResetCallFfrtQueue_->wait(ResetCallbackAsyncTask);
45 return ret;
46 }
47
RegisterNetFactoryResetCallback(const sptr<INetFactoryResetCallback> & callback)48 int32_t NetFactoryResetCallback::RegisterNetFactoryResetCallback(const sptr<INetFactoryResetCallback> &callback)
49 {
50 uint32_t callbackCounts = callbacks_.size();
51 NETMGR_LOG_I("callback counts [%{public}u]", callbackCounts);
52 if (callbackCounts >= LIMIT_CALLBACK_NUM) {
53 NETMGR_LOG_E("callback counts cannot more than [%{public}u]", LIMIT_CALLBACK_NUM);
54 return NETMANAGER_ERR_PARAMETER_ERROR;
55 }
56
57 for (uint32_t i = 0; i < callbackCounts; i++) {
58 if (callback->AsObject().GetRefPtr() == callbacks_[i]->AsObject().GetRefPtr()) {
59 NETMGR_LOG_W("NetFactoryResetCallback_ had this callback");
60 return NETMANAGER_ERR_PARAMETER_ERROR;
61 }
62 }
63
64 callbacks_.emplace_back(callback);
65 NETMGR_LOG_I("End RegisterNetFactoryResetCallback,callback counts [%{public}zu]", callbacks_.size());
66 return NETMANAGER_SUCCESS;
67 }
68
UnregisterNetFactoryResetCallbackAsync(const sptr<INetFactoryResetCallback> & callback)69 int32_t NetFactoryResetCallback::UnregisterNetFactoryResetCallbackAsync(const sptr<INetFactoryResetCallback> &callback)
70 {
71 if (callback == nullptr || callback->AsObject() == nullptr || callback->AsObject().GetRefPtr() == nullptr) {
72 NETMGR_LOG_E("The parameter of callback is null");
73 return NETMANAGER_ERR_PARAMETER_ERROR;
74 }
75 if (!factoryResetCallFfrtQueue_) {
76 NETMGR_LOG_E("FFRT Init Fail");
77 return NETMANAGER_ERR_PARAMETER_ERROR;
78 }
79 int32_t ret = NETMANAGER_SUCCESS;
80 ffrt::task_handle UnregisterNetFactoryResetCallbackAsync =
81 factoryResetCallFfrtQueue_->submit_h([this, &callback, &ret]() {
82 ret = UnregisterNetFactoryResetCallback(callback);
83 }, ffrt::task_attr().name("FfrtUnregisterNetFactoryResetCallbackAsync"));
84 factoryResetCallFfrtQueue_->wait(UnregisterNetFactoryResetCallbackAsync);
85
86 return ret;
87 }
88
UnregisterNetFactoryResetCallback(const sptr<INetFactoryResetCallback> & callback)89 int32_t NetFactoryResetCallback::UnregisterNetFactoryResetCallback(const sptr<INetFactoryResetCallback> &callback)
90 {
91 NETMGR_LOG_I("Enter UnregisterNetFactoryResetCallback");
92 auto it = std::remove_if(callbacks_.begin(), callbacks_.end(),
93 [callback](const sptr<INetFactoryResetCallback> &tempCallback) -> bool {
94 if (tempCallback == nullptr || tempCallback->AsObject() == nullptr ||
95 tempCallback->AsObject().GetRefPtr() == nullptr) {
96 return true;
97 }
98 return callback->AsObject().GetRefPtr() == tempCallback->AsObject().GetRefPtr();
99 });
100 callbacks_.erase(it, callbacks_.end());
101 NETMGR_LOG_I("End UnregisterNetFactoryResetCallback");
102 return NETMANAGER_SUCCESS;
103 }
104
105
NotifyNetFactoryResetAsync()106 int32_t NetFactoryResetCallback::NotifyNetFactoryResetAsync()
107 {
108 NETMGR_LOG_I("NotifyNetFactoryResetAsync enter");
109 int32_t ret = NETMANAGER_SUCCESS;
110 if (!factoryResetCallFfrtQueue_) {
111 NETMGR_LOG_E("FFRT Init Fail");
112 return NETMANAGER_ERR_PARAMETER_ERROR;
113 }
114 ffrt::task_handle NotifyNetFactoryResetAsyncTask = factoryResetCallFfrtQueue_->submit_h([this, &ret]() {
115 ret = NotifyNetFactoryReset();
116 }, ffrt::task_attr().name("FfrtNotifyNetFactoryResetAsync"));
117 factoryResetCallFfrtQueue_->wait(NotifyNetFactoryResetAsyncTask);
118 return ret;
119 }
120
NotifyNetFactoryReset()121 int32_t NetFactoryResetCallback::NotifyNetFactoryReset()
122 {
123 NETMGR_LOG_I("NotifyNetFactoryReset enter, callback count = [%{public}zu]", callbacks_.size());
124 for (const auto &callback : callbacks_) {
125 if (callback != nullptr && callback->AsObject() != nullptr && callback->AsObject().GetRefPtr() != nullptr) {
126 callback->OnNetFactoryReset();
127 }
128 }
129
130 return NETMANAGER_SUCCESS;
131 }
132
133 } // namespace NetManagerStandard
134 } // namespace OHOS
135