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 "satellite_sms_proxy.h"
17 
18 #include "satellite/satellite_sms_service_ipc_interface_code.h"
19 #include "telephony_errors.h"
20 #include "telephony_log_wrapper.h"
21 #include "telephony_types.h"
22 
23 namespace OHOS {
24 namespace Telephony {
WriteInterfaceToken(MessageParcel & data)25 bool SatelliteSmsProxy::WriteInterfaceToken(MessageParcel &data)
26 {
27     if (!data.WriteInterfaceToken(SatelliteSmsProxy::GetDescriptor())) {
28         TELEPHONY_LOGE("write interface token failed");
29         return false;
30     }
31     return true;
32 }
33 
RegisterSmsNotify(int32_t slotId,int32_t what,const sptr<ISatelliteSmsCallback> & callback)34 int32_t SatelliteSmsProxy::RegisterSmsNotify(int32_t slotId, int32_t what, const sptr<ISatelliteSmsCallback> &callback)
35 {
36     MessageParcel data;
37     MessageParcel reply;
38     MessageOption option;
39     int32_t ret = TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
40 
41     if (callback == nullptr) {
42         TELEPHONY_LOGE("RegisterSmsNotify callback is null");
43         return TELEPHONY_ERR_WRITE_DATA_FAIL;
44     }
45     if (!WriteInterfaceToken(data)) {
46         TELEPHONY_LOGE("RegisterSmsNotify WriteInterfaceToken is false");
47         return ret;
48     }
49     if (!data.WriteInt32(slotId)) {
50         return TELEPHONY_ERR_WRITE_DATA_FAIL;
51     }
52     if (!data.WriteInt32(what)) {
53         return TELEPHONY_ERR_WRITE_DATA_FAIL;
54     }
55     if (!data.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
56         return TELEPHONY_ERR_WRITE_DATA_FAIL;
57     }
58 
59     auto remote = Remote();
60     if (remote == nullptr) {
61         TELEPHONY_LOGE("RegisterSmsNotify Remote is null");
62         return ret;
63     }
64 
65     TELEPHONY_LOGD("Satellite RegisterSmsNotify slotId: %{public}d, what: %{public}d", slotId, what);
66     ret = remote->SendRequest(uint32_t(SatelliteSmsServiceInterfaceCode::REGISTER_SMS_NOTIFY), data, reply, option);
67     if (ret != ERR_NONE) {
68         TELEPHONY_LOGE("RegisterSmsNotify failed, error code is %{public}d ", ret);
69         return ret;
70     }
71 
72     if (!reply.ReadInt32(ret)) {
73         TELEPHONY_LOGE("RegisterSmsNotify read reply failed");
74     }
75     return ret;
76 }
77 
UnRegisterSmsNotify(int32_t slotId,int32_t what)78 int32_t SatelliteSmsProxy::UnRegisterSmsNotify(int32_t slotId, int32_t what)
79 {
80     MessageParcel data;
81     MessageParcel reply;
82     MessageOption option;
83     int32_t ret = TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
84     if (!WriteInterfaceToken(data)) {
85         TELEPHONY_LOGE("UnRegisterSmsNotify WriteInterfaceToken is false");
86         return ret;
87     }
88     if (!data.WriteInt32(slotId)) {
89         return TELEPHONY_ERR_WRITE_DATA_FAIL;
90     }
91     if (!data.WriteInt32(what)) {
92         return TELEPHONY_ERR_WRITE_DATA_FAIL;
93     }
94 
95     auto remote = Remote();
96     if (remote == nullptr) {
97         TELEPHONY_LOGE("UnRegisterSmsNotify Remote is null");
98         return ret;
99     }
100 
101     TELEPHONY_LOGD("Satellite UnRegisterSmsNotify slotId: %{public}d, what: %{public}d", slotId, what);
102     ret = remote->SendRequest(uint32_t(SatelliteSmsServiceInterfaceCode::UNREGISTER_SMS_NOTIFY), data, reply, option);
103     if (ret != ERR_NONE) {
104         TELEPHONY_LOGE("UnRegisterSmsNotify failed, error code is %{public}d ", ret);
105         return ret;
106     }
107 
108     if (!reply.ReadInt32(ret)) {
109         TELEPHONY_LOGE("UnRegisterSmsNotify read reply failed");
110     }
111     return ret;
112 }
113 
SendSms(int32_t slotId,int32_t eventId,SatelliteMessage & message)114 int32_t SatelliteSmsProxy::SendSms(int32_t slotId, int32_t eventId, SatelliteMessage &message)
115 {
116     MessageParcel data;
117     MessageParcel reply;
118     MessageOption option;
119     int32_t ret = TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
120     if (!WriteInterfaceToken(data)) {
121         TELEPHONY_LOGE("SendSms WriteInterfaceToken is false");
122         return ret;
123     }
124     if (!data.WriteInt32(slotId)) {
125         return TELEPHONY_ERR_WRITE_DATA_FAIL;
126     }
127     if (!data.WriteInt32(eventId)) {
128         return TELEPHONY_ERR_WRITE_DATA_FAIL;
129     }
130 
131     if (!data.WriteInt64(message.refId)) {
132         return TELEPHONY_ERR_WRITE_DATA_FAIL;
133     }
134     if (!data.WriteString(message.smscPdu)) {
135         return TELEPHONY_ERR_WRITE_DATA_FAIL;
136     }
137     if (!data.WriteString(message.pdu)) {
138         return TELEPHONY_ERR_WRITE_DATA_FAIL;
139     }
140 
141     auto remote = Remote();
142     if (remote == nullptr) {
143         TELEPHONY_LOGE("SendSms Remote is null");
144         return ret;
145     }
146 
147     TELEPHONY_LOGD("Satellite SendSms slotId: %{public}d, eventId: %{public}d", slotId, eventId);
148     ret = remote->SendRequest(uint32_t(SatelliteSmsServiceInterfaceCode::SEND_SMS), data, reply, option);
149     if (ret != ERR_NONE) {
150         TELEPHONY_LOGE("SendSms failed, error code is %{public}d ", ret);
151         return ret;
152     }
153 
154     if (!reply.ReadInt32(ret)) {
155         TELEPHONY_LOGE("SendSms read reply failed");
156     }
157     return ret;
158 }
SendSmsMoreMode(int32_t slotId,int32_t eventId,SatelliteMessage & message)159 int32_t SatelliteSmsProxy::SendSmsMoreMode(int32_t slotId, int32_t eventId, SatelliteMessage &message)
160 {
161     MessageParcel data;
162     MessageParcel reply;
163     MessageOption option;
164     int32_t ret = TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
165     if (!WriteInterfaceToken(data)) {
166         TELEPHONY_LOGE("SendSmsMoreMode WriteInterfaceToken is false");
167         return ret;
168     }
169     if (!data.WriteInt32(slotId)) {
170         return TELEPHONY_ERR_WRITE_DATA_FAIL;
171     }
172     if (!data.WriteInt32(eventId)) {
173         return TELEPHONY_ERR_WRITE_DATA_FAIL;
174     }
175 
176     if (!data.WriteInt64(message.refId)) {
177         return TELEPHONY_ERR_WRITE_DATA_FAIL;
178     }
179     if (!data.WriteString(message.smscPdu)) {
180         return TELEPHONY_ERR_WRITE_DATA_FAIL;
181     }
182     if (!data.WriteString(message.pdu)) {
183         return TELEPHONY_ERR_WRITE_DATA_FAIL;
184     }
185 
186     auto remote = Remote();
187     if (remote == nullptr) {
188         TELEPHONY_LOGE("SendSmsMoreMode Remote is null");
189         return ret;
190     }
191     TELEPHONY_LOGD("Satellite SendSmsMoreMode slotId: %{public}d, eventId: %{public}d", slotId, eventId);
192     ret = remote->SendRequest(uint32_t(SatelliteSmsServiceInterfaceCode::SEND_SMS_MORE_MODE), data, reply, option);
193     if (ret != ERR_NONE) {
194         TELEPHONY_LOGE("SendSmsMoreMode failed, error code is %{public}d ", ret);
195         return ret;
196     }
197 
198     if (!reply.ReadInt32(ret)) {
199         TELEPHONY_LOGE("SendSmsMoreMode read reply failed");
200     }
201     return ret;
202 }
SendSmsAck(int32_t slotId,int32_t eventId,bool success,int32_t cause)203 int32_t SatelliteSmsProxy::SendSmsAck(int32_t slotId, int32_t eventId, bool success, int32_t cause)
204 {
205     MessageParcel data;
206     MessageParcel reply;
207     MessageOption option;
208     int32_t ret = TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
209     if (!WriteInterfaceToken(data)) {
210         TELEPHONY_LOGE("SendSmsAck WriteInterfaceToken is false");
211         return ret;
212     }
213     if (!data.WriteInt32(slotId)) {
214         return TELEPHONY_ERR_WRITE_DATA_FAIL;
215     }
216     if (!data.WriteInt32(eventId)) {
217         return TELEPHONY_ERR_WRITE_DATA_FAIL;
218     }
219 
220     if (!data.WriteBool(success)) {
221         return TELEPHONY_ERR_WRITE_DATA_FAIL;
222     }
223     if (!data.WriteInt32(cause)) {
224         return TELEPHONY_ERR_WRITE_DATA_FAIL;
225     }
226 
227     auto remote = Remote();
228     if (remote == nullptr) {
229         TELEPHONY_LOGE("SendSmsAck Remote is null");
230         return ret;
231     }
232     TELEPHONY_LOGD("Satellite SendSmsAck slotId: %{public}d, eventId: %{public}d", slotId, eventId);
233     ret = remote->SendRequest(uint32_t(SatelliteSmsServiceInterfaceCode::SEND_SMS_ACK), data, reply, option);
234     if (ret != ERR_NONE) {
235         TELEPHONY_LOGE("SendSmsAck failed, error code is %{public}d ", ret);
236         return ret;
237     }
238 
239     if (!reply.ReadInt32(ret)) {
240         TELEPHONY_LOGE("SendSmsAck read reply failed");
241     }
242     return ret;
243 }
244 } // namespace Telephony
245 } // namespace OHOS
246