call.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2026 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 "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 <asio/steady_timer.hpp>
 
#include <mutex>
#include <map>
#include <memory>
#include <vector>
#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 : uint8_t { DISCONNECTED, TRYING, PROGRESSING, RINGING, CONNECTED, COUNT__ };
 
    enum class CallState : uint8_t { INACTIVE, ACTIVE, HOLD, BUSY, PEER_BUSY, MERROR, OVER, COUNT__ };
 
    enum class LinkType : uint8_t { 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 : uint8_t { INCOMING, OUTGOING, MISSED };
 
    virtual ~Call();
 
    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(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 hold(OnReadyCb&& cb) = 0;
 
    virtual bool resume(OnReadyCb&& cb) = 0;
 
    virtual void sendKeyframe(int streamIdx = -1) = 0;
 
    virtual bool isIceEnabled() const = 0;
 
    virtual void peerHungup();
 
    virtual void removeCall(int code = 0);
 
    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;
 
    virtual std::map<std::string, bool> getRemoteAudioStreams() 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);
 
    // 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, int code);
 
    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_ {};
 
    asio::steady_timer timeoutTimer_;
};
 
// Helpers
 
inline std::shared_ptr<Call>
getPtr(Call& call)
{
    return call.shared_from_this();
}
 
} // namespace jami