mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-15 21:45:19 +00:00
3151 lines
138 KiB
Swift
3151 lines
138 KiB
Swift
import Postbox
|
|
import SwiftSignalKit
|
|
import TelegramApi
|
|
import MtProtoKit
|
|
|
|
public final class TelegramKeyPair: Equatable {
|
|
public let id: Int64
|
|
public let publicKey: TelegramPublicKey
|
|
|
|
public init(id: Int64, publicKey: TelegramPublicKey) {
|
|
self.id = id
|
|
self.publicKey = publicKey
|
|
}
|
|
|
|
public static func ==(lhs: TelegramKeyPair, rhs: TelegramKeyPair) -> Bool {
|
|
if lhs.id != rhs.id {
|
|
return false
|
|
}
|
|
if lhs.publicKey != rhs.publicKey {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
|
|
public final class TelegramPublicKey: Equatable {
|
|
let value: Int256
|
|
|
|
init(value: Int256) {
|
|
self.value = value
|
|
}
|
|
|
|
public static func ==(lhs: TelegramPublicKey, rhs: TelegramPublicKey) -> Bool {
|
|
return lhs.value == rhs.value
|
|
}
|
|
}
|
|
public extension TelegramPublicKey {
|
|
convenience init?(data: Data) {
|
|
guard data.count == 32 else {
|
|
return nil
|
|
}
|
|
|
|
var int256 = Int256(
|
|
_0: 0,
|
|
_1: 0,
|
|
_2: 0,
|
|
_3: 0
|
|
)
|
|
|
|
data.withUnsafeBytes { buffer in
|
|
if let baseAddress = buffer.baseAddress {
|
|
let int64Buffer = baseAddress.assumingMemoryBound(to: Int64.self)
|
|
int256._0 = int64Buffer[0]
|
|
int256._1 = int64Buffer[1]
|
|
int256._2 = int64Buffer[2]
|
|
int256._3 = int64Buffer[3]
|
|
}
|
|
}
|
|
|
|
self.init(value: int256)
|
|
|
|
assert(self.data == data)
|
|
}
|
|
|
|
var data: Data {
|
|
var data = Data(count: 32)
|
|
data.withUnsafeMutableBytes { buffer in
|
|
if let baseAddress = buffer.baseAddress {
|
|
let int64Buffer = baseAddress.assumingMemoryBound(to: Int64.self)
|
|
int64Buffer[0] = self.value._0
|
|
int64Buffer[1] = self.value._1
|
|
int64Buffer[2] = self.value._2
|
|
int64Buffer[3] = self.value._3
|
|
}
|
|
}
|
|
return data
|
|
}
|
|
}
|
|
|
|
public protocol TelegramE2EEncryptionProvider: AnyObject {
|
|
func generateKeyPair() -> TelegramKeyPair?
|
|
func generateCallZeroBlock(keyPair: TelegramKeyPair, userId: Int64) -> Data?
|
|
}
|
|
|
|
public struct GroupCallInfo: Equatable {
|
|
public var id: Int64
|
|
public var accessHash: Int64
|
|
public var participantCount: Int
|
|
public var streamDcId: Int32?
|
|
public var title: String?
|
|
public var scheduleTimestamp: Int32?
|
|
public var subscribedToScheduled: Bool
|
|
public var recordingStartTimestamp: Int32?
|
|
public var sortAscending: Bool
|
|
public var defaultParticipantsAreMuted: GroupCallParticipantsContext.State.DefaultParticipantsAreMuted?
|
|
public var isVideoEnabled: Bool
|
|
public var unmutedVideoLimit: Int
|
|
public var isStream: Bool
|
|
public var isCreator: Bool
|
|
|
|
public init(
|
|
id: Int64,
|
|
accessHash: Int64,
|
|
participantCount: Int,
|
|
streamDcId: Int32?,
|
|
title: String?,
|
|
scheduleTimestamp: Int32?,
|
|
subscribedToScheduled: Bool,
|
|
recordingStartTimestamp: Int32?,
|
|
sortAscending: Bool,
|
|
defaultParticipantsAreMuted: GroupCallParticipantsContext.State.DefaultParticipantsAreMuted?,
|
|
isVideoEnabled: Bool,
|
|
unmutedVideoLimit: Int,
|
|
isStream: Bool,
|
|
isCreator: Bool
|
|
) {
|
|
self.id = id
|
|
self.accessHash = accessHash
|
|
self.participantCount = participantCount
|
|
self.streamDcId = streamDcId
|
|
self.title = title
|
|
self.scheduleTimestamp = scheduleTimestamp
|
|
self.subscribedToScheduled = subscribedToScheduled
|
|
self.recordingStartTimestamp = recordingStartTimestamp
|
|
self.sortAscending = sortAscending
|
|
self.defaultParticipantsAreMuted = defaultParticipantsAreMuted
|
|
self.isVideoEnabled = isVideoEnabled
|
|
self.unmutedVideoLimit = unmutedVideoLimit
|
|
self.isStream = isStream
|
|
self.isCreator = isCreator
|
|
}
|
|
}
|
|
|
|
public struct GroupCallSummary: Equatable {
|
|
public var info: GroupCallInfo
|
|
public var topParticipants: [GroupCallParticipantsContext.Participant]
|
|
}
|
|
|
|
extension GroupCallInfo {
|
|
init?(_ call: Api.GroupCall) {
|
|
switch call {
|
|
case let .groupCall(flags, id, accessHash, participantsCount, title, streamDcId, recordStartDate, scheduleDate, _, unmutedVideoLimit, _):
|
|
self.init(
|
|
id: id,
|
|
accessHash: accessHash,
|
|
participantCount: Int(participantsCount),
|
|
streamDcId: streamDcId,
|
|
title: title,
|
|
scheduleTimestamp: scheduleDate,
|
|
subscribedToScheduled: (flags & (1 << 8)) != 0,
|
|
recordingStartTimestamp: recordStartDate,
|
|
sortAscending: (flags & (1 << 6)) != 0,
|
|
defaultParticipantsAreMuted: GroupCallParticipantsContext.State.DefaultParticipantsAreMuted(isMuted: (flags & (1 << 1)) != 0, canChange: (flags & (1 << 2)) != 0),
|
|
isVideoEnabled: (flags & (1 << 9)) != 0,
|
|
unmutedVideoLimit: Int(unmutedVideoLimit),
|
|
isStream: (flags & (1 << 12)) != 0,
|
|
isCreator: (flags & (1 << 15)) != 0
|
|
)
|
|
case .groupCallDiscarded:
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum GetCurrentGroupCallError {
|
|
case generic
|
|
}
|
|
|
|
public enum InternalGroupCallReference: Equatable {
|
|
case id(id: Int64, accessHash: Int64)
|
|
case link(slug: String)
|
|
case message(id: MessageId)
|
|
}
|
|
|
|
extension InternalGroupCallReference {
|
|
var apiInputGroupCall: Api.InputGroupCall {
|
|
switch self {
|
|
case let .id(id, accessHash):
|
|
return .inputGroupCall(id: id, accessHash: accessHash)
|
|
case let .link(slug):
|
|
return .inputGroupCallSlug(slug: slug)
|
|
case let .message(id):
|
|
return .inputGroupCallInviteMessage(msgId: id.id)
|
|
}
|
|
}
|
|
}
|
|
|
|
func _internal_getCurrentGroupCall(account: Account, reference: InternalGroupCallReference, peerId: PeerId? = nil) -> Signal<GroupCallSummary?, GetCurrentGroupCallError> {
|
|
let accountPeerId = account.peerId
|
|
let inputCall: Api.InputGroupCall
|
|
switch reference {
|
|
case let .id(id, accessHash):
|
|
inputCall = .inputGroupCall(id: id, accessHash: accessHash)
|
|
case let .link(slug):
|
|
inputCall = .inputGroupCallSlug(slug: slug)
|
|
case let .message(id):
|
|
if id.peerId.namespace != Namespaces.Peer.CloudUser {
|
|
return .fail(.generic)
|
|
}
|
|
if id.namespace != Namespaces.Message.Cloud {
|
|
return .fail(.generic)
|
|
}
|
|
inputCall = .inputGroupCallInviteMessage(msgId: id.id)
|
|
}
|
|
return account.network.request(Api.functions.phone.getGroupCall(call: inputCall, limit: 4))
|
|
|> mapError { _ -> GetCurrentGroupCallError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<GroupCallSummary?, GetCurrentGroupCallError> in
|
|
switch result {
|
|
case let .groupCall(call, participants, _, chats, users):
|
|
return account.postbox.transaction { transaction -> GroupCallSummary? in
|
|
guard let info = GroupCallInfo(call) else {
|
|
return nil
|
|
}
|
|
|
|
let parsedPeers = AccumulatedPeers(transaction: transaction, chats: chats, users: users)
|
|
if let peerId = peerId {
|
|
transaction.updatePeerCachedData(peerIds: [peerId], update: { _, current in
|
|
if let cachedData = current as? CachedChannelData {
|
|
return cachedData.withUpdatedActiveCall(CachedChannelData.ActiveCall.init(id: info.id, accessHash: info.accessHash, title: info.title, scheduleTimestamp: info.scheduleTimestamp, subscribedToScheduled: cachedData.activeCall?.subscribedToScheduled ?? false, isStream: info.isStream))
|
|
} else if let cachedData = current as? CachedGroupData {
|
|
return cachedData.withUpdatedActiveCall(CachedChannelData.ActiveCall(id: info.id, accessHash: info.accessHash, title: info.title, scheduleTimestamp: info.scheduleTimestamp, subscribedToScheduled: cachedData.activeCall?.subscribedToScheduled ?? false, isStream: info.isStream))
|
|
} else {
|
|
return current
|
|
}
|
|
})
|
|
}
|
|
|
|
updatePeers(transaction: transaction, accountPeerId: accountPeerId, peers: parsedPeers)
|
|
|
|
let parsedParticipants = participants.compactMap { GroupCallParticipantsContext.Participant($0, transaction: transaction) }
|
|
return GroupCallSummary(
|
|
info: info,
|
|
topParticipants: parsedParticipants
|
|
)
|
|
}
|
|
|> mapError { _ -> GetCurrentGroupCallError in
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func _internal_getCurrentGroupCallInfo(account: Account, reference: InternalGroupCallReference) -> Signal<(participants: [PeerId], duration: Int32?)?, NoError> {
|
|
let accountPeerId = account.peerId
|
|
let inputCall: Api.InputGroupCall
|
|
switch reference {
|
|
case let .id(id, accessHash):
|
|
inputCall = .inputGroupCall(id: id, accessHash: accessHash)
|
|
case let .link(slug):
|
|
inputCall = .inputGroupCallSlug(slug: slug)
|
|
case let .message(id):
|
|
if id.peerId.namespace != Namespaces.Peer.CloudUser {
|
|
return .single(nil)
|
|
}
|
|
if id.namespace != Namespaces.Message.Cloud {
|
|
return .single(nil)
|
|
}
|
|
inputCall = .inputGroupCallInviteMessage(msgId: id.id)
|
|
}
|
|
return account.network.request(Api.functions.phone.getGroupCall(call: inputCall, limit: 4))
|
|
|> map(Optional.init)
|
|
|> `catch` { _ -> Signal<Api.phone.GroupCall?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
|> mapToSignal { result -> Signal<(participants: [PeerId], duration: Int32?)?, NoError> in
|
|
guard let result else {
|
|
return .single(nil)
|
|
}
|
|
switch result {
|
|
case let .groupCall(call, participants, _, chats, users):
|
|
return account.postbox.transaction { transaction -> (participants: [PeerId], duration: Int32?)? in
|
|
if case let .groupCallDiscarded(_, _, duration) = call {
|
|
return ([], duration)
|
|
}
|
|
|
|
let parsedPeers = AccumulatedPeers(transaction: transaction, chats: chats, users: users)
|
|
|
|
updatePeers(transaction: transaction, accountPeerId: accountPeerId, peers: parsedPeers)
|
|
|
|
let parsedParticipants = participants.compactMap { GroupCallParticipantsContext.Participant($0, transaction: transaction) }
|
|
return (
|
|
parsedParticipants.map(\.peer.id),
|
|
nil
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum CreateGroupCallError {
|
|
case generic
|
|
case anonymousNotAllowed
|
|
case scheduledTooLate
|
|
}
|
|
|
|
func _internal_createGroupCall(account: Account, peerId: PeerId, title: String?, scheduleDate: Int32?, isExternalStream: Bool) -> Signal<GroupCallInfo, CreateGroupCallError> {
|
|
return account.postbox.transaction { transaction -> Api.InputPeer? in
|
|
let callPeer = transaction.getPeer(peerId).flatMap(apiInputPeer)
|
|
return callPeer
|
|
}
|
|
|> castError(CreateGroupCallError.self)
|
|
|> mapToSignal { inputPeer -> Signal<GroupCallInfo, CreateGroupCallError> in
|
|
guard let inputPeer = inputPeer else {
|
|
return .fail(.generic)
|
|
}
|
|
var flags: Int32 = 0
|
|
if let _ = title {
|
|
flags |= (1 << 0)
|
|
}
|
|
if let _ = scheduleDate {
|
|
flags |= (1 << 1)
|
|
}
|
|
if isExternalStream {
|
|
flags |= (1 << 2)
|
|
}
|
|
return account.network.request(Api.functions.phone.createGroupCall(flags: flags, peer: inputPeer, randomId: Int32.random(in: Int32.min ... Int32.max), title: title, scheduleDate: scheduleDate))
|
|
|> mapError { error -> CreateGroupCallError in
|
|
if error.errorDescription == "ANONYMOUS_CALLS_DISABLED" {
|
|
return .anonymousNotAllowed
|
|
} else if error.errorDescription == "SCHEDULE_DATE_TOO_LATE" {
|
|
return .scheduledTooLate
|
|
}
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<GroupCallInfo, CreateGroupCallError> in
|
|
var parsedCall: GroupCallInfo?
|
|
loop: for update in result.allUpdates {
|
|
switch update {
|
|
case let .updateGroupCall(_, _, call):
|
|
parsedCall = GroupCallInfo(call)
|
|
break loop
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
guard let callInfo = parsedCall else {
|
|
return .fail(.generic)
|
|
}
|
|
|
|
return account.postbox.transaction { transaction -> GroupCallInfo in
|
|
transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, cachedData -> CachedPeerData? in
|
|
if let cachedData = cachedData as? CachedChannelData {
|
|
return cachedData.withUpdatedActiveCall(CachedChannelData.ActiveCall(id: callInfo.id, accessHash: callInfo.accessHash, title: callInfo.title, scheduleTimestamp: callInfo.scheduleTimestamp, subscribedToScheduled: callInfo.subscribedToScheduled, isStream: callInfo.isStream))
|
|
} else if let cachedData = cachedData as? CachedGroupData {
|
|
return cachedData.withUpdatedActiveCall(CachedChannelData.ActiveCall(id: callInfo.id, accessHash: callInfo.accessHash, title: callInfo.title, scheduleTimestamp: callInfo.scheduleTimestamp, subscribedToScheduled: callInfo.subscribedToScheduled, isStream: callInfo.isStream))
|
|
} else {
|
|
return cachedData
|
|
}
|
|
})
|
|
|
|
account.stateManager.addUpdates(result)
|
|
|
|
return callInfo
|
|
}
|
|
|> castError(CreateGroupCallError.self)
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum StartScheduledGroupCallError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_startScheduledGroupCall(account: Account, peerId: PeerId, callId: Int64, accessHash: Int64) -> Signal<GroupCallInfo, StartScheduledGroupCallError> {
|
|
return account.network.request(Api.functions.phone.startScheduledGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash)))
|
|
|> mapError { error -> StartScheduledGroupCallError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<GroupCallInfo, StartScheduledGroupCallError> in
|
|
var parsedCall: GroupCallInfo?
|
|
loop: for update in result.allUpdates {
|
|
switch update {
|
|
case let .updateGroupCall(_, _, call):
|
|
parsedCall = GroupCallInfo(call)
|
|
break loop
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
guard let callInfo = parsedCall else {
|
|
return .fail(.generic)
|
|
}
|
|
|
|
return account.postbox.transaction { transaction -> GroupCallInfo in
|
|
transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, cachedData -> CachedPeerData? in
|
|
if let cachedData = cachedData as? CachedChannelData {
|
|
return cachedData.withUpdatedActiveCall(CachedChannelData.ActiveCall(id: callInfo.id, accessHash: callInfo.accessHash, title: callInfo.title, scheduleTimestamp: nil, subscribedToScheduled: false, isStream: callInfo.isStream))
|
|
} else if let cachedData = cachedData as? CachedGroupData {
|
|
return cachedData.withUpdatedActiveCall(CachedChannelData.ActiveCall(id: callInfo.id, accessHash: callInfo.accessHash, title: callInfo.title, scheduleTimestamp: nil, subscribedToScheduled: false, isStream: callInfo.isStream))
|
|
} else {
|
|
return cachedData
|
|
}
|
|
})
|
|
|
|
account.stateManager.addUpdates(result)
|
|
|
|
return callInfo
|
|
}
|
|
|> castError(StartScheduledGroupCallError.self)
|
|
}
|
|
}
|
|
|
|
public enum ToggleScheduledGroupCallSubscriptionError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_toggleScheduledGroupCallSubscription(account: Account, peerId: PeerId, reference: InternalGroupCallReference, subscribe: Bool) -> Signal<Void, ToggleScheduledGroupCallSubscriptionError> {
|
|
return account.postbox.transaction { transaction -> Void in
|
|
transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, cachedData -> CachedPeerData? in
|
|
if let cachedData = cachedData as? CachedChannelData, let activeCall = cachedData.activeCall {
|
|
return cachedData.withUpdatedActiveCall(CachedChannelData.ActiveCall(id: activeCall.id, accessHash: activeCall.accessHash, title: activeCall.title, scheduleTimestamp: activeCall.scheduleTimestamp, subscribedToScheduled: true, isStream: activeCall.isStream))
|
|
} else if let cachedData = cachedData as? CachedGroupData, let activeCall = cachedData.activeCall {
|
|
return cachedData.withUpdatedActiveCall(CachedChannelData.ActiveCall(id: activeCall.id, accessHash: activeCall.accessHash, title: activeCall.title, scheduleTimestamp: activeCall.scheduleTimestamp, subscribedToScheduled: true, isStream: activeCall.isStream))
|
|
} else {
|
|
return cachedData
|
|
}
|
|
})
|
|
}
|
|
|> castError(ToggleScheduledGroupCallSubscriptionError.self)
|
|
|> mapToSignal { _ -> Signal<Void, ToggleScheduledGroupCallSubscriptionError> in
|
|
return account.network.request(Api.functions.phone.toggleGroupCallStartSubscription(call: reference.apiInputGroupCall, subscribed: subscribe ? .boolTrue : .boolFalse))
|
|
|> mapError { error -> ToggleScheduledGroupCallSubscriptionError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<Void, ToggleScheduledGroupCallSubscriptionError> in
|
|
var parsedCall: GroupCallInfo?
|
|
loop: for update in result.allUpdates {
|
|
switch update {
|
|
case let .updateGroupCall(_, _, call):
|
|
parsedCall = GroupCallInfo(call)
|
|
break loop
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
guard let callInfo = parsedCall else {
|
|
return .fail(.generic)
|
|
}
|
|
|
|
return account.postbox.transaction { transaction in
|
|
transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, cachedData -> CachedPeerData? in
|
|
if let cachedData = cachedData as? CachedChannelData {
|
|
return cachedData.withUpdatedActiveCall(CachedChannelData.ActiveCall(id: callInfo.id, accessHash: callInfo.accessHash, title: callInfo.title, scheduleTimestamp: callInfo.scheduleTimestamp, subscribedToScheduled: callInfo.subscribedToScheduled, isStream: callInfo.isStream))
|
|
} else if let cachedData = cachedData as? CachedGroupData {
|
|
return cachedData.withUpdatedActiveCall(CachedChannelData.ActiveCall(id: callInfo.id, accessHash: callInfo.accessHash, title: callInfo.title, scheduleTimestamp: callInfo.scheduleTimestamp, subscribedToScheduled: callInfo.subscribedToScheduled, isStream: callInfo.isStream))
|
|
} else {
|
|
return cachedData
|
|
}
|
|
})
|
|
|
|
account.stateManager.addUpdates(result)
|
|
}
|
|
|> castError(ToggleScheduledGroupCallSubscriptionError.self)
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum UpdateGroupCallJoinAsPeerError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_updateGroupCallJoinAsPeer(account: Account, peerId: PeerId, joinAs: PeerId) -> Signal<Never, UpdateGroupCallJoinAsPeerError> {
|
|
return account.postbox.transaction { transaction -> (Api.InputPeer, Api.InputPeer)? in
|
|
if let peer = transaction.getPeer(peerId), let joinAsPeer = transaction.getPeer(joinAs), let inputPeer = apiInputPeer(peer), let joinInputPeer = apiInputPeer(joinAsPeer) {
|
|
return (inputPeer, joinInputPeer)
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|> castError(UpdateGroupCallJoinAsPeerError.self)
|
|
|> mapToSignal { result in
|
|
guard let (inputPeer, joinInputPeer) = result else {
|
|
return .fail(.generic)
|
|
}
|
|
return account.network.request(Api.functions.phone.saveDefaultGroupCallJoinAs(peer: inputPeer, joinAs: joinInputPeer))
|
|
|> mapError { _ -> UpdateGroupCallJoinAsPeerError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<Never, UpdateGroupCallJoinAsPeerError> in
|
|
return account.postbox.transaction { transaction in
|
|
transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, cachedData -> CachedPeerData? in
|
|
if let cachedData = cachedData as? CachedChannelData {
|
|
return cachedData.withUpdatedCallJoinPeerId(joinAs)
|
|
} else if let cachedData = cachedData as? CachedGroupData {
|
|
return cachedData.withUpdatedCallJoinPeerId(joinAs)
|
|
} else {
|
|
return cachedData
|
|
}
|
|
})
|
|
}
|
|
|> castError(UpdateGroupCallJoinAsPeerError.self)
|
|
|> ignoreValues
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum GetGroupCallParticipantsError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_getGroupCallParticipants(account: Account, reference: InternalGroupCallReference, offset: String, ssrcs: [UInt32], limit: Int32, sortAscending: Bool?) -> Signal<GroupCallParticipantsContext.State, GetGroupCallParticipantsError> {
|
|
let accountPeerId = account.peerId
|
|
|
|
let sortAscendingValue: Signal<(Bool, Int32?, Bool, GroupCallParticipantsContext.State.DefaultParticipantsAreMuted?, Bool, Int, Bool, Bool), GetGroupCallParticipantsError>
|
|
|
|
sortAscendingValue = _internal_getCurrentGroupCall(account: account, reference: reference)
|
|
|> mapError { _ -> GetGroupCallParticipantsError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<(Bool, Int32?, Bool, GroupCallParticipantsContext.State.DefaultParticipantsAreMuted?, Bool, Int, Bool, Bool), GetGroupCallParticipantsError> in
|
|
guard let result = result else {
|
|
return .fail(.generic)
|
|
}
|
|
return .single((sortAscending ?? result.info.sortAscending, result.info.scheduleTimestamp, result.info.subscribedToScheduled, result.info.defaultParticipantsAreMuted, result.info.isVideoEnabled, result.info.unmutedVideoLimit, result.info.isStream, result.info.isCreator))
|
|
}
|
|
|
|
return combineLatest(
|
|
account.network.request(Api.functions.phone.getGroupParticipants(call: reference.apiInputGroupCall, ids: [], sources: ssrcs.map { Int32(bitPattern: $0) }, offset: offset, limit: limit))
|
|
|> mapError { _ -> GetGroupCallParticipantsError in
|
|
return .generic
|
|
},
|
|
sortAscendingValue
|
|
)
|
|
|> mapToSignal { result, sortAscendingAndScheduleTimestamp -> Signal<GroupCallParticipantsContext.State, GetGroupCallParticipantsError> in
|
|
return account.postbox.transaction { transaction -> GroupCallParticipantsContext.State in
|
|
var parsedParticipants: [GroupCallParticipantsContext.Participant] = []
|
|
let totalCount: Int
|
|
let version: Int32
|
|
let nextParticipantsFetchOffset: String?
|
|
|
|
let (sortAscendingValue, scheduleTimestamp, subscribedToScheduled, defaultParticipantsAreMuted, isVideoEnabled, unmutedVideoLimit, isStream, isCreator) = sortAscendingAndScheduleTimestamp
|
|
|
|
switch result {
|
|
case let .groupParticipants(count, participants, nextOffset, chats, users, apiVersion):
|
|
totalCount = Int(count)
|
|
version = apiVersion
|
|
|
|
if participants.count != 0 && !nextOffset.isEmpty {
|
|
nextParticipantsFetchOffset = nextOffset
|
|
} else {
|
|
nextParticipantsFetchOffset = nil
|
|
}
|
|
|
|
let parsedPeers = AccumulatedPeers(transaction: transaction, chats: chats, users: users)
|
|
updatePeers(transaction: transaction, accountPeerId: accountPeerId, peers: parsedPeers)
|
|
|
|
parsedParticipants = participants.compactMap { GroupCallParticipantsContext.Participant($0, transaction: transaction) }
|
|
}
|
|
|
|
parsedParticipants.sort(by: { GroupCallParticipantsContext.Participant.compare(lhs: $0, rhs: $1, sortAscending: sortAscendingValue) })
|
|
|
|
return GroupCallParticipantsContext.State(
|
|
participants: parsedParticipants,
|
|
nextParticipantsFetchOffset: nextParticipantsFetchOffset,
|
|
adminIds: Set(),
|
|
isCreator: isCreator,
|
|
defaultParticipantsAreMuted: defaultParticipantsAreMuted ?? GroupCallParticipantsContext.State.DefaultParticipantsAreMuted(isMuted: false, canChange: false),
|
|
sortAscending: sortAscendingValue,
|
|
recordingStartTimestamp: nil,
|
|
title: nil,
|
|
scheduleTimestamp: scheduleTimestamp,
|
|
subscribedToScheduled: subscribedToScheduled,
|
|
totalCount: totalCount,
|
|
isVideoEnabled: isVideoEnabled,
|
|
unmutedVideoLimit: unmutedVideoLimit,
|
|
isStream: isStream,
|
|
version: version
|
|
)
|
|
}
|
|
|> castError(GetGroupCallParticipantsError.self)
|
|
}
|
|
}
|
|
|
|
public enum JoinGroupCallError {
|
|
case generic
|
|
case anonymousNotAllowed
|
|
case tooManyParticipants
|
|
case invalidJoinAsPeer
|
|
}
|
|
|
|
public struct JoinGroupCallResult {
|
|
public enum ConnectionMode {
|
|
case rtc
|
|
case broadcast(isExternalStream: Bool)
|
|
}
|
|
|
|
public var callInfo: GroupCallInfo
|
|
public var state: GroupCallParticipantsContext.State
|
|
public var connectionMode: ConnectionMode
|
|
public var jsonParams: String
|
|
}
|
|
|
|
public class JoinGroupCallE2E {
|
|
public let publicKey: TelegramPublicKey
|
|
public let block: Data
|
|
|
|
public init(publicKey: TelegramPublicKey, block: Data) {
|
|
self.publicKey = publicKey
|
|
self.block = block
|
|
}
|
|
}
|
|
|
|
func _internal_joinGroupCall(account: Account, peerId: PeerId?, joinAs: PeerId?, callId: Int64, reference: InternalGroupCallReference, preferMuted: Bool, joinPayload: String, peerAdminIds: Signal<[PeerId], NoError>, inviteHash: String? = nil, generateE2E: ((Data?) -> JoinGroupCallE2E?)?) -> Signal<JoinGroupCallResult, JoinGroupCallError> {
|
|
enum InternalJoinError {
|
|
case error(JoinGroupCallError)
|
|
case restart
|
|
}
|
|
|
|
var e2eData: Signal<JoinGroupCallE2E?, NoError> = .single(nil)
|
|
if let generateE2E {
|
|
e2eData = _internal_pollConferenceCallBlockchain(network: account.network, reference: reference, subChainId: 0, offset: -1, limit: 1)
|
|
|> map { result -> JoinGroupCallE2E? in
|
|
guard let result else {
|
|
return nil
|
|
}
|
|
guard let block = result.blocks.last else {
|
|
return generateE2E(nil)
|
|
}
|
|
return generateE2E(block)
|
|
}
|
|
}
|
|
|
|
let signal: Signal<JoinGroupCallResult, InternalJoinError> = e2eData
|
|
|> castError(InternalJoinError.self)
|
|
|> mapToSignal { e2eData -> Signal<JoinGroupCallResult, InternalJoinError> in
|
|
return account.postbox.transaction { transaction -> Api.InputPeer? in
|
|
if let joinAs = joinAs {
|
|
return transaction.getPeer(joinAs).flatMap(apiInputPeer)
|
|
} else {
|
|
return .inputPeerSelf
|
|
}
|
|
}
|
|
|> castError(InternalJoinError.self)
|
|
|> mapToSignal { inputJoinAs -> Signal<JoinGroupCallResult, InternalJoinError> in
|
|
guard let inputJoinAs = inputJoinAs else {
|
|
return .fail(.error(.generic))
|
|
}
|
|
|
|
var flags: Int32 = 0
|
|
if preferMuted {
|
|
flags |= (1 << 0)
|
|
}
|
|
flags |= (1 << 2)
|
|
if let _ = inviteHash {
|
|
flags |= (1 << 1)
|
|
}
|
|
if e2eData != nil {
|
|
flags |= (1 << 3)
|
|
}
|
|
|
|
let joinRequest = account.network.request(Api.functions.phone.joinGroupCall(flags: flags, call: reference.apiInputGroupCall, joinAs: inputJoinAs, inviteHash: inviteHash, publicKey: e2eData?.publicKey.value, block: (e2eData?.block).flatMap({ Buffer.init(data: $0) }), inviteMsgId: nil, params: .dataJSON(data: joinPayload)))
|
|
|> `catch` { error -> Signal<Api.Updates, InternalJoinError> in
|
|
if error.errorDescription == "GROUPCALL_ANONYMOUS_FORBIDDEN" {
|
|
return .fail(.error(.anonymousNotAllowed))
|
|
} else if error.errorDescription == "GROUPCALL_PARTICIPANTS_TOO_MUCH" {
|
|
return .fail(.error(.tooManyParticipants))
|
|
} else if error.errorDescription == "JOIN_AS_PEER_INVALID" {
|
|
if let peerId {
|
|
let _ = (account.postbox.transaction { transaction -> Void in
|
|
transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, current in
|
|
if let current = current as? CachedChannelData {
|
|
return current.withUpdatedCallJoinPeerId(nil)
|
|
} else if let current = current as? CachedGroupData {
|
|
return current.withUpdatedCallJoinPeerId(nil)
|
|
} else {
|
|
return current
|
|
}
|
|
})
|
|
}).start()
|
|
}
|
|
|
|
return .fail(.error(.invalidJoinAsPeer))
|
|
} else if error.errorDescription == "GROUPCALL_INVALID" {
|
|
return account.postbox.transaction { transaction -> Signal<Api.Updates, InternalJoinError> in
|
|
if let peerId {
|
|
transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, current in
|
|
if let current = current as? CachedGroupData {
|
|
if current.activeCall?.id == callId {
|
|
return current.withUpdatedActiveCall(nil)
|
|
}
|
|
} else if let current = current as? CachedChannelData {
|
|
if current.activeCall?.id == callId {
|
|
return current.withUpdatedActiveCall(nil)
|
|
}
|
|
}
|
|
return current
|
|
})
|
|
}
|
|
|
|
return .fail(.error(.generic))
|
|
}
|
|
|> castError(InternalJoinError.self)
|
|
|> switchToLatest
|
|
} else if error.errorDescription.hasPrefix("CONF_WRITE_CHAIN_INVALID") {
|
|
return .fail(.restart)
|
|
} else {
|
|
return .fail(.error(.generic))
|
|
}
|
|
}
|
|
|
|
let getParticipantsRequest = _internal_getGroupCallParticipants(account: account, reference: reference, offset: "", ssrcs: [], limit: 100, sortAscending: true)
|
|
|> mapError { _ -> InternalJoinError in
|
|
return .error(.generic)
|
|
}
|
|
|
|
return combineLatest(
|
|
joinRequest,
|
|
getParticipantsRequest
|
|
)
|
|
|> mapToSignal { updates, participantsState -> Signal<JoinGroupCallResult, InternalJoinError> in
|
|
let peer = account.postbox.transaction { transaction -> Peer? in
|
|
return peerId.flatMap(transaction.getPeer)
|
|
}
|
|
|> castError(InternalJoinError.self)
|
|
|
|
return combineLatest(
|
|
peerAdminIds |> castError(InternalJoinError.self) |> take(1),
|
|
peer
|
|
)
|
|
|> mapToSignal { peerAdminIds, peer -> Signal<JoinGroupCallResult, InternalJoinError> in
|
|
var state = participantsState
|
|
if let peer {
|
|
if let channel = peer as? TelegramChannel {
|
|
state.isCreator = channel.flags.contains(.isCreator)
|
|
} else if let group = peer as? TelegramGroup {
|
|
if case .creator = group.role {
|
|
state.isCreator = true
|
|
} else {
|
|
state.isCreator = false
|
|
}
|
|
}
|
|
}
|
|
|
|
account.stateManager.addUpdates(updates)
|
|
|
|
var maybeParsedCall: GroupCallInfo?
|
|
var maybeParsedClientParams: String?
|
|
loop: for update in updates.allUpdates {
|
|
switch update {
|
|
case let .updateGroupCall(_, _, call):
|
|
maybeParsedCall = GroupCallInfo(call)
|
|
|
|
switch call {
|
|
case let .groupCall(flags, _, _, _, title, _, recordStartDate, scheduleDate, _, unmutedVideoLimit, _):
|
|
let isMuted = (flags & (1 << 1)) != 0
|
|
let canChange = (flags & (1 << 2)) != 0
|
|
let isVideoEnabled = (flags & (1 << 9)) != 0
|
|
state.defaultParticipantsAreMuted = GroupCallParticipantsContext.State.DefaultParticipantsAreMuted(isMuted: isMuted, canChange: canChange)
|
|
state.title = title
|
|
state.recordingStartTimestamp = recordStartDate
|
|
state.scheduleTimestamp = scheduleDate
|
|
state.isVideoEnabled = isVideoEnabled
|
|
state.unmutedVideoLimit = Int(unmutedVideoLimit)
|
|
default:
|
|
break
|
|
}
|
|
case let .updateGroupCallConnection(_, params):
|
|
switch params {
|
|
case let .dataJSON(data):
|
|
maybeParsedClientParams = data
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
guard let parsedCall = maybeParsedCall, let parsedClientParams = maybeParsedClientParams else {
|
|
return .fail(.error(.generic))
|
|
}
|
|
|
|
state.sortAscending = parsedCall.sortAscending
|
|
|
|
state.adminIds = Set(peerAdminIds)
|
|
|
|
let connectionMode: JoinGroupCallResult.ConnectionMode
|
|
if let clientParamsData = parsedClientParams.data(using: .utf8), let dict = (try? JSONSerialization.jsonObject(with: clientParamsData, options: [])) as? [String: Any] {
|
|
if let stream = dict["stream"] as? Bool, stream {
|
|
var isExternalStream = false
|
|
if let rtmp = dict["rtmp"] as? Bool, rtmp {
|
|
isExternalStream = true
|
|
}
|
|
connectionMode = .broadcast(isExternalStream: isExternalStream)
|
|
} else {
|
|
connectionMode = .rtc
|
|
}
|
|
} else {
|
|
connectionMode = .broadcast(isExternalStream: false)
|
|
}
|
|
|
|
return account.postbox.transaction { transaction -> JoinGroupCallResult in
|
|
if let peerId {
|
|
transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, cachedData -> CachedPeerData? in
|
|
if let cachedData = cachedData as? CachedChannelData {
|
|
return cachedData.withUpdatedCallJoinPeerId(joinAs).withUpdatedActiveCall(CachedChannelData.ActiveCall(id: parsedCall.id, accessHash: parsedCall.accessHash, title: parsedCall.title, scheduleTimestamp: nil, subscribedToScheduled: false, isStream: parsedCall.isStream))
|
|
} else if let cachedData = cachedData as? CachedGroupData {
|
|
return cachedData.withUpdatedCallJoinPeerId(joinAs).withUpdatedActiveCall(CachedChannelData.ActiveCall(id: parsedCall.id, accessHash: parsedCall.accessHash, title: parsedCall.title, scheduleTimestamp: nil, subscribedToScheduled: false, isStream: parsedCall.isStream))
|
|
} else {
|
|
return cachedData
|
|
}
|
|
})
|
|
}
|
|
|
|
var state = state
|
|
|
|
for update in updates.allUpdates {
|
|
switch update {
|
|
case let .updateGroupCallParticipants(_, participants, _):
|
|
loop: for participant in participants {
|
|
switch participant {
|
|
case let .groupCallParticipant(flags, apiPeerId, date, activeDate, source, volume, about, raiseHandRating, video, presentation):
|
|
let peerId: PeerId = apiPeerId.peerId
|
|
let ssrc = UInt32(bitPattern: source)
|
|
guard let peer = transaction.getPeer(peerId) else {
|
|
continue loop
|
|
}
|
|
let muted = (flags & (1 << 0)) != 0
|
|
let mutedByYou = (flags & (1 << 9)) != 0
|
|
var muteState: GroupCallParticipantsContext.Participant.MuteState?
|
|
if muted {
|
|
let canUnmute = (flags & (1 << 2)) != 0
|
|
muteState = GroupCallParticipantsContext.Participant.MuteState(canUnmute: canUnmute, mutedByYou: mutedByYou)
|
|
} else if mutedByYou {
|
|
muteState = GroupCallParticipantsContext.Participant.MuteState(canUnmute: false, mutedByYou: mutedByYou)
|
|
}
|
|
var videoDescription = video.flatMap(GroupCallParticipantsContext.Participant.VideoDescription.init)
|
|
var presentationDescription = presentation.flatMap(GroupCallParticipantsContext.Participant.VideoDescription.init)
|
|
if muteState?.canUnmute == false {
|
|
videoDescription = nil
|
|
presentationDescription = nil
|
|
}
|
|
let joinedVideo = (flags & (1 << 15)) != 0
|
|
if !state.participants.contains(where: { $0.peer.id == peer.id }) {
|
|
state.participants.append(GroupCallParticipantsContext.Participant(
|
|
peer: peer,
|
|
ssrc: ssrc,
|
|
videoDescription: videoDescription,
|
|
presentationDescription: presentationDescription,
|
|
joinTimestamp: date,
|
|
raiseHandRating: raiseHandRating,
|
|
hasRaiseHand: raiseHandRating != nil,
|
|
activityTimestamp: activeDate.flatMap(Double.init),
|
|
activityRank: nil,
|
|
muteState: muteState,
|
|
volume: volume,
|
|
about: about,
|
|
joinedVideo: joinedVideo
|
|
))
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
state.participants.sort(by: { GroupCallParticipantsContext.Participant.compare(lhs: $0, rhs: $1, sortAscending: state.sortAscending) })
|
|
|
|
return JoinGroupCallResult(
|
|
callInfo: parsedCall,
|
|
state: state,
|
|
connectionMode: connectionMode,
|
|
jsonParams: parsedClientParams
|
|
)
|
|
}
|
|
|> castError(InternalJoinError.self)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return signal |> restartOrMapError { error in
|
|
switch error {
|
|
case .restart:
|
|
return .restart
|
|
case let .error(e):
|
|
return .error(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
func _internal_inviteConferenceCallParticipant(account: Account, reference: InternalGroupCallReference, peerId: EnginePeer.Id, isVideo: Bool) -> Signal<MessageId?, NoError> {
|
|
return account.postbox.transaction { transaction -> Api.InputUser? in
|
|
return transaction.getPeer(peerId).flatMap(apiInputUser)
|
|
}
|
|
|> mapToSignal { inputPeer -> Signal<MessageId?, NoError> in
|
|
guard let inputPeer else {
|
|
return .complete()
|
|
}
|
|
|
|
var flags: Int32 = 0
|
|
if isVideo {
|
|
flags |= 1 << 0
|
|
}
|
|
return account.network.request(Api.functions.phone.inviteConferenceCallParticipant(flags: flags, call: reference.apiInputGroupCall, userId: inputPeer))
|
|
|> map(Optional.init)
|
|
|> `catch` { _ -> Signal<Api.Updates?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
|> mapToSignal { result -> Signal<MessageId?, NoError> in
|
|
if let result {
|
|
account.stateManager.addUpdates(result)
|
|
if let message = result.messageIds.first {
|
|
return .single(message)
|
|
}
|
|
}
|
|
return .single(nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum RemoveGroupCallBlockchainParticipantsMode {
|
|
case kick
|
|
case cleanup
|
|
}
|
|
|
|
public enum RemoveGroupCallBlockchainParticipantsResult {
|
|
case success
|
|
case pollBlocksAndRetry
|
|
}
|
|
|
|
func _internal_removeGroupCallBlockchainParticipants(account: Account, callId: Int64, accessHash: Int64, mode: RemoveGroupCallBlockchainParticipantsMode, participantIds: [Int64], block: Data) -> Signal<RemoveGroupCallBlockchainParticipantsResult, NoError> {
|
|
var flags: Int32 = 0
|
|
switch mode {
|
|
case .kick:
|
|
flags |= 1 << 1
|
|
case .cleanup:
|
|
flags |= 1 << 0
|
|
}
|
|
return account.network.request(Api.functions.phone.deleteConferenceCallParticipants(flags: flags, call: .inputGroupCall(id: callId, accessHash: accessHash), ids: participantIds, block: Buffer(data: block)))
|
|
|> map { updates -> RemoveGroupCallBlockchainParticipantsResult in
|
|
account.stateManager.addUpdates(updates)
|
|
return .success
|
|
}
|
|
|> `catch` { _ -> Signal<RemoveGroupCallBlockchainParticipantsResult, NoError> in
|
|
return .single(.pollBlocksAndRetry)
|
|
}
|
|
}
|
|
|
|
public struct JoinGroupCallAsScreencastResult {
|
|
public var jsonParams: String
|
|
public var endpointId: String
|
|
}
|
|
|
|
func _internal_joinGroupCallAsScreencast(account: Account, callId: Int64, accessHash: Int64, joinPayload: String) -> Signal<JoinGroupCallAsScreencastResult, JoinGroupCallError> {
|
|
return account.network.request(Api.functions.phone.joinGroupCallPresentation(call: .inputGroupCall(id: callId, accessHash: accessHash), params: .dataJSON(data: joinPayload)))
|
|
|> mapError { _ -> JoinGroupCallError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { updates -> Signal<JoinGroupCallAsScreencastResult, JoinGroupCallError> in
|
|
account.stateManager.addUpdates(updates)
|
|
|
|
var maybeParsedClientParams: String?
|
|
loop: for update in updates.allUpdates {
|
|
switch update {
|
|
case let .updateGroupCallConnection(_, params):
|
|
switch params {
|
|
case let .dataJSON(data):
|
|
maybeParsedClientParams = data
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
guard let parsedClientParams = maybeParsedClientParams else {
|
|
return .fail(.generic)
|
|
}
|
|
|
|
var maybeEndpointId: String?
|
|
|
|
if let jsonData = parsedClientParams.data(using: .utf8), let json = try? JSONSerialization.jsonObject(with: jsonData, options: []) as? [String: Any] {
|
|
if let videoSection = json["video"] as? [String: Any] {
|
|
maybeEndpointId = videoSection["endpoint"] as? String
|
|
}
|
|
}
|
|
|
|
guard let endpointId = maybeEndpointId else {
|
|
return .fail(.generic)
|
|
}
|
|
|
|
return .single(JoinGroupCallAsScreencastResult(
|
|
jsonParams: parsedClientParams,
|
|
endpointId: endpointId
|
|
))
|
|
}
|
|
}
|
|
|
|
public enum LeaveGroupCallAsScreencastError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_leaveGroupCallAsScreencast(account: Account, callId: Int64, accessHash: Int64) -> Signal<Never, LeaveGroupCallAsScreencastError> {
|
|
return account.network.request(Api.functions.phone.leaveGroupCallPresentation(call: .inputGroupCall(id: callId, accessHash: accessHash)))
|
|
|> mapError { _ -> LeaveGroupCallAsScreencastError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { updates -> Signal<Never, LeaveGroupCallAsScreencastError> in
|
|
account.stateManager.addUpdates(updates)
|
|
|
|
return .complete()
|
|
}
|
|
}
|
|
|
|
public enum LeaveGroupCallError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_leaveGroupCall(account: Account, callId: Int64, accessHash: Int64, source: UInt32) -> Signal<Never, LeaveGroupCallError> {
|
|
return account.network.request(Api.functions.phone.leaveGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash), source: Int32(bitPattern: source)))
|
|
|> mapError { _ -> LeaveGroupCallError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<Never, LeaveGroupCallError> in
|
|
account.stateManager.addUpdates(result)
|
|
|
|
return .complete()
|
|
}
|
|
}
|
|
|
|
public enum StopGroupCallError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_stopGroupCall(account: Account, peerId: PeerId?, callId: Int64, accessHash: Int64) -> Signal<Never, StopGroupCallError> {
|
|
return account.network.request(Api.functions.phone.discardGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash)))
|
|
|> mapError { _ -> StopGroupCallError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<Never, StopGroupCallError> in
|
|
return account.postbox.transaction { transaction -> Void in
|
|
if let peerId {
|
|
transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, cachedData -> CachedPeerData? in
|
|
if let cachedData = cachedData as? CachedChannelData {
|
|
return cachedData.withUpdatedActiveCall(nil).withUpdatedCallJoinPeerId(nil)
|
|
} else if let cachedData = cachedData as? CachedGroupData {
|
|
return cachedData.withUpdatedActiveCall(nil).withUpdatedCallJoinPeerId(nil)
|
|
} else {
|
|
return cachedData
|
|
}
|
|
})
|
|
if var peer = transaction.getPeer(peerId) as? TelegramChannel {
|
|
var flags = peer.flags
|
|
flags.remove(.hasVoiceChat)
|
|
flags.remove(.hasActiveVoiceChat)
|
|
peer = peer.withUpdatedFlags(flags)
|
|
updatePeersCustom(transaction: transaction, peers: [peer], update: { _, updated in
|
|
return updated
|
|
})
|
|
}
|
|
if var peer = transaction.getPeer(peerId) as? TelegramGroup {
|
|
var flags = peer.flags
|
|
flags.remove(.hasVoiceChat)
|
|
flags.remove(.hasActiveVoiceChat)
|
|
peer = peer.updateFlags(flags: flags, version: peer.version)
|
|
updatePeersCustom(transaction: transaction, peers: [peer], update: { _, updated in
|
|
return updated
|
|
})
|
|
}
|
|
}
|
|
|
|
account.stateManager.addUpdates(result)
|
|
}
|
|
|> castError(StopGroupCallError.self)
|
|
|> ignoreValues
|
|
}
|
|
}
|
|
|
|
func _internal_checkGroupCall(account: Account, callId: Int64, accessHash: Int64, ssrcs: [UInt32]) -> Signal<[UInt32], NoError> {
|
|
return account.network.request(Api.functions.phone.checkGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash), sources: ssrcs.map(Int32.init(bitPattern:))))
|
|
|> `catch` { _ -> Signal<[Int32], NoError> in
|
|
return .single([])
|
|
}
|
|
|> map { result -> [UInt32] in
|
|
return result.map(UInt32.init(bitPattern:))
|
|
}
|
|
}
|
|
|
|
private func binaryInsertionIndex(_ inputArr: [GroupCallParticipantsContext.Participant], searchItem: Int32) -> Int {
|
|
var lo = 0
|
|
var hi = inputArr.count - 1
|
|
while lo <= hi {
|
|
let mid = (lo + hi) / 2
|
|
if inputArr[mid].joinTimestamp < searchItem {
|
|
lo = mid + 1
|
|
} else if searchItem < inputArr[mid].joinTimestamp {
|
|
hi = mid - 1
|
|
} else {
|
|
return mid
|
|
}
|
|
}
|
|
return lo
|
|
}
|
|
|
|
public final class GroupCallParticipantsContext {
|
|
public struct Participant: Equatable, CustomStringConvertible {
|
|
public struct MuteState: Equatable {
|
|
public var canUnmute: Bool
|
|
public var mutedByYou: Bool
|
|
|
|
public init(canUnmute: Bool, mutedByYou: Bool) {
|
|
self.canUnmute = canUnmute
|
|
self.mutedByYou = mutedByYou
|
|
}
|
|
}
|
|
|
|
public struct VideoDescription: Equatable {
|
|
public struct SsrcGroup: Equatable {
|
|
public var semantics: String
|
|
public var ssrcs: [UInt32]
|
|
}
|
|
|
|
public var endpointId: String
|
|
public var ssrcGroups: [SsrcGroup]
|
|
public var audioSsrc: UInt32?
|
|
public var isPaused: Bool
|
|
|
|
public init(endpointId: String, ssrcGroups: [SsrcGroup], audioSsrc: UInt32?, isPaused: Bool) {
|
|
self.endpointId = endpointId
|
|
self.ssrcGroups = ssrcGroups
|
|
self.audioSsrc = audioSsrc
|
|
self.isPaused = isPaused
|
|
}
|
|
}
|
|
|
|
public var peer: Peer
|
|
public var ssrc: UInt32?
|
|
public var videoDescription: VideoDescription?
|
|
public var presentationDescription: VideoDescription?
|
|
public var joinTimestamp: Int32
|
|
public var raiseHandRating: Int64?
|
|
public var hasRaiseHand: Bool
|
|
public var activityTimestamp: Double?
|
|
public var activityRank: Int?
|
|
public var muteState: MuteState?
|
|
public var volume: Int32?
|
|
public var about: String?
|
|
public var joinedVideo: Bool
|
|
|
|
public init(
|
|
peer: Peer,
|
|
ssrc: UInt32?,
|
|
videoDescription: VideoDescription?,
|
|
presentationDescription: VideoDescription?,
|
|
joinTimestamp: Int32,
|
|
raiseHandRating: Int64?,
|
|
hasRaiseHand: Bool,
|
|
activityTimestamp: Double?,
|
|
activityRank: Int?,
|
|
muteState: MuteState?,
|
|
volume: Int32?,
|
|
about: String?,
|
|
joinedVideo: Bool
|
|
) {
|
|
self.peer = peer
|
|
self.ssrc = ssrc
|
|
self.videoDescription = videoDescription
|
|
self.presentationDescription = presentationDescription
|
|
self.joinTimestamp = joinTimestamp
|
|
self.raiseHandRating = raiseHandRating
|
|
self.hasRaiseHand = hasRaiseHand
|
|
self.activityTimestamp = activityTimestamp
|
|
self.activityRank = activityRank
|
|
self.muteState = muteState
|
|
self.volume = volume
|
|
self.about = about
|
|
self.joinedVideo = joinedVideo
|
|
}
|
|
|
|
public var description: String {
|
|
return "Participant(peer: \(peer.id): \(peer.debugDisplayTitle), ssrc: \(String(describing: self.ssrc))"
|
|
}
|
|
|
|
public mutating func mergeActivity(from other: Participant, mergeActivityTimestamp: Bool) {
|
|
self.activityRank = other.activityRank
|
|
if mergeActivityTimestamp {
|
|
self.activityTimestamp = other.activityTimestamp
|
|
}
|
|
}
|
|
|
|
public static func ==(lhs: Participant, rhs: Participant) -> Bool {
|
|
if !lhs.peer.isEqual(rhs.peer) {
|
|
return false
|
|
}
|
|
if lhs.ssrc != rhs.ssrc {
|
|
return false
|
|
}
|
|
if lhs.videoDescription != rhs.videoDescription {
|
|
return false
|
|
}
|
|
if lhs.presentationDescription != rhs.presentationDescription {
|
|
return false
|
|
}
|
|
if lhs.joinTimestamp != rhs.joinTimestamp {
|
|
return false
|
|
}
|
|
if lhs.raiseHandRating != rhs.raiseHandRating {
|
|
return false
|
|
}
|
|
if lhs.hasRaiseHand != rhs.hasRaiseHand {
|
|
return false
|
|
}
|
|
if lhs.activityTimestamp != rhs.activityTimestamp {
|
|
return false
|
|
}
|
|
if lhs.activityRank != rhs.activityRank {
|
|
return false
|
|
}
|
|
if lhs.muteState != rhs.muteState {
|
|
return false
|
|
}
|
|
if lhs.volume != rhs.volume {
|
|
return false
|
|
}
|
|
if lhs.about != rhs.about {
|
|
return false
|
|
}
|
|
if lhs.raiseHandRating != rhs.raiseHandRating {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public static func compare(lhs: Participant, rhs: Participant, sortAscending: Bool) -> Bool {
|
|
let lhsCanUnmute = lhs.muteState?.canUnmute ?? true
|
|
let rhsCanUnmute = rhs.muteState?.canUnmute ?? true
|
|
if lhsCanUnmute != rhsCanUnmute {
|
|
return lhsCanUnmute
|
|
}
|
|
|
|
if let lhsActivityRank = lhs.activityRank, let rhsActivityRank = rhs.activityRank {
|
|
if lhsActivityRank != rhsActivityRank {
|
|
return lhsActivityRank < rhsActivityRank
|
|
}
|
|
} else if lhs.activityRank != nil {
|
|
return true
|
|
} else if rhs.activityRank != nil {
|
|
return false
|
|
}
|
|
|
|
if let lhsActivityTimestamp = lhs.activityTimestamp, let rhsActivityTimestamp = rhs.activityTimestamp {
|
|
if lhsActivityTimestamp != rhsActivityTimestamp {
|
|
return lhsActivityTimestamp > rhsActivityTimestamp
|
|
}
|
|
} else if lhs.activityTimestamp != nil {
|
|
return true
|
|
} else if rhs.activityTimestamp != nil {
|
|
return false
|
|
}
|
|
|
|
if let lhsRaiseHandRating = lhs.raiseHandRating, let rhsRaiseHandRating = rhs.raiseHandRating {
|
|
if lhsRaiseHandRating != rhsRaiseHandRating {
|
|
return lhsRaiseHandRating > rhsRaiseHandRating
|
|
}
|
|
} else if lhs.raiseHandRating != nil {
|
|
return true
|
|
} else if rhs.raiseHandRating != nil {
|
|
return false
|
|
}
|
|
|
|
if lhs.joinTimestamp != rhs.joinTimestamp {
|
|
if sortAscending {
|
|
return lhs.joinTimestamp < rhs.joinTimestamp
|
|
} else {
|
|
return lhs.joinTimestamp > rhs.joinTimestamp
|
|
}
|
|
}
|
|
|
|
return lhs.peer.id < rhs.peer.id
|
|
}
|
|
}
|
|
|
|
public struct State: Equatable {
|
|
public struct DefaultParticipantsAreMuted: Equatable {
|
|
public var isMuted: Bool
|
|
public var canChange: Bool
|
|
|
|
public init(isMuted: Bool, canChange: Bool) {
|
|
self.isMuted = isMuted
|
|
self.canChange = canChange
|
|
}
|
|
}
|
|
|
|
public var participants: [Participant]
|
|
public var nextParticipantsFetchOffset: String?
|
|
public var adminIds: Set<PeerId>
|
|
public var isCreator: Bool
|
|
public var defaultParticipantsAreMuted: DefaultParticipantsAreMuted
|
|
public var sortAscending: Bool
|
|
public var recordingStartTimestamp: Int32?
|
|
public var title: String?
|
|
public var scheduleTimestamp: Int32?
|
|
public var subscribedToScheduled: Bool
|
|
public var totalCount: Int
|
|
public var isVideoEnabled: Bool
|
|
public var unmutedVideoLimit: Int
|
|
public var isStream: Bool
|
|
public var version: Int32
|
|
|
|
public mutating func mergeActivity(from other: State, myPeerId: PeerId?, previousMyPeerId: PeerId?, mergeActivityTimestamps: Bool) {
|
|
var indexMap: [PeerId: Int] = [:]
|
|
for i in 0 ..< other.participants.count {
|
|
indexMap[other.participants[i].peer.id] = i
|
|
}
|
|
|
|
for i in 0 ..< self.participants.count {
|
|
if let index = indexMap[self.participants[i].peer.id] {
|
|
self.participants[i].mergeActivity(from: other.participants[index], mergeActivityTimestamp: mergeActivityTimestamps)
|
|
if self.participants[i].peer.id == myPeerId || self.participants[i].peer.id == previousMyPeerId {
|
|
self.participants[i].joinTimestamp = other.participants[index].joinTimestamp
|
|
}
|
|
}
|
|
}
|
|
|
|
self.participants.sort(by: { GroupCallParticipantsContext.Participant.compare(lhs: $0, rhs: $1, sortAscending: self.sortAscending) })
|
|
}
|
|
|
|
public init(
|
|
participants: [Participant],
|
|
nextParticipantsFetchOffset: String?,
|
|
adminIds: Set<PeerId>,
|
|
isCreator: Bool,
|
|
defaultParticipantsAreMuted: DefaultParticipantsAreMuted,
|
|
sortAscending: Bool,
|
|
recordingStartTimestamp: Int32?,
|
|
title: String?,
|
|
scheduleTimestamp: Int32?,
|
|
subscribedToScheduled: Bool,
|
|
totalCount: Int,
|
|
isVideoEnabled: Bool,
|
|
unmutedVideoLimit: Int,
|
|
isStream: Bool,
|
|
version: Int32
|
|
) {
|
|
self.participants = participants
|
|
self.nextParticipantsFetchOffset = nextParticipantsFetchOffset
|
|
self.adminIds = adminIds
|
|
self.isCreator = isCreator
|
|
self.defaultParticipantsAreMuted = defaultParticipantsAreMuted
|
|
self.sortAscending = sortAscending
|
|
self.recordingStartTimestamp = recordingStartTimestamp
|
|
self.title = title
|
|
self.scheduleTimestamp = scheduleTimestamp
|
|
self.subscribedToScheduled = subscribedToScheduled
|
|
self.totalCount = totalCount
|
|
self.isVideoEnabled = isVideoEnabled
|
|
self.unmutedVideoLimit = unmutedVideoLimit
|
|
self.isStream = isStream
|
|
self.version = version
|
|
}
|
|
}
|
|
|
|
private struct OverlayState: Equatable {
|
|
struct MuteStateChange: Equatable {
|
|
var state: Participant.MuteState?
|
|
var volume: Int32?
|
|
var disposable: Disposable
|
|
|
|
static func ==(lhs: MuteStateChange, rhs: MuteStateChange) -> Bool {
|
|
if lhs.state != rhs.state {
|
|
return false
|
|
}
|
|
if lhs.volume != rhs.volume {
|
|
return false
|
|
}
|
|
if lhs.disposable !== rhs.disposable {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
|
|
var pendingMuteStateChanges: [PeerId: MuteStateChange] = [:]
|
|
|
|
var hasLocalVideo: PeerId? = nil
|
|
|
|
var isEmpty: Bool {
|
|
if !self.pendingMuteStateChanges.isEmpty {
|
|
return false
|
|
}
|
|
if self.hasLocalVideo != nil {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
|
|
private struct InternalState: Equatable {
|
|
var state: State
|
|
var overlayState: OverlayState
|
|
}
|
|
|
|
public enum Update {
|
|
public struct StateUpdate {
|
|
public struct ParticipantUpdate {
|
|
public enum ParticipationStatusChange {
|
|
case none
|
|
case joined
|
|
case left
|
|
}
|
|
|
|
public var peerId: PeerId
|
|
public var ssrc: UInt32?
|
|
public var videoDescription: GroupCallParticipantsContext.Participant.VideoDescription?
|
|
public var presentationDescription: GroupCallParticipantsContext.Participant.VideoDescription?
|
|
public var joinTimestamp: Int32
|
|
public var activityTimestamp: Double?
|
|
public var raiseHandRating: Int64?
|
|
public var muteState: Participant.MuteState?
|
|
public var participationStatusChange: ParticipationStatusChange
|
|
public var volume: Int32?
|
|
public var about: String?
|
|
public var joinedVideo: Bool
|
|
public var isMin: Bool
|
|
|
|
init(
|
|
peerId: PeerId,
|
|
ssrc: UInt32?,
|
|
videoDescription: GroupCallParticipantsContext.Participant.VideoDescription?,
|
|
presentationDescription: GroupCallParticipantsContext.Participant.VideoDescription?,
|
|
joinTimestamp: Int32,
|
|
activityTimestamp: Double?,
|
|
raiseHandRating: Int64?,
|
|
muteState: Participant.MuteState?,
|
|
participationStatusChange: ParticipationStatusChange,
|
|
volume: Int32?,
|
|
about: String?,
|
|
joinedVideo: Bool,
|
|
isMin: Bool
|
|
) {
|
|
self.peerId = peerId
|
|
self.ssrc = ssrc
|
|
self.videoDescription = videoDescription
|
|
self.presentationDescription = presentationDescription
|
|
self.joinTimestamp = joinTimestamp
|
|
self.activityTimestamp = activityTimestamp
|
|
self.raiseHandRating = raiseHandRating
|
|
self.muteState = muteState
|
|
self.participationStatusChange = participationStatusChange
|
|
self.volume = volume
|
|
self.about = about
|
|
self.joinedVideo = joinedVideo
|
|
self.isMin = isMin
|
|
}
|
|
}
|
|
|
|
public var participantUpdates: [ParticipantUpdate]
|
|
public var version: Int32
|
|
|
|
public var removePendingMuteStates: Set<PeerId>
|
|
}
|
|
|
|
case state(update: StateUpdate)
|
|
case call(isTerminated: Bool, defaultParticipantsAreMuted: State.DefaultParticipantsAreMuted, title: String?, recordingStartTimestamp: Int32?, scheduleTimestamp: Int32?, isVideoEnabled: Bool, participantCount: Int?)
|
|
case conferenceChainBlocks(subChainId: Int, blocks: [Data], nextOffset: Int)
|
|
}
|
|
|
|
public final class MemberEvent {
|
|
public let peerId: PeerId
|
|
public let canUnmute: Bool
|
|
public let joined: Bool
|
|
|
|
public init(peerId: PeerId, canUnmute: Bool, joined: Bool) {
|
|
self.peerId = peerId
|
|
self.canUnmute = canUnmute
|
|
self.joined = joined
|
|
}
|
|
}
|
|
|
|
private let account: Account
|
|
private let peerId: PeerId?
|
|
public let myPeerId: PeerId
|
|
public let id: Int64
|
|
public let reference: InternalGroupCallReference
|
|
|
|
private var hasReceivedSpeakingParticipantsReport: Bool = false
|
|
|
|
private var stateValue: InternalState {
|
|
didSet {
|
|
if self.stateValue != oldValue {
|
|
self.statePromise.set(self.stateValue)
|
|
}
|
|
}
|
|
}
|
|
private let statePromise: ValuePromise<InternalState>
|
|
|
|
public var immediateState: State?
|
|
|
|
public var state: Signal<State, NoError> {
|
|
let accountPeerId = self.account.peerId
|
|
let myPeerId = self.myPeerId
|
|
return self.statePromise.get()
|
|
|> map { state -> State in
|
|
var publicState = state.state
|
|
var sortAgain = false
|
|
var canSeeHands = state.state.isCreator || state.state.adminIds.contains(accountPeerId)
|
|
for participant in publicState.participants {
|
|
if participant.peer.id == myPeerId {
|
|
if let muteState = participant.muteState {
|
|
if muteState.canUnmute {
|
|
canSeeHands = true
|
|
}
|
|
} else {
|
|
canSeeHands = true
|
|
}
|
|
break
|
|
}
|
|
}
|
|
for i in 0 ..< publicState.participants.count {
|
|
if let pendingMuteState = state.overlayState.pendingMuteStateChanges[publicState.participants[i].peer.id] {
|
|
publicState.participants[i].muteState = pendingMuteState.state
|
|
publicState.participants[i].volume = pendingMuteState.volume
|
|
}
|
|
if !canSeeHands && publicState.participants[i].raiseHandRating != nil {
|
|
publicState.participants[i].raiseHandRating = nil
|
|
sortAgain = true
|
|
}
|
|
|
|
//TODO:wip-release
|
|
/*if let hasLocalVideoPeerId = state.overlayState.hasLocalVideo, hasLocalVideoPeerId == publicState.participants[i].peer.id {
|
|
if publicState.participants[i].videoDescription == nil {
|
|
publicState.participants[i].videoDescription = GroupCallParticipantsContext.Participant.VideoDescription(endpointId: "_local", ssrcGroups: [], audioSsrc: nil, isPaused: false)
|
|
}
|
|
}*/
|
|
}
|
|
if sortAgain {
|
|
publicState.participants.sort(by: { GroupCallParticipantsContext.Participant.compare(lhs: $0, rhs: $1, sortAscending: publicState.sortAscending) })
|
|
}
|
|
return publicState
|
|
}
|
|
|> beforeNext { [weak self] next in
|
|
Queue.mainQueue().async {
|
|
self?.immediateState = next
|
|
}
|
|
}
|
|
}
|
|
|
|
private var activeSpeakersValue: Set<PeerId> = Set() {
|
|
didSet {
|
|
if self.activeSpeakersValue != oldValue {
|
|
self.activeSpeakersPromise.set(self.activeSpeakersValue)
|
|
}
|
|
}
|
|
}
|
|
private let activeSpeakersPromise = ValuePromise<Set<PeerId>>(Set())
|
|
public var activeSpeakers: Signal<Set<PeerId>, NoError> {
|
|
return self.activeSpeakersPromise.get()
|
|
}
|
|
|
|
private let memberEventsPipe = ValuePipe<MemberEvent>()
|
|
public var memberEvents: Signal<MemberEvent, NoError> {
|
|
return self.memberEventsPipe.signal()
|
|
}
|
|
|
|
private var updateQueue: [Update.StateUpdate] = []
|
|
private var isProcessingUpdate: Bool = false
|
|
private let disposable = MetaDisposable()
|
|
|
|
private let updatesDisposable = MetaDisposable()
|
|
private var activitiesDisposable: Disposable?
|
|
|
|
private var isLoadingMore: Bool = false
|
|
private var shouldResetStateFromServer: Bool = false
|
|
private var missingSsrcs = Set<UInt32>()
|
|
|
|
private var activityRankResetTimer: SwiftSignalKit.Timer?
|
|
|
|
private let updateDefaultMuteDisposable = MetaDisposable()
|
|
private let resetInviteLinksDisposable = MetaDisposable()
|
|
private let updateShouldBeRecordingDisposable = MetaDisposable()
|
|
private let subscribeDisposable = MetaDisposable()
|
|
|
|
private var localVideoIsMuted: Bool? = nil
|
|
private var localIsVideoPaused: Bool? = nil
|
|
private var localIsPresentationPaused: Bool? = nil
|
|
public struct ServiceState {
|
|
fileprivate var nextActivityRank: Int = 0
|
|
}
|
|
|
|
public private(set) var serviceState: ServiceState
|
|
|
|
init(account: Account, peerId: PeerId?, myPeerId: PeerId, id: Int64, reference: InternalGroupCallReference, state: State, previousServiceState: ServiceState?) {
|
|
self.account = account
|
|
self.peerId = peerId
|
|
self.myPeerId = myPeerId
|
|
self.id = id
|
|
self.reference = reference
|
|
self.stateValue = InternalState(state: state, overlayState: OverlayState())
|
|
self.statePromise = ValuePromise<InternalState>(self.stateValue)
|
|
self.serviceState = previousServiceState ?? ServiceState()
|
|
|
|
self.updatesDisposable.set((self.account.stateManager.groupCallParticipantUpdates
|
|
|> deliverOnMainQueue).start(next: { [weak self] updates in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
var filteredUpdates: [Update] = []
|
|
for (callId, update) in updates {
|
|
if callId == id {
|
|
filteredUpdates.append(update)
|
|
}
|
|
}
|
|
if !filteredUpdates.isEmpty {
|
|
strongSelf.addUpdates(updates: filteredUpdates)
|
|
}
|
|
}))
|
|
|
|
if let peerId {
|
|
let activityCategory: PeerActivitySpace.Category = .voiceChat
|
|
self.activitiesDisposable = (self.account.peerInputActivities(peerId: PeerActivitySpace(peerId: peerId, category: activityCategory))
|
|
|> deliverOnMainQueue).start(next: { [weak self] activities in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
|
|
let peerIds = Set(activities.map { item -> PeerId in
|
|
item.0
|
|
})
|
|
strongSelf.activeSpeakersValue = peerIds
|
|
|
|
if !strongSelf.hasReceivedSpeakingParticipantsReport {
|
|
var updatedParticipants = strongSelf.stateValue.state.participants
|
|
var indexMap: [PeerId: Int] = [:]
|
|
for i in 0 ..< updatedParticipants.count {
|
|
indexMap[updatedParticipants[i].peer.id] = i
|
|
}
|
|
var updated = false
|
|
|
|
for (activityPeerId, activity) in activities {
|
|
if case let .speakingInGroupCall(intTimestamp) = activity {
|
|
let timestamp = Double(intTimestamp)
|
|
|
|
if let index = indexMap[activityPeerId] {
|
|
if let activityTimestamp = updatedParticipants[index].activityTimestamp {
|
|
if activityTimestamp < timestamp {
|
|
updatedParticipants[index].activityTimestamp = timestamp
|
|
updated = true
|
|
}
|
|
} else {
|
|
updatedParticipants[index].activityTimestamp = timestamp
|
|
updated = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if updated {
|
|
updatedParticipants.sort(by: { GroupCallParticipantsContext.Participant.compare(lhs: $0, rhs: $1, sortAscending: strongSelf.stateValue.state.sortAscending) })
|
|
|
|
strongSelf.stateValue = InternalState(
|
|
state: State(
|
|
participants: updatedParticipants,
|
|
nextParticipantsFetchOffset: strongSelf.stateValue.state.nextParticipantsFetchOffset,
|
|
adminIds: strongSelf.stateValue.state.adminIds,
|
|
isCreator: strongSelf.stateValue.state.isCreator,
|
|
defaultParticipantsAreMuted: strongSelf.stateValue.state.defaultParticipantsAreMuted,
|
|
sortAscending: strongSelf.stateValue.state.sortAscending,
|
|
recordingStartTimestamp: strongSelf.stateValue.state.recordingStartTimestamp,
|
|
title: strongSelf.stateValue.state.title,
|
|
scheduleTimestamp: strongSelf.stateValue.state.scheduleTimestamp,
|
|
subscribedToScheduled: strongSelf.stateValue.state.subscribedToScheduled,
|
|
totalCount: strongSelf.stateValue.state.totalCount,
|
|
isVideoEnabled: strongSelf.stateValue.state.isVideoEnabled,
|
|
unmutedVideoLimit: strongSelf.stateValue.state.unmutedVideoLimit,
|
|
isStream: strongSelf.stateValue.state.isStream,
|
|
version: strongSelf.stateValue.state.version
|
|
),
|
|
overlayState: strongSelf.stateValue.overlayState
|
|
)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
self.activityRankResetTimer = SwiftSignalKit.Timer(timeout: 10.0, repeat: true, completion: { [weak self] in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
|
|
var updated = false
|
|
let timestamp = CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970
|
|
|
|
for i in 0 ..< strongSelf.stateValue.state.participants.count {
|
|
if strongSelf.stateValue.state.participants[i].activityRank != nil {
|
|
var clearRank = false
|
|
if let activityTimestamp = strongSelf.stateValue.state.participants[i].activityTimestamp {
|
|
if activityTimestamp < timestamp - 60.0 {
|
|
clearRank = true
|
|
}
|
|
} else {
|
|
clearRank = true
|
|
}
|
|
if clearRank {
|
|
updated = true
|
|
strongSelf.stateValue.state.participants[i].activityRank = nil
|
|
}
|
|
}
|
|
}
|
|
if updated {
|
|
strongSelf.stateValue.state.participants.sort(by: { GroupCallParticipantsContext.Participant.compare(lhs: $0, rhs: $1, sortAscending: strongSelf.stateValue.state.sortAscending) })
|
|
}
|
|
}, queue: .mainQueue())
|
|
self.activityRankResetTimer?.start()
|
|
}
|
|
|
|
deinit {
|
|
self.disposable.dispose()
|
|
self.updatesDisposable.dispose()
|
|
self.activitiesDisposable?.dispose()
|
|
self.updateDefaultMuteDisposable.dispose()
|
|
self.updateShouldBeRecordingDisposable.dispose()
|
|
self.activityRankResetTimer?.invalidate()
|
|
self.resetInviteLinksDisposable.dispose()
|
|
self.subscribeDisposable.dispose()
|
|
}
|
|
|
|
public func addUpdates(updates: [Update]) {
|
|
var stateUpdates: [Update.StateUpdate] = []
|
|
for update in updates {
|
|
if case let .state(update) = update {
|
|
stateUpdates.append(update)
|
|
} else if case let .call(_, defaultParticipantsAreMuted, title, recordingStartTimestamp, scheduleTimestamp, isVideoEnabled, participantsCount) = update {
|
|
var state = self.stateValue.state
|
|
state.defaultParticipantsAreMuted = defaultParticipantsAreMuted
|
|
state.recordingStartTimestamp = recordingStartTimestamp
|
|
state.title = title
|
|
state.scheduleTimestamp = scheduleTimestamp
|
|
state.isVideoEnabled = isVideoEnabled
|
|
if let participantsCount = participantsCount {
|
|
state.totalCount = participantsCount
|
|
}
|
|
|
|
self.stateValue.state = state
|
|
}
|
|
}
|
|
|
|
if !stateUpdates.isEmpty {
|
|
self.updateQueue.append(contentsOf: stateUpdates)
|
|
self.beginProcessingUpdatesIfNeeded()
|
|
}
|
|
}
|
|
|
|
public func removeLocalPeerId() {
|
|
var state = self.stateValue.state
|
|
|
|
state.participants.removeAll(where: { $0.peer.id == self.myPeerId })
|
|
|
|
self.stateValue.state = state
|
|
}
|
|
|
|
private func takeNextActivityRank() -> Int {
|
|
let value = self.serviceState.nextActivityRank
|
|
self.serviceState.nextActivityRank += 1
|
|
return value
|
|
}
|
|
|
|
public func updateAdminIds(_ adminIds: Set<PeerId>) {
|
|
if self.stateValue.state.adminIds != adminIds {
|
|
self.stateValue.state.adminIds = adminIds
|
|
}
|
|
}
|
|
|
|
public func reportSpeakingParticipants(ids: [PeerId: UInt32]) {
|
|
if !ids.isEmpty {
|
|
self.hasReceivedSpeakingParticipantsReport = true
|
|
}
|
|
|
|
let strongSelf = self
|
|
|
|
var updatedParticipants = strongSelf.stateValue.state.participants
|
|
var indexMap: [PeerId: Int] = [:]
|
|
for i in 0 ..< updatedParticipants.count {
|
|
indexMap[updatedParticipants[i].peer.id] = i
|
|
}
|
|
var updated = false
|
|
|
|
let timestamp = CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970
|
|
|
|
for (activityPeerId, _) in ids {
|
|
if let index = indexMap[activityPeerId] {
|
|
var updateTimestamp = false
|
|
if let activityTimestamp = updatedParticipants[index].activityTimestamp {
|
|
if activityTimestamp < timestamp {
|
|
updateTimestamp = true
|
|
}
|
|
} else {
|
|
updateTimestamp = true
|
|
}
|
|
if updateTimestamp {
|
|
updatedParticipants[index].activityTimestamp = timestamp
|
|
if updatedParticipants[index].activityRank == nil {
|
|
updatedParticipants[index].activityRank = self.takeNextActivityRank()
|
|
}
|
|
updated = true
|
|
}
|
|
}
|
|
}
|
|
|
|
if updated {
|
|
updatedParticipants.sort(by: { GroupCallParticipantsContext.Participant.compare(lhs: $0, rhs: $1, sortAscending: strongSelf.stateValue.state.sortAscending) })
|
|
|
|
strongSelf.stateValue = InternalState(
|
|
state: State(
|
|
participants: updatedParticipants,
|
|
nextParticipantsFetchOffset: strongSelf.stateValue.state.nextParticipantsFetchOffset,
|
|
adminIds: strongSelf.stateValue.state.adminIds,
|
|
isCreator: strongSelf.stateValue.state.isCreator,
|
|
defaultParticipantsAreMuted: strongSelf.stateValue.state.defaultParticipantsAreMuted,
|
|
sortAscending: strongSelf.stateValue.state.sortAscending,
|
|
recordingStartTimestamp: strongSelf.stateValue.state.recordingStartTimestamp,
|
|
title: strongSelf.stateValue.state.title,
|
|
scheduleTimestamp: strongSelf.stateValue.state.scheduleTimestamp,
|
|
subscribedToScheduled: strongSelf.stateValue.state.subscribedToScheduled,
|
|
totalCount: strongSelf.stateValue.state.totalCount,
|
|
isVideoEnabled: strongSelf.stateValue.state.isVideoEnabled,
|
|
unmutedVideoLimit: strongSelf.stateValue.state.unmutedVideoLimit,
|
|
isStream: strongSelf.stateValue.state.isStream,
|
|
version: strongSelf.stateValue.state.version
|
|
),
|
|
overlayState: strongSelf.stateValue.overlayState
|
|
)
|
|
}
|
|
|
|
self.ensureHaveParticipants(ssrcs: Set(ids.map { $0.1 }))
|
|
}
|
|
|
|
public func ensureHaveParticipants(ssrcs: Set<UInt32>) {
|
|
var missingSsrcs = Set<UInt32>()
|
|
|
|
var existingSsrcs = Set<UInt32>()
|
|
for participant in self.stateValue.state.participants {
|
|
if let ssrc = participant.ssrc {
|
|
existingSsrcs.insert(ssrc)
|
|
}
|
|
if let presentationDescription = participant.presentationDescription, let presentationAudioSsrc = presentationDescription.audioSsrc {
|
|
existingSsrcs.insert(presentationAudioSsrc)
|
|
}
|
|
}
|
|
|
|
for ssrc in ssrcs {
|
|
if !existingSsrcs.contains(ssrc) {
|
|
missingSsrcs.insert(ssrc)
|
|
}
|
|
}
|
|
|
|
if !missingSsrcs.isEmpty {
|
|
self.missingSsrcs.formUnion(missingSsrcs)
|
|
self.loadMissingSsrcs()
|
|
}
|
|
}
|
|
|
|
private func loadMissingSsrcs() {
|
|
if self.missingSsrcs.isEmpty {
|
|
return
|
|
}
|
|
if self.isLoadingMore {
|
|
return
|
|
}
|
|
self.isLoadingMore = true
|
|
|
|
let ssrcs = self.missingSsrcs
|
|
|
|
Logger.shared.log("GroupCallParticipantsContext", "will request ssrcs=\(ssrcs)")
|
|
|
|
self.disposable.set((_internal_getGroupCallParticipants(account: self.account, reference: self.reference, offset: "", ssrcs: Array(ssrcs), limit: 100, sortAscending: true)
|
|
|> deliverOnMainQueue).start(next: { [weak self] state in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
strongSelf.isLoadingMore = false
|
|
|
|
strongSelf.missingSsrcs.subtract(ssrcs)
|
|
|
|
Logger.shared.log("GroupCallParticipantsContext", "did receive response for ssrcs=\(ssrcs), \(state.participants)")
|
|
|
|
var updatedState = strongSelf.stateValue.state
|
|
|
|
updatedState.participants = mergeAndSortParticipants(current: updatedState.participants, with: state.participants, sortAscending: updatedState.sortAscending)
|
|
|
|
updatedState.totalCount = max(updatedState.totalCount, state.totalCount)
|
|
updatedState.version = max(updatedState.version, updatedState.version)
|
|
|
|
strongSelf.stateValue.state = updatedState
|
|
|
|
if strongSelf.shouldResetStateFromServer {
|
|
strongSelf.resetStateFromServer()
|
|
} else {
|
|
strongSelf.loadMissingSsrcs()
|
|
}
|
|
}))
|
|
}
|
|
|
|
private func beginProcessingUpdatesIfNeeded() {
|
|
if self.isProcessingUpdate {
|
|
return
|
|
}
|
|
if self.updateQueue.isEmpty {
|
|
return
|
|
}
|
|
self.isProcessingUpdate = true
|
|
let update = self.updateQueue.removeFirst()
|
|
self.processUpdate(update: update)
|
|
}
|
|
|
|
private func endedProcessingUpdate() {
|
|
assert(self.isProcessingUpdate)
|
|
self.isProcessingUpdate = false
|
|
self.beginProcessingUpdatesIfNeeded()
|
|
}
|
|
|
|
private func processUpdate(update: Update.StateUpdate) {
|
|
if update.version < self.stateValue.state.version {
|
|
for peerId in update.removePendingMuteStates {
|
|
self.stateValue.overlayState.pendingMuteStateChanges.removeValue(forKey: peerId)
|
|
}
|
|
self.endedProcessingUpdate()
|
|
return
|
|
}
|
|
|
|
if update.version > self.stateValue.state.version + 1 {
|
|
for peerId in update.removePendingMuteStates {
|
|
self.stateValue.overlayState.pendingMuteStateChanges.removeValue(forKey: peerId)
|
|
}
|
|
self.resetStateFromServer()
|
|
return
|
|
}
|
|
|
|
let isVersionUpdate = update.version != self.stateValue.state.version
|
|
|
|
let _ = (self.account.postbox.transaction { transaction -> [PeerId: Peer] in
|
|
var peers: [PeerId: Peer] = [:]
|
|
|
|
for participantUpdate in update.participantUpdates {
|
|
if let peer = transaction.getPeer(participantUpdate.peerId) {
|
|
peers[peer.id] = peer
|
|
}
|
|
}
|
|
|
|
return peers
|
|
}
|
|
|> deliverOnMainQueue).start(next: { [weak self] peers in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
|
|
var updatedParticipants = strongSelf.stateValue.state.participants
|
|
var updatedTotalCount = strongSelf.stateValue.state.totalCount
|
|
|
|
for participantUpdate in update.participantUpdates {
|
|
if case .left = participantUpdate.participationStatusChange {
|
|
if let index = updatedParticipants.firstIndex(where: { $0.peer.id == participantUpdate.peerId }) {
|
|
updatedParticipants.remove(at: index)
|
|
updatedTotalCount = max(0, updatedTotalCount - 1)
|
|
strongSelf.memberEventsPipe.putNext(MemberEvent(peerId: participantUpdate.peerId, canUnmute: false, joined: false))
|
|
} else if isVersionUpdate {
|
|
updatedTotalCount = max(0, updatedTotalCount - 1)
|
|
}
|
|
} else {
|
|
guard let peer = peers[participantUpdate.peerId] else {
|
|
assertionFailure()
|
|
continue
|
|
}
|
|
var previousJoinTimestamp: Int32?
|
|
var previousActivityTimestamp: Double?
|
|
var previousActivityRank: Int?
|
|
var previousMuteState: GroupCallParticipantsContext.Participant.MuteState?
|
|
var previousVolume: Int32?
|
|
if let index = updatedParticipants.firstIndex(where: { $0.peer.id == participantUpdate.peerId }) {
|
|
previousJoinTimestamp = updatedParticipants[index].joinTimestamp
|
|
previousActivityTimestamp = updatedParticipants[index].activityTimestamp
|
|
previousActivityRank = updatedParticipants[index].activityRank
|
|
previousMuteState = updatedParticipants[index].muteState
|
|
previousVolume = updatedParticipants[index].volume
|
|
updatedParticipants.remove(at: index)
|
|
} else if case .joined = participantUpdate.participationStatusChange {
|
|
updatedTotalCount += 1
|
|
strongSelf.memberEventsPipe.putNext(MemberEvent(peerId: participantUpdate.peerId, canUnmute: participantUpdate.muteState?.canUnmute ?? true, joined: true))
|
|
}
|
|
|
|
var activityTimestamp: Double?
|
|
if let previousActivityTimestamp = previousActivityTimestamp, let updatedActivityTimestamp = participantUpdate.activityTimestamp {
|
|
activityTimestamp = max(updatedActivityTimestamp, previousActivityTimestamp)
|
|
} else {
|
|
activityTimestamp = participantUpdate.activityTimestamp ?? previousActivityTimestamp
|
|
}
|
|
|
|
if let muteState = participantUpdate.muteState, !muteState.canUnmute {
|
|
previousActivityRank = nil
|
|
activityTimestamp = nil
|
|
}
|
|
|
|
var volume = participantUpdate.volume
|
|
var muteState = participantUpdate.muteState
|
|
if participantUpdate.isMin {
|
|
if let previousMuteState = previousMuteState {
|
|
if previousMuteState.mutedByYou {
|
|
muteState = previousMuteState
|
|
}
|
|
}
|
|
if let previousVolume = previousVolume {
|
|
volume = previousVolume
|
|
}
|
|
}
|
|
let participant = Participant(
|
|
peer: peer,
|
|
ssrc: participantUpdate.ssrc,
|
|
videoDescription: participantUpdate.videoDescription,
|
|
presentationDescription: participantUpdate.presentationDescription,
|
|
joinTimestamp: previousJoinTimestamp ?? participantUpdate.joinTimestamp,
|
|
raiseHandRating: participantUpdate.raiseHandRating,
|
|
hasRaiseHand: participantUpdate.raiseHandRating != nil,
|
|
activityTimestamp: activityTimestamp,
|
|
activityRank: previousActivityRank,
|
|
muteState: muteState,
|
|
volume: volume,
|
|
about: participantUpdate.about,
|
|
joinedVideo: participantUpdate.joinedVideo
|
|
)
|
|
updatedParticipants.append(participant)
|
|
}
|
|
}
|
|
|
|
updatedTotalCount = max(updatedTotalCount, updatedParticipants.count)
|
|
|
|
var updatedOverlayState = strongSelf.stateValue.overlayState
|
|
for peerId in update.removePendingMuteStates {
|
|
updatedOverlayState.pendingMuteStateChanges.removeValue(forKey: peerId)
|
|
}
|
|
|
|
let nextParticipantsFetchOffset = strongSelf.stateValue.state.nextParticipantsFetchOffset
|
|
let adminIds = strongSelf.stateValue.state.adminIds
|
|
let isCreator = strongSelf.stateValue.state.isCreator
|
|
let defaultParticipantsAreMuted = strongSelf.stateValue.state.defaultParticipantsAreMuted
|
|
let recordingStartTimestamp = strongSelf.stateValue.state.recordingStartTimestamp
|
|
let title = strongSelf.stateValue.state.title
|
|
let scheduleTimestamp = strongSelf.stateValue.state.scheduleTimestamp
|
|
let subscribedToScheduled = strongSelf.stateValue.state.subscribedToScheduled
|
|
let isVideoEnabled = strongSelf.stateValue.state.isVideoEnabled
|
|
let isStream = strongSelf.stateValue.state.isStream
|
|
let unmutedVideoLimit = strongSelf.stateValue.state.unmutedVideoLimit
|
|
|
|
updatedParticipants.sort(by: { GroupCallParticipantsContext.Participant.compare(lhs: $0, rhs: $1, sortAscending: strongSelf.stateValue.state.sortAscending) })
|
|
|
|
strongSelf.stateValue = InternalState(
|
|
state: State(
|
|
participants: updatedParticipants,
|
|
nextParticipantsFetchOffset: nextParticipantsFetchOffset,
|
|
adminIds: adminIds,
|
|
isCreator: isCreator,
|
|
defaultParticipantsAreMuted: defaultParticipantsAreMuted,
|
|
sortAscending: strongSelf.stateValue.state.sortAscending,
|
|
recordingStartTimestamp: recordingStartTimestamp,
|
|
title: title,
|
|
scheduleTimestamp: scheduleTimestamp,
|
|
subscribedToScheduled: subscribedToScheduled,
|
|
totalCount: updatedTotalCount,
|
|
isVideoEnabled: isVideoEnabled,
|
|
unmutedVideoLimit: unmutedVideoLimit,
|
|
isStream: isStream,
|
|
version: update.version
|
|
),
|
|
overlayState: updatedOverlayState
|
|
)
|
|
|
|
strongSelf.endedProcessingUpdate()
|
|
})
|
|
}
|
|
|
|
private func resetStateFromServer() {
|
|
if self.isLoadingMore {
|
|
self.shouldResetStateFromServer = true
|
|
return
|
|
}
|
|
|
|
self.isLoadingMore = true
|
|
|
|
self.updateQueue.removeAll()
|
|
|
|
self.disposable.set((_internal_getGroupCallParticipants(account: self.account, reference: self.reference, offset: "", ssrcs: [], limit: 100, sortAscending: self.stateValue.state.sortAscending)
|
|
|> deliverOnMainQueue).start(next: { [weak self] state in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
strongSelf.isLoadingMore = false
|
|
strongSelf.shouldResetStateFromServer = false
|
|
var state = state
|
|
state.adminIds = strongSelf.stateValue.state.adminIds
|
|
state.isCreator = strongSelf.stateValue.state.isCreator
|
|
state.defaultParticipantsAreMuted = strongSelf.stateValue.state.defaultParticipantsAreMuted
|
|
state.title = strongSelf.stateValue.state.title
|
|
state.recordingStartTimestamp = strongSelf.stateValue.state.recordingStartTimestamp
|
|
state.scheduleTimestamp = strongSelf.stateValue.state.scheduleTimestamp
|
|
state.mergeActivity(from: strongSelf.stateValue.state, myPeerId: nil, previousMyPeerId: nil, mergeActivityTimestamps: false)
|
|
strongSelf.stateValue.state = state
|
|
strongSelf.endedProcessingUpdate()
|
|
}))
|
|
}
|
|
|
|
public func updateMuteState(peerId: PeerId, muteState: Participant.MuteState?, volume: Int32?, raiseHand: Bool?) {
|
|
if let current = self.stateValue.overlayState.pendingMuteStateChanges[peerId] {
|
|
if current.state == muteState {
|
|
return
|
|
}
|
|
current.disposable.dispose()
|
|
self.stateValue.overlayState.pendingMuteStateChanges.removeValue(forKey: peerId)
|
|
}
|
|
|
|
for participant in self.stateValue.state.participants {
|
|
if participant.peer.id == peerId {
|
|
var raiseHandEqual: Bool = true
|
|
if let raiseHand = raiseHand {
|
|
raiseHandEqual = (participant.raiseHandRating == nil && !raiseHand) ||
|
|
(participant.raiseHandRating != nil && raiseHand)
|
|
}
|
|
if participant.muteState == muteState && participant.volume == volume && raiseHandEqual {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
let disposable = MetaDisposable()
|
|
if raiseHand == nil {
|
|
self.stateValue.overlayState.pendingMuteStateChanges[peerId] = OverlayState.MuteStateChange(
|
|
state: muteState,
|
|
volume: volume,
|
|
disposable: disposable
|
|
)
|
|
}
|
|
|
|
let account = self.account
|
|
let id = self.id
|
|
let reference = self.reference
|
|
let myPeerId = self.myPeerId
|
|
|
|
let signal: Signal<Api.Updates?, NoError> = self.account.postbox.transaction { transaction -> Api.InputPeer? in
|
|
return transaction.getPeer(peerId).flatMap(apiInputPeer)
|
|
}
|
|
|> mapToSignal { inputPeer -> Signal<Api.Updates?, NoError> in
|
|
guard let inputPeer = inputPeer else {
|
|
return .single(nil)
|
|
}
|
|
var flags: Int32 = 0
|
|
if let volume = volume, volume > 0 {
|
|
flags |= 1 << 1
|
|
}
|
|
var muted: Api.Bool?
|
|
if let muteState = muteState, (!muteState.canUnmute || peerId == myPeerId || muteState.mutedByYou) {
|
|
flags |= 1 << 0
|
|
muted = .boolTrue
|
|
} else if peerId == myPeerId {
|
|
flags |= 1 << 0
|
|
muted = .boolFalse
|
|
}
|
|
let raiseHandApi: Api.Bool?
|
|
if let raiseHand = raiseHand {
|
|
flags |= 1 << 2
|
|
raiseHandApi = raiseHand ? .boolTrue : .boolFalse
|
|
} else {
|
|
raiseHandApi = nil
|
|
}
|
|
|
|
return account.network.request(Api.functions.phone.editGroupCallParticipant(flags: flags, call: reference.apiInputGroupCall, participant: inputPeer, muted: muted, volume: volume, raiseHand: raiseHandApi, videoStopped: nil, videoPaused: nil, presentationPaused: nil))
|
|
|> map(Optional.init)
|
|
|> `catch` { _ -> Signal<Api.Updates?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
}
|
|
|
|
disposable.set((signal
|
|
|> deliverOnMainQueue).start(next: { [weak self] updates in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
|
|
if let updates = updates {
|
|
var stateUpdates: [GroupCallParticipantsContext.Update] = []
|
|
|
|
loop: for update in updates.allUpdates {
|
|
switch update {
|
|
case let .updateGroupCallParticipants(call, participants, version):
|
|
switch call {
|
|
case let .inputGroupCall(updateCallId, _):
|
|
if updateCallId != id {
|
|
continue loop
|
|
}
|
|
case .inputGroupCallSlug, .inputGroupCallInviteMessage:
|
|
continue loop
|
|
}
|
|
stateUpdates.append(.state(update: GroupCallParticipantsContext.Update.StateUpdate(participants: participants, version: version, removePendingMuteStates: [peerId])))
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
strongSelf.addUpdates(updates: stateUpdates)
|
|
|
|
strongSelf.account.stateManager.addUpdates(updates)
|
|
} else {
|
|
strongSelf.stateValue.overlayState.pendingMuteStateChanges.removeValue(forKey: peerId)
|
|
}
|
|
}))
|
|
}
|
|
|
|
public func updateVideoState(peerId: PeerId, isVideoMuted: Bool?, isVideoPaused: Bool?, isPresentationPaused: Bool?) {
|
|
if self.localVideoIsMuted == isVideoMuted && self.localIsVideoPaused == isVideoPaused && self.localIsPresentationPaused == isPresentationPaused {
|
|
return
|
|
}
|
|
self.localVideoIsMuted = isVideoMuted
|
|
self.localIsVideoPaused = isVideoPaused
|
|
self.localIsPresentationPaused = isPresentationPaused
|
|
|
|
//TODO:wip-release
|
|
/*if let isVideoMuted {
|
|
self.stateValue.overlayState.hasLocalVideo = isVideoMuted ? nil : peerId
|
|
}*/
|
|
|
|
let disposable = MetaDisposable()
|
|
|
|
let account = self.account
|
|
let id = self.id
|
|
let reference = self.reference
|
|
|
|
let signal: Signal<Api.Updates?, NoError> = self.account.postbox.transaction { transaction -> Api.InputPeer? in
|
|
return transaction.getPeer(peerId).flatMap(apiInputPeer)
|
|
}
|
|
|> mapToSignal { inputPeer -> Signal<Api.Updates?, NoError> in
|
|
guard let inputPeer = inputPeer else {
|
|
return .single(nil)
|
|
}
|
|
var flags: Int32 = 0
|
|
var videoMuted: Api.Bool?
|
|
|
|
if let isVideoMuted = isVideoMuted {
|
|
videoMuted = isVideoMuted ? .boolTrue : .boolFalse
|
|
flags |= 1 << 3
|
|
}
|
|
|
|
var videoPaused: Api.Bool?
|
|
if isVideoMuted != nil, let isVideoPaused = isVideoPaused {
|
|
videoPaused = isVideoPaused ? .boolTrue : .boolFalse
|
|
flags |= 1 << 4
|
|
}
|
|
var presentationPaused: Api.Bool?
|
|
|
|
if let isPresentationPaused = isPresentationPaused {
|
|
presentationPaused = isPresentationPaused ? .boolTrue : .boolFalse
|
|
flags |= 1 << 5
|
|
}
|
|
|
|
return account.network.request(Api.functions.phone.editGroupCallParticipant(flags: flags, call: reference.apiInputGroupCall, participant: inputPeer, muted: nil, volume: nil, raiseHand: nil, videoStopped: videoMuted, videoPaused: videoPaused, presentationPaused: presentationPaused))
|
|
|> map(Optional.init)
|
|
|> `catch` { _ -> Signal<Api.Updates?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
}
|
|
|
|
disposable.set((signal
|
|
|> deliverOnMainQueue).start(next: { [weak self] updates in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
|
|
if let updates = updates {
|
|
var stateUpdates: [GroupCallParticipantsContext.Update] = []
|
|
|
|
loop: for update in updates.allUpdates {
|
|
switch update {
|
|
case let .updateGroupCallParticipants(call, participants, version):
|
|
switch call {
|
|
case let .inputGroupCall(updateCallId, _):
|
|
if updateCallId != id {
|
|
continue loop
|
|
}
|
|
case .inputGroupCallSlug, .inputGroupCallInviteMessage:
|
|
continue loop
|
|
}
|
|
stateUpdates.append(.state(update: GroupCallParticipantsContext.Update.StateUpdate(participants: participants, version: version, removePendingMuteStates: [peerId])))
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
strongSelf.addUpdates(updates: stateUpdates)
|
|
|
|
strongSelf.account.stateManager.addUpdates(updates)
|
|
}
|
|
}))
|
|
}
|
|
|
|
public func raiseHand() {
|
|
self.updateMuteState(peerId: self.myPeerId, muteState: nil, volume: nil, raiseHand: true)
|
|
}
|
|
|
|
public func lowerHand() {
|
|
self.updateMuteState(peerId: self.myPeerId, muteState: nil, volume: nil, raiseHand: false)
|
|
}
|
|
|
|
public func updateShouldBeRecording(_ shouldBeRecording: Bool, title: String?, videoOrientation: Bool?) {
|
|
var flags: Int32 = 0
|
|
if shouldBeRecording {
|
|
flags |= 1 << 0
|
|
}
|
|
if let title = title, !title.isEmpty {
|
|
flags |= (1 << 1)
|
|
}
|
|
var videoPortrait: Api.Bool?
|
|
if let videoOrientation = videoOrientation {
|
|
flags |= (1 << 2)
|
|
videoPortrait = videoOrientation ? .boolTrue : .boolFalse
|
|
}
|
|
|
|
self.updateShouldBeRecordingDisposable.set((self.account.network.request(Api.functions.phone.toggleGroupCallRecord(flags: flags, call: self.reference.apiInputGroupCall, title: title, videoPortrait: videoPortrait))
|
|
|> deliverOnMainQueue).start(next: { [weak self] updates in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
strongSelf.account.stateManager.addUpdates(updates)
|
|
}))
|
|
}
|
|
|
|
public func updateDefaultParticipantsAreMuted(isMuted: Bool) {
|
|
if isMuted == self.stateValue.state.defaultParticipantsAreMuted.isMuted {
|
|
return
|
|
}
|
|
self.stateValue.state.defaultParticipantsAreMuted.isMuted = isMuted
|
|
|
|
self.updateDefaultMuteDisposable.set((self.account.network.request(Api.functions.phone.toggleGroupCallSettings(flags: 1 << 0, call: self.reference.apiInputGroupCall, joinMuted: isMuted ? .boolTrue : .boolFalse))
|
|
|> deliverOnMainQueue).start(next: { [weak self] updates in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
strongSelf.account.stateManager.addUpdates(updates)
|
|
}))
|
|
}
|
|
|
|
public func resetInviteLinks() {
|
|
self.resetInviteLinksDisposable.set((self.account.network.request(Api.functions.phone.toggleGroupCallSettings(flags: 1 << 1, call: self.reference.apiInputGroupCall, joinMuted: nil))
|
|
|> deliverOnMainQueue).start(next: { [weak self] updates in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
strongSelf.account.stateManager.addUpdates(updates)
|
|
}))
|
|
}
|
|
|
|
public func toggleScheduledSubscription(_ subscribe: Bool) {
|
|
guard let peerId = self.peerId else {
|
|
return
|
|
}
|
|
if subscribe == self.stateValue.state.subscribedToScheduled {
|
|
return
|
|
}
|
|
self.stateValue.state.subscribedToScheduled = subscribe
|
|
|
|
self.subscribeDisposable.set(_internal_toggleScheduledGroupCallSubscription(account: self.account, peerId: peerId, reference: self.reference, subscribe: subscribe).start())
|
|
}
|
|
|
|
public func loadMore(token: String) {
|
|
if token != self.stateValue.state.nextParticipantsFetchOffset {
|
|
Logger.shared.log("GroupCallParticipantsContext", "loadMore called with an invalid token \(token) (the valid one is \(String(describing: self.stateValue.state.nextParticipantsFetchOffset)))")
|
|
return
|
|
}
|
|
if self.isLoadingMore {
|
|
return
|
|
}
|
|
self.isLoadingMore = true
|
|
|
|
self.disposable.set((_internal_getGroupCallParticipants(account: self.account, reference: self.reference, offset: token, ssrcs: [], limit: 100, sortAscending: self.stateValue.state.sortAscending)
|
|
|> deliverOnMainQueue).start(next: { [weak self] state in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
strongSelf.isLoadingMore = false
|
|
|
|
var updatedState = strongSelf.stateValue.state
|
|
|
|
updatedState.participants = mergeAndSortParticipants(current: updatedState.participants, with: state.participants, sortAscending: updatedState.sortAscending)
|
|
|
|
updatedState.nextParticipantsFetchOffset = state.nextParticipantsFetchOffset
|
|
updatedState.totalCount = max(updatedState.totalCount, state.totalCount)
|
|
updatedState.version = max(updatedState.version, updatedState.version)
|
|
|
|
strongSelf.stateValue.state = updatedState
|
|
|
|
if strongSelf.shouldResetStateFromServer {
|
|
strongSelf.resetStateFromServer()
|
|
}
|
|
}))
|
|
}
|
|
}
|
|
|
|
extension GroupCallParticipantsContext.Update.StateUpdate.ParticipantUpdate {
|
|
init(_ apiParticipant: Api.GroupCallParticipant) {
|
|
switch apiParticipant {
|
|
case let .groupCallParticipant(flags, apiPeerId, date, activeDate, source, volume, about, raiseHandRating, video, presentation):
|
|
let peerId: PeerId = apiPeerId.peerId
|
|
let ssrc = UInt32(bitPattern: source)
|
|
let muted = (flags & (1 << 0)) != 0
|
|
let mutedByYou = (flags & (1 << 9)) != 0
|
|
var muteState: GroupCallParticipantsContext.Participant.MuteState?
|
|
if muted {
|
|
let canUnmute = (flags & (1 << 2)) != 0
|
|
muteState = GroupCallParticipantsContext.Participant.MuteState(canUnmute: canUnmute, mutedByYou: mutedByYou)
|
|
} else if mutedByYou {
|
|
muteState = GroupCallParticipantsContext.Participant.MuteState(canUnmute: false, mutedByYou: mutedByYou)
|
|
}
|
|
let isRemoved = (flags & (1 << 1)) != 0
|
|
let justJoined = (flags & (1 << 4)) != 0
|
|
let joinedVideo = (flags & (1 << 15)) != 0
|
|
let isMin = (flags & (1 << 8)) != 0
|
|
|
|
let participationStatusChange: GroupCallParticipantsContext.Update.StateUpdate.ParticipantUpdate.ParticipationStatusChange
|
|
if isRemoved {
|
|
participationStatusChange = .left
|
|
} else if justJoined {
|
|
participationStatusChange = .joined
|
|
} else {
|
|
participationStatusChange = .none
|
|
}
|
|
|
|
var videoDescription = video.flatMap(GroupCallParticipantsContext.Participant.VideoDescription.init)
|
|
var presentationDescription = presentation.flatMap(GroupCallParticipantsContext.Participant.VideoDescription.init)
|
|
if muteState?.canUnmute == false {
|
|
videoDescription = nil
|
|
presentationDescription = nil
|
|
}
|
|
self.init(
|
|
peerId: peerId,
|
|
ssrc: ssrc,
|
|
videoDescription: videoDescription,
|
|
presentationDescription: presentationDescription,
|
|
joinTimestamp: date,
|
|
activityTimestamp: activeDate.flatMap(Double.init),
|
|
raiseHandRating: raiseHandRating,
|
|
muteState: muteState,
|
|
participationStatusChange: participationStatusChange,
|
|
volume: volume,
|
|
about: about,
|
|
joinedVideo: joinedVideo,
|
|
isMin: isMin
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension GroupCallParticipantsContext.Update.StateUpdate {
|
|
init(participants: [Api.GroupCallParticipant], version: Int32, removePendingMuteStates: Set<PeerId> = Set()) {
|
|
self.init(
|
|
participantUpdates: participants.map { GroupCallParticipantsContext.Update.StateUpdate.ParticipantUpdate($0) },
|
|
version: version,
|
|
removePendingMuteStates: removePendingMuteStates
|
|
)
|
|
}
|
|
}
|
|
|
|
public enum InviteToGroupCallError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_inviteToGroupCall(account: Account, callId: Int64, accessHash: Int64, peerId: PeerId) -> Signal<Never, InviteToGroupCallError> {
|
|
return account.postbox.transaction { transaction -> Peer? in
|
|
return transaction.getPeer(peerId)
|
|
}
|
|
|> castError(InviteToGroupCallError.self)
|
|
|> mapToSignal { user -> Signal<Never, InviteToGroupCallError> in
|
|
guard let user = user else {
|
|
return .fail(.generic)
|
|
}
|
|
guard let apiUser = apiInputUser(user) else {
|
|
return .fail(.generic)
|
|
}
|
|
|
|
return account.network.request(Api.functions.phone.inviteToGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash), users: [apiUser]))
|
|
|> mapError { _ -> InviteToGroupCallError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<Never, InviteToGroupCallError> in
|
|
account.stateManager.addUpdates(result)
|
|
|
|
return .complete()
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct GroupCallInviteLinks {
|
|
public let listenerLink: String
|
|
public let speakerLink: String?
|
|
|
|
public init(listenerLink: String, speakerLink: String?) {
|
|
self.listenerLink = listenerLink
|
|
self.speakerLink = speakerLink
|
|
}
|
|
}
|
|
|
|
func _internal_groupCallInviteLinks(account: Account, reference: InternalGroupCallReference, isConference: Bool) -> Signal<GroupCallInviteLinks?, NoError> {
|
|
let call = reference.apiInputGroupCall
|
|
let listenerInvite: Signal<String?, NoError> = account.network.request(Api.functions.phone.exportGroupCallInvite(flags: 0, call: call))
|
|
|> map(Optional.init)
|
|
|> `catch` { _ -> Signal<Api.phone.ExportedGroupCallInvite?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
|> mapToSignal { result -> Signal<String?, NoError> in
|
|
if let result = result, case let .exportedGroupCallInvite(link) = result {
|
|
return .single(link)
|
|
}
|
|
return .single(nil)
|
|
}
|
|
|
|
let speakerInvite: Signal<String?, NoError> = account.network.request(Api.functions.phone.exportGroupCallInvite(flags: 1 << 0, call: call))
|
|
|> map(Optional.init)
|
|
|> `catch` { _ -> Signal<Api.phone.ExportedGroupCallInvite?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
|> mapToSignal { result -> Signal<String?, NoError> in
|
|
if let result = result, case let .exportedGroupCallInvite(link) = result {
|
|
return .single(link)
|
|
}
|
|
return .single(nil)
|
|
}
|
|
|
|
if isConference {
|
|
return speakerInvite
|
|
|> map { speakerLink -> GroupCallInviteLinks? in
|
|
guard let speakerLink = speakerLink else {
|
|
return nil
|
|
}
|
|
return GroupCallInviteLinks(listenerLink: speakerLink, speakerLink: speakerLink)
|
|
}
|
|
}
|
|
|
|
return combineLatest(listenerInvite, speakerInvite)
|
|
|> map { listenerLink, speakerLink in
|
|
|
|
if let listenerLink = listenerLink {
|
|
return GroupCallInviteLinks(listenerLink: listenerLink, speakerLink: speakerLink)
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum EditGroupCallTitleError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_editGroupCallTitle(account: Account, callId: Int64, accessHash: Int64, title: String) -> Signal<Never, EditGroupCallTitleError> {
|
|
return account.network.request(Api.functions.phone.editGroupCallTitle(call: .inputGroupCall(id: callId, accessHash: accessHash), title: title)) |> mapError { _ -> EditGroupCallTitleError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<Never, EditGroupCallTitleError> in
|
|
account.stateManager.addUpdates(result)
|
|
return .complete()
|
|
}
|
|
}
|
|
|
|
func _internal_groupCallDisplayAsAvailablePeers(accountPeerId: PeerId, network: Network, postbox: Postbox, peerId: PeerId) -> Signal<[FoundPeer], NoError> {
|
|
return postbox.transaction { transaction -> Api.InputPeer? in
|
|
return transaction.getPeer(peerId).flatMap(apiInputPeer)
|
|
}
|
|
|> mapToSignal { inputPeer in
|
|
guard let inputPeer = inputPeer else {
|
|
return .complete()
|
|
}
|
|
return network.request(Api.functions.phone.getGroupCallJoinAs(peer: inputPeer))
|
|
|> map(Optional.init)
|
|
|> `catch` { _ -> Signal<Api.phone.JoinAsPeers?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
|> mapToSignal { result -> Signal<[FoundPeer], NoError> in
|
|
guard let result = result else {
|
|
return .single([])
|
|
}
|
|
switch result {
|
|
case let .joinAsPeers(_, chats, users):
|
|
return postbox.transaction { transaction -> [FoundPeer] in
|
|
var subscribers: [PeerId: Int32] = [:]
|
|
let parsedPeers = AccumulatedPeers(transaction: transaction, chats: chats, users: users)
|
|
for chat in chats {
|
|
if let groupOrChannel = parseTelegramGroupOrChannel(chat: chat) {
|
|
switch chat {
|
|
case let .channel(_, _, _, _, _, _, _, _, _, _, _, _, participantsCount, _, _, _, _, _, _, _, _, _):
|
|
if let participantsCount = participantsCount {
|
|
subscribers[groupOrChannel.id] = participantsCount
|
|
}
|
|
case let .chat(_, _, _, _, participantsCount, _, _, _, _, _):
|
|
subscribers[groupOrChannel.id] = participantsCount
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
updatePeers(transaction: transaction, accountPeerId: accountPeerId, peers: parsedPeers)
|
|
|
|
var peers: [Peer] = []
|
|
for chat in chats {
|
|
if let peer = transaction.getPeer(chat.peerId) {
|
|
peers.append(peer)
|
|
}
|
|
}
|
|
|
|
return peers.map { FoundPeer(peer: $0, subscribers: subscribers[$0.id]) }
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
public final class CachedDisplayAsPeers: Codable {
|
|
public let peerIds: [PeerId]
|
|
public let timestamp: Int32
|
|
|
|
public init(peerIds: [PeerId], timestamp: Int32) {
|
|
self.peerIds = peerIds
|
|
self.timestamp = timestamp
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: StringCodingKey.self)
|
|
|
|
self.peerIds = (try container.decode([Int64].self, forKey: "peerIds")).map(PeerId.init)
|
|
self.timestamp = try container.decode(Int32.self, forKey: "timestamp")
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: StringCodingKey.self)
|
|
|
|
try container.encode(self.peerIds.map { $0.toInt64() }, forKey: "peerIds")
|
|
try container.encode(self.timestamp, forKey: "timestamp")
|
|
}
|
|
}
|
|
|
|
func _internal_clearCachedGroupCallDisplayAsAvailablePeers(account: Account, peerId: PeerId) -> Signal<Never, NoError> {
|
|
return account.postbox.transaction { transaction -> Void in
|
|
let key = ValueBoxKey(length: 8)
|
|
key.setInt64(0, value: peerId.toInt64())
|
|
transaction.removeItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedGroupCallDisplayAsPeers, key: key))
|
|
}
|
|
|> ignoreValues
|
|
}
|
|
|
|
func _internal_cachedGroupCallDisplayAsAvailablePeers(account: Account, peerId: PeerId) -> Signal<[FoundPeer], NoError> {
|
|
let key = ValueBoxKey(length: 8)
|
|
key.setInt64(0, value: peerId.toInt64())
|
|
return account.postbox.transaction { transaction -> ([FoundPeer], Int32)? in
|
|
let cached = transaction.retrieveItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedGroupCallDisplayAsPeers, key: key))?.get(CachedDisplayAsPeers.self)
|
|
if let cached = cached {
|
|
var peers: [FoundPeer] = []
|
|
for peerId in cached.peerIds {
|
|
if let peer = transaction.getPeer(peerId) {
|
|
var subscribers: Int32?
|
|
if let cachedData = transaction.getPeerCachedData(peerId: peerId) as? CachedChannelData {
|
|
subscribers = cachedData.participantsSummary.memberCount
|
|
}
|
|
peers.append(FoundPeer(peer: peer, subscribers: subscribers))
|
|
}
|
|
}
|
|
return (peers, cached.timestamp)
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|> mapToSignal { cachedPeersAndTimestamp -> Signal<[FoundPeer], NoError> in
|
|
let currentTimestamp = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
|
|
if let (cachedPeers, timestamp) = cachedPeersAndTimestamp, currentTimestamp - timestamp < 60 * 3 && !cachedPeers.isEmpty {
|
|
return .single(cachedPeers)
|
|
} else {
|
|
return _internal_groupCallDisplayAsAvailablePeers(accountPeerId: account.peerId, network: account.network, postbox: account.postbox, peerId: peerId)
|
|
|> mapToSignal { peers -> Signal<[FoundPeer], NoError> in
|
|
return account.postbox.transaction { transaction -> [FoundPeer] in
|
|
let currentTimestamp = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
|
|
if let entry = CodableEntry(CachedDisplayAsPeers(peerIds: peers.map { $0.peer.id }, timestamp: currentTimestamp)) {
|
|
transaction.putItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedGroupCallDisplayAsPeers, key: key), entry: entry)
|
|
}
|
|
return peers
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func _internal_updatedCurrentPeerGroupCall(postbox: Postbox, network: Network, accountPeerId: PeerId, peerId: PeerId) -> Signal<CachedChannelData.ActiveCall?, NoError> {
|
|
return _internal_fetchAndUpdateCachedPeerData(accountPeerId: accountPeerId, peerId: peerId, network: network, postbox: postbox)
|
|
|> mapToSignal { _ -> Signal<CachedChannelData.ActiveCall?, NoError> in
|
|
return postbox.transaction { transaction -> CachedChannelData.ActiveCall? in
|
|
return (transaction.getPeerCachedData(peerId: peerId) as? CachedChannelData)?.activeCall
|
|
}
|
|
}
|
|
}
|
|
|
|
private func mergeAndSortParticipants(current currentParticipants: [GroupCallParticipantsContext.Participant], with updatedParticipants: [GroupCallParticipantsContext.Participant], sortAscending: Bool) -> [GroupCallParticipantsContext.Participant] {
|
|
var mergedParticipants = currentParticipants
|
|
|
|
var existingParticipantIndices: [PeerId: Int] = [:]
|
|
for i in 0 ..< mergedParticipants.count {
|
|
existingParticipantIndices[mergedParticipants[i].peer.id] = i
|
|
}
|
|
for participant in updatedParticipants {
|
|
if let _ = existingParticipantIndices[participant.peer.id] {
|
|
} else {
|
|
existingParticipantIndices[participant.peer.id] = mergedParticipants.count
|
|
mergedParticipants.append(participant)
|
|
}
|
|
}
|
|
|
|
mergedParticipants.sort(by: { GroupCallParticipantsContext.Participant.compare(lhs: $0, rhs: $1, sortAscending: sortAscending) })
|
|
|
|
return mergedParticipants
|
|
}
|
|
|
|
public final class AudioBroadcastDataSource {
|
|
let download: Download
|
|
|
|
fileprivate init(download: Download) {
|
|
self.download = download
|
|
}
|
|
}
|
|
|
|
func _internal_getAudioBroadcastDataSource(account: Account, callId: Int64, accessHash: Int64) -> Signal<AudioBroadcastDataSource?, NoError> {
|
|
return account.network.request(Api.functions.phone.getGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash), limit: 4))
|
|
|> map(Optional.init)
|
|
|> `catch` { _ -> Signal<Api.phone.GroupCall?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
|> mapToSignal { result -> Signal<AudioBroadcastDataSource?, NoError> in
|
|
guard let result = result else {
|
|
return .single(nil)
|
|
}
|
|
switch result {
|
|
case let .groupCall(call, _, _, _, _):
|
|
if let datacenterId = GroupCallInfo(call)?.streamDcId.flatMap(Int.init) {
|
|
return account.network.download(datacenterId: datacenterId, isMedia: true, tag: nil)
|
|
|> map { download -> AudioBroadcastDataSource? in
|
|
return AudioBroadcastDataSource(download: download)
|
|
}
|
|
} else {
|
|
return .single(nil)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct GetAudioBroadcastPartResult {
|
|
public enum Status {
|
|
case data(Data)
|
|
case notReady
|
|
case resyncNeeded
|
|
case rejoinNeeded
|
|
}
|
|
|
|
public var status: Status
|
|
public var responseTimestamp: Double
|
|
|
|
public init(status: Status, responseTimestamp: Double) {
|
|
self.status = status
|
|
self.responseTimestamp = responseTimestamp
|
|
}
|
|
}
|
|
|
|
func _internal_getAudioBroadcastPart(dataSource: AudioBroadcastDataSource, callId: Int64, accessHash: Int64, timestampIdMilliseconds: Int64, durationMilliseconds: Int64) -> Signal<GetAudioBroadcastPartResult, NoError> {
|
|
let scale: Int32
|
|
switch durationMilliseconds {
|
|
case 1000:
|
|
scale = 0
|
|
case 500:
|
|
scale = 1
|
|
default:
|
|
return .single(GetAudioBroadcastPartResult(status: .notReady, responseTimestamp: Double(timestampIdMilliseconds) / 1000.0))
|
|
}
|
|
|
|
return dataSource.download.requestWithAdditionalData(Api.functions.upload.getFile(flags: 0, location: .inputGroupCallStream(flags: 0, call: .inputGroupCall(id: callId, accessHash: accessHash), timeMs: timestampIdMilliseconds, scale: scale, videoChannel: nil, videoQuality: nil), offset: 0, limit: 128 * 1024), automaticFloodWait: false, failOnServerErrors: true)
|
|
|> map { result, responseTimestamp -> GetAudioBroadcastPartResult in
|
|
switch result {
|
|
case let .file(_, _, bytes):
|
|
return GetAudioBroadcastPartResult(
|
|
status: .data(bytes.makeData()),
|
|
responseTimestamp: responseTimestamp
|
|
)
|
|
case .fileCdnRedirect:
|
|
return GetAudioBroadcastPartResult(
|
|
status: .notReady,
|
|
responseTimestamp: responseTimestamp
|
|
)
|
|
}
|
|
}
|
|
|> `catch` { error, responseTimestamp -> Signal<GetAudioBroadcastPartResult, NoError> in
|
|
if error.errorDescription == "GROUPCALL_JOIN_MISSING" {
|
|
return .single(GetAudioBroadcastPartResult(
|
|
status: .rejoinNeeded,
|
|
responseTimestamp: responseTimestamp
|
|
))
|
|
} else if error.errorDescription.hasPrefix("FLOOD_WAIT") || error.errorDescription == "TIME_TOO_BIG" {
|
|
return .single(GetAudioBroadcastPartResult(
|
|
status: .notReady,
|
|
responseTimestamp: responseTimestamp
|
|
))
|
|
} else if error.errorDescription == "TIME_INVALID" || error.errorDescription == "TIME_TOO_SMALL" {
|
|
return .single(GetAudioBroadcastPartResult(
|
|
status: .resyncNeeded,
|
|
responseTimestamp: responseTimestamp
|
|
))
|
|
} else {
|
|
return .single(GetAudioBroadcastPartResult(
|
|
status: .resyncNeeded,
|
|
responseTimestamp: responseTimestamp
|
|
))
|
|
}
|
|
}
|
|
}
|
|
|
|
func _internal_getVideoBroadcastPart(dataSource: AudioBroadcastDataSource, callId: Int64, accessHash: Int64, timestampIdMilliseconds: Int64, durationMilliseconds: Int64, channelId: Int32, quality: Int32) -> Signal<GetAudioBroadcastPartResult, NoError> {
|
|
let scale: Int32
|
|
switch durationMilliseconds {
|
|
case 1000:
|
|
scale = 0
|
|
case 500:
|
|
scale = 1
|
|
case 32000:
|
|
scale = -5
|
|
default:
|
|
return .single(GetAudioBroadcastPartResult(status: .notReady, responseTimestamp: Double(timestampIdMilliseconds) / 1000.0))
|
|
}
|
|
|
|
return dataSource.download.requestWithAdditionalData(Api.functions.upload.getFile(flags: 0, location: .inputGroupCallStream(flags: 1 << 0, call: .inputGroupCall(id: callId, accessHash: accessHash), timeMs: timestampIdMilliseconds, scale: scale, videoChannel: channelId, videoQuality: quality), offset: 0, limit: 512 * 1024), automaticFloodWait: false, failOnServerErrors: true)
|
|
|> map { result, responseTimestamp -> GetAudioBroadcastPartResult in
|
|
switch result {
|
|
case let .file(_, _, bytes):
|
|
return GetAudioBroadcastPartResult(
|
|
status: .data(bytes.makeData()),
|
|
responseTimestamp: responseTimestamp
|
|
)
|
|
case .fileCdnRedirect:
|
|
return GetAudioBroadcastPartResult(
|
|
status: .notReady,
|
|
responseTimestamp: responseTimestamp
|
|
)
|
|
}
|
|
}
|
|
|> `catch` { error, responseTimestamp -> Signal<GetAudioBroadcastPartResult, NoError> in
|
|
if error.errorDescription == "GROUPCALL_JOIN_MISSING" {
|
|
return .single(GetAudioBroadcastPartResult(
|
|
status: .rejoinNeeded,
|
|
responseTimestamp: responseTimestamp
|
|
))
|
|
} else if error.errorDescription.hasPrefix("FLOOD_WAIT") || error.errorDescription == "TIME_TOO_BIG" {
|
|
return .single(GetAudioBroadcastPartResult(
|
|
status: .notReady,
|
|
responseTimestamp: responseTimestamp
|
|
))
|
|
} else if error.errorDescription == "TIME_INVALID" || error.errorDescription == "TIME_TOO_SMALL" || error.errorDescription.hasSuffix("_CHANNEL_INVALID") {
|
|
return .single(GetAudioBroadcastPartResult(
|
|
status: .resyncNeeded,
|
|
responseTimestamp: responseTimestamp
|
|
))
|
|
} else {
|
|
return .single(GetAudioBroadcastPartResult(
|
|
status: .resyncNeeded,
|
|
responseTimestamp: responseTimestamp
|
|
))
|
|
}
|
|
}
|
|
}
|
|
|
|
extension GroupCallParticipantsContext.Participant {
|
|
init?(_ apiParticipant: Api.GroupCallParticipant, transaction: Transaction) {
|
|
switch apiParticipant {
|
|
case let .groupCallParticipant(flags, apiPeerId, date, activeDate, source, volume, about, raiseHandRating, video, presentation):
|
|
let peerId: PeerId = apiPeerId.peerId
|
|
let ssrc = UInt32(bitPattern: source)
|
|
guard let peer = transaction.getPeer(peerId) else {
|
|
return nil
|
|
}
|
|
let muted = (flags & (1 << 0)) != 0
|
|
let mutedByYou = (flags & (1 << 9)) != 0
|
|
var muteState: GroupCallParticipantsContext.Participant.MuteState?
|
|
if muted {
|
|
let canUnmute = (flags & (1 << 2)) != 0
|
|
muteState = GroupCallParticipantsContext.Participant.MuteState(canUnmute: canUnmute, mutedByYou: mutedByYou)
|
|
} else if mutedByYou {
|
|
muteState = GroupCallParticipantsContext.Participant.MuteState(canUnmute: false, mutedByYou: mutedByYou)
|
|
}
|
|
|
|
var videoDescription = video.flatMap(GroupCallParticipantsContext.Participant.VideoDescription.init)
|
|
var presentationDescription = presentation.flatMap(GroupCallParticipantsContext.Participant.VideoDescription.init)
|
|
if muteState?.canUnmute == false {
|
|
videoDescription = nil
|
|
presentationDescription = nil
|
|
}
|
|
let joinedVideo = (flags & (1 << 15)) != 0
|
|
|
|
self.init(
|
|
peer: peer,
|
|
ssrc: ssrc,
|
|
videoDescription: videoDescription,
|
|
presentationDescription: presentationDescription,
|
|
joinTimestamp: date,
|
|
raiseHandRating: raiseHandRating,
|
|
hasRaiseHand: raiseHandRating != nil,
|
|
activityTimestamp: activeDate.flatMap(Double.init),
|
|
activityRank: nil,
|
|
muteState: muteState,
|
|
volume: volume,
|
|
about: about,
|
|
joinedVideo: joinedVideo
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
private extension GroupCallParticipantsContext.Participant.VideoDescription {
|
|
init(_ apiVideo: Api.GroupCallParticipantVideo) {
|
|
switch apiVideo {
|
|
case let .groupCallParticipantVideo(flags, endpoint, sourceGroups, audioSource):
|
|
var parsedSsrcGroups: [SsrcGroup] = []
|
|
for group in sourceGroups {
|
|
switch group {
|
|
case let .groupCallParticipantVideoSourceGroup(semantics, sources):
|
|
parsedSsrcGroups.append(SsrcGroup(semantics: semantics, ssrcs: sources.map(UInt32.init(bitPattern:))))
|
|
}
|
|
}
|
|
let isPaused = (flags & (1 << 0)) != 0
|
|
self.init(endpointId: endpoint, ssrcGroups: parsedSsrcGroups, audioSsrc: audioSource.flatMap(UInt32.init(bitPattern:)), isPaused: isPaused)
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct GroupCallStreamCredentials : Equatable {
|
|
public var url: String
|
|
public var streamKey: String
|
|
}
|
|
|
|
public enum GetGroupCallStreamCredentialsError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_getGroupCallStreamCredentials(account: Account, peerId: PeerId, revokePreviousCredentials: Bool) -> Signal<GroupCallStreamCredentials, GetGroupCallStreamCredentialsError> {
|
|
return account.postbox.transaction { transaction -> Api.InputPeer? in
|
|
return transaction.getPeer(peerId).flatMap(apiInputPeer)
|
|
}
|
|
|> castError(GetGroupCallStreamCredentialsError.self)
|
|
|> mapToSignal { inputPeer -> Signal<GroupCallStreamCredentials, GetGroupCallStreamCredentialsError> in
|
|
guard let inputPeer = inputPeer else {
|
|
return .fail(.generic)
|
|
}
|
|
|
|
return account.network.request(Api.functions.phone.getGroupCallStreamRtmpUrl(peer: inputPeer, revoke: revokePreviousCredentials ? .boolTrue : .boolFalse))
|
|
|> mapError { _ -> GetGroupCallStreamCredentialsError in
|
|
return .generic
|
|
}
|
|
|> map { result -> GroupCallStreamCredentials in
|
|
switch result {
|
|
case let .groupCallStreamRtmpUrl(url, key):
|
|
return GroupCallStreamCredentials(url: url, streamKey: key)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum CreateConferenceCallError {
|
|
case generic
|
|
}
|
|
|
|
public final class EngineCreatedGroupCall {
|
|
public let slug: String
|
|
public let link: String
|
|
public let callInfo: GroupCallInfo
|
|
|
|
public init(slug: String, link: String, callInfo: GroupCallInfo) {
|
|
self.slug = slug
|
|
self.link = link
|
|
self.callInfo = callInfo
|
|
}
|
|
}
|
|
|
|
func _internal_createConferenceCall(postbox: Postbox, network: Network, accountPeerId: PeerId) -> Signal<EngineCreatedGroupCall, CreateConferenceCallError> {
|
|
return network.request(Api.functions.phone.createConferenceCall(randomId: Int32.random(in: Int32.min ... Int32.max)))
|
|
|> mapError { _ -> CreateConferenceCallError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result in
|
|
switch result {
|
|
case let .groupCall(call, participants, _, chats, users):
|
|
return postbox.transaction { transaction -> Signal<EngineCreatedGroupCall, CreateConferenceCallError> in
|
|
guard let info = GroupCallInfo(call) else {
|
|
return .fail(.generic)
|
|
}
|
|
|
|
let parsedPeers = AccumulatedPeers(transaction: transaction, chats: chats, users: users)
|
|
|
|
updatePeers(transaction: transaction, accountPeerId: accountPeerId, peers: parsedPeers)
|
|
|
|
let parsedParticipants = participants.compactMap { GroupCallParticipantsContext.Participant($0, transaction: transaction) }
|
|
let _ = parsedParticipants
|
|
|
|
let speakerInvite: Signal<EngineCreatedGroupCall, CreateConferenceCallError> = network.request(Api.functions.phone.exportGroupCallInvite(flags: 1 << 0, call: .inputGroupCall(id: info.id, accessHash: info.accessHash)))
|
|
|> map(Optional.init)
|
|
|> `catch` { _ -> Signal<Api.phone.ExportedGroupCallInvite?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
|> castError(CreateConferenceCallError.self)
|
|
|> mapToSignal { result -> Signal<EngineCreatedGroupCall, CreateConferenceCallError> in
|
|
if let result, case let .exportedGroupCallInvite(link) = result {
|
|
let slug = link.components(separatedBy: "/").last ?? link
|
|
return .single(EngineCreatedGroupCall(
|
|
slug: slug,
|
|
link: link,
|
|
callInfo: info
|
|
))
|
|
}
|
|
return .fail(.generic)
|
|
}
|
|
return speakerInvite
|
|
}
|
|
|> mapError { _ -> CreateConferenceCallError in
|
|
}
|
|
|> switchToLatest
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum RevokeConferenceInviteLinkError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_revokeConferenceInviteLink(account: Account, reference: InternalGroupCallReference, link: String) -> Signal<GroupCallInviteLinks, RevokeConferenceInviteLinkError> {
|
|
return account.network.request(Api.functions.phone.toggleGroupCallSettings(flags: 1 << 1, call: reference.apiInputGroupCall, joinMuted: .boolFalse))
|
|
|> mapError { _ -> RevokeConferenceInviteLinkError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<GroupCallInviteLinks, RevokeConferenceInviteLinkError> in
|
|
account.stateManager.addUpdates(result)
|
|
|
|
return _internal_groupCallInviteLinks(account: account, reference: reference, isConference: true)
|
|
|> castError(RevokeConferenceInviteLinkError.self)
|
|
|> mapToSignal { result -> Signal<GroupCallInviteLinks, RevokeConferenceInviteLinkError> in
|
|
guard let result = result else {
|
|
return .fail(.generic)
|
|
}
|
|
return .single(result)
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum ConfirmAddConferenceParticipantError {
|
|
case generic
|
|
}
|
|
|
|
func _internal_pollConferenceCallBlockchain(network: Network, reference: InternalGroupCallReference, subChainId: Int, offset: Int, limit: Int) -> Signal<(blocks: [Data], nextOffset: Int)?, NoError> {
|
|
return network.request(Api.functions.phone.getGroupCallChainBlocks(call: reference.apiInputGroupCall, subChainId: Int32(subChainId), offset: Int32(offset), limit: Int32(limit)))
|
|
|> map(Optional.init)
|
|
|> `catch` { error -> Signal<Api.Updates?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
|> map { result -> (blocks: [Data], nextOffset: Int)? in
|
|
guard let result = result else {
|
|
return nil
|
|
}
|
|
var blocks: [Data] = []
|
|
var nextOffset: Int?
|
|
for update in result.allUpdates {
|
|
switch update {
|
|
case let .updateGroupCallChainBlocks(_, updateSubChainId, updateBlocks, updateNextOffset):
|
|
if updateSubChainId == Int32(subChainId) {
|
|
blocks.append(contentsOf: updateBlocks.map { $0.makeData() })
|
|
nextOffset = Int(updateNextOffset)
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
guard let nextOffset = nextOffset else {
|
|
return nil
|
|
}
|
|
return (blocks: blocks, nextOffset: nextOffset)
|
|
}
|
|
}
|
|
|
|
func _internal_sendConferenceCallBroadcast(account: Account, callId: Int64, accessHash: Int64, block: Data) -> Signal<Never, NoError> {
|
|
return account.network.request(Api.functions.phone.sendConferenceCallBroadcast(call: .inputGroupCall(id: callId, accessHash: accessHash), block: Buffer(data: block)))
|
|
|> retry(retryOnError: { _ in
|
|
return true
|
|
}, delayIncrement: 0.1, maxDelay: 1.0, maxRetries: 5, onQueue: Queue.concurrentDefaultQueue())
|
|
|> map(Optional.init)
|
|
|> `catch` { error -> Signal<Api.Updates?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
|> mapToSignal { result -> Signal<Never, NoError> in
|
|
guard let result = result else {
|
|
return .complete()
|
|
}
|
|
account.stateManager.addUpdates(result)
|
|
|
|
return .complete()
|
|
}
|
|
}
|
|
|
|
func _internal_refreshInlineGroupCall(account: Account, messageId: MessageId) -> Signal<Never, NoError> {
|
|
return _internal_getCurrentGroupCallInfo(account: account, reference: .message(id: messageId))
|
|
|> mapToSignal { result -> Signal<Never, NoError> in
|
|
return account.postbox.transaction { transaction -> Void in
|
|
transaction.updateMessage(messageId, update: { currentMessage in
|
|
var storeForwardInfo: StoreMessageForwardInfo?
|
|
if let forwardInfo = currentMessage.forwardInfo {
|
|
storeForwardInfo = StoreMessageForwardInfo(authorId: forwardInfo.author?.id, sourceId: forwardInfo.source?.id, sourceMessageId: forwardInfo.sourceMessageId, date: forwardInfo.date, authorSignature: forwardInfo.authorSignature, psaType: forwardInfo.psaType, flags: forwardInfo.flags)
|
|
}
|
|
var updatedMedia = currentMessage.media
|
|
|
|
for i in 0 ..< updatedMedia.count {
|
|
if let action = updatedMedia[i] as? TelegramMediaAction, case let .conferenceCall(conferenceCall) = action.action {
|
|
let otherParticipants: [PeerId] = conferenceCall.otherParticipants
|
|
var duration: Int32? = conferenceCall.duration
|
|
if let result {
|
|
duration = result.duration
|
|
} else {
|
|
duration = nil
|
|
}
|
|
|
|
updatedMedia[i] = TelegramMediaAction(action: .conferenceCall(TelegramMediaActionType.ConferenceCall(
|
|
callId: conferenceCall.callId,
|
|
duration: duration,
|
|
flags: conferenceCall.flags,
|
|
otherParticipants: otherParticipants
|
|
)))
|
|
}
|
|
}
|
|
return .update(StoreMessage(
|
|
id: currentMessage.id,
|
|
globallyUniqueId: currentMessage.globallyUniqueId,
|
|
groupingKey: currentMessage.groupingKey,
|
|
threadId: currentMessage.threadId,
|
|
timestamp: currentMessage.timestamp,
|
|
flags: StoreMessageFlags(currentMessage.flags),
|
|
tags: currentMessage.tags,
|
|
globalTags: currentMessage.globalTags,
|
|
localTags: currentMessage.localTags,
|
|
forwardInfo: storeForwardInfo,
|
|
authorId: currentMessage.author?.id,
|
|
text: currentMessage.text,
|
|
attributes: currentMessage.attributes,
|
|
media: updatedMedia
|
|
))
|
|
})
|
|
}
|
|
|> ignoreValues
|
|
}
|
|
}
|