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 SMS_RECEIVE_HANDLER_H
17#define SMS_RECEIVE_HANDLER_H
18
19#include <vector>
20
21#include "tel_ril_sms_parcel.h"
22#include "sms_base_message.h"
23#include "sms_receive_indexer.h"
24#include "sms_receive_reliability_handler.h"
25#include "sms_wap_push_handler.h"
26#include "tel_event_handler.h"
27#include "datashare_helper.h"
28#include "system_ability_definition.h"
29
30#ifdef ABILITY_POWER_SUPPORT
31#include "power_mgr_client.h"
32#include "power_mgr_errors.h"
33#endif
34
35namespace OHOS {
36namespace Telephony {
37class SmsReceiveHandler : public TelEventHandler {
38public:
39    explicit SmsReceiveHandler(int32_t slotId);
40    virtual ~SmsReceiveHandler();
41    virtual void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override;
42    bool IsDataShareReady();
43    void ApplyRunningLock();
44    void ReduceRunningLock();
45    void ReleaseRunningLock();
46
47protected:
48    virtual int32_t HandleSmsByType(const std::shared_ptr<SmsBaseMessage> smsBaseMessage) = 0;
49    virtual int32_t HandleAck(const std::shared_ptr<SmsBaseMessage> smsBaseMessage) = 0;
50    virtual void HandleRemainDataShare(const std::shared_ptr<SmsBaseMessage> smsBaseMessage) = 0;
51    virtual bool ReplySmsToSmsc(int result) = 0;
52    virtual void HandleMessageQueue();
53    virtual void HandleReconnectEvent();
54    virtual std::shared_ptr<SmsBaseMessage> TransformMessageInfo(const std::shared_ptr<SmsMessageInfo> info) = 0;
55    void CombineMessagePart(const std::shared_ptr<SmsReceiveIndexer> &smsIndexer);
56    bool IsRepeatedMessagePart(const std::shared_ptr<SmsReceiveIndexer> &smsIndexer);
57    bool AddMsgToDB(const std::shared_ptr<SmsReceiveIndexer> indexer);
58
59private:
60    SmsReceiveHandler(const SmsReceiveHandler &) = delete;
61    SmsReceiveHandler(const SmsReceiveHandler &&) = delete;
62    SmsReceiveHandler &operator=(const SmsReceiveHandler &) = delete;
63    SmsReceiveHandler &operator=(const SmsReceiveHandler &&) = delete;
64    void HandleReceivedSms(const std::shared_ptr<SmsBaseMessage> smsBaseMessage);
65    void HandleReceivedSmsWithoutDataShare(const std::shared_ptr<SmsBaseMessage> smsBaseMessage);
66    bool CombineMultiPageMessage(const std::shared_ptr<SmsReceiveIndexer> &indexer,
67        std::shared_ptr<std::vector<std::string>> pdus,
68        std::shared_ptr<SmsReceiveReliabilityHandler> reliabilityHandler);
69    void UpdateMultiPageMessage(
70        const std::shared_ptr<SmsReceiveIndexer> &indexer, std::shared_ptr<std::vector<std::string>> pdus);
71    void CreateRunningLockInner();
72    void HandleRunningLockTimeoutEvent(const AppExecFwk::InnerEvent::Pointer &event);
73
74protected:
75    int32_t slotId_ = -1;
76
77private:
78    static const uint32_t RUNNING_LOCK_TIMEOUT_EVENT_ID = 100000;
79    static const uint32_t DELAY_RELEASE_RUNNING_LOCK_EVENT_ID = 100001;
80    static const uint32_t RETRY_CONNECT_DATASHARE_EVENT_ID = 100002;
81
82    static const int64_t RUNNING_LOCK_DEFAULT_TIMEOUT_MS = 60 * 1000; // 60s
83    static const int64_t DELAY_RELEASE_RUNNING_LOCK_TIMEOUT_MS = 5 * 1000; // 5s
84    static const int64_t DELAY_REDUCE_RUNNING_LOCK_TIMEOUT_MS = 8 * 1000; // 8s
85    static const int64_t DELAY_REDUCE_RUNNING_LOCK_SMS_QUEUE_TIMEOUT_MS = 20 * 1000; // 20s
86    static const int64_t DELAY_RETRY_CONNECT_DATASHARE_MS = 5 * 1000; // 5s
87    static const uint8_t RECONNECT_MAX_COUNT = 20;
88    static const int32_t E_OK = 0;
89
90    std::mutex queueMutex_;
91    std::mutex datashareMutex_;
92    std::unique_ptr<SmsWapPushHandler> smsWapPushHandler_;
93#ifdef ABILITY_POWER_SUPPORT
94    std::shared_ptr<PowerMgr::RunningLock> smsRunningLock_;
95#endif
96    std::atomic_uint smsRunningLockCount_;
97    std::atomic_int smsLockSerialNum_;
98    std::mutex mutexRunningLock_;
99};
100} // namespace Telephony
101} // namespace OHOS
102#endif