1 /*
2 * Copyright (c) 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 "js_continuation_state_client.h"
17 #include "if_system_ability_manager.h"
18 #include "system_ability_definition.h"
19 #include "iservice_registry.h"
20 #include "ipc_skeleton.h"
21 #include "distributedsched_ipc_interface_code.h"
22 #include "napi_error_code.h"
23 #include "dtbschedmgr_log.h"
24
25 namespace OHOS {
26 namespace DistributedSchedule {
27 namespace {
28 const std::string TAG = "ContinuationStateClient";
29 const std::u16string DMS_PROXY_INTERFACE_TOKEN = u"ohos.distributedschedule.accessToken";
30 }
31
GetDmsProxy()32 sptr<IRemoteObject> ContinuationStateClient::GetDmsProxy()
33 {
34 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
35 if (samgrProxy == nullptr) {
36 HILOGE("fail to get samgr.");
37 return nullptr;
38 }
39 return samgrProxy->CheckSystemAbility(DISTRIBUTED_SCHED_SA_ID);
40 }
41
RegisterContinueStateCallback(const sptr<JsContinuationStateManagerStub> stub)42 int32_t ContinuationStateClient::RegisterContinueStateCallback(const sptr<JsContinuationStateManagerStub> stub)
43 {
44 HILOGI("call");
45 JsContinuationStateManagerStub::StateCallbackData callbackData = stub->callbackData_;
46 sptr <IRemoteObject> remote = GetDmsProxy();
47 if (remote == nullptr) {
48 HILOGE("get dms proxy failed.");
49 return DMS_GET_SAMGR_EXCEPTION;
50 }
51 MessageParcel data;
52 if (!data.WriteInterfaceToken(DMS_PROXY_INTERFACE_TOKEN)) {
53 HILOGE("write token failed.");
54 return SEND_REQUEST_DEF_FAIL;
55 }
56 if (!data.WriteString(callbackData.bundleName)) {
57 HILOGE("write bundleName failed.");
58 return SEND_REQUEST_DEF_FAIL;
59 }
60 if (!data.WriteInt32(callbackData.missionId)) {
61 HILOGE("write missionId failed.");
62 return SEND_REQUEST_DEF_FAIL;
63 }
64 if (!data.WriteString(callbackData.moduleName)) {
65 HILOGE("write moduleName failed.");
66 return SEND_REQUEST_DEF_FAIL;
67 }
68 if (!data.WriteString(callbackData.abilityName)) {
69 HILOGE("write abilityName failed.");
70 return SEND_REQUEST_DEF_FAIL;
71 }
72 if (!data.WriteRemoteObject(stub)) {
73 HILOGE("write stub failed.");
74 return SEND_REQUEST_DEF_FAIL;
75 }
76 MessageParcel reply;
77 MessageOption option;
78 int32_t error = remote->SendRequest(
79 static_cast<uint32_t>(IDSchedInterfaceCode::CONTINUE_STATE_CALLBACK_REGISTER),
80 data, reply, option);
81 if (error != ERR_NONE) {
82 HILOGE("send register request failed. error code is %{public}d", error);
83 return SEND_REQUEST_DEF_FAIL;
84 }
85 int32_t result = reply.ReadInt32();
86 HILOGI("end, register result is: %{public}d", result);
87 return result;
88 }
89
90
UnRegisterContinueStateCallback(const sptr<JsContinuationStateManagerStub> stub)91 int32_t ContinuationStateClient::UnRegisterContinueStateCallback(const sptr<JsContinuationStateManagerStub> stub)
92 {
93 HILOGI("call");
94 JsContinuationStateManagerStub::StateCallbackData callbackData = stub->callbackData_;
95 sptr <IRemoteObject> remote = GetDmsProxy();
96 if (remote == nullptr) {
97 HILOGE("get dms proxy failed.");
98 return DMS_GET_SAMGR_EXCEPTION;
99 }
100
101 MessageParcel data;
102 if (!data.WriteInterfaceToken(DMS_PROXY_INTERFACE_TOKEN)) {
103 HILOGE("write token failed.");
104 return SEND_REQUEST_DEF_FAIL;
105 }
106
107 if (!data.WriteString(callbackData.bundleName)) {
108 HILOGE("write bundleName failed.");
109 return SEND_REQUEST_DEF_FAIL;
110 }
111 if (!data.WriteInt32(callbackData.missionId)) {
112 HILOGE("write missionId failed.");
113 return SEND_REQUEST_DEF_FAIL;
114 }
115 if (!data.WriteString(callbackData.moduleName)) {
116 HILOGE("write moduleName failed.");
117 return SEND_REQUEST_DEF_FAIL;
118 }
119 if (!data.WriteString(callbackData.abilityName)) {
120 HILOGE("write abilityName failed.");
121 return SEND_REQUEST_DEF_FAIL;
122 }
123
124 MessageParcel reply;
125 MessageOption option;
126 int32_t error = remote->SendRequest(
127 static_cast<uint32_t>(IDSchedInterfaceCode::CONTINUE_STATE_CALLBACK_UNREGISTER),
128 data, reply, option);
129 if (error != ERR_NONE) {
130 HILOGE("send register request failed. error code is %{public}d", error);
131 return SEND_REQUEST_DEF_FAIL;
132 }
133 int32_t result = reply.ReadInt32();
134 HILOGI("end, register result is: %{public}d", result);
135 return result;
136 }
137 } // namespace DistributedSchedule
138 } // namespace OHOS