1
2/*
3 * Copyright (C) 2023 Huawei Device Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef TELEPHONY_SATELLITE_CALL_CLIENT_H
18#define TELEPHONY_SATELLITE_CALL_CLIENT_H
19
20#include "event_runner.h"
21#include "i_satellite_service.h"
22#include "iremote_stub.h"
23#include "rwlock.h"
24#include "satellite_call_interface.h"
25#include "singleton.h"
26#include "system_ability_status_change_stub.h"
27
28namespace OHOS {
29namespace Telephony {
30class SatelliteCallClient {
31    DECLARE_DELAYED_SINGLETON(SatelliteCallClient);
32
33public:
34    /**
35     * @brief Get SatelliteCall Remote Object ptr
36     *
37     * @return sptr<SatelliteCallInterface>
38     */
39    sptr<SatelliteCallInterface> GetSatelliteCallProxy();
40
41    /**
42     * @brief Get the remote object ptr, initiate a listener and subscribe the system ability
43     */
44    void Init();
45
46    /**
47     * @brief Clear the listener and the remote ptr when destroy the SatelliteCallClient Object
48     */
49    void UnInit();
50
51    /**
52     * @brief Register SatelliteCallCallback Handler, put the handler and slot id into {handlerMap_}
53     *
54     * @param slotId Indicates the card slot index number,
55     * @param handler Indicates the event handler ptr
56     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
57     */
58    int32_t RegisterSatelliteCallCallbackHandler(
59        int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler);
60
61    /**
62     * @brief Get the event handler ptr from {handlerMap_}
63     *
64     * @param slotId Indicates the card slot index number,
65     * @return AppExecFwk::EventHandler
66     */
67    std::shared_ptr<AppExecFwk::EventHandler> GetHandler(int32_t slotId);
68
69    /****************** call basic ******************/
70    /**
71     * @brief Satellite dial the call interface
72     *
73     * @param SatelliteCallInfo Indicates the call detail information, contains phone number, slot id,
74     * video state, call index
75     * @param CLIRMode Indicates the CLIR mode, like default, transfer, inhibition
76     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
77     */
78    int32_t Dial(const SatelliteCallInfo &callInfo, CLIRMode mode);
79
80    /**
81     * @brief Satellite HangUp the call interface
82     *
83     * @param slotId Indicates the call slot id,
84     * @param index Indicates the call id,
85     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
86     */
87    int32_t HangUp(int32_t slotId, int32_t index);
88
89    /**
90     * @brief Satellite Reject the call interface
91     *
92     * @param slotId Indicates the call slot id,
93     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
94     */
95    int32_t Reject(int32_t slotId);
96
97    /**
98     * @brief Satellite Answer the call interface
99     *
100     * @param slotId Indicates the call slot id,
101     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
102     */
103    int32_t Answer(int32_t slotId);
104
105    /**
106     * @brief Get Satellite Calls Data Request
107     *
108     * @param slotId Indicates the card slot index number,
109     * @param lastCallsDataFlag The Satellite call data id, is a number in milliseconds
110     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
111     */
112    int32_t GetSatelliteCallsDataRequest(int32_t slotId, int64_t lastCallsDataFlag);
113
114    /**
115     * @brief Get Satellite status
116     *
117     * @param slotId Indicates the card slot index number,
118     * @return Returns true on satellite enable, others on false.
119     */
120    bool IsSatelliteEnabled(int32_t slotId);
121
122private:
123    /**
124     * Is Connect ImsCall Remote Object
125     *
126     * @return bool
127     */
128    bool IsConnect();
129    int32_t RegisterSatelliteCallCallback();
130    int32_t ReConnectService();
131    void Clean();
132
133    class SatelliteServiceDeathRecipient : public IRemoteObject::DeathRecipient {
134    public:
135        explicit SatelliteServiceDeathRecipient(SatelliteCallClient &client) : client_(client) {}
136        ~SatelliteServiceDeathRecipient() override = default;
137        void OnRemoteDied(const wptr<IRemoteObject> &remote) override
138        {
139            client_.OnRemoteDied(remote);
140        }
141
142    private:
143        SatelliteCallClient &client_;
144    };
145
146    void RemoveDeathRecipient(const wptr<IRemoteObject> &remote);
147
148    void OnRemoteDied(const wptr<IRemoteObject> &remote);
149
150private:
151    sptr<ISatelliteService> satelliteServiceProxy_ = nullptr;
152    sptr<SatelliteCallInterface> satelliteCallProxy_ = nullptr;
153    sptr<SatelliteCallCallbackInterface> satelliteCallCallback_ = nullptr;
154    sptr<IRemoteObject::DeathRecipient> deathRecipient_ { nullptr };
155    std::map<int32_t, std::shared_ptr<AppExecFwk::EventHandler>> handlerMap_;
156    Utils::RWLock rwClientLock_;
157    std::mutex mutexProxy_;
158    std::mutex mutexMap_;
159};
160} // namespace Telephony
161} // namespace OHOS
162
163#endif // TELEPHONY_SATELLITE_CALL_CLIENT_H