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#ifndef SHORT_MESSAGE_H
17#define SHORT_MESSAGE_H
18
19#include <codecvt>
20#include <locale>
21#include <memory>
22
23#include "parcel.h"
24
25namespace OHOS {
26namespace Telephony {
27class ShortMessage : public Parcelable {
28public:
29    /**
30     * @brief SmsMessageClass
31     * Indicates the SMS type.
32     * from 3GPP TS 23.038 V4.3.0 5 CBS Data Coding Scheme.
33     */
34    using SmsMessageClass = enum {
35        /**
36         * class0 Indicates an instant message, which is displayed immediately after being received.
37         */
38        SMS_INSTANT_MESSAGE = 0,
39        /**
40         * class1 Indicates an SMS message that can be stored on the device
41         * or SIM card based on the storage status.
42         */
43        SMS_OPTIONAL_MESSAGE,
44        /**
45         * class2 Indicates an SMS message containing SIM card information,
46         * which is to be stored in a SIM card.
47         */
48        SMS_SIM_MESSAGE,
49        /**
50         * class3 Indicates an SMS message to be forwarded to another device.
51         */
52        SMS_FORWARD_MESSAGE,
53        /**
54         * Indicates an unknown type.
55         */
56        SMS_CLASS_UNKNOWN,
57    };
58
59    /**
60     * @brief SimMessageStatus
61     * from 3GPP TS 51.011 V4.0.0 (2001-03) section 10.5.3 Parameter Definitions.
62     */
63    using SmsSimMessageStatus = enum {
64        /**
65         * status free space ON SIM.
66         */
67        SMS_SIM_MESSAGE_STATUS_FREE = 0,
68        /**
69         * REC READ received unread message.
70         */
71        SMS_SIM_MESSAGE_STATUS_READ = 1,
72        /**
73         * REC UNREAD received read message.
74         */
75        SMS_SIM_MESSAGE_STATUS_UNREAD = 3,
76        /**
77         * "STO SENT" stored unsent message (only applicable to SMs).
78         */
79        SMS_SIM_MESSAGE_STATUS_SENT = 5,
80        /**
81         * "STO UNSENT" stored sent message (only applicable to SMs).
82         */
83        SMS_SIM_MESSAGE_STATUS_UNSENT = 7,
84    };
85
86    /**
87     * @brief Obtains the SMS message body.
88     *
89     * @return std::u16string returns the message body.
90     */
91    std::u16string GetVisibleMessageBody() const;
92
93    /**
94     * @brief Obtains the address of the sender, which is to be displayed on the UI.
95     *
96     * @return std::u16string returns the raw address.
97     */
98    std::u16string GetVisibleRawAddress() const;
99
100    /**
101     * @brief Obtains the SMS type.
102     *
103     * @return returns SMS type, {@link SmsMessageClass}.
104     */
105    SmsMessageClass GetMessageClass() const;
106
107    /**
108     * @brief Obtains the short message service center (SMSC) address.
109     *
110     * @param smscAddress SMS center address
111     * @return Interface execution results.
112     */
113    int32_t GetScAddress(std::u16string &smscAddress) const;
114
115    /**
116     * @brief Obtains the SMSC timestamp.
117     *
118     * @return int64_t returns the SMSC timestamp.
119     */
120    int64_t GetScTimestamp() const;
121
122    /**
123     * @brief Checks whether the received SMS is a "replace short message".
124     *
125     * @return returns true if the received SMS is a "replace short message", false otherwise.
126     */
127    bool IsReplaceMessage() const;
128
129    /**
130     * @brief Indicates the SMS message status from the SMS-STATUS-REPORT message sent by the
131     * Short Message Service Center (SMSC).
132     *
133     * @return int32_t returns the SMS message status from the SMS-STATUS-REPORT message.
134     */
135    int32_t GetStatus() const;
136
137    /**
138     * @brief Indicates whether the current message is SMS-STATUS-REPORT.
139     *
140     * @return Returns true if the current message is SMS-STATUS-REPORT, false otherwise.
141     */
142    bool IsSmsStatusReportMessage() const;
143
144    /**
145     * @brief Checks whether the received SMS contains "TP-Reply-Path"
146     *
147     * @return returns true if the received SMS contains "TP-Reply-Path", false otherwise.
148     */
149    bool HasReplyPath() const;
150
151    /**
152     * @brief Get the Icc Message Status object.
153     *
154     * @return returns from 3GPP TS 51.011 V4.0.0 (2001-03) section 10.5.3 Parameter Definitions.
155     * {@link SmsSimMessageStatus}
156     */
157    SmsSimMessageStatus GetIccMessageStatus() const;
158
159    /**
160     * @brief Get the protocol id used for sending SMS messages.
161     *
162     * @return int32_t returns protocol id used for sending SMS messages
163     */
164    int32_t GetProtocolId() const;
165
166    /**
167     * @brief Get the protocol data unit.
168     *
169     * @return returns the pdu code
170     */
171    std::vector<unsigned char> GetPdu() const;
172
173    /**
174     * @brief Get the user data part.
175     *
176     * @return returns the user data of pdu
177     */
178    std::string GetRawUserData() const;
179
180    /**
181     * @brief Create a Message object
182     * Creates an SMS message instance based on the
183     * protocol data unit (PDU) and the specified SMS protocol.
184     *
185     * @param pdu Indicates pdu code.
186     * @param specification Indicates 3gpp or 3gpp2.
187     * @return Returns {@code 0} if CreateMessage success
188     */
189    static int32_t CreateMessage(
190        std::vector<unsigned char> &pdu, std::u16string specification, ShortMessage &messageObj);
191
192    /**
193     * @brief Create a Icc Message object
194     * Creates an SMS message instance based on the
195     * ICC protocol data unit (PDU) and the specified SMS protocol
196     *
197     * @param pdu Indicates pdu code.
198     * @param specification Indicates 3gpp or 3gpp2.
199     * @param index Indicates the message index.
200     * @return returns a ShortMessage object
201     */
202    static ShortMessage CreateIccMessage(std::vector<unsigned char> &pdu, std::string specification, int32_t index);
203
204    /**
205     * @brief GetIndexOnSim
206     *
207     * @return int32_t returns the index
208     */
209    int32_t GetIndexOnSim() const;
210
211    ~ShortMessage() = default;
212    ShortMessage() = default;
213    virtual bool Marshalling(Parcel &parcel) const override;
214    static ShortMessage UnMarshalling(Parcel &parcel);
215    bool ReadFromParcel(Parcel &parcel);
216
217public:
218    static constexpr int MIN_ICC_PDU_LEN = 1;
219    std::u16string visibleMessageBody_;
220    std::u16string visibleRawAddress_;
221    SmsMessageClass messageClass_ = SMS_CLASS_UNKNOWN;
222    SmsSimMessageStatus simMessageStatus_ = SMS_SIM_MESSAGE_STATUS_FREE;
223    std::u16string scAddress_;
224    int64_t scTimestamp_ = 0;
225    bool isReplaceMessage_ = false;
226    int32_t status_ = -1;
227    bool isSmsStatusReportMessage_ = false;
228    bool hasReplyPath_ = false;
229    int32_t protocolId_ = -1;
230    std::vector<unsigned char> pdu_;
231    std::string rawUserData_;
232    int32_t indexOnSim_ = 0;
233};
234} // namespace Telephony
235} // namespace OHOS
236#endif