tdesktop/Telegram/SourceFiles/data/data_group_call.h

229 lines
6.5 KiB
C
Raw Normal View History

2020-11-20 19:25:35 +00:00
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#pragma once
#include "base/timer.h"
class PeerData;
2020-11-20 19:25:35 +00:00
2020-11-29 15:18:51 +00:00
class ApiWrap;
2021-04-15 13:55:32 +00:00
namespace Calls {
struct ParticipantVideoParams;
2021-04-15 13:55:32 +00:00
} // namespace Calls
2020-11-20 19:25:35 +00:00
namespace Data {
struct LastSpokeTimes {
crl::time anything = 0;
crl::time voice = 0;
};
2021-03-08 07:57:00 +00:00
struct GroupCallParticipant {
not_null<PeerData*> peer;
std::shared_ptr<Calls::ParticipantVideoParams> videoParams;
2021-03-08 07:57:00 +00:00
TimeId date = 0;
TimeId lastActive = 0;
uint64 raisedHandRating = 0;
2021-03-08 07:57:00 +00:00
uint32 ssrc = 0;
int volume = 0;
bool applyVolumeFromMin = true;
bool sounding = false;
bool speaking = false;
bool muted = false;
bool mutedByMe = false;
bool canSelfUnmute = false;
bool onlyMinLoaded = false;
[[nodiscard]] const std::string &cameraEndpoint() const;
[[nodiscard]] const std::string &screenEndpoint() const;
2021-03-08 07:57:00 +00:00
};
2020-11-20 19:25:35 +00:00
class GroupCall final {
public:
2021-04-12 11:36:19 +00:00
GroupCall(
not_null<PeerData*> peer,
uint64 id,
uint64 accessHash,
TimeId scheduleDate);
2020-11-24 11:56:46 +00:00
~GroupCall();
2020-11-20 19:25:35 +00:00
[[nodiscard]] uint64 id() const;
[[nodiscard]] bool loaded() const;
[[nodiscard]] not_null<PeerData*> peer() const;
2020-11-20 19:25:35 +00:00
[[nodiscard]] MTPInputGroupCall input() const;
2021-03-05 16:59:35 +00:00
[[nodiscard]] QString title() const {
return _title.current();
}
[[nodiscard]] rpl::producer<QString> titleValue() const {
return _title.value();
}
void setTitle(const QString &title) {
_title = title;
}
2021-03-09 09:27:17 +00:00
[[nodiscard]] TimeId recordStartDate() const {
2021-03-09 13:24:32 +00:00
return _recordStartDate.current();
}
[[nodiscard]] rpl::producer<TimeId> recordStartDateValue() const {
return _recordStartDate.value();
}
[[nodiscard]] rpl::producer<TimeId> recordStartDateChanges() const {
return _recordStartDate.changes();
2021-03-09 09:27:17 +00:00
}
[[nodiscard]] TimeId scheduleDate() const {
return _scheduleDate.current();
}
[[nodiscard]] rpl::producer<TimeId> scheduleDateValue() const {
return _scheduleDate.value();
}
[[nodiscard]] rpl::producer<TimeId> scheduleDateChanges() const {
return _scheduleDate.changes();
}
[[nodiscard]] bool scheduleStartSubscribed() const {
return _scheduleStartSubscribed.current();
}
[[nodiscard]] rpl::producer<bool> scheduleStartSubscribedValue() const {
return _scheduleStartSubscribed.value();
}
2020-11-20 19:25:35 +00:00
void setPeer(not_null<PeerData*> peer);
2021-03-08 07:57:00 +00:00
using Participant = GroupCallParticipant;
struct ParticipantUpdate {
std::optional<Participant> was;
std::optional<Participant> now;
};
2020-11-20 19:25:35 +00:00
static constexpr auto kSoundStatusKeptFor = crl::time(350);
2020-11-20 19:25:35 +00:00
[[nodiscard]] auto participants() const
-> const std::vector<Participant> &;
void requestParticipants();
[[nodiscard]] bool participantsLoaded() const;
[[nodiscard]] PeerData *participantPeerByAudioSsrc(uint32 ssrc) const;
2021-05-11 09:35:04 +00:00
[[nodiscard]] const Participant *participantByPeer(
not_null<PeerData*> peer) const;
[[nodiscard]] const Participant *participantByEndpoint(
const std::string &endpoint) const;
2020-11-20 19:25:35 +00:00
[[nodiscard]] rpl::producer<> participantsReloaded();
[[nodiscard]] rpl::producer<ParticipantUpdate> participantUpdated() const;
void enqueueUpdate(const MTPUpdate &update);
void applyLocalUpdate(
const MTPDupdateGroupCallParticipants &update);
void applyLastSpoke(uint32 ssrc, LastSpokeTimes when, crl::time now);
void applyActiveUpdate(
2021-03-03 15:29:33 +00:00
PeerId participantPeerId,
LastSpokeTimes when,
2021-03-03 15:29:33 +00:00
PeerData *participantPeerLoaded);
2020-11-24 11:56:46 +00:00
2021-03-08 07:57:00 +00:00
void resolveParticipants(const base::flat_set<uint32> &ssrcs);
[[nodiscard]] rpl::producer<
not_null<const base::flat_map<
uint32,
LastSpokeTimes>*>> participantsResolved() const {
return _participantsResolved.events();
}
2021-03-08 07:57:00 +00:00
2020-11-20 19:25:35 +00:00
[[nodiscard]] int fullCount() const;
[[nodiscard]] rpl::producer<int> fullCountValue() const;
2020-11-20 19:25:35 +00:00
void setInCall();
2020-11-24 11:56:46 +00:00
void reload();
void processFullCall(const MTPphone_GroupCall &call);
2020-11-24 11:56:46 +00:00
2020-11-28 16:18:51 +00:00
void setJoinMutedLocally(bool muted);
[[nodiscard]] bool joinMuted() const;
[[nodiscard]] bool canChangeJoinMuted() const;
[[nodiscard]] bool joinedToTop() const;
2020-11-28 16:18:51 +00:00
2020-11-20 19:25:35 +00:00
private:
2020-11-29 15:18:51 +00:00
enum class ApplySliceSource {
FullReloaded,
2020-11-29 15:18:51 +00:00
SliceLoaded,
UnknownLoaded,
UpdateReceived,
2021-04-15 13:55:32 +00:00
UpdateConstructed,
2020-11-29 15:18:51 +00:00
};
2021-03-18 18:46:52 +00:00
enum class QueuedType : uint8 {
VersionedParticipant,
Participant,
Call,
};
2020-11-29 15:18:51 +00:00
[[nodiscard]] ApiWrap &api() const;
2021-03-18 20:57:16 +00:00
void discard(const MTPDgroupCallDiscarded &data);
[[nodiscard]] bool inCall() const;
void applyParticipantsSlice(
const QVector<MTPGroupCallParticipant> &list,
2020-11-29 15:18:51 +00:00
ApplySliceSource sliceSource);
void requestUnknownParticipants();
void changePeerEmptyCallFlag();
void checkFinishSpeakingByActive();
void applyCallFields(const MTPDgroupCall &data);
2021-03-18 18:46:52 +00:00
void applyEnqueuedUpdate(const MTPUpdate &update);
void setServerParticipantsCount(int count);
void computeParticipantsCount();
void processQueuedUpdates();
void processFullCallUsersChats(const MTPphone_GroupCall &call);
void processFullCallFields(const MTPphone_GroupCall &call);
[[nodiscard]] bool requestParticipantsAfterReload(
const MTPphone_GroupCall &call) const;
[[nodiscard]] bool processSavedFullCall();
void finishParticipantsSliceRequest();
2021-05-11 09:35:04 +00:00
[[nodiscard]] Participant *findParticipant(not_null<PeerData*> peer);
2020-11-24 11:56:46 +00:00
2020-11-20 19:25:35 +00:00
const uint64 _id = 0;
const uint64 _accessHash = 0;
not_null<PeerData*> _peer;
2020-11-20 19:25:35 +00:00
int _version = 0;
mtpRequestId _participantsRequestId = 0;
2020-11-24 11:56:46 +00:00
mtpRequestId _reloadRequestId = 0;
2021-03-05 16:59:35 +00:00
rpl::variable<QString> _title;
2020-11-20 19:25:35 +00:00
2021-03-18 18:46:52 +00:00
base::flat_multi_map<
std::pair<int, QueuedType>,
MTPUpdate> _queuedUpdates;
base::Timer _reloadByQueuedUpdatesTimer;
std::optional<MTPphone_GroupCall> _savedFull;
2020-11-20 19:25:35 +00:00
std::vector<Participant> _participants;
base::flat_map<uint32, not_null<PeerData*>> _participantPeerByAudioSsrc;
2021-03-03 15:29:33 +00:00
base::flat_map<not_null<PeerData*>, crl::time> _speakingByActiveFinishes;
base::Timer _speakingByActiveFinishTimer;
2020-11-26 11:04:00 +00:00
QString _nextOffset;
int _serverParticipantsCount = 0;
rpl::variable<int> _fullCount = 0;
2021-03-09 13:24:32 +00:00
rpl::variable<TimeId> _recordStartDate = 0;
rpl::variable<TimeId> _scheduleDate = 0;
rpl::variable<bool> _scheduleStartSubscribed = false;
base::flat_map<uint32, LastSpokeTimes> _unknownSpokenSsrcs;
2021-03-03 15:29:33 +00:00
base::flat_map<PeerId, LastSpokeTimes> _unknownSpokenPeerIds;
rpl::event_stream<
not_null<const base::flat_map<
uint32,
LastSpokeTimes>*>> _participantsResolved;
2021-03-03 15:29:33 +00:00
mtpRequestId _unknownParticipantPeersRequestId = 0;
2020-11-29 15:18:51 +00:00
rpl::event_stream<ParticipantUpdate> _participantUpdates;
rpl::event_stream<> _participantsReloaded;
2020-11-28 16:18:51 +00:00
bool _joinMuted = false;
bool _canChangeJoinMuted = true;
bool _allParticipantsLoaded = false;
bool _joinedToTop = false;
2021-03-18 18:46:52 +00:00
bool _applyingQueuedUpdates = false;
2020-11-20 19:25:35 +00:00
};
} // namespace Data