1/*
2 * Copyright (c) 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 "device_manager_impl.h"
17#include "device_manager_impl_mock.h"
18#include "dm_constants.h"
19
20#include "gtest/gtest.h"
21
22namespace OHOS {
23namespace DistributedHardware {
24using namespace OHOS::Storage::DistributedFile;
25const std::string NETWORKID_ONE = "45656596896323231";
26const std::string NETWORKID_TWO = "45656596896323232";
27const std::string NETWORKID_THREE = "45656596896323233";
28constexpr int32_t NETWORKTYPE_WITH_WIFI = 2;
29constexpr int32_t NETWORKTYPE_NONE_WIFI = 4;
30DeviceManagerImpl &DeviceManagerImpl::GetInstance()
31{
32    GTEST_LOG_(INFO) << "GetInstance start";
33    static DeviceManagerImpl instance;
34    return instance;
35}
36
37int32_t DeviceManagerImpl::InitDeviceManager(const std::string &pkgName, std::shared_ptr<DmInitCallback> dmInitCallback)
38{
39    return DfsDeviceManagerImpl::dfsDeviceManagerImpl->InitDeviceManager(pkgName, dmInitCallback);
40}
41
42int32_t DeviceManagerImpl::UnInitDeviceManager(const std::string &pkgName)
43{
44    return DfsDeviceManagerImpl::dfsDeviceManagerImpl->UnInitDeviceManager(pkgName);
45}
46
47int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName,
48                                                const std::string &extra,
49                                                std::vector<DmDeviceInfo> &deviceList)
50{
51    return DfsDeviceManagerImpl::dfsDeviceManagerImpl->GetTrustedDeviceList(pkgName, extra, deviceList);
52}
53
54int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName,
55                                                const std::string &extra,
56                                                bool isRefresh,
57                                                std::vector<DmDeviceInfo> &deviceList)
58{
59    return 0;
60}
61
62int32_t DeviceManagerImpl::GetAvailableDeviceList(const std::string &pkgName,
63                                                  std::vector<DmDeviceBasicInfo> &deviceList)
64{
65    return 0;
66}
67
68int32_t DeviceManagerImpl::GetDeviceInfo(const std::string &pkgName,
69                                         const std::string networkId,
70                                         DmDeviceInfo &deviceInfo)
71{
72    return 0;
73}
74
75int32_t DeviceManagerImpl::GetLocalDeviceInfo(const std::string &pkgName, DmDeviceInfo &info)
76{
77    return DfsDeviceManagerImpl::dfsDeviceManagerImpl->GetLocalDeviceInfo(pkgName, info);
78}
79
80int32_t DeviceManagerImpl::RegisterDevStateCallback(const std::string &pkgName,
81                                                    const std::string &extra,
82                                                    std::shared_ptr<DeviceStateCallback> callback)
83{
84    return DfsDeviceManagerImpl::dfsDeviceManagerImpl->RegisterDevStateCallback(pkgName, extra, callback);
85}
86
87int32_t DeviceManagerImpl::RegisterDevStatusCallback(const std::string &pkgName,
88                                                     const std::string &extra,
89                                                     std::shared_ptr<DeviceStatusCallback> callback)
90{
91    return 0;
92}
93
94int32_t DeviceManagerImpl::UnRegisterDevStateCallback(const std::string &pkgName)
95{
96    return DfsDeviceManagerImpl::dfsDeviceManagerImpl->UnRegisterDevStateCallback(pkgName);
97}
98
99int32_t DeviceManagerImpl::UnRegisterDevStatusCallback(const std::string &pkgName)
100{
101    return 0;
102}
103
104int32_t DeviceManagerImpl::StartDeviceDiscovery(const std::string &pkgName,
105                                                const DmSubscribeInfo &subscribeInfo,
106                                                const std::string &extra,
107                                                std::shared_ptr<DiscoveryCallback> callback)
108{
109    return 0;
110}
111
112int32_t DeviceManagerImpl::StartDeviceDiscovery(const std::string &pkgName,
113                                                uint64_t tokenId,
114                                                const std::string &filterOptions,
115                                                std::shared_ptr<DiscoveryCallback> callback)
116{
117    return 0;
118}
119
120int32_t DeviceManagerImpl::StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId)
121{
122    return 0;
123}
124
125int32_t DeviceManagerImpl::StopDeviceDiscovery(uint64_t tokenId, const std::string &pkgName)
126{
127    return 0;
128}
129
130int32_t DeviceManagerImpl::PublishDeviceDiscovery(const std::string &pkgName,
131                                                  const DmPublishInfo &publishInfo,
132                                                  std::shared_ptr<PublishCallback> callback)
133{
134    return 0;
135}
136
137int32_t DeviceManagerImpl::UnPublishDeviceDiscovery(const std::string &pkgName, int32_t publishId)
138{
139    return 0;
140}
141
142int32_t DeviceManagerImpl::AuthenticateDevice(const std::string &pkgName,
143                                              int32_t authType,
144                                              const DmDeviceInfo &deviceInfo,
145                                              const std::string &extra,
146                                              std::shared_ptr<AuthenticateCallback> callback)
147{
148    return 0;
149}
150
151int32_t DeviceManagerImpl::UnAuthenticateDevice(const std::string &pkgName, const DmDeviceInfo &deviceInfo)
152{
153    return 0;
154}
155
156int32_t DeviceManagerImpl::RegisterDeviceManagerFaCallback(const std::string &pkgName,
157                                                           std::shared_ptr<DeviceManagerUiCallback> callback)
158{
159    return 0;
160}
161
162int32_t DeviceManagerImpl::UnRegisterDeviceManagerFaCallback(const std::string &pkgName)
163{
164    return 0;
165}
166
167int32_t DeviceManagerImpl::VerifyAuthentication(const std::string &pkgName,
168                                                const std::string &authPara,
169                                                std::shared_ptr<VerifyAuthCallback> callback)
170{
171    return 0;
172}
173
174int32_t DeviceManagerImpl::GetFaParam(const std::string &pkgName, DmAuthParam &dmFaParam)
175{
176    return 0;
177}
178
179int32_t DeviceManagerImpl::SetUserOperation(const std::string &pkgName, int32_t action, const std::string &params)
180{
181    return 0;
182}
183
184int32_t DeviceManagerImpl::GetUdidByNetworkId(const std::string &pkgName,
185                                              const std::string &netWorkId,
186                                              std::string &udid)
187{
188    return 0;
189}
190
191int32_t DeviceManagerImpl::GetUuidByNetworkId(const std::string &pkgName,
192                                              const std::string &netWorkId,
193                                              std::string &uuid)
194{
195    return 0;
196}
197
198int32_t DeviceManagerImpl::RegisterDevStateCallback(const std::string &pkgName, const std::string &extra)
199{
200    return 0;
201}
202
203int32_t DeviceManagerImpl::UnRegisterDevStateCallback(const std::string &pkgName, const std::string &extra)
204{
205    return 0;
206}
207
208int32_t DeviceManagerImpl::RequestCredential(const std::string &pkgName,
209                                             const std::string &reqJsonStr,
210                                             std::string &returnJsonStr)
211{
212    return 0;
213}
214
215int32_t DeviceManagerImpl::ImportCredential(const std::string &pkgName, const std::string &credentialInfo)
216{
217    return 0;
218}
219
220int32_t DeviceManagerImpl::DeleteCredential(const std::string &pkgName, const std::string &deleteInfo)
221{
222    return 0;
223}
224
225int32_t DeviceManagerImpl::RegisterCredentialCallback(const std::string &pkgName,
226                                                      std::shared_ptr<CredentialCallback> callback)
227{
228    return 0;
229}
230
231int32_t DeviceManagerImpl::UnRegisterCredentialCallback(const std::string &pkgName)
232{
233    return 0;
234}
235
236int32_t DeviceManagerImpl::NotifyEvent(const std::string &pkgName, const int32_t eventId, const std::string &event)
237{
238    return 0;
239}
240
241int32_t DeviceManagerImpl::OnDmServiceDied()
242{
243    return 0;
244}
245
246int32_t DeviceManagerImpl::GetEncryptedUuidByNetworkId(const std::string &pkgName,
247                                                       const std::string &networkId,
248                                                       std::string &uuid)
249{
250    return 0;
251}
252
253int32_t DeviceManagerImpl::GenerateEncryptedUuid(const std::string &pkgName,
254                                                 const std::string &uuid,
255                                                 const std::string &appId,
256                                                 std::string &encryptedUuid)
257{
258    return 0;
259}
260
261int32_t DeviceManagerImpl::CheckAPIAccessPermission()
262{
263    return 0;
264}
265
266int32_t DeviceManagerImpl::CheckNewAPIAccessPermission()
267{
268    return 0;
269}
270
271int32_t DeviceManagerImpl::GetLocalDeviceNetWorkId(const std::string &pkgName, std::string &networkId)
272{
273    return 0;
274}
275
276int32_t DeviceManagerImpl::GetLocalDeviceId(const std::string &pkgName, std::string &deviceId)
277{
278    return 0;
279}
280
281int32_t DeviceManagerImpl::GetLocalDeviceName(const std::string &pkgName, std::string &deviceName)
282{
283    return 0;
284}
285
286int32_t DeviceManagerImpl::GetLocalDeviceType(const std::string &pkgName, int32_t &deviceType)
287{
288    return 0;
289}
290
291int32_t DeviceManagerImpl::GetDeviceName(const std::string &pkgName,
292                                         const std::string &networkId,
293                                         std::string &deviceName)
294{
295    return 0;
296}
297
298int32_t DeviceManagerImpl::GetDeviceType(const std::string &pkgName, const std::string &networkId, int32_t &deviceType)
299{
300    return 0;
301}
302
303int32_t DeviceManagerImpl::BindDevice(const std::string &pkgName,
304                                      int32_t bindType,
305                                      const std::string &deviceId,
306                                      const std::string &bindParam,
307                                      std::shared_ptr<AuthenticateCallback> callback)
308{
309    return 0;
310}
311
312int32_t DeviceManagerImpl::UnBindDevice(const std::string &pkgName, const std::string &deviceId)
313{
314    return 0;
315}
316
317int32_t DeviceManagerImpl::GetNetworkTypeByNetworkId(const std::string &pkgName,
318                                                     const std::string &netWorkId,
319                                                     int32_t &netWorkType)
320{
321    GTEST_LOG_(INFO) << "GetTrustedDeviceList start";
322    if (netWorkId == NETWORKID_ONE) {
323        return ERR_DM_INPUT_PARA_INVALID;
324    }
325
326    if (netWorkId == NETWORKID_TWO) {
327        netWorkType = NETWORKTYPE_WITH_WIFI;
328        return DM_OK;
329    }
330
331    netWorkType = NETWORKTYPE_NONE_WIFI;
332    return DM_OK;
333}
334} // namespace DistributedHardware
335} // namespace OHOS
336