1/*
2 * Copyright (c) 2021 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 <gtest/gtest.h>
17#include "accessibility_common_helper.h"
18#include "iservice_registry.h"
19#include "mock_bundle_manager.h"
20#include "string_ex.h"
21#include "system_ability_definition.h"
22#include "system_ability_manager_proxy.h"
23#include "mock_accessible_ability_manager_service_stub.h"
24
25namespace OHOS {
26static sptr<AppExecFwk::BundleMgrService> g_bundleMgrService = nullptr;
27static sptr<OHOS::Accessibility::MockAccessibleAbilityManagerServiceStub> g_MgrService = nullptr;
28
29SystemAbilityManagerClient& SystemAbilityManagerClient::GetInstance()
30{
31    static auto instance = new SystemAbilityManagerClient();
32    return *instance;
33}
34
35sptr<ISystemAbilityManager> SystemAbilityManagerClient::GetSystemAbilityManager()
36{
37    if (systemAbilityManager_ != nullptr) {
38        return systemAbilityManager_;
39    }
40
41    systemAbilityManager_ = new SystemAbilityManagerProxy(nullptr);
42    return systemAbilityManager_;
43}
44
45sptr<IRemoteObject> SystemAbilityManagerProxy::GetSystemAbility(int32_t systemAbilityId)
46{
47    sptr<IRemoteObject> remote = nullptr;
48    switch (systemAbilityId) {
49        case BUNDLE_MGR_SERVICE_SYS_ABILITY_ID:
50            if (!g_bundleMgrService) {
51                g_bundleMgrService = new AppExecFwk::BundleMgrService();
52            }
53            remote = g_bundleMgrService;
54            break;
55        case ACCESSIBILITY_MANAGER_SERVICE_ID: {
56            bool notNullFlag = Accessibility::AccessibilityCommonHelper::GetInstance().GetRemoteObjectNotNullFlag();
57            if (notNullFlag) {
58                if (!g_MgrService) {
59                    g_MgrService = new OHOS::Accessibility::MockAccessibleAbilityManagerServiceStub();
60                }
61                remote = g_MgrService;
62            }
63            break;
64        }
65        default:
66            GTEST_LOG_(INFO) << "This service is not dummy!!!!" << systemAbilityId;
67            break;
68    }
69    return remote;
70}
71
72sptr<IRemoteObject> SystemAbilityManagerProxy::GetSystemAbility(int32_t systemAbilityId,
73    const std::string& deviceId)
74{
75    return GetSystemAbility(systemAbilityId);
76}
77
78sptr<IRemoteObject> SystemAbilityManagerProxy::CheckSystemAbilityWrapper(int32_t code, MessageParcel& data)
79{
80    return nullptr;
81}
82
83sptr<IRemoteObject> SystemAbilityManagerProxy::CheckSystemAbility(int32_t systemAbilityId)
84{
85    return nullptr;
86}
87
88int32_t GetOnDemandSystemAbilityIds(std::vector<int32_t>& systemAbilityIds)
89{
90    return -1;
91}
92
93sptr<IRemoteObject> SystemAbilityManagerProxy::CheckSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
94{
95    return nullptr;
96}
97
98sptr<IRemoteObject> SystemAbilityManagerProxy::CheckSystemAbility(int32_t systemAbilityId, bool& isExist)
99{
100    return nullptr;
101}
102
103int32_t SystemAbilityManagerProxy::AddOnDemandSystemAbilityInfo(int32_t systemAbilityId,
104    const std::u16string& localAbilityManagerName)
105{
106    return -1;
107}
108
109int32_t SystemAbilityManagerProxy::RemoveSystemAbilityWrapper(int32_t code, MessageParcel& data)
110{
111    return -1;
112}
113
114int32_t SystemAbilityManagerProxy::RemoveSystemAbility(int32_t systemAbilityId)
115{
116    return -1;
117}
118
119std::vector<std::u16string> SystemAbilityManagerProxy::ListSystemAbilities(unsigned int dumpFlags)
120{
121    std::vector<std::u16string> saNames;
122
123    return saNames;
124}
125
126int32_t SystemAbilityManagerProxy::SubscribeSystemAbility(int32_t systemAbilityId,
127    const sptr<ISystemAbilityStatusChange>& listener)
128{
129    return -1;
130}
131
132int32_t SystemAbilityManagerProxy::UnSubscribeSystemAbility(int32_t systemAbilityId,
133    const sptr<ISystemAbilityStatusChange>& listener)
134{
135    return -1;
136}
137
138sptr<IRemoteObject> SystemAbilityManagerProxy::LoadSystemAbility(int32_t systemAbilityId, int32_t timeout)
139{
140    return nullptr;
141}
142
143int32_t SystemAbilityManagerProxy::LoadSystemAbility(int32_t systemAbilityId,
144    const sptr<ISystemAbilityLoadCallback>& callback)
145{
146    return -1;
147}
148
149int32_t SystemAbilityManagerProxy::LoadSystemAbility(int32_t systemAbilityId, const std::string& deviceId,
150    const sptr<ISystemAbilityLoadCallback>& callback)
151{
152    return -1;
153}
154
155int32_t SystemAbilityManagerProxy::UnloadSystemAbility(int32_t systemAbilityId)
156{
157    return -1;
158}
159
160int32_t SystemAbilityManagerProxy::CancelUnloadSystemAbility(int32_t systemAbilityId)
161{
162    return -1;
163}
164
165int32_t SystemAbilityManagerProxy::AddSystemAbility(int32_t systemAbilityId, const sptr<IRemoteObject>& ability,
166    const SAExtraProp& extraProp)
167{
168    return -1;
169}
170
171int32_t SystemAbilityManagerProxy::AddSystemAbilityWrapper(int32_t code, MessageParcel& data)
172{
173    return -1;
174}
175
176int32_t SystemAbilityManagerProxy::AddSystemProcess(
177    const std::u16string& procName, const sptr<IRemoteObject>& procObject)
178{
179    return -1;
180}
181
182int32_t SystemAbilityManagerProxy::GetSystemProcessInfo(
183    int32_t systemAbilityId, SystemProcessInfo& systemProcessInfo)
184{
185    return -1;
186}
187
188int32_t SystemAbilityManagerProxy::GetRunningSystemProcess(std::list<SystemProcessInfo>& systemProcessInfos)
189{
190    return -1;
191}
192
193int32_t SystemAbilityManagerProxy::SubscribeSystemProcess(const sptr<ISystemProcessStatusChange>& listener)
194{
195    return -1;
196}
197
198int32_t SystemAbilityManagerProxy::UnSubscribeSystemProcess(const sptr<ISystemProcessStatusChange>& listener)
199{
200    return -1;
201}
202
203int32_t SystemAbilityManagerProxy::GetOnDemandReasonExtraData(int64_t extraDataId, MessageParcel& extraDataParcel)
204{
205    return -1;
206}
207
208int32_t SystemAbilityManagerProxy::GetOnDemandPolicy(int32_t systemAbilityId, OnDemandPolicyType type,
209    std::vector<SystemAbilityOnDemandEvent>& abilityOnDemandEvents)
210{
211    return -1;
212}
213
214int32_t SystemAbilityManagerProxy::UpdateOnDemandPolicy(int32_t systemAbilityId, OnDemandPolicyType type,
215    const std::vector<SystemAbilityOnDemandEvent>& sabilityOnDemandEvents)
216{
217    return -1;
218}
219
220int32_t SystemAbilityManagerProxy::GetOnDemandSystemAbilityIds(std::vector<int32_t>& systemAbilityIds)
221{
222    return -1;
223}
224
225int32_t SystemAbilityManagerProxy::SendStrategy(int32_t type, std::vector<int32_t>& systemAbilityIds,
226    int32_t level, std::string& action)
227{
228    return -1;
229}
230
231int32_t SystemAbilityManagerProxy::UnloadAllIdleSystemAbility()
232{
233    return -1;
234}
235
236int32_t SystemAbilityManagerProxy::GetCommonEventExtraDataIdlist(int32_t saId,
237    std::vector<int64_t>& extraDataIdList, const std::string& eventName)
238{
239    return -1;
240}
241
242int32_t SystemAbilityManagerProxy::GetExtensionSaIds(const std::string& extension, std::vector<int32_t> &saIds)
243{
244    return -1;
245}
246
247int32_t SystemAbilityManagerProxy::GetExtensionRunningSaList(const std::string& extension,
248    std::vector<sptr<IRemoteObject>>& saList)
249{
250    return -1;
251}
252
253int32_t SystemAbilityManagerProxy::GetRunningSaExtensionInfoList(const std::string& extension,
254    std::vector<SaExtensionInfo>& infoList)
255{
256    return -1;
257};
258sptr<IRemoteObject> SystemAbilityManagerProxy::Recompute(int32_t systemAbilityId, int32_t code)
259{
260    return nullptr;
261}
262}