Skip to content
Snippets Groups Projects
Select Git revision
  • cc4e824b1be9251545b8fe607015ab3bd667d8eb
  • master default protected
  • release/202106
  • release/202104
  • release/202101
  • release/202012
  • release/202005
  • release/202001
  • release/201912
  • release/201911
  • release/windows-test/201910
  • release/201908
  • release/201906
  • release/201905
  • release/201904
  • release/201903
  • release/201902
  • release/201901
  • release/201812
  • release/201811
  • release/201808
  • 1.0.0
  • 0.3.0
  • 0.2.1
  • 0.2.0
  • 0.1.0
26 results

ringnotify.cpp

Blame
    • Sébastien Blin's avatar
      cc4e824b
      ringnotify: rewrite notification system · cc4e824b
      Sébastien Blin authored and Andreas Traczyk's avatar Andreas Traczyk committed
      
      Ring will now use three types of notifications:
      
      1. Call notifications: opened when an incoming call is here
      and closed at the end of the call.
      2. Request notifications: opened when a new trust request
      arrives and closed when the user accepts/refuse/block or
      just open the conversation.
      3. Chat notifications: arrives with new interactions and if
      the current conversation is different or the client not focused. Closed
      by Gnome or when the conversation is opened.
      
      Change-Id: I5e5abf20507bac8bb37c429bc929c671fe66bd6b
      Gitlab: #868
      Reviewed-by: default avatarAndreas Traczyk <andreas.traczyk@savoirfairelinux.com>
      cc4e824b
      History
      ringnotify: rewrite notification system
      Sébastien Blin authored and Andreas Traczyk's avatar Andreas Traczyk committed
      
      Ring will now use three types of notifications:
      
      1. Call notifications: opened when an incoming call is here
      and closed at the end of the call.
      2. Request notifications: opened when a new trust request
      arrives and closed when the user accepts/refuse/block or
      just open the conversation.
      3. Chat notifications: arrives with new interactions and if
      the current conversation is different or the client not focused. Closed
      by Gnome or when the conversation is opened.
      
      Change-Id: I5e5abf20507bac8bb37c429bc929c671fe66bd6b
      Gitlab: #868
      Reviewed-by: default avatarAndreas Traczyk <andreas.traczyk@savoirfairelinux.com>
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    call.h 6.15 KiB
    /****************************************************************************
     *    Copyright (C) 2017-2024 Savoir-faire Linux Inc.                       *
     *   Author: Nicolas Jäger <nicolas.jager@savoirfairelinux.com>             *
     *   Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>           *
     *                                                                          *
     *   This library is free software; you can redistribute it and/or          *
     *   modify it under the terms of the GNU Lesser General Public             *
     *   License as published by the Free Software Foundation; either           *
     *   version 2.1 of the License, or (at your option) any later version.     *
     *                                                                          *
     *   This library 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      *
     *   Lesser 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 <http://www.gnu.org/licenses/>.  *
     ***************************************************************************/
    #pragma once
    
    // Qt
    #include <QObject>
    
    // std
    #include <string>
    #include <ctime>
    #include <chrono>
    
    #include "typedefs.h"
    #include <media_const.h>
    
    namespace lrc {
    
    namespace api {
    
    namespace call {
    Q_NAMESPACE
    Q_CLASSINFO("RegisterEnumClassesUnscoped", "false")
    
    enum class Status {
        INVALID,
        INCOMING_RINGING,
        OUTGOING_RINGING,
        CONNECTING,
        SEARCHING,
        IN_PROGRESS,
        PAUSED,
        INACTIVE,
        ENDED,
        PEER_BUSY,
        TIMEOUT,
        TERMINATING,
        CONNECTED
    };
    Q_ENUM_NS(Status)
    
    static inline QString
    to_string(const call::Status& status)
    {
        switch (status) {
        case call::Status::PAUSED:
            return QObject::tr("Hold");
        case call::Status::IN_PROGRESS:
            return QObject::tr("Talking");
        case call::Status::INVALID:
            return QObject::tr("ERROR");
        case call::Status::INCOMING_RINGING:
            return QObject::tr("Incoming");
        case call::Status::OUTGOING_RINGING:
            return QObject::tr("Calling");
        case call::Status::CONNECTING:
            return QObject::tr("Connecting");
        case call::Status::SEARCHING:
            return QObject::tr("Searching");
        case call::Status::INACTIVE:
            return QObject::tr("Inactive");
        case call::Status::ENDED:
            return QObject::tr("Finished");
        case call::Status::TIMEOUT:
            return QObject::tr("Timeout");
        case call::Status::PEER_BUSY:
            return QObject::tr("Peer busy");
        case call::Status::TERMINATING:
            return QObject::tr("Finished");
        case call::Status::CONNECTED:
            return QObject::tr("Communication established");
        default:
            return ""; // to remove a build warning, should not happen
        }
    }
    
    /**
     * Convert status from daemon into a Status
     * @warning status is a string from the daemon, not from to_string()
     * @param  status
     * @return
     */
    static inline Status
    to_status(const QString& status)
    {
        if (status == "INCOMING")
            return Status::INCOMING_RINGING;
        else if (status == "CONNECTING")
            return Status::CONNECTING;
        else if (status == "RINGING")
            return Status::OUTGOING_RINGING;
        else if (status == "HUNGUP" || status == "FAILURE")
            return Status::TERMINATING;
        else if (status == "HOLD" || status == "ACTIVE_DETACHED")
            return Status::PAUSED;
        else if (status == "UNHOLD" || status == "CURRENT" || status == "ACTIVE_ATTACHED")
            return Status::IN_PROGRESS;
        else if (status == "PEER_BUSY")
            return Status::PEER_BUSY;
        else if (status == "BUSY")
            return Status::TIMEOUT;
        else if (status == "INACTIVE")
            return Status::INACTIVE;
        else if (status == "OVER")
            return Status::ENDED;
        return Status::INVALID;
    }
    
    enum class Type { INVALID, DIALOG, CONFERENCE };
    Q_ENUM_NS(Type)
    
    enum class Layout { GRID, ONE_WITH_SMALL, ONE };
    
    struct Info
    {
        QString id;
        std::chrono::steady_clock::time_point startTime;
        Status status = Status::INVALID;
        Type type = Type::INVALID;
        QString peerUri;
        bool isOutgoing;
        bool audioMuted = false; // this flag is used to check device audio status
        bool videoMuted = false; // this flag is used to check device video status
        bool isAudioOnly = false;
        Layout layout = Layout::GRID;
        VectorMapStringString mediaList = {};
        QStringList recordingPeers {};
    
        bool hasMediaWithType(const QString& type, const QString& mediaType) const
        {
            for (const auto& m : mediaList)
                if (m[libjami::Media::MediaAttributeKey::SOURCE].startsWith(type)
                    && m[libjami::Media::MediaAttributeKey::MEDIA_TYPE] == mediaType)
                    return true;
            return false;
        }
    };
    
    static inline bool
    canSendSIPMessage(const Info& call)
    {
        switch (call.status) {
        case call::Status::PAUSED:
        case call::Status::IN_PROGRESS:
        case call::Status::INCOMING_RINGING:
        case call::Status::OUTGOING_RINGING:
        case call::Status::CONNECTED:
            return true;
        case call::Status::INVALID:
        case call::Status::CONNECTING:
        case call::Status::SEARCHING:
        case call::Status::INACTIVE:
        case call::Status::ENDED:
        case call::Status::PEER_BUSY:
        case call::Status::TIMEOUT:
        case call::Status::TERMINATING:
        default:
            return false;
        }
    }
    
    static inline bool
    isTerminating(const Status& status)
    {
        switch (status) {
        case call::Status::INVALID:
        case call::Status::INACTIVE:
        case call::Status::ENDED:
        case call::Status::PEER_BUSY:
        case call::Status::TIMEOUT:
        case call::Status::TERMINATING:
            return true;
        case call::Status::PAUSED:
        case call::Status::IN_PROGRESS:
        case call::Status::INCOMING_RINGING:
        case call::Status::OUTGOING_RINGING:
        case call::Status::CONNECTED:
        case call::Status::CONNECTING:
        case call::Status::SEARCHING:
        default:
            return false;
        }
    }
    
    } // namespace call
    } // namespace api
    } // namespace lrc