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 "wifi_device_mgr_service_impl.h"
17 #include "wifi_device_service_impl.h"
18 #include "wifi_logger.h"
19 #include "wifi_dumper.h"
20 #include "wifi_manager.h"
21 #ifndef OHOS_ARCH_LITE
22 #include <file_ex.h>
23 #endif
24
25 DEFINE_WIFILOG_HOTSPOT_LABEL("WifiDeviceMgrServiceImpl");
26
27 namespace OHOS {
28 namespace Wifi {
29 const std::string EXTENSION_BACKUP = "backup";
30 const std::string EXTENSION_RESTORE = "restore";
31 std::mutex WifiDeviceMgrServiceImpl::g_instanceLock;
32 std::mutex WifiDeviceMgrServiceImpl::g_initMutex;
33 sptr<WifiDeviceMgrServiceImpl> WifiDeviceMgrServiceImpl::g_instance;
34 const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(
35 WifiDeviceMgrServiceImpl::GetInstance().GetRefPtr());
36
GetInstance()37 sptr<WifiDeviceMgrServiceImpl> WifiDeviceMgrServiceImpl::GetInstance()
38 {
39 if (g_instance == nullptr) {
40 std::lock_guard<std::mutex> autoLock(g_instanceLock);
41 if (g_instance == nullptr) {
42 sptr<WifiDeviceMgrServiceImpl> service = new (std::nothrow) WifiDeviceMgrServiceImpl;
43 g_instance = service;
44 }
45 }
46 return g_instance;
47 }
48
WifiDeviceMgrServiceImpl()49 WifiDeviceMgrServiceImpl::WifiDeviceMgrServiceImpl()
50 : SystemAbility(WIFI_DEVICE_ABILITY_ID, true), mPublishFlag(false), mState(ServiceRunningState::STATE_NOT_START)
51 {}
52
~WifiDeviceMgrServiceImpl()53 WifiDeviceMgrServiceImpl::~WifiDeviceMgrServiceImpl()
54 {}
55
OnStart()56 void WifiDeviceMgrServiceImpl::OnStart()
57 {
58 WIFI_LOGI("Start sta service!");
59 if (mState == ServiceRunningState::STATE_RUNNING) {
60 WIFI_LOGW("Service has already started.");
61 return;
62 }
63 if (WifiManager::GetInstance().Init() < 0) {
64 WIFI_LOGE("WifiManager init failed!");
65 return;
66 }
67 if (!Init()) {
68 WIFI_LOGE("Failed to init service");
69 OnStop();
70 return;
71 }
72 mState = ServiceRunningState::STATE_RUNNING;
73 auto &pWifiStaManager = WifiManager::GetInstance().GetWifiStaManager();
74 if (pWifiStaManager) {
75 pWifiStaManager->StartUnloadStaSaTimer();
76 }
77 }
78
OnStop()79 void WifiDeviceMgrServiceImpl::OnStop()
80 {
81 mState = ServiceRunningState::STATE_NOT_START;
82 mPublishFlag = false;
83 WIFI_LOGI("Stop sta service!");
84 }
85
Init()86 bool WifiDeviceMgrServiceImpl::Init()
87 {
88 std::lock_guard<std::mutex> lock(g_initMutex);
89 if (!mPublishFlag) {
90 for (int i = 0; i < STA_INSTANCE_MAX_NUM; i++) {
91 sptr<WifiDeviceServiceImpl> wifi = new WifiDeviceServiceImpl(i);
92 if (wifi == nullptr) {
93 WIFI_LOGE("create sta service id %{public}d failed!", i);
94 return false;
95 }
96 mWifiService[i] = wifi->AsObject();
97 }
98
99 bool ret = Publish(WifiDeviceMgrServiceImpl::GetInstance());
100 if (!ret) {
101 WIFI_LOGE("Failed to publish sta service!");
102 return false;
103 }
104 mPublishFlag = true;
105 }
106 return true;
107 }
108
GetWifiRemote(int instId)109 sptr<IRemoteObject> WifiDeviceMgrServiceImpl::GetWifiRemote(int instId)
110 {
111 std::lock_guard<std::mutex> lock(g_initMutex);
112 auto iter = mWifiService.find(instId);
113 if (iter != mWifiService.end()) {
114 return mWifiService[instId];
115 }
116 return nullptr;
117 }
118
GetDeviceServiceMgr()119 std::map<int, sptr<IRemoteObject>>& WifiDeviceMgrServiceImpl::GetDeviceServiceMgr()
120 {
121 return mWifiService;
122 }
123
124 #ifndef OHOS_ARCH_LITE
Dump(int32_t fd,const std::vector<std::u16string> & args)125 int32_t WifiDeviceMgrServiceImpl::Dump(int32_t fd, const std::vector<std::u16string>& args)
126 {
127 WIFI_LOGI("Enter sta dump func.");
128 std::vector<std::string> vecArgs;
129 std::transform(args.begin(), args.end(), std::back_inserter(vecArgs), [](const std::u16string &arg) {
130 return Str16ToStr8(arg);
131 });
132
133 WifiDumper dumper;
134 std::string result;
135 dumper.DeviceDump(WifiDeviceServiceImpl::SaBasicDump, vecArgs, result);
136 if (!SaveStringToFd(fd, result)) {
137 WIFI_LOGE("WiFi device save string to fd failed.");
138 return ERR_OK;
139 }
140 return ERR_OK;
141 }
142
OnExtension(const std::string & extension,MessageParcel & data,MessageParcel & reply)143 int32_t WifiDeviceMgrServiceImpl::OnExtension(const std::string& extension, MessageParcel& data, MessageParcel& reply)
144 {
145 WIFI_LOGI("extension is %{public}s.", extension.c_str());
146 if (extension == EXTENSION_BACKUP) {
147 return WifiDeviceServiceImpl::OnBackup(data, reply);
148 } else if (extension == EXTENSION_RESTORE) {
149 return WifiDeviceServiceImpl::OnRestore(data, reply);
150 }
151 return 0;
152 }
153 #endif
154 } // namespace Wifi
155 } // namespace OHOS