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 "ondemand_helper.h"
17
18 #include <iostream>
19 #include <memory>
20 #include <thread>
21 #include <unistd.h>
22
23 #include "datetime_ex.h"
24 #include "errors.h"
25 #include "if_system_ability_manager.h"
26 #include "ipc_types.h"
27 #include "iremote_object.h"
28 #include "iservice_registry.h"
29 #include "isystem_ability_load_callback.h"
30 #ifdef SUPPORT_ACCESS_TOKEN
31 #include "nativetoken_kit.h"
32 #include "token_setproc.h"
33 #endif
34 #include "sam_mock_permission.h"
35 #ifdef SUPPORT_SOFTBUS
36 #include "softbus_bus_center.h"
37 #endif
38 #include "system_ability_ondemand_reason.h"
39 #include "system_ability_definition.h"
40 #include "parameter.h"
41 #include "parameters.h"
42
43 using namespace OHOS;
44 using namespace std;
45
46 namespace OHOS {
47 namespace {
48 constexpr int32_t LOOP_TIME = 1000;
49 constexpr int32_t MOCK_ONDEMAND_ABILITY_A = 1494;
50 constexpr int32_t MOCK_ONDEMAND_ABILITY_B = 1497;
51 constexpr int32_t MOCK_ONDEMAND_ABILITY_C = 1499;
52 constexpr int32_t SLEEP_1_SECONDS = 1 * 1000 * 1000;
53 constexpr int32_t SLEEP_3_SECONDS = 3 * 1000 * 1000;
54 constexpr int32_t SLEEP_6_SECONDS = 6 * 1000 * 1000;
55 }
56
OnDemandHelper()57 OnDemandHelper::OnDemandHelper()
58 {
59 loadCallback_ = new OnDemandLoadCallback();
60 loadCallback2_ = new OnDemandLoadCallback();
61 loadCallback3_ = new OnDemandLoadCallback();
62 loadCallback4_ = new OnDemandLoadCallback();
63 }
64
GetInstance()65 OnDemandHelper& OnDemandHelper::GetInstance()
66 {
67 static OnDemandHelper instance;
68 return instance;
69 }
70
GetSystemProcessInfo(int32_t systemAbilityId)71 void OnDemandHelper::GetSystemProcessInfo(int32_t systemAbilityId)
72 {
73 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
74 if (sm == nullptr) {
75 cout << "GetSystemAbilityManager samgr object null!" << endl;
76 return;
77 }
78 SystemProcessInfo processInfo;
79 int32_t ret = sm->GetSystemProcessInfo(systemAbilityId, processInfo);
80 if (ret != ERR_OK) {
81 cout << "GetSystemProcessInfo failed" << endl;
82 return;
83 }
84 cout << "processName: " << processInfo.processName << " pid: " << processInfo.pid << endl;
85 }
86
SyncOnDemandAbility(int32_t systemAbilityId)87 sptr<IRemoteObject> OnDemandHelper::SyncOnDemandAbility(int32_t systemAbilityId)
88 {
89 int64_t begin = GetTickCount();
90 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
91 if (sm == nullptr) {
92 cout << "GetSystemAbilityManager samgr object null!" << endl;
93 return nullptr;
94 }
95 int32_t timeout = 4;
96 sptr<IRemoteObject> result = sm->LoadSystemAbility(systemAbilityId, timeout);
97 if (result == nullptr) {
98 cout << "systemAbilityId:" << systemAbilityId << " syncload failed, result code:" << result << endl;
99 return nullptr;
100 }
101 cout << "SyncLoadSystemAbility result:" << result << " spend:" << (GetTickCount() - begin) << "ms"
102 << " systemAbilityId:" << systemAbilityId << endl;
103 return result;
104 }
105
TestSyncOnDemandAbility(int32_t systemAbilityId)106 int32_t OnDemandHelper::TestSyncOnDemandAbility(int32_t systemAbilityId)
107 {
108 sptr<IRemoteObject> ptr = SyncOnDemandAbility(systemAbilityId);
109 MessageParcel data;
110 MessageParcel reply;
111 MessageOption option;
112 int32_t getdp = 2;
113 int32_t errCode = ptr->SendRequest(getdp, data, reply, option);
114 if (errCode != ERR_NONE) {
115 cout << "transact failed, errCode = " << errCode;
116 return errCode;
117 }
118 int32_t ret = reply.ReadInt32();
119 cout << "ret = " << ret;
120 return ret;
121 }
122
UnloadAllIdleSystemAbility()123 int32_t OnDemandHelper::UnloadAllIdleSystemAbility()
124 {
125 SamMockPermission::MockProcess("memmgrservice");
126 int64_t begin = GetTickCount();
127 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
128 if (sm == nullptr) {
129 cout << "UnloadAllIdleSystemAbility samgr object null!" << endl;
130 return ERR_NULL_OBJECT;
131 }
132 int32_t result = sm->UnloadAllIdleSystemAbility();
133 if (result != ERR_OK) {
134 cout << "UnloadAllIdleSystemAbility failed, result code:" << result << endl;
135 return result;
136 }
137 cout << "UnloadAllIdleSystemAbility result:" << result << " spend:" << (GetTickCount() - begin) << "ms" << endl;
138 return ERR_OK;
139 }
140
GetLruIdleSystemAbilityProc()141 int32_t OnDemandHelper::GetLruIdleSystemAbilityProc()
142 {
143 SamMockPermission::MockProcess("memmgrservice");
144 int64_t begin = GetTickCount();
145 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
146 if (sm == nullptr) {
147 cout << "GetLruIdleSystemAbilityProc samgr object null!" << endl;
148 return ERR_NULL_OBJECT;
149 }
150 vector<IdleProcessInfo> procInfos;
151 int32_t result = sm->GetLruIdleSystemAbilityProc(procInfos);
152 if (result != ERR_OK) {
153 cout << "GetLruIdleSystemAbilityProc failed, result code:" << result << endl;
154 return result;
155 }
156 cout << "GetLruIdleSystemAbilityProc result:" << result << " spend:" << (GetTickCount() - begin) << "ms" << endl;
157 for (const auto& proc:procInfos) {
158 cout << "pid:" << proc.pid << ", "
159 << "processName:" << Str16ToStr8(proc.processName) << ", "
160 << "lastIdleTime:" << proc.lastIdleTime << endl;
161 }
162 return ERR_OK;
163 }
164
UnloadProcess(const vector<u16string> & processList)165 int32_t OnDemandHelper::UnloadProcess(const vector<u16string>& processList)
166 {
167 SamMockPermission::MockProcess("memmgrservice");
168 int64_t begin = GetTickCount();
169 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
170 if (sm == nullptr) {
171 cout << "UnloadProcess samgr object null!" << endl;
172 return ERR_NULL_OBJECT;
173 }
174 int32_t result = sm->UnloadProcess(processList);
175 if (result != ERR_OK) {
176 cout << "UnloadProcess failed, result code:" << result << endl;
177 return result;
178 }
179 cout << "UnloadProcess result:" << result << " spend:" << (GetTickCount() - begin) << "ms" << endl;
180 return ERR_OK;
181 }
182
LoadOndemandAbilityCase1()183 int32_t OnDemandHelper::LoadOndemandAbilityCase1()
184 {
185 cout << "LoadOndemandAbilityCase1 start" << endl;
186 int64_t begin = GetTickCount();
187 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
188 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
189 usleep(SLEEP_3_SECONDS);
190 cout << "LoadOndemandAbilityCase1 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
191 return ERR_OK;
192 }
193
LoadOndemandAbilityCase2()194 int32_t OnDemandHelper::LoadOndemandAbilityCase2()
195 {
196 cout << "LoadOndemandAbilityCase2 start" << endl;
197 int64_t begin = GetTickCount();
198 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
199 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
200 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
201 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback2);
202 usleep(SLEEP_3_SECONDS);
203 cout << "LoadOndemandAbilityCase2 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
204 return ERR_OK;
205 }
206
LoadOndemandAbilityCase3()207 int32_t OnDemandHelper::LoadOndemandAbilityCase3()
208 {
209 cout << "LoadOndemandAbilityCase3 start" << endl;
210 int64_t begin = GetTickCount();
211 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
212 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
213 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
214 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
215 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback2);
216 usleep(SLEEP_3_SECONDS);
217 cout << "LoadOndemandAbilityCase3 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
218 return ERR_OK;
219 }
220
LoadOndemandAbilityCase4()221 int32_t OnDemandHelper::LoadOndemandAbilityCase4()
222 {
223 cout << "LoadOndemandAbilityCase4 start" << endl;
224 int64_t begin = GetTickCount();
225 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
226 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
227 usleep(SLEEP_3_SECONDS);
228 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
229 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback2);
230 usleep(SLEEP_3_SECONDS);
231 cout << "LoadOndemandAbilityCase4 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
232 return ERR_OK;
233 }
234
LoadOndemandAbilityCase5()235 int32_t OnDemandHelper::LoadOndemandAbilityCase5()
236 {
237 cout << "LoadOndemandAbilityCase5 start" << endl;
238 int64_t begin = GetTickCount();
239 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
240 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
241 usleep(SLEEP_3_SECONDS);
242 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
243 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
244 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback2);
245 usleep(SLEEP_3_SECONDS);
246 cout << "LoadOndemandAbilityCase5 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
247 return ERR_OK;
248 }
249
LoadOndemandAbilityCase6()250 int32_t OnDemandHelper::LoadOndemandAbilityCase6()
251 {
252 cout << "LoadOndemandAbilityCase6 start" << endl;
253 int64_t begin = GetTickCount();
254 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
255 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
256 usleep(SLEEP_3_SECONDS);
257 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
258 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_B, callback2);
259 usleep(SLEEP_3_SECONDS);
260 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
261 sptr<OnDemandLoadCallback> callback3 = new OnDemandLoadCallback();
262 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback3);
263 usleep(SLEEP_3_SECONDS);
264 cout << "LoadOndemandAbilityCase6 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
265 return ERR_OK;
266 }
267
LoadOndemandAbilityCase7()268 int32_t OnDemandHelper::LoadOndemandAbilityCase7()
269 {
270 cout << "LoadOndemandAbilityCase7 start" << endl;
271 int64_t begin = GetTickCount();
272 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
273 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
274 usleep(SLEEP_3_SECONDS);
275 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
276 usleep(SLEEP_1_SECONDS);
277 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
278 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback2);
279 usleep(SLEEP_6_SECONDS);
280 cout << "LoadOndemandAbilityCase7 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
281 return ERR_OK;
282 }
283
LoadOndemandAbilityCase8()284 int32_t OnDemandHelper::LoadOndemandAbilityCase8()
285 {
286 cout << "LoadOndemandAbilityCase8 start" << endl;
287 int64_t begin = GetTickCount();
288 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
289 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
290 usleep(SLEEP_3_SECONDS);
291 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
292 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_B, callback2);
293 usleep(SLEEP_3_SECONDS);
294 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
295 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_B);
296 usleep(SLEEP_1_SECONDS);
297 sptr<OnDemandLoadCallback> callback3 = new OnDemandLoadCallback();
298 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_B, callback3);
299 usleep(SLEEP_6_SECONDS);
300 cout << "LoadOndemandAbilityCase8 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
301 return ERR_OK;
302 }
303
LoadOndemandAbilityCase9()304 int32_t OnDemandHelper::LoadOndemandAbilityCase9()
305 {
306 cout << "LoadOndemandAbilityCase9 start" << endl;
307 int64_t begin = GetTickCount();
308 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
309 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_C, callback1);
310 usleep(SLEEP_6_SECONDS);
311 cout << "LoadOndemandAbilityCase9 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
312 return ERR_OK;
313 }
314
LoadOndemandAbilityCase10()315 int32_t OnDemandHelper::LoadOndemandAbilityCase10()
316 {
317 cout << "LoadOndemandAbilityCase10 start" << endl;
318 int64_t begin = GetTickCount();
319 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
320 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
321 usleep(SLEEP_3_SECONDS);
322 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
323 usleep(SLEEP_1_SECONDS);
324 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
325 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback2);
326 sptr<OnDemandLoadCallback> callback3 = new OnDemandLoadCallback();
327 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback3);
328 sptr<OnDemandLoadCallback> callback4 = new OnDemandLoadCallback();
329 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback4);
330 sptr<OnDemandLoadCallback> callback5 = new OnDemandLoadCallback();
331 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback5);
332 sptr<OnDemandLoadCallback> callback6 = new OnDemandLoadCallback();
333 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback6);
334 usleep(SLEEP_6_SECONDS);
335 usleep(SLEEP_3_SECONDS);
336 cout << "LoadOndemandAbilityCase10 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
337 return ERR_OK;
338 }
339
LoadOndemandAbilityCase11()340 int32_t OnDemandHelper::LoadOndemandAbilityCase11()
341 {
342 cout << "LoadOndemandAbilityCase10 start" << endl;
343 int64_t begin = GetTickCount();
344 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
345 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
346 usleep(SLEEP_3_SECONDS);
347 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
348 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback2);
349 sptr<OnDemandLoadCallback> callback3 = new OnDemandLoadCallback();
350 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback3);
351 sptr<OnDemandLoadCallback> callback4 = new OnDemandLoadCallback();
352 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback4);
353 sptr<OnDemandLoadCallback> callback5 = new OnDemandLoadCallback();
354 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback5);
355 sptr<OnDemandLoadCallback> callback6 = new OnDemandLoadCallback();
356 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback6);
357 usleep(SLEEP_6_SECONDS);
358 usleep(SLEEP_3_SECONDS);
359 cout << "LoadOndemandAbilityCase10 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
360 return ERR_OK;
361 }
362
UnloadOndemandAbilityCase1()363 int32_t OnDemandHelper::UnloadOndemandAbilityCase1()
364 {
365 cout << "UnloadOndemandAbilityCase1 start" << endl;
366 int64_t begin = GetTickCount();
367 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
368 cout << "UnloadOndemandAbilityCase1 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
369 return ERR_OK;
370 }
371
UnloadOndemandAbilityCase2()372 int32_t OnDemandHelper::UnloadOndemandAbilityCase2()
373 {
374 cout << "UnloadOndemandAbilityCase2 start" << endl;
375 int64_t begin = GetTickCount();
376 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
377 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
378 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
379 usleep(SLEEP_6_SECONDS);
380 cout << "UnloadOndemandAbilityCase2 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
381 return ERR_OK;
382 }
383
UnloadOndemandAbilityCase3()384 int32_t OnDemandHelper::UnloadOndemandAbilityCase3()
385 {
386 cout << "UnloadOndemandAbilityCase3 start" << endl;
387 int64_t begin = GetTickCount();
388 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
389 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
390 usleep(SLEEP_3_SECONDS);
391 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
392 usleep(SLEEP_3_SECONDS);
393 cout << "UnloadOndemandAbilityCase3 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
394 return ERR_OK;
395 }
396
UnloadOndemandAbilityCase4()397 int32_t OnDemandHelper::UnloadOndemandAbilityCase4()
398 {
399 cout << "UnloadOndemandAbilityCase4 start" << endl;
400 int64_t begin = GetTickCount();
401 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
402 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
403 usleep(SLEEP_3_SECONDS);
404 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
405 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_B, callback2);
406 usleep(SLEEP_3_SECONDS);
407 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
408 usleep(SLEEP_3_SECONDS);
409 cout << "UnloadOndemandAbilityCase4 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
410 return ERR_OK;
411 }
412
UnloadOndemandAbilityCase5()413 int32_t OnDemandHelper::UnloadOndemandAbilityCase5()
414 {
415 cout << "UnloadOndemandAbilityCase5 start" << endl;
416 int64_t begin = GetTickCount();
417 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
418 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
419 usleep(SLEEP_3_SECONDS);
420 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
421 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_B, callback2);
422 usleep(SLEEP_3_SECONDS);
423 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
424 usleep(SLEEP_1_SECONDS);
425 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
426 usleep(SLEEP_3_SECONDS);
427 cout << "UnloadOndemandAbilityCase5 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
428 return ERR_OK;
429 }
430
UnloadOndemandAbilityCase6()431 int32_t OnDemandHelper::UnloadOndemandAbilityCase6()
432 {
433 cout << "UnloadOndemandAbilityCase6 start" << endl;
434 int64_t begin = GetTickCount();
435 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
436 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
437 usleep(SLEEP_3_SECONDS);
438 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
439 usleep(SLEEP_1_SECONDS);
440 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
441 usleep(SLEEP_3_SECONDS);
442 cout << "UnloadOndemandAbilityCase6 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
443 return ERR_OK;
444 }
445
UnloadOndemandAbilityCase7()446 int32_t OnDemandHelper::UnloadOndemandAbilityCase7()
447 {
448 cout << "UnloadOndemandAbilityCase7 start" << endl;
449 int64_t begin = GetTickCount();
450 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
451 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_C, callback1);
452 usleep(SLEEP_6_SECONDS);
453 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_C);
454 usleep(SLEEP_6_SECONDS);
455 cout << "UnloadOndemandAbilityCase7 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
456 return ERR_OK;
457 }
458
UnloadOndemandAbilityCase8()459 int32_t OnDemandHelper::UnloadOndemandAbilityCase8()
460 {
461 cout << "UnloadOndemandAbilityCase6 start" << endl;
462 int64_t begin = GetTickCount();
463 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
464 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
465 usleep(SLEEP_3_SECONDS);
466 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
467 usleep(SLEEP_1_SECONDS);
468 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
469 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
470 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
471 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
472 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
473 usleep(SLEEP_3_SECONDS);
474 cout << "UnloadOndemandAbilityCase6 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
475 return ERR_OK;
476 }
477
UnloadOndemandAbilityCase9()478 int32_t OnDemandHelper::UnloadOndemandAbilityCase9()
479 {
480 cout << "UnloadOndemandAbilityCase6 start" << endl;
481 int64_t begin = GetTickCount();
482 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
483 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
484 usleep(SLEEP_3_SECONDS);
485 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
486 usleep(SLEEP_1_SECONDS);
487 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
488 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
489 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
490 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
491 usleep(SLEEP_3_SECONDS);
492 cout << "UnloadOndemandAbilityCase6 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
493 return ERR_OK;
494 }
495
GetOndemandAbilityCase1()496 int32_t OnDemandHelper::GetOndemandAbilityCase1()
497 {
498 cout << "GetOndemandAbilityCase1 start" << endl;
499 int64_t begin = GetTickCount();
500 GetSystemAbility(MOCK_ONDEMAND_ABILITY_A);
501 usleep(SLEEP_3_SECONDS);
502 cout << "GetOndemandAbilityCase1 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
503 return ERR_OK;
504 }
505
GetOndemandAbilityCase2()506 int32_t OnDemandHelper::GetOndemandAbilityCase2()
507 {
508 cout << "GetOndemandAbilityCase2 start" << endl;
509 int64_t begin = GetTickCount();
510 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
511 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_B, callback1);
512 usleep(SLEEP_3_SECONDS);
513 GetSystemAbility(MOCK_ONDEMAND_ABILITY_A);
514 usleep(SLEEP_3_SECONDS);
515 cout << "GetOndemandAbilityCase2 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
516 return ERR_OK;
517 }
518
GetOndemandAbilityCase3()519 int32_t OnDemandHelper::GetOndemandAbilityCase3()
520 {
521 cout << "GetOndemandAbilityCase3 start" << endl;
522 int64_t begin = GetTickCount();
523 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
524 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
525 GetSystemAbility(MOCK_ONDEMAND_ABILITY_A);
526 usleep(SLEEP_3_SECONDS);
527 cout << "GetOndemandAbilityCase3 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
528 return ERR_OK;
529 }
530
GetOndemandAbilityCase4()531 int32_t OnDemandHelper::GetOndemandAbilityCase4()
532 {
533 cout << "GetOndemandAbilityCase4 start" << endl;
534 int64_t begin = GetTickCount();
535 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
536 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
537 usleep(SLEEP_3_SECONDS);
538 GetSystemAbility(MOCK_ONDEMAND_ABILITY_A);
539 usleep(SLEEP_3_SECONDS);
540 cout << "GetOndemandAbilityCase4 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
541 return ERR_OK;
542 }
543
GetOndemandAbilityCase5()544 int32_t OnDemandHelper::GetOndemandAbilityCase5()
545 {
546 cout << "GetOndemandAbilityCase5 start" << endl;
547 int64_t begin = GetTickCount();
548 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
549 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
550 usleep(SLEEP_3_SECONDS);
551 sptr<OnDemandLoadCallback> callback2 = new OnDemandLoadCallback();
552 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_B, callback2);
553 usleep(SLEEP_3_SECONDS);
554 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
555 usleep(SLEEP_1_SECONDS);
556 GetSystemAbility(MOCK_ONDEMAND_ABILITY_A);
557 cout << "GetOndemandAbilityCase5 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
558 return ERR_OK;
559 }
560
GetOndemandAbilityCase6()561 int32_t OnDemandHelper::GetOndemandAbilityCase6()
562 {
563 cout << "GetOndemandAbilityCase6 start" << endl;
564 int64_t begin = GetTickCount();
565 sptr<OnDemandLoadCallback> callback1 = new OnDemandLoadCallback();
566 LoadSystemAbility(MOCK_ONDEMAND_ABILITY_A, callback1);
567 usleep(SLEEP_3_SECONDS);
568 UnloadSystemAbility(MOCK_ONDEMAND_ABILITY_A);
569 usleep(SLEEP_1_SECONDS);
570 GetSystemAbility(MOCK_ONDEMAND_ABILITY_A);
571 cout << "GetOndemandAbilityCase6 done, spend:" << (GetTickCount() - begin) << " ms" << endl;
572 return ERR_OK;
573 }
574
GetSystemProcess()575 void OnDemandHelper::GetSystemProcess()
576 {
577 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
578 if (sm == nullptr) {
579 cout << "GetSystemAbilityManager samgr object null!" << endl;
580 return;
581 }
582 std::list<SystemProcessInfo> systemProcessInfos;
583 int32_t ret = sm->GetRunningSystemProcess(systemProcessInfos);
584 if (ret != ERR_OK) {
585 cout << "GetRunningSystemProcess failed" << endl;
586 return;
587 }
588 cout << "GetRunningSystemProcess size: "<< systemProcessInfos.size() << endl;
589 for (const auto& systemProcessInfo : systemProcessInfos) {
590 cout << "processName: " << systemProcessInfo.processName << " pid:" << systemProcessInfo.pid << endl;
591 }
592 }
593
InitSystemProcessStatusChange()594 void OnDemandHelper::InitSystemProcessStatusChange()
595 {
596 systemProcessStatusChange_ = new SystemProcessStatusChange();
597 }
598
SubscribeSystemProcess()599 void OnDemandHelper::SubscribeSystemProcess()
600 {
601 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
602 if (sm == nullptr) {
603 cout << "GetSystemAbilityManager samgr object null!" << endl;
604 return;
605 }
606 int32_t ret = sm->SubscribeSystemProcess(systemProcessStatusChange_);
607 if (ret != ERR_OK) {
608 cout << "SubscribeSystemProcess failed" << endl;
609 return;
610 }
611 cout << "SubscribeSystemProcess success" << endl;
612 }
613
UnSubscribeSystemProcess()614 void OnDemandHelper::UnSubscribeSystemProcess()
615 {
616 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
617 if (sm == nullptr) {
618 cout << "GetSystemAbilityManager samgr object null!" << endl;
619 return;
620 }
621 int32_t ret = sm->UnSubscribeSystemProcess(systemProcessStatusChange_);
622 if (ret != ERR_OK) {
623 cout << "UnSubscribeSystemProcess failed" << endl;
624 return;
625 }
626 cout << "UnSubscribeSystemProcess success" << endl;
627 }
628
OnSystemProcessStarted(SystemProcessInfo & systemProcessInfo)629 void OnDemandHelper::SystemProcessStatusChange::OnSystemProcessStarted(SystemProcessInfo& systemProcessInfo)
630 {
631 cout << "OnSystemProcessStarted, processName: " << systemProcessInfo.processName << " pid:"
632 << systemProcessInfo.pid << " uid:" << systemProcessInfo.uid << endl;
633 }
634
OnSystemProcessStopped(SystemProcessInfo & systemProcessInfo)635 void OnDemandHelper::SystemProcessStatusChange::OnSystemProcessStopped(SystemProcessInfo& systemProcessInfo)
636 {
637 cout << "OnSystemProcessStopped, processName: " << systemProcessInfo.processName << " pid:"
638 << systemProcessInfo.pid << " uid:" << systemProcessInfo.uid << endl;
639 }
640
LoadSystemAbility(int32_t systemAbilityId,const sptr<ISystemAbilityLoadCallback> & callback)641 int32_t OnDemandHelper::LoadSystemAbility(int32_t systemAbilityId, const sptr<ISystemAbilityLoadCallback>& callback)
642 {
643 int64_t begin = GetTickCount();
644 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
645 if (sm == nullptr) {
646 cout << "GetSystemAbilityManager samgr object null!" << endl;
647 return ERR_NULL_OBJECT;
648 }
649 int32_t result = sm->LoadSystemAbility(systemAbilityId, callback);
650 if (result != ERR_OK) {
651 cout << "systemAbilityId:" << systemAbilityId << " unload failed, result code:" << result << endl;
652 return result;
653 }
654 cout << "LoadSystemAbility result:" << result << " spend:" << (GetTickCount() - begin) << " ms"
655 << " systemAbilityId:" << systemAbilityId << endl;
656 return ERR_OK;
657 }
658
UnloadSystemAbility(int32_t systemAbilityId)659 int32_t OnDemandHelper::UnloadSystemAbility(int32_t systemAbilityId)
660 {
661 SamMockPermission::MockProcess("listen_test");
662 int64_t begin = GetTickCount();
663 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
664 if (sm == nullptr) {
665 cout << "GetSystemAbilityManager samgr object null!" << endl;
666 return ERR_NULL_OBJECT;
667 }
668 int32_t result = sm->UnloadSystemAbility(systemAbilityId);
669 if (result != ERR_OK) {
670 cout << "systemAbilityId:" << systemAbilityId << " unload failed, result code:" << result << endl;
671 return result;
672 }
673 cout << "UnloadSystemAbility result:" << result << " spend:" << (GetTickCount() - begin) << " ms"
674 << " systemAbilityId:" << systemAbilityId << endl;
675 return ERR_OK;
676 }
677
OnDemandAbility(int32_t systemAbilityId)678 int32_t OnDemandHelper::OnDemandAbility(int32_t systemAbilityId)
679 {
680 int64_t begin = GetTickCount();
681 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
682 if (sm == nullptr) {
683 cout << "GetSystemAbilityManager samgr object null!" << endl;
684 return ERR_NULL_OBJECT;
685 }
686 int32_t result = sm->LoadSystemAbility(systemAbilityId, loadCallback_);
687 if (result != ERR_OK) {
688 cout << "systemAbilityId:" << systemAbilityId << " load failed, result code:" << result << endl;
689 return result;
690 }
691 cout << "LoadSystemAbility result:" << result << " spend:" << (GetTickCount() - begin) << " ms"
692 << " systemAbilityId:" << systemAbilityId << endl;
693 return ERR_OK;
694 }
695
696 #ifdef SUPPORT_SOFTBUS
GetDeviceList()697 void OnDemandHelper::GetDeviceList()
698 {
699 NodeBasicInfo *info = NULL;
700 int32_t infoNum = 0;
701 int32_t ret = GetAllNodeDeviceInfo("ondemand", &info, &infoNum);
702 if (ret != 0) {
703 cout << "get remote deviceid GetAllNodeDeviceInfo failed" << endl;
704 return;
705 }
706 for (int32_t i = 0; i < infoNum; i++) {
707 cout << "networkid : " << std::string(info->networkId) << " deviceName : "
708 << std::string(info->deviceName) << endl;
709 info++;
710 }
711 }
712
GetFirstDevice()713 std::string OnDemandHelper::GetFirstDevice()
714 {
715 NodeBasicInfo *info = NULL;
716 int32_t infoNum = 0;
717 int32_t ret = GetAllNodeDeviceInfo("ondemand", &info, &infoNum);
718 if (ret != 0) {
719 cout << "get remote deviceid GetAllNodeDeviceInfo failed" << endl;
720 return "";
721 }
722 if (infoNum <= 0) {
723 cout << "get remote deviceid failed, no remote device" << endl;
724 return "";
725 }
726 return std::string(info->networkId);
727 }
728 #endif
729
LoadRemoteAbility(int32_t systemAbilityId,const std::string & deviceId,const sptr<ISystemAbilityLoadCallback> & callback)730 int32_t OnDemandHelper::LoadRemoteAbility(int32_t systemAbilityId, const std::string& deviceId,
731 const sptr<ISystemAbilityLoadCallback>& callback)
732 {
733 cout << "LoadRemoteAbility start"<< endl;
734 int64_t begin = GetTickCount();
735 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
736 if (sm == nullptr) {
737 cout << "GetSystemAbilityManager samgr object null!" << endl;
738 return ERR_NULL_OBJECT;
739 }
740 int32_t result = -1;
741 if (callback == nullptr) {
742 result = sm->LoadSystemAbility(systemAbilityId, deviceId, loadCallback_);
743 } else {
744 result = sm->LoadSystemAbility(systemAbilityId, deviceId, callback);
745 }
746
747 if (result != ERR_OK) {
748 cout << "systemAbilityId:" << systemAbilityId << " load failed, result code:" << result << endl;
749 }
750 cout << "LoadRemoteAbility result:" << result << " spend:" << (GetTickCount() - begin) << " ms"
751 << " systemAbilityId:" << systemAbilityId << endl;
752 return result;
753 }
754
LoadRemoteAbilityMuti(int32_t systemAbilityId,const std::string & deviceId)755 void OnDemandHelper::LoadRemoteAbilityMuti(int32_t systemAbilityId, const std::string& deviceId)
756 {
757 std::thread thread1([systemAbilityId, deviceId, this]() {
758 cout << "LoadRemoteAbilityMuti thread1" << endl;
759 LoadRemoteAbility(systemAbilityId, deviceId, loadCallback_);
760 });
761 std::thread thread2([systemAbilityId, deviceId, this]() {
762 cout << "LoadRemoteAbilityMuti thread2" << endl;
763 LoadRemoteAbility(systemAbilityId, deviceId, loadCallback_);
764 });
765 std::thread thread3([systemAbilityId, deviceId, this]() {
766 cout << "LoadRemoteAbilityMuti thread3" << endl;
767 LoadRemoteAbility(systemAbilityId, deviceId, loadCallback_);
768 });
769 thread1.detach();
770 thread2.detach();
771 thread3.detach();
772 }
773
LoadRemoteAbilityMutiCb(int32_t systemAbilityId,const std::string & deviceId)774 void OnDemandHelper::LoadRemoteAbilityMutiCb(int32_t systemAbilityId, const std::string& deviceId)
775 {
776 std::thread thread1([systemAbilityId, deviceId, this]() {
777 cout << "LoadRemoteAbilityMuti thread1" << endl;
778 LoadRemoteAbility(systemAbilityId, deviceId, loadCallback_);
779 });
780 std::thread thread2([systemAbilityId, deviceId, this]() {
781 cout << "LoadRemoteAbilityMuti thread2" << endl;
782 LoadRemoteAbility(systemAbilityId, deviceId, loadCallback2_);
783 });
784 std::thread thread3([systemAbilityId, deviceId, this]() {
785 cout << "LoadRemoteAbilityMuti thread3" << endl;
786 LoadRemoteAbility(systemAbilityId, deviceId, loadCallback3_);
787 });
788 thread1.detach();
789 thread2.detach();
790 thread3.detach();
791 }
792
LoadRemoteAbilityMutiSA(int32_t systemAbilityId,const std::string & deviceId)793 void OnDemandHelper::LoadRemoteAbilityMutiSA(int32_t systemAbilityId, const std::string& deviceId)
794 {
795 std::thread thread1([systemAbilityId, deviceId, this]() {
796 cout << "LoadRemoteAbilityMuti thread1" << endl;
797 LoadRemoteAbility(systemAbilityId, deviceId, loadCallback_);
798 });
799 std::thread thread2([deviceId, this]() {
800 cout << "LoadRemoteAbilityMuti thread2" << endl;
801 LoadRemoteAbility(DISTRIBUTED_SCHED_TEST_LISTEN_ID, deviceId, loadCallback_);
802 });
803 std::thread thread3([deviceId, this]() {
804 cout << "LoadRemoteAbilityMuti thread3" << endl;
805 LoadRemoteAbility(DISTRIBUTED_SCHED_TEST_MEDIA_ID, deviceId, loadCallback_);
806 });
807 thread1.detach();
808 thread2.detach();
809 thread3.detach();
810 }
811
LoadRemoteAbilityMutiSACb(int32_t systemAbilityId,const std::string & deviceId)812 void OnDemandHelper::LoadRemoteAbilityMutiSACb(int32_t systemAbilityId, const std::string& deviceId)
813 {
814 std::thread thread1([systemAbilityId, deviceId, this]() {
815 cout << "LoadRemoteAbilityMuti thread1" << endl;
816 LoadRemoteAbility(systemAbilityId, deviceId, loadCallback_);
817 });
818 std::thread thread2([deviceId, this]() {
819 cout << "LoadRemoteAbilityMuti thread2" << endl;
820 LoadRemoteAbility(DISTRIBUTED_SCHED_SA_ID, deviceId, loadCallback2_);
821 });
822 std::thread thread3([deviceId, this]() {
823 cout << "LoadRemoteAbilityMuti thread3" << endl;
824 LoadRemoteAbility(DISTRIBUTED_SCHED_TEST_MEDIA_ID, deviceId, loadCallback3_);
825 });
826 thread1.detach();
827 thread2.detach();
828 thread3.detach();
829 }
830
LoadRemoteAbilityPressure(int32_t systemAbilityId,const std::string & deviceId)831 void OnDemandHelper::LoadRemoteAbilityPressure(int32_t systemAbilityId, const std::string& deviceId)
832 {
833 for (int i = 0 ; i < LOOP_TIME; ++i) {
834 LoadRemoteAbility(systemAbilityId, deviceId, nullptr);
835 }
836 }
837
GetSystemAbility(int32_t systemAbilityId)838 sptr<IRemoteObject> OnDemandHelper::GetSystemAbility(int32_t systemAbilityId)
839 {
840 int64_t begin = GetTickCount();
841 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
842 if (sm == nullptr) {
843 cout << "GetSystemAbilityManager samgr object null!" << endl;
844 return nullptr;
845 }
846 sptr<IRemoteObject> remoteObject = sm->GetSystemAbility(systemAbilityId);
847 if (remoteObject == nullptr) {
848 cout << "GetSystemAbility systemAbilityId:" << systemAbilityId << " failed !" << endl;
849 return nullptr;
850 }
851 cout << "GetSystemAbility result: success "<< " spend:"
852 << (GetTickCount() - begin) << " ms" << " systemAbilityId:" << systemAbilityId << endl;
853 return remoteObject;
854 }
855
CheckSystemAbility(int32_t systemAbilityId)856 sptr<IRemoteObject> OnDemandHelper::CheckSystemAbility(int32_t systemAbilityId)
857 {
858 int64_t begin = GetTickCount();
859 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
860 if (sm == nullptr) {
861 cout << "GetSystemAbilityManager samgr object null!" << endl;
862 return nullptr;
863 }
864 sptr<IRemoteObject> remoteObject = sm->CheckSystemAbility(systemAbilityId);
865 if (remoteObject == nullptr) {
866 cout << "CheckSystemAbility systemAbilityId:" << systemAbilityId << " failed !" << endl;
867 return nullptr;
868 }
869 cout << "CheckSystemAbility result: success "<< " spend:"
870 << (GetTickCount() - begin) << " ms" << " systemAbilityId:" << systemAbilityId << endl;
871 return remoteObject;
872 }
873
CheckSystemAbility(int32_t systemAbilityId,const std::string & deviceId)874 sptr<IRemoteObject> OnDemandHelper::CheckSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
875 {
876 int64_t begin = GetTickCount();
877 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
878 if (sm == nullptr) {
879 cout << "GetSystemAbilityManager samgr object null!" << endl;
880 return nullptr;
881 }
882 sptr<IRemoteObject> remoteObject = sm->CheckSystemAbility(systemAbilityId, deviceId);
883 if (remoteObject == nullptr) {
884 cout << "CheckSystemAbilityRmt systemAbilityId:" << systemAbilityId << " failed !" << endl;
885 return nullptr;
886 }
887 cout << "CheckSystemAbilityRmt result: success "<< " spend:"
888 << (GetTickCount() - begin) << " ms" << " systemAbilityId:" << systemAbilityId << endl;
889 return remoteObject;
890 }
891
GetOnDemandPolicy(int32_t systemAbilityId,OnDemandPolicyType type)892 void OnDemandHelper::GetOnDemandPolicy(int32_t systemAbilityId, OnDemandPolicyType type)
893 {
894 SamMockPermission::MockProcess("listen_test");
895 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
896 if (sm == nullptr) {
897 cout << "GetSystemAbilityManager samgr object null!" << endl;
898 return;
899 }
900 std::vector<SystemAbilityOnDemandEvent> abilityOnDemandEvents;
901 int32_t ret = sm->GetOnDemandPolicy(systemAbilityId, type, abilityOnDemandEvents);
902 if (ret != ERR_OK) {
903 cout << "GetOnDemandPolicy failed" << endl;
904 return;
905 }
906 cout << "GetOnDemandPolicy success" << endl;
907 for (auto& event : abilityOnDemandEvents) {
908 cout << "eventId: " << static_cast<int32_t>(event.eventId) << " name:" << event.name
909 << " value:" << event.value << endl;
910 }
911 }
912
UpdateOnDemandPolicy(int32_t systemAbilityId,OnDemandPolicyType type,std::vector<SystemAbilityOnDemandEvent> & abilityOnDemandEvents)913 void OnDemandHelper::UpdateOnDemandPolicy(int32_t systemAbilityId, OnDemandPolicyType type,
914 std::vector<SystemAbilityOnDemandEvent>& abilityOnDemandEvents)
915 {
916 SamMockPermission::MockProcess("listen_test");
917 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
918 if (sm == nullptr) {
919 cout << "GetSystemAbilityManager samgr object null!" << endl;
920 return;
921 }
922 for (auto& event : abilityOnDemandEvents) {
923 cout << "update eventId: " << static_cast<int32_t>(event.eventId) << " name:" << event.name
924 << " value:" << event.value << endl;
925 }
926 int32_t ret = sm->UpdateOnDemandPolicy(systemAbilityId, type, abilityOnDemandEvents);
927 if (ret != ERR_OK) {
928 cout << "UpdateOnDemandPolicy failed" << endl;
929 return;
930 }
931 cout << "UpdateOnDemandPolicy success" << endl;
932 }
933
OnLoadSystemAbility(int32_t systemAbilityId)934 void OnDemandHelper::OnLoadSystemAbility(int32_t systemAbilityId)
935 {
936 }
937
OnLoadSystemAbilitySuccess(int32_t systemAbilityId,const sptr<IRemoteObject> & remoteObject)938 void OnDemandHelper::OnDemandLoadCallback::OnLoadSystemAbilitySuccess(int32_t systemAbilityId,
939 const sptr<IRemoteObject>& remoteObject)
940 {
941 cout << "OnLoadSystemAbilitySuccess systemAbilityId:" << systemAbilityId << " IRemoteObject result:" <<
942 ((remoteObject != nullptr) ? "succeed" : "failed") << endl;
943 OnDemandHelper::GetInstance().OnLoadSystemAbility(systemAbilityId);
944 }
945
OnLoadSystemAbilityFail(int32_t systemAbilityId)946 void OnDemandHelper::OnDemandLoadCallback::OnLoadSystemAbilityFail(int32_t systemAbilityId)
947 {
948 cout << "OnLoadSystemAbilityFail systemAbilityId:" << systemAbilityId << endl;
949 }
950
OnLoadSACompleteForRemote(const std::string & deviceId,int32_t systemAbilityId,const sptr<IRemoteObject> & remoteObject)951 void OnDemandHelper::OnDemandLoadCallback::OnLoadSACompleteForRemote(const std::string& deviceId,
952 int32_t systemAbilityId, const sptr<IRemoteObject>& remoteObject)
953 {
954 cout << "OnLoadSACompleteForRemote systemAbilityId:" << systemAbilityId << " IRemoteObject result:" <<
955 ((remoteObject != nullptr) ? "succeed" : "failed") << endl;
956 }
957
GetExtensionSaIds(const std::string & extension,std::vector<int32_t> & saIds)958 int32_t OnDemandHelper::GetExtensionSaIds(const std::string& extension, std::vector<int32_t> &saIds)
959 {
960 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
961 int32_t ret;
962 if ((ret = sm->GetExtensionSaIds(extension, saIds)) != ERR_OK) {
963 return ret;
964 }
965 cout << __func__ << "saIds size: " << saIds.size() << endl;
966 if (saIds.size() != 0) {
967 cout << __func__ << "saIds: ";
968 for (uint32_t loop = 0; loop < saIds.size(); ++loop) {
969 cout << saIds[loop] << ", ";
970 }
971 cout << endl;
972 }
973 return ERR_OK;
974 }
975
GetExtensionRunningSaList(const std::string & extension,std::vector<sptr<IRemoteObject>> & saList)976 int32_t OnDemandHelper::GetExtensionRunningSaList(const std::string& extension,
977 std::vector<sptr<IRemoteObject>>& saList)
978 {
979 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
980 int32_t ret;
981 if ((ret = sm->GetExtensionRunningSaList(extension, saList)) != ERR_OK) {
982 return ret;
983 }
984 cout << __func__ << "saList size: " << saList.size() << endl;
985 if (saList.size() != 0) {
986 cout << __func__ << "saIds: ";
987 for (uint32_t loop = 0; loop < saList.size(); ++loop) {
988 cout << (saList[loop] != nullptr) << ", ";
989 }
990 cout << endl;
991 }
992 return ERR_OK;
993 }
994
GetCommonEventExtraId(int32_t saId,const std::string & eventName)995 void OnDemandHelper::GetCommonEventExtraId(int32_t saId, const std::string& eventName)
996 {
997 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
998 if (sm == nullptr) {
999 cout << "GetCommonEventExtraId get samgr failed" << endl;
1000 return;
1001 }
1002 std::vector<int64_t> extraDataIdList;
1003 int32_t ret = sm->GetCommonEventExtraDataIdlist(saId, extraDataIdList, eventName);
1004 if (ret != ERR_OK) {
1005 cout << "GetCommonEventExtraDataIdlist failed ret is " << ret << endl;
1006 return;
1007 }
1008 cout << __func__ << "extra id size: " << extraDataIdList.size() << endl;
1009 for (auto& item : extraDataIdList) {
1010 cout << item << ", ";
1011 MessageParcel extraDataParcel;
1012 ret = sm->GetOnDemandReasonExtraData(item, extraDataParcel);
1013 if (ret != ERR_OK) {
1014 cout << "get extra data failed" << endl;
1015 continue;
1016 }
1017 auto extraData = extraDataParcel.ReadParcelable<OnDemandReasonExtraData>();
1018 if (extraData == nullptr) {
1019 cout << "get extra data read parcel fail" << endl;
1020 continue;
1021 }
1022 auto want = extraData->GetWant();
1023 cout << "get extra data event name is " << want["common_event_action_name"] << endl;
1024 }
1025 cout << endl;
1026 return;
1027 }
1028 }
1029