call.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004-2025 Savoir-faire Linux Inc.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include "logger.h"
 
#include "conference.h"
#include "media/recordable.h"
#include "media/peerrecorder.h"
#include "media/media_codec.h"
#include "media/media_attribute.h"
 
#include <dhtnet/ip_utils.h>
 
#include <atomic>
#include <mutex>
#include <map>
#include <sstream>
#include <memory>
#include <vector>
#include <condition_variable>
#include <set>
#include <list>
#include <functional>
 
template<typename T>
bool
is_uninitialized(std::weak_ptr<T> const& weak)
{
    using wt = std::weak_ptr<T>;
    return !weak.owner_before(wt {}) && !wt {}.owner_before(weak);
}
 
namespace jami {
 
class VoIPLink;
class Account;
class AudioDeviceGuard;
 
class Call;
class Conference;
 
using CallMap = std::map<std::string, std::shared_ptr<Call>>;
 
namespace video {
class VideoGenerator;
}
 
/*
 * @file call.h
 * @brief A call is the base class for protocol-based calls
 */
 
class Call : public Recordable, public PeerRecorder, public std::enable_shared_from_this<Call>
{
public:
    enum class ConnectionState : unsigned {
        DISCONNECTED,
        TRYING,
        PROGRESSING,
        RINGING,
        CONNECTED,
        COUNT__
    };
 
    enum class CallState : unsigned {
        INACTIVE,
        ACTIVE,
        HOLD,
        BUSY,
        PEER_BUSY,
        MERROR,
        OVER,
        COUNT__
    };
 
    enum class LinkType { GENERIC, SIP };
 
    using SubcallSet = std::set<std::shared_ptr<Call>, std::owner_less<std::shared_ptr<Call>>>;
    using OnReadyCb = std::function<void(bool)>;
    using StateListenerCb = std::function<bool(CallState, ConnectionState, int)>;
 
    enum class CallType : unsigned { INCOMING, OUTGOING, MISSED };
 
    virtual ~Call();
 
    std::weak_ptr<Call> weak() { return std::static_pointer_cast<Call>(shared_from_this()); }
 
    virtual LinkType getLinkType() const { return LinkType::GENERIC; }
 
    const std::string& getCallId() const { return id_; }
 
    std::shared_ptr<Conference> getConference() const { return conf_.lock(); }
    bool isConferenceParticipant() const { return not is_uninitialized(conf_); }
 
    std::weak_ptr<Account> getAccount() const { return account_; }
    std::string getAccountId() const;
 
    CallType getCallType() const { return type_; }
 
    void setPeerNumber(const std::string& number) { peerNumber_ = number; }
 
    const std::string& getPeerNumber() const { return peerNumber_; }
    void setPeerDisplayName(const std::string& name) { peerDisplayName_ = name; }
 
    const std::string& toUsername() const { return toUsername_; }
    void toUsername(const std::string& username) { toUsername_ = username; }
 
    const std::string& getPeerDisplayName() const { return peerDisplayName_; }
    bool isIncoming() const { return type_ == CallType::INCOMING; }
 
    bool setState(CallState call_state, signed code = 0);
    bool setState(CallState call_state, ConnectionState cnx_state, signed code = 0);
    bool setState(ConnectionState cnx_state, signed code = 0);
 
    CallState getState() const;
 
    ConnectionState getConnectionState() const;
 
    std::string getStateStr() const;
 
    void setIPToIP(bool IPToIP) { isIPToIP_ = IPToIP; }
 
    virtual std::map<std::string, std::string> getDetails() const;
 
    virtual void answer() = 0;
 
    virtual void answer(const std::vector<libjami::MediaMap>& mediaList) = 0;
 
    virtual bool checkMediaChangeRequest(const std::vector<libjami::MediaMap>& remoteMediaList) = 0;
 
    virtual void handleMediaChangeRequest(const std::vector<libjami::MediaMap>& remoteMediaList) = 0;
 
    virtual void answerMediaChangeRequest(const std::vector<libjami::MediaMap>& mediaList,
                                          bool isRemote = false)
        = 0;
    virtual void hangup(int reason) = 0;
 
    virtual void refuse() = 0;
 
    virtual void transfer(const std::string& to) = 0;
 
    virtual bool attendedTransfer(const std::string& to) = 0;
 
    virtual bool onhold(OnReadyCb&& cb) = 0;
 
    virtual bool offhold(OnReadyCb&& cb) = 0;
 
    virtual void sendKeyframe(int streamIdx = -1) = 0;
 
    virtual bool isIceEnabled() const = 0;
 
    virtual void peerHungup();
 
    virtual void removeCall();
 
    virtual void updateRecState(bool state) = 0;
 
    void addStateListener(StateListenerCb&& listener)
    {
        std::lock_guard lk {callMutex_};
        stateChangedListeners_.emplace_back(std::move(listener));
    }
 
    void addSubCall(Call& call);
 
    bool isSubcall() const
    {
        std::lock_guard lk {callMutex_};
        return parent_ != nullptr;
    }
 
    std::chrono::milliseconds getCallDuration() const
    {
        return duration_start_ == time_point::min()
                   ? std::chrono::milliseconds::zero()
                   : std::chrono::duration_cast<std::chrono::milliseconds>(clock::now()
                                                                           - duration_start_);
    }
 
    // media management
    virtual bool toggleRecording();
 
    virtual std::vector<MediaAttribute> getMediaAttributeList() const = 0;
 
    virtual std::map<std::string, bool> getAudioStreams() const = 0;
 
#ifdef ENABLE_VIDEO
    virtual void createSinks(ConfInfo& infos) = 0;
#endif
 
    virtual void switchInput(const std::string& = {}) {};
 
    virtual void muteMedia(const std::string& mediaType, bool isMuted) = 0;
 
    virtual void carryingDTMFdigits(char code) = 0;
 
    virtual bool requestMediaChange(const std::vector<libjami::MediaMap>& mediaList) = 0;
 
    virtual std::vector<libjami::MediaMap> currentMediaList() const = 0;
 
    virtual void sendTextMessage(const std::map<std::string, std::string>& messages,
                                 const std::string& from)
        = 0;
 
    void onTextMessage(std::map<std::string, std::string>&& messages);
 
    virtual std::shared_ptr<SystemCodecInfo> getAudioCodec() const
    {
        return {};
    }
    virtual std::shared_ptr<SystemCodecInfo> getVideoCodec() const
    {
        return {};
    }
 
    virtual void restartMediaSender() = 0;
 
    // Media status methods
    virtual bool hasVideo() const = 0;
    virtual bool isCaptureDeviceMuted(const MediaType& mediaType) const = 0;
 
    void setConferenceInfo(const std::string& msg);
 
    virtual void enterConference(std::shared_ptr<Conference> conference) = 0;
    virtual void exitConference() = 0;
 
    std::vector<std::map<std::string, std::string>> getConferenceInfos() const
    {
        return confInfo_.toVectorMapStringString();
    }
 
    std::unique_ptr<AudioDeviceGuard> audioGuard;
    void sendConfOrder(const Json::Value& root);
    void sendConfInfo(const std::string& json);
    void resetConfInfo();
 
    virtual void monitor() const = 0;
 
    int conferenceProtocolVersion() const
    {
        return peerConfProtocol_;
    }
 
protected:
    using clock = std::chrono::steady_clock;
    using time_point = clock::time_point;
    virtual void merge(Call& scall);
 
    Call(const std::shared_ptr<Account>& account,
         const std::string& id,
         Call::CallType type,
         const std::map<std::string, std::string>& details = {});
 
    // TODO all these members are not protected against multi-thread access
 
    const std::string id_ {};
 
    mutable std::shared_ptr<Call> parent_;
 
    SubcallSet subcalls_;
 
    using MsgList = std::list<std::pair<std::map<std::string, std::string>, std::string>>;
 
    MsgList pendingOutMessages_;
 
    mutable std::recursive_mutex callMutex_ {};
 
    mutable std::mutex confInfoMutex_ {};
    mutable ConfInfo confInfo_ {};
    time_point duration_start_ {time_point::min()};
 
private:
    bool validStateTransition(CallState newState);
 
    void checkPendingIM();
 
    void checkAudio();
 
    void subcallStateChanged(Call&, Call::CallState, Call::ConnectionState);
 
    SubcallSet safePopSubcalls();
 
    std::vector<StateListenerCb> stateChangedListeners_ {};
 
protected:
    std::weak_ptr<Conference> conf_ {};
 
    CallType type_;
 
    std::weak_ptr<Account> account_;
 
    ConnectionState connectionState_ {ConnectionState::DISCONNECTED};
 
    CallState callState_ {CallState::INACTIVE};
 
    std::string reason_ {};
 
    bool isIPToIP_ {false};
 
    std::string peerNumber_ {};
 
    std::string peerDisplayName_ {};
 
    time_t timestamp_start_ {0};
 
    MsgList pendingInMessages_;
 
    int peerConfProtocol_ {0};
    std::string toUsername_ {};
};
 
// Helpers
 
inline std::shared_ptr<Call>
getPtr(Call& call)
{
    return call.shared_from_this();
}
 
} // namespace jami