xref: /base/telephony/cellular_call/services/control/include/control_base.h

/*
 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef CELLULAR_CALL_CONTROL_BASE_H
#define CELLULAR_CALL_CONTROL_BASE_H

#include "call_manager_errors.h"
#include "event_handler.h"
#include "cellular_call_data_struct.h"
#include "telephony_log_wrapper.h"
#include "base_connection.h"
#include "tel_ril_call_parcel.h"
#include "mmi_code_utils.h"

namespace OHOS {
namespace Telephony {
class ControlBase {
public:
    /**
     * constructor
     */
    ControlBase() = default;

    /**
     * destructor
     */
    virtual ~ControlBase() = default;

    /**
     * Dial
     *
     * 27007-430_2001 6.27 Informative examples
     * 3GPP TS 22.030 [19]
     *
     * originate a voice call
     *
     * @param CellularCallInfo
     * @param bool
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    virtual int32_t Dial(const CellularCallInfo &callInfo, bool isEcc) = 0;

    /**
     * HangUp
     *
     * 3GPP TS 27.007 V3.9.0 (2001-06) Call related supplementary services +CHLD
     * 3GPP TS 27.007 V3.9.0 (2001-06) 7.22	Informative examples
     * 3GPP TS 22.030 [19]
     *
     * release call
     *
     * @param CellularCallInfo
     * @param CallSupplementType
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    virtual int32_t HangUp(const CellularCallInfo &callInfo, CallSupplementType type) = 0;

    /**
     * Answer
     *
     * 27007-430_2001 6.6 Alternating mode call control method
     * 3GPP TS 22.030 [19]
     *
     * Answer an incoming voice call.
     *
     * @param CellularCallInfo
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    virtual int32_t Answer(const CellularCallInfo &callInfo) = 0;

    /**
     * Reject
     *
     * 27007-430_2001 6.6 Alternating mode call control method
     * 3GPP TS 22.030 [19]
     *
     * Reject an incoming voice call
     *
     * @param CellularCallInfo
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    virtual int32_t Reject(const CellularCallInfo &callInfo) = 0;

    /**
     * HoldCall
     *
     * 22083-400_2001 2 Call hold
     * 3GPP TS 22.030 [3]
     * 3GPP TS 23.083 V4.2.0 (2001-04) 2 Call hold (HOLD)
     *
     * The call hold service allows a served mobile subscriber
     *
     * @param slotId
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    virtual int32_t HoldCall(int32_t slotId) = 0;

    /**
     * UnHoldCall
     *
     * 22083-400_2001 2 Call hold
     * 3GPP TS 22.030 [3]
     *
     * Retrieve the held call.
     *
     * @param slotId
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    virtual int32_t UnHoldCall(int32_t slotId) = 0;

    /**
     * SwitchCall
     *
     * 22083-400_2001 2 Call hold
     * 3GPP TS 22.030 [3]
     *
     * Alternate from one call to the other
     *
     * @param slotId
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    virtual int32_t SwitchCall(int32_t slotId) = 0;

    /**
     * CombineConference
     *
     * 22084-400_2001 1.3.8.2	Managing an active multiParty call
     * 3GPP TS 22.030
     *
     * Add another remote party
     * @param slotId
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    virtual int32_t CombineConference(int32_t slotId) = 0;

    /**
     * HangUpAllConnection
     *
     * @param slotId
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    virtual int32_t HangUpAllConnection(int32_t slotId) = 0;

    /**
     * ReportCallsData
     *
     * @param slotId
     * @param CallInfoList
     * @returns Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    virtual int32_t ReportCallsData(int32_t slotId, const CallInfoList &callInfoList) = 0;

    /**
     * Dial PreJudgment
     *
     * @param CellularCallInfo
     * @returns Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    int32_t DialPreJudgment(const CellularCallInfo &callInfo, bool isEcc);

    /**
     * Is Need Execute MMI
     *
     * @param slotId
     * @param std::string phoneString
     * @param CLIRMode
     * @param isNeedUseIms
     * @returns bool
     */
    bool IsNeedExecuteMMI(int32_t slotId, std::string &phoneString, CLIRMode &clirMode, bool isNeedUseIms);

    /**
     * Is Dtmf Key
     *
     * 23014-400_2001 6	Support of DTMF across the air interface
     * 3GPP TS 22.030
     *
     * @param char
     * @returns bool
     */
    bool IsDtmfKey(char c) const;

    bool IsConnectedOut(TelCallState preState, TelCallState curState);

    int32_t SetReadyToCall(int32_t slotId, bool isReadyToCall);

    /**
     * Determine whether the call can be initiated currently
     *
     * @param std::map<std::string, BaseConnection>
     * @return Returns true can to call
     */
    template<typename T>
    bool CanCall(T &&t)
    {
        unsigned int maximumCalls = 6;
        return t.size() <= maximumCalls;
    }

    /**
     * FindConnectionByState
     *
     * @param std::map<std::string, BaseConnection>
     * @param TelCallState
     * @return pointer
     */
    template<typename T1, typename T2>
    T2 FindConnectionByState(const T1 &&t1, TelCallState state) const
    {
        for (auto &it : t1) {
            T2 pConnection = &it.second;
            if (pConnection != nullptr && pConnection->GetStatus() == state) {
                return pConnection;
            }
        }
        return nullptr;
    }

    /**
     * FindConnectionByIndex
     *
     * @param std::map<std::string, BaseConnection>
     * @param index
     * @return pointer
     */
    template<typename T1, typename T2>
    T2 FindConnectionByIndex(const T1 &&t1, int32_t index) const
    {
        for (auto &it : t1) {
            T2 pConnection = &it.second;
            if (pConnection != nullptr && pConnection->GetIndex() == index) {
                return pConnection;
            }
        }
        return nullptr;
    }

    /**
     * SetConnectionData
     *
     * @param std::map<std::string, BaseConnection>
     * @param string phoneNum
     * @param BaseConnection
     * @return bool
     */
    template<typename T1, typename T2>
    bool SetConnectionData(T1 &&t1, const int32_t &key, const T2 &con)
    {
        if (!t1.insert(std::make_pair(key, con)).second) {
            TELEPHONY_LOGE("SetConnectionData, key already exists.");
            return false;
        }
        return true;
    }

    /**
     * Determines if a connection is currently in this state
     *
     * @param std::map<std::string, BaseConnection>
     * @param TelCallState
     * @return Returns true or false
     */
    template<typename T1>
    bool IsInState(T1 &&t, TelCallState state)
    {
        for (const auto &it : t) {
            auto pConnection = &it.second;
            if (pConnection != nullptr && pConnection->GetStatus() == state) {
                return true;
            }
        }
        return false;
    }

    /**
     * StartDtmf
     *
     * 23014-400_2001 6	Support of DTMF across the air interface
     * 3GPP TS 22.030
     *
     * START DTMF : Containing the digit value (0-9,A,B,C,D,*,#)
     * @param std::map<std::string, BaseConnection>
     * @param Dtmf Code
     * @param CellularCallInfo
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    template<typename T>
    int32_t StartDtmf(T &&t, char cDtmfCode, const CellularCallInfo &callInfo) const
    {
        /**
         * The messages when sent across the air interface should contain the following information:
         * a) START DTMF : Containing the digit value (0-9,A,B,C,D,*,#);
         * b) START DTMF ACKNOWLEDGE: Containing the digit value (0-9,A,B,C,D,*,#) corresponding to the DTMF tone that
         * the network applies towards the remote user;
         * c) STOP DTMF : No further info;
         * d) STOP DTMF ACKNOWLEDGE: No further info.
         * Only a single digit will be passed in each START DTMF and START DTMF ACKNOWLEDGE message
         */
        TELEPHONY_LOGD("ControlBase::StartDtmf start");
        auto pConnection = FindConnectionByIndex<T &, decltype(&t.begin()->second)>(t, callInfo.index);

        if (pConnection == nullptr) {
            TELEPHONY_LOGE("StartDtmf, error type: connection is null");
            return CALL_ERR_CALL_CONNECTION_NOT_EXIST;
        }
        if (!IsDtmfKey(cDtmfCode)) {
            TELEPHONY_LOGE("StartDtmf return, error type: cDtmfCode invalid.");
            return CALL_ERR_PARAMETER_OUT_OF_RANGE;
        }
        return pConnection->StartDtmfRequest(callInfo.slotId, cDtmfCode, pConnection->GetIndex());
    }

    /**
     * StopDtmf
     *
     * 23014-400_2001 6	Support of DTMF across the air interface
     * 3GPP TS 22.030
     *
     * STOP DTMF : No further info
     * @param std::map<std::string, BaseConnection>
     * @param CellularCallInfo
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    template<typename T>
    int32_t StopDtmf(T &&t, const CellularCallInfo &callInfo) const
    {
        /**
         * The messages when sent across the air interface should contain the following information:
         * a) START DTMF : Containing the digit value (0-9,A,B,C,D,*,#);
         * b) START DTMF ACKNOWLEDGE: Containing the digit value (0-9,A,B,C,D,*,#) corresponding to the DTMF tone that
         * the network applies towards the remote user;
         * c) STOP DTMF : No further info;
         * d) STOP DTMF ACKNOWLEDGE: No further info.
         * Only a single digit will be passed in each START DTMF and START DTMF ACKNOWLEDGE message
         */
        TELEPHONY_LOGD("ControlBase::StopDtmf start");
        auto pConnection = FindConnectionByIndex<T &, decltype(&t.begin()->second)>(t, callInfo.index);
        if (pConnection == nullptr) {
            TELEPHONY_LOGE("StopDtmf, error type: connection is null");
            return CALL_ERR_CALL_CONNECTION_NOT_EXIST;
        }
        return pConnection->StopDtmfRequest(callInfo.slotId, pConnection->GetIndex());
    }

    /**
     * SendDtmf
     *
     * 23014-400_2001 6	Support of DTMF across the air interface
     * 3GPP TS 22.030
     *
     * @param std::map<std::string, BaseConnection>
     * @param Dtmf Code
     * @param CellularCallInfo
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    template<typename T>
    int32_t SendDtmf(T &&t, char cDtmfCode, const CellularCallInfo &callInfo) const
    {
        /**
         * 3gpp 27007-430_2001
         *
         * C.2.11	DTMF and tone generation +VTS
         *
         * This command allows the transmission of DTMF tones and arbitrary tones (see note).
         * These tones may be used (for example) when announcing the start of a recording period.
         * The command is write only.
         * In this profile of commands, this command does not operate in data or fax modes of operation (+FCLASS=0,1,2
         7). NOTE 1:	D is used only for dialling.

         The string parameter of the command consists of combinations of the following separated by commas:
         1. <DTMF>. A single ASCII character in the set 0 9, #,*,A D.
         This is interpreted as a single ACSII character whose duration is set by the +VTD command.
            NOTE 2:	In GSM this operates only in voice mode.
         2. [<tone1>,<tone2>,<duration>].
         This is interpreted as a dual tone of frequencies <tone1> and <tone2>, lasting for a time <duration> (in 10
         ms multiples). NOTE 3:	This does not operate in GSM.
         3. {<DTMF>,<duration>}. This is interpreted as a DTMF tone of different duration from that mandated by the
         +VTD command. NOTE 4:	In GSM this operates only in voice mode.
         */
        TELEPHONY_LOGD("ControlBase::SendDtmf start");
        auto pConnection = FindConnectionByIndex<T &, decltype(&t.begin()->second)>(t, callInfo.index);
        if (pConnection == nullptr) {
            TELEPHONY_LOGE("SendDtmf, error type: connection is null");
            return CALL_ERR_CALL_CONNECTION_NOT_EXIST;
        }
        if (!IsDtmfKey(cDtmfCode)) {
            TELEPHONY_LOGE("SendDtmf return, error type: cDtmfCode invalid.");
            return CALL_ERR_PARAMETER_OUT_OF_RANGE;
        }
        return pConnection->SendDtmfRequest(callInfo.slotId, cDtmfCode, pConnection->GetIndex());
    }

    /**
     * GetCallFailReason
     *
     * 3GPP TS 24.008 V17.4.0 (2021-09) 10.5.4.11	Cause
     *
     * @return Error Code: Returns TELEPHONY_SUCCESS on success, others on failure.
     */
    template<typename T>
    int32_t GetCallFailReason(int32_t slotId, T &&t) const
    {
        decltype(t.begin()->second) connection;
        return connection.GetCallFailReasonRequest(slotId);
    }

protected:
    bool isIgnoredIncomingCall_ = false;

private:
    /**
     * Check call with airplane mode on
     */
    bool CheckAirplaneModeScene(const CellularCallInfo &callInfo);

    /**
     * check call with activate sim
    */
    bool CheckActivateSimScene(int32_t slotId);

    /**
     * Handle call with airplane mode on
     */
    int32_t HandleEcc(const CellularCallInfo &callInfo, bool isEcc, bool isAirplaneModeOn, bool isActivateSim);

private:
    std::shared_ptr<AppExecFwk::EventRunner> eventLoop_;
    std::condition_variable cv_;
    std::mutex mutex_;
};
} // namespace Telephony
} // namespace OHOS

#endif // CELLULAR_CALL_CONTROL_BASE_H