-update api [skip ci]

2025-06-16 05:55:20 +00:00 · 2021-03-09 11:54:18 +04:00 · 2021-03-09 11:54:18 +04:00 · e310a63ecd
commit e310a63ecd
parent 6790b2426f
5 changed files with 135 additions and 46 deletions
--- a/submodules/SSignalKit/SwiftSignalKit/Source/ThreadPool.swift
+++ b/submodules/SSignalKit/SwiftSignalKit/Source/ThreadPool.swift
@ -12,7 +12,7 @@ public final class ThreadPoolTask {
        self.action = action
    }
    
-    func execute() {
+    public func execute() {
        if !state.cancelled.with({ $0 })  {
            self.action(self.state)
        }
--- a/submodules/TelegramApi/Sources/Api0.swift
+++ b/submodules/TelegramApi/Sources/Api0.swift
@ -500,6 +500,7 @@ fileprivate let parsers: [Int32 : (BufferReader) -> Any?] = {
    dict[-1038136962] = { return Api.EncryptedFile.parse_encryptedFileEmpty($0) }
    dict[1248893260] = { return Api.EncryptedFile.parse_encryptedFile($0) }
    dict[-557924733] = { return Api.CodeSettings.parse_codeSettings($0) }
+    dict[-1343921601] = { return Api.phone.JoinAsPeers.parse_joinAsPeers($0) }
    dict[-391902247] = { return Api.SecureValueError.parse_secureValueErrorData($0) }
    dict[12467706] = { return Api.SecureValueError.parse_secureValueErrorFrontSide($0) }
    dict[-2037765467] = { return Api.SecureValueError.parse_secureValueErrorReverseSide($0) }
@ -667,7 +668,7 @@ fileprivate let parsers: [Int32 : (BufferReader) -> Any?] = {
    dict[-667654413] = { return Api.InputFileLocation.parse_inputPhotoLegacyFileLocation($0) }
    dict[668375447] = { return Api.InputFileLocation.parse_inputPeerPhotoFileLocation($0) }
    dict[230353641] = { return Api.InputFileLocation.parse_inputStickerSetThumb($0) }
-    dict[-775148961] = { return Api.InputFileLocation.parse_inputGroupCallStream($0) }
+    dict[-1146808775] = { return Api.InputFileLocation.parse_inputGroupCallStream($0) }
    dict[286776671] = { return Api.GeoPoint.parse_geoPointEmpty($0) }
    dict[-1297942941] = { return Api.GeoPoint.parse_geoPoint($0) }
    dict[506920429] = { return Api.InputPhoneCall.parse_inputPhoneCall($0) }
@ -1246,6 +1247,8 @@ public struct Api {
                _1.serialize(buffer, boxed)
            case let _1 as Api.CodeSettings:
                _1.serialize(buffer, boxed)
+            case let _1 as Api.phone.JoinAsPeers:
+                _1.serialize(buffer, boxed)
            case let _1 as Api.SecureValueError:
                _1.serialize(buffer, boxed)
            case let _1 as Api.InputStickerSetItem:
--- a/submodules/TelegramApi/Sources/Api2.swift
+++ b/submodules/TelegramApi/Sources/Api2.swift
@ -17025,7 +17025,7 @@ public extension Api {
        case inputPhotoLegacyFileLocation(id: Int64, accessHash: Int64, fileReference: Buffer, volumeId: Int64, localId: Int32, secret: Int64)
        case inputPeerPhotoFileLocation(flags: Int32, peer: Api.InputPeer, volumeId: Int64, localId: Int32)
        case inputStickerSetThumb(stickerset: Api.InputStickerSet, volumeId: Int64, localId: Int32)
-        case inputGroupCallStream(call: Api.InputGroupCall, date: Int32)
+        case inputGroupCallStream(call: Api.InputGroupCall, timeMs: Int64, scale: Int32)
    
    public func serialize(_ buffer: Buffer, _ boxed: Swift.Bool) {
    switch self {
@ -17104,12 +17104,13 @@ public extension Api {
                    serializeInt64(volumeId, buffer: buffer, boxed: false)
                    serializeInt32(localId, buffer: buffer, boxed: false)
                    break
-                case .inputGroupCallStream(let call, let date):
+                case .inputGroupCallStream(let call, let timeMs, let scale):
                    if boxed {
-                        buffer.appendInt32(-775148961)
+                        buffer.appendInt32(-1146808775)
                    }
                    call.serialize(buffer, true)
-                    serializeInt32(date, buffer: buffer, boxed: false)
+                    serializeInt64(timeMs, buffer: buffer, boxed: false)
+                    serializeInt32(scale, buffer: buffer, boxed: false)
                    break
    }
    }
@ -17134,8 +17135,8 @@ public extension Api {
                return ("inputPeerPhotoFileLocation", [("flags", flags), ("peer", peer), ("volumeId", volumeId), ("localId", localId)])
                case .inputStickerSetThumb(let stickerset, let volumeId, let localId):
                return ("inputStickerSetThumb", [("stickerset", stickerset), ("volumeId", volumeId), ("localId", localId)])
-                case .inputGroupCallStream(let call, let date):
-                return ("inputGroupCallStream", [("call", call), ("date", date)])
+                case .inputGroupCallStream(let call, let timeMs, let scale):
+                return ("inputGroupCallStream", [("call", call), ("timeMs", timeMs), ("scale", scale)])
    }
    }
    
@ -17302,12 +17303,15 @@ public extension Api {
            if let signature = reader.readInt32() {
                _1 = Api.parse(reader, signature: signature) as? Api.InputGroupCall
            }
-            var _2: Int32?
-            _2 = reader.readInt32()
+            var _2: Int64?
+            _2 = reader.readInt64()
+            var _3: Int32?
+            _3 = reader.readInt32()
            let _c1 = _1 != nil
            let _c2 = _2 != nil
-            if _c1 && _c2 {
-                return Api.InputFileLocation.inputGroupCallStream(call: _1!, date: _2!)
+            let _c3 = _3 != nil
+            if _c1 && _c2 && _c3 {
+                return Api.InputFileLocation.inputGroupCallStream(call: _1!, timeMs: _2!, scale: _3!)
            }
            else {
                return nil
--- a/submodules/TelegramApi/Sources/Api4.swift
+++ b/submodules/TelegramApi/Sources/Api4.swift
@ -1610,6 +1610,66 @@ public struct photos {
 }
 public extension Api {
 public struct phone {
+    public enum JoinAsPeers: TypeConstructorDescription {
+        case joinAsPeers(peers: [Api.Peer], chats: [Api.Chat], users: [Api.User])
+    
+    public func serialize(_ buffer: Buffer, _ boxed: Swift.Bool) {
+    switch self {
+                case .joinAsPeers(let peers, let chats, let users):
+                    if boxed {
+                        buffer.appendInt32(-1343921601)
+                    }
+                    buffer.appendInt32(481674261)
+                    buffer.appendInt32(Int32(peers.count))
+                    for item in peers {
+                        item.serialize(buffer, true)
+                    }
+                    buffer.appendInt32(481674261)
+                    buffer.appendInt32(Int32(chats.count))
+                    for item in chats {
+                        item.serialize(buffer, true)
+                    }
+                    buffer.appendInt32(481674261)
+                    buffer.appendInt32(Int32(users.count))
+                    for item in users {
+                        item.serialize(buffer, true)
+                    }
+                    break
+    }
+    }
+    
+    public func descriptionFields() -> (String, [(String, Any)]) {
+        switch self {
+                case .joinAsPeers(let peers, let chats, let users):
+                return ("joinAsPeers", [("peers", peers), ("chats", chats), ("users", users)])
+    }
+    }
+    
+        public static func parse_joinAsPeers(_ reader: BufferReader) -> JoinAsPeers? {
+            var _1: [Api.Peer]?
+            if let _ = reader.readInt32() {
+                _1 = Api.parseVector(reader, elementSignature: 0, elementType: Api.Peer.self)
+            }
+            var _2: [Api.Chat]?
+            if let _ = reader.readInt32() {
+                _2 = Api.parseVector(reader, elementSignature: 0, elementType: Api.Chat.self)
+            }
+            var _3: [Api.User]?
+            if let _ = reader.readInt32() {
+                _3 = Api.parseVector(reader, elementSignature: 0, elementType: Api.User.self)
+            }
+            let _c1 = _1 != nil
+            let _c2 = _2 != nil
+            let _c3 = _3 != nil
+            if _c1 && _c2 && _c3 {
+                return Api.phone.JoinAsPeers.joinAsPeers(peers: _1!, chats: _2!, users: _3!)
+            }
+            else {
+                return nil
+            }
+        }
+    
+    }
    public enum GroupCall: TypeConstructorDescription {
        case groupCall(call: Api.GroupCall, participants: [Api.GroupCallParticipant], participantsNextOffset: String, chats: [Api.Chat], users: [Api.User])
    
@ -7794,6 +7854,20 @@ public extension Api {
                        return result
                    })
                }
+            
+                public static func getGroupCallJoinAs(peer: Api.InputPeer) -> (FunctionDescription, Buffer, DeserializeFunctionResponse<Api.phone.JoinAsPeers>) {
+                    let buffer = Buffer()
+                    buffer.appendInt32(-277077702)
+                    peer.serialize(buffer, true)
+                    return (FunctionDescription(name: "phone.getGroupCallJoinAs", parameters: [("peer", peer)]), buffer, DeserializeFunctionResponse { (buffer: Buffer) -> Api.phone.JoinAsPeers? in
+                        let reader = BufferReader(buffer)
+                        var result: Api.phone.JoinAsPeers?
+                        if let signature = reader.readInt32() {
+                            result = Api.parse(reader, signature: signature) as? Api.phone.JoinAsPeers
+                        }
+                        return result
+                    })
+                }
            }
    }
 }
--- a/submodules/TelegramCore/Sources/GroupCalls.swift
+++ b/submodules/TelegramCore/Sources/GroupCalls.swift
@ -1775,43 +1775,50 @@ public func editGroupCallTitle(account: Account, callId: Int64, accessHash: Int6
    }
 }

-public func groupCallDisplayAsAvailablePeers(network: Network, postbox: Postbox) -> Signal<[FoundPeer], NoError> {
-    return network.request(Api.functions.channels.getAdminedPublicChannels(flags: 1 << 2))
-    |> retryRequest
-    |> mapToSignal { result in
-        let chats: [Api.Chat]
-        switch result {
-            case let .chatsSlice(_, c):
-                chats = c
-            case let .chats(c):
-                chats = c
+public func groupCallDisplayAsAvailablePeers(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()
        }
-        var subscribers: [PeerId: Int32] = [:]
-        let peers = chats.compactMap(parseTelegramGroupOrChannel)
-        for chat in chats {
-            if let groupOrChannel = parseTelegramGroupOrChannel(chat: chat) {
-                switch chat {
-                case let .channel(_, _, _, _, _, _, _, _, _, _, _, _, participantsCount):
-                    if let participantsCount = participantsCount {
-                        subscribers[groupOrChannel.id] = participantsCount
+        return network.request(Api.functions.phone.getGroupCallJoinAs(peer: inputPeer))
+        |> retryRequest
+        |> mapToSignal { result in
+            var peers:[Peer]
+            switch result {
+            case let .joinAsPeers(peers, chats, users):
+                var subscribers: [PeerId: Int32] = [:]
+                let peers = chats.compactMap(parseTelegramGroupOrChannel)
+                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
+                        }
                    }
-                case let .chat(_, _, _, _, participantsCount, _, _, _, _, _):
-                    subscribers[groupOrChannel.id] = participantsCount
-                default:
-                    break
+                }
+                return postbox.transaction { transaction -> [Peer] in
+                    updatePeers(transaction: transaction, peers: peers, update: { _, updated in
+                        return updated
+                    })
+                    return peers
+                } |> map { peers -> [FoundPeer] in
+                    return peers.map { FoundPeer(peer: $0, subscribers: subscribers[$0.id]) }
                }
            }
        }
        
-        return postbox.transaction { transaction -> [Peer] in
-            updatePeers(transaction: transaction, peers: peers, update: { _, updated in
-                return updated
-            })
-            return peers
-        } |> map { peers -> [FoundPeer] in
-            return peers.map { FoundPeer(peer: $0, subscribers: subscribers[$0.id]) }
-        }
    }
+    
+    
 }

 public final class CachedDisplayAsPeers: PostboxCoding {
@ -1834,8 +1841,9 @@ public final class CachedDisplayAsPeers: PostboxCoding {
    }
 }

-public func cachedGroupCallDisplayAsAvailablePeers(account: Account) -> Signal<[FoundPeer], NoError> {
-    let key = ValueBoxKey(length: 0)
+public func 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)) as? CachedDisplayAsPeers
        if let cached = cached {
@ -1859,7 +1867,7 @@ public func cachedGroupCallDisplayAsAvailablePeers(account: Account) -> Signal<[
        if let (cachedPeers, timestamp) = cachedPeersAndTimestamp, currentTimestamp - timestamp < 60 * 5 {
            return .single(cachedPeers)
        } else {
-            return groupCallDisplayAsAvailablePeers(network: account.network, postbox: account.postbox)
+            return groupCallDisplayAsAvailablePeers(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)
@ -1930,7 +1938,7 @@ public struct GetAudioBroadcastPartResult {
 }

 public func getAudioBroadcastPart(account: Account, callId: Int64, accessHash: Int64, datacenterId: Int, timestampId: Int32) -> Signal<GetAudioBroadcastPartResult, NoError> {
-    return account.network.multiplexedRequestManager.requestWithAdditionalInfo(to: .main(datacenterId), consumerId: Int64.random(in: 0 ..< Int64.max), data: Api.functions.upload.getFile(flags: 0, location: .inputGroupCallStream(call: .inputGroupCall(id: callId, accessHash: accessHash), date: timestampId), offset: 0, limit: 128 * 1024), tag: nil, continueInBackground: false, automaticFloodWait: false)
+    return account.network.multiplexedRequestManager.requestWithAdditionalInfo(to: .main(datacenterId), consumerId: Int64.random(in: 0 ..< Int64.max), data: Api.functions.upload.getFile(flags: 0, location: .inputGroupCallStream(call: .inputGroupCall(id: callId, accessHash: accessHash), timeMs: 0, scale: 0), offset: 0, limit: 128 * 1024), tag: nil, continueInBackground: false, automaticFloodWait: false)
    |> map { result, responseTimestamp -> GetAudioBroadcastPartResult in
        switch result {
        case let .file(_, _, bytes):