Support new featured stickers & emoji API

2025-06-15 21:45:19 +00:00 · 2022-12-25 03:37:36 +04:00 · 2022-12-25 03:37:36 +04:00 · 7869790318
commit 7869790318
parent 07c09c3fb8
8 changed files with 147 additions and 82 deletions
--- a/submodules/TelegramApi/Sources/Api0.swift
+++ b/submodules/TelegramApi/Sources/Api0.swift
@ -754,6 +754,7 @@ fileprivate let parsers: [Int32 : (BufferReader) -> Any?] = {
    dict[1678812626] = { return Api.StickerSetCovered.parse_stickerSetCovered($0) }
    dict[1087454222] = { return Api.StickerSetCovered.parse_stickerSetFullCovered($0) }
    dict[872932635] = { return Api.StickerSetCovered.parse_stickerSetMultiCovered($0) }
+    dict[2008112412] = { return Api.StickerSetCovered.parse_stickerSetNoCovered($0) }
    dict[-1609668650] = { return Api.Theme.parse_theme($0) }
    dict[-94849324] = { return Api.ThemeSettings.parse_themeSettings($0) }
    dict[-305282981] = { return Api.TopPeer.parse_topPeer($0) }
@ -867,10 +868,10 @@ fileprivate let parsers: [Int32 : (BufferReader) -> Any?] = {
    dict[196268545] = { return Api.Update.parse_updateStickerSetsOrder($0) }
    dict[-2112423005] = { return Api.Update.parse_updateTheme($0) }
    dict[8703322] = { return Api.Update.parse_updateTranscribedAudio($0) }
+    dict[542282808] = { return Api.Update.parse_updateUser($0) }
    dict[674706841] = { return Api.Update.parse_updateUserEmojiStatus($0) }
    dict[-1484486364] = { return Api.Update.parse_updateUserName($0) }
    dict[88680979] = { return Api.Update.parse_updateUserPhone($0) }
-    dict[-232290676] = { return Api.Update.parse_updateUserPhoto($0) }
    dict[-440534818] = { return Api.Update.parse_updateUserStatus($0) }
    dict[-1071741569] = { return Api.Update.parse_updateUserTyping($0) }
    dict[2139689491] = { return Api.Update.parse_updateWebPage($0) }
--- a/submodules/TelegramApi/Sources/Api20.swift
+++ b/submodules/TelegramApi/Sources/Api20.swift
@ -181,6 +181,7 @@ public extension Api {
        case stickerSetCovered(set: Api.StickerSet, cover: Api.Document)
        case stickerSetFullCovered(set: Api.StickerSet, packs: [Api.StickerPack], keywords: [Api.StickerKeyword], documents: [Api.Document])
        case stickerSetMultiCovered(set: Api.StickerSet, covers: [Api.Document])
+        case stickerSetNoCovered(set: Api.StickerSet)
    
    public func serialize(_ buffer: Buffer, _ boxed: Swift.Bool) {
    switch self {
@ -223,6 +224,12 @@ public extension Api {
                        item.serialize(buffer, true)
                    }
                    break
+                case .stickerSetNoCovered(let set):
+                    if boxed {
+                        buffer.appendInt32(2008112412)
+                    }
+                    set.serialize(buffer, true)
+                    break
    }
    }
    
@ -234,6 +241,8 @@ public extension Api {
                return ("stickerSetFullCovered", [("set", set as Any), ("packs", packs as Any), ("keywords", keywords as Any), ("documents", documents as Any)])
                case .stickerSetMultiCovered(let set, let covers):
                return ("stickerSetMultiCovered", [("set", set as Any), ("covers", covers as Any)])
+                case .stickerSetNoCovered(let set):
+                return ("stickerSetNoCovered", [("set", set as Any)])
    }
    }
    
@ -301,6 +310,19 @@ public extension Api {
                return nil
            }
        }
+        public static func parse_stickerSetNoCovered(_ reader: BufferReader) -> StickerSetCovered? {
+            var _1: Api.StickerSet?
+            if let signature = reader.readInt32() {
+                _1 = Api.parse(reader, signature: signature) as? Api.StickerSet
+            }
+            let _c1 = _1 != nil
+            if _c1 {
+                return Api.StickerSetCovered.stickerSetNoCovered(set: _1!)
+            }
+            else {
+                return nil
+            }
+        }
    
    }
 }
@ -755,10 +777,10 @@ public extension Api {
        case updateStickerSetsOrder(flags: Int32, order: [Int64])
        case updateTheme(theme: Api.Theme)
        case updateTranscribedAudio(flags: Int32, peer: Api.Peer, msgId: Int32, transcriptionId: Int64, text: String)
+        case updateUser(userId: Int64)
        case updateUserEmojiStatus(userId: Int64, emojiStatus: Api.EmojiStatus)
        case updateUserName(userId: Int64, firstName: String, lastName: String, usernames: [Api.Username])
        case updateUserPhone(userId: Int64, phone: String)
-        case updateUserPhoto(userId: Int64, date: Int32, photo: Api.UserProfilePhoto, previous: Api.Bool)
        case updateUserStatus(userId: Int64, status: Api.UserStatus)
        case updateUserTyping(userId: Int64, action: Api.SendMessageAction)
        case updateWebPage(webpage: Api.WebPage, pts: Int32, ptsCount: Int32)
@ -1649,6 +1671,12 @@ public extension Api {
                    serializeInt64(transcriptionId, buffer: buffer, boxed: false)
                    serializeString(text, buffer: buffer, boxed: false)
                    break
+                case .updateUser(let userId):
+                    if boxed {
+                        buffer.appendInt32(542282808)
+                    }
+                    serializeInt64(userId, buffer: buffer, boxed: false)
+                    break
                case .updateUserEmojiStatus(let userId, let emojiStatus):
                    if boxed {
                        buffer.appendInt32(674706841)
@ -1676,15 +1704,6 @@ public extension Api {
                    serializeInt64(userId, buffer: buffer, boxed: false)
                    serializeString(phone, buffer: buffer, boxed: false)
                    break
-                case .updateUserPhoto(let userId, let date, let photo, let previous):
-                    if boxed {
-                        buffer.appendInt32(-232290676)
-                    }
-                    serializeInt64(userId, buffer: buffer, boxed: false)
-                    serializeInt32(date, buffer: buffer, boxed: false)
-                    photo.serialize(buffer, true)
-                    previous.serialize(buffer, true)
-                    break
                case .updateUserStatus(let userId, let status):
                    if boxed {
                        buffer.appendInt32(-440534818)
@ -1920,14 +1939,14 @@ public extension Api {
                return ("updateTheme", [("theme", theme as Any)])
                case .updateTranscribedAudio(let flags, let peer, let msgId, let transcriptionId, let text):
                return ("updateTranscribedAudio", [("flags", flags as Any), ("peer", peer as Any), ("msgId", msgId as Any), ("transcriptionId", transcriptionId as Any), ("text", text as Any)])
+                case .updateUser(let userId):
+                return ("updateUser", [("userId", userId as Any)])
                case .updateUserEmojiStatus(let userId, let emojiStatus):
                return ("updateUserEmojiStatus", [("userId", userId as Any), ("emojiStatus", emojiStatus as Any)])
                case .updateUserName(let userId, let firstName, let lastName, let usernames):
                return ("updateUserName", [("userId", userId as Any), ("firstName", firstName as Any), ("lastName", lastName as Any), ("usernames", usernames as Any)])
                case .updateUserPhone(let userId, let phone):
                return ("updateUserPhone", [("userId", userId as Any), ("phone", phone as Any)])
-                case .updateUserPhoto(let userId, let date, let photo, let previous):
-                return ("updateUserPhoto", [("userId", userId as Any), ("date", date as Any), ("photo", photo as Any), ("previous", previous as Any)])
                case .updateUserStatus(let userId, let status):
                return ("updateUserStatus", [("userId", userId as Any), ("status", status as Any)])
                case .updateUserTyping(let userId, let action):
@ -3711,6 +3730,17 @@ public extension Api {
                return nil
            }
        }
+        public static func parse_updateUser(_ reader: BufferReader) -> Update? {
+            var _1: Int64?
+            _1 = reader.readInt64()
+            let _c1 = _1 != nil
+            if _c1 {
+                return Api.Update.updateUser(userId: _1!)
+            }
+            else {
+                return nil
+            }
+        }
        public static func parse_updateUserEmojiStatus(_ reader: BufferReader) -> Update? {
            var _1: Int64?
            _1 = reader.readInt64()
@ -3763,30 +3793,6 @@ public extension Api {
                return nil
            }
        }
-        public static func parse_updateUserPhoto(_ reader: BufferReader) -> Update? {
-            var _1: Int64?
-            _1 = reader.readInt64()
-            var _2: Int32?
-            _2 = reader.readInt32()
-            var _3: Api.UserProfilePhoto?
-            if let signature = reader.readInt32() {
-                _3 = Api.parse(reader, signature: signature) as? Api.UserProfilePhoto
-            }
-            var _4: Api.Bool?
-            if let signature = reader.readInt32() {
-                _4 = Api.parse(reader, signature: signature) as? Api.Bool
-            }
-            let _c1 = _1 != nil
-            let _c2 = _2 != nil
-            let _c3 = _3 != nil
-            let _c4 = _4 != nil
-            if _c1 && _c2 && _c3 && _c4 {
-                return Api.Update.updateUserPhoto(userId: _1!, date: _2!, photo: _3!, previous: _4!)
-            }
-            else {
-                return nil
-            }
-        }
        public static func parse_updateUserStatus(_ reader: BufferReader) -> Update? {
            var _1: Int64?
            _1 = reader.readInt64()
--- a/submodules/TelegramCore/Sources/State/AccountStateManagementUtils.swift
+++ b/submodules/TelegramCore/Sources/State/AccountStateManagementUtils.swift
@ -1305,14 +1305,6 @@ private func finalStateWithUpdatesAndServerTime(accountPeerId: PeerId, postbox:
                        return peer
                    }
                })
-            case let .updateUserPhoto(userId, _, photo, _):
-                updatedState.updatePeer(PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt64Value(userId)), { peer in
-                    if let user = peer as? TelegramUser {
-                        return user.withUpdatedPhoto(parsedTelegramProfilePhoto(photo))
-                    } else {
-                        return peer
-                    }
-                })
            case let .updateUserPhone(userId, phone):
                updatedState.updatePeer(PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt64Value(userId)), { peer in
                    if let user = peer as? TelegramUser {
--- a/submodules/TelegramCore/Sources/State/ManagedSynchronizeInstalledStickerPacksOperations.swift
+++ b/submodules/TelegramCore/Sources/State/ManagedSynchronizeInstalledStickerPacksOperations.swift
@ -240,6 +240,8 @@ private func installRemoteStickerPacks(network: Network, infos: [StickerPackColl
                                archivedIds.insert(StickerPackCollectionInfo(apiSet: set, namespace: info.id.namespace).id)
                            case let .stickerSetFullCovered(set, _, _, _):
                                archivedIds.insert(StickerPackCollectionInfo(apiSet: set, namespace: info.id.namespace).id)
+                                case let .stickerSetNoCovered(set):
+                                    archivedIds.insert(StickerPackCollectionInfo(apiSet: set, namespace: info.id.namespace).id)
                            }
                        }
                        return archivedIds
--- a/submodules/TelegramCore/Sources/State/StickerManagement.swift
+++ b/submodules/TelegramCore/Sources/State/StickerManagement.swift
@ -2,6 +2,7 @@ import Foundation
 import TelegramApi
 import Postbox
 import SwiftSignalKit
+import MtProtoKit

 enum FeaturedStickerPacksCategory {
    case stickerPacks
@ -48,6 +49,52 @@ func manageStickerPacks(network: Network, postbox: Postbox) -> Signal<Void, NoEr
    } |> then(.complete() |> suspendAwareDelay(1.0 * 60.0 * 60.0, queue: Queue.concurrentDefaultQueue()))) |> restart
 }

+func resolveMissingStickerSets(network: Network, postbox: Postbox, stickerSets: [Api.StickerSetCovered], ignorePacksWithHashes: [Int64: Int32]) -> Signal<[Api.StickerSetCovered], NoError> {
+    var missingSignals: [Signal<(Int, Api.StickerSetCovered)?, NoError>] = []
+    for i in 0 ..< stickerSets.count {
+        switch stickerSets[i] {
+        case let .stickerSetNoCovered(value):
+            switch value {
+            case let .stickerSet(_, _, id, accessHash, _, _, _, _, _, _, _, hash):
+                if ignorePacksWithHashes[id] == hash {
+                    continue
+                }
+                
+                missingSignals.append(network.request(Api.functions.messages.getStickerSet(stickerset: .inputStickerSetID(id: id, accessHash: accessHash), hash: 0))
+                |> map(Optional.init)
+                |> `catch` { _ -> Signal<Api.messages.StickerSet?, NoError> in
+                    return .single(nil)
+                }
+                |> map { result -> (Int, Api.StickerSetCovered)? in
+                    if let result = result {
+                        switch result {
+                        case let .stickerSet(set, packs, keywords, documents):
+                            return (i, Api.StickerSetCovered.stickerSetFullCovered(set: set, packs: packs, keywords: keywords, documents: documents))
+                        case .stickerSetNotModified:
+                            return nil
+                        }
+                    } else {
+                        return nil
+                    }
+                })
+            }
+        default:
+            break
+        }
+    }
+    
+    return combineLatest(missingSignals)
+    |> map { results -> [Api.StickerSetCovered] in
+        var updatedSets = stickerSets
+        for result in results {
+            if let result = result {
+                updatedSets[result.0] = result.1
+            }
+        }
+        return updatedSets
+    }
+}
+
 func updatedFeaturedStickerPacks(network: Network, postbox: Postbox, category: FeaturedStickerPacksCategory) -> Signal<Void, NoError> {
    return postbox.transaction { transaction -> Signal<Void, NoError> in
        let initialPacks = transaction.getOrderedListItems(collectionId: category.itemListNamespace)
@ -75,28 +122,34 @@ func updatedFeaturedStickerPacks(network: Network, postbox: Postbox, category: F
        switch category {
        case .stickerPacks:
            signal = network.request(Api.functions.messages.getFeaturedStickers(hash: initialHash))
-            |> map { result -> FeaturedList in
+            |> mapToSignal { result -> Signal<FeaturedList, MTRpcError> in
                switch result {
                case .featuredStickersNotModified:
-                    return .notModified
+                    return .single(.notModified)
                case let .featuredStickers(flags, _, _, sets, unread):
-                    let unreadIds = Set(unread)
-                    var updatedPacks: [FeaturedStickerPackItem] = []
-                    for set in sets {
-                        var (info, items) = parsePreviewStickerSet(set, namespace: category.collectionIdNamespace)
-                        if let previousPack = initialPackMap[info.id.id] {
-                            if previousPack.info.hash == info.hash {
-                                items = previousPack.topItems
+                    return resolveMissingStickerSets(network: network, postbox: postbox, stickerSets: sets, ignorePacksWithHashes: initialPackMap.mapValues({ item in
+                        item.info.hash
+                    }))
+                    |> castError(MTRpcError.self)
+                    |> map { sets -> FeaturedList in
+                        let unreadIds = Set(unread)
+                        var updatedPacks: [FeaturedStickerPackItem] = []
+                        for set in sets {
+                            var (info, items) = parsePreviewStickerSet(set, namespace: category.collectionIdNamespace)
+                            if let previousPack = initialPackMap[info.id.id] {
+                                if previousPack.info.hash == info.hash {
+                                    items = previousPack.topItems
+                                }
                            }
+                            updatedPacks.append(FeaturedStickerPackItem(info: info, topItems: items, unread: unreadIds.contains(info.id.id)))
                        }
-                        updatedPacks.append(FeaturedStickerPackItem(info: info, topItems: items, unread: unreadIds.contains(info.id.id)))
+                        let isPremium = flags & (1 << 0) != 0
+                        return .content(FeaturedListContent(
+                            unreadIds: unreadIds,
+                            packs: updatedPacks,
+                            isPremium: isPremium
+                        ))
                    }
-                    let isPremium = flags & (1 << 0) != 0
-                    return .content(FeaturedListContent(
-                        unreadIds: unreadIds,
-                        packs: updatedPacks,
-                        isPremium: isPremium
-                    ))
                }
            }
            |> `catch` { _ -> Signal<FeaturedList, NoError> in
@ -104,28 +157,34 @@ func updatedFeaturedStickerPacks(network: Network, postbox: Postbox, category: F
            }
        case .emojiPacks:
            signal = network.request(Api.functions.messages.getFeaturedEmojiStickers(hash: initialHash))
-            |> map { result -> FeaturedList in
+            |> mapToSignal { result -> Signal<FeaturedList, MTRpcError> in
                switch result {
                case .featuredStickersNotModified:
-                    return .notModified
+                    return .single(.notModified)
                case let .featuredStickers(flags, _, _, sets, unread):
-                    let unreadIds = Set(unread)
-                    var updatedPacks: [FeaturedStickerPackItem] = []
-                    for set in sets {
-                        var (info, items) = parsePreviewStickerSet(set, namespace: category.collectionIdNamespace)
-                        if let previousPack = initialPackMap[info.id.id] {
-                            if previousPack.info.hash == info.hash {
-                                items = previousPack.topItems
+                    return resolveMissingStickerSets(network: network, postbox: postbox, stickerSets: sets, ignorePacksWithHashes: initialPackMap.mapValues({ item in
+                        item.info.hash
+                    }))
+                    |> castError(MTRpcError.self)
+                    |> map { sets -> FeaturedList in
+                        let unreadIds = Set(unread)
+                        var updatedPacks: [FeaturedStickerPackItem] = []
+                        for set in sets {
+                            var (info, items) = parsePreviewStickerSet(set, namespace: category.collectionIdNamespace)
+                            if let previousPack = initialPackMap[info.id.id] {
+                                if previousPack.info.hash == info.hash {
+                                    items = previousPack.topItems
+                                }
                            }
+                            updatedPacks.append(FeaturedStickerPackItem(info: info, topItems: items, unread: unreadIds.contains(info.id.id)))
                        }
-                        updatedPacks.append(FeaturedStickerPackItem(info: info, topItems: items, unread: unreadIds.contains(info.id.id)))
+                        let isPremium = flags & (1 << 0) != 0
+                        return .content(FeaturedListContent(
+                            unreadIds: unreadIds,
+                            packs: updatedPacks,
+                            isPremium: isPremium
+                        ))
                    }
-                    let isPremium = flags & (1 << 0) != 0
-                    return .content(FeaturedListContent(
-                        unreadIds: unreadIds,
-                        packs: updatedPacks,
-                        isPremium: isPremium
-                    ))
                }
            }
            |> `catch` { _ -> Signal<FeaturedList, NoError> in
@ -273,5 +332,9 @@ func parsePreviewStickerSet(_ set: Api.StickerSetCovered, namespace: ItemCollect
            }
        }
        return (info, items)
+    case let .stickerSetNoCovered(set):
+        let info = StickerPackCollectionInfo(apiSet: set, namespace: namespace)
+        let items: [StickerPackItem] = []
+        return (info, items)
    }
 }
--- a/submodules/TelegramCore/Sources/State/UpdatesApiUtils.swift
+++ b/submodules/TelegramCore/Sources/State/UpdatesApiUtils.swift
@ -301,8 +301,6 @@ extension Api.Update {
                return [PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt64Value(userId))]
            case let .updateUserPhone(userId, _):
                return [PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt64Value(userId))]
-            case let .updateUserPhoto(userId, _, _, _):
-                return [PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt64Value(userId))]
            case let .updateServiceNotification(_, inboxDate, _, _, _, _):
                if let _ = inboxDate {
                    return [PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt64Value(777000))]
--- a/submodules/TelegramCore/Sources/TelegramEngine/Stickers/StickerPack.swift
+++ b/submodules/TelegramCore/Sources/TelegramEngine/Stickers/StickerPack.swift
@ -103,7 +103,7 @@ func _internal_stickerPacksAttachedToMedia(account: Account, media: AnyMediaRefe
    |> map { result -> [StickerPackReference] in
        return result.map { pack in
            switch pack {
-            case let .stickerSetCovered(set, _), let .stickerSetMultiCovered(set, _), let .stickerSetFullCovered(set, _, _, _):
+            case let .stickerSetCovered(set, _), let .stickerSetMultiCovered(set, _), let .stickerSetFullCovered(set, _, _, _), let .stickerSetNoCovered(set):
                let info = StickerPackCollectionInfo(apiSet: set, namespace: Namespaces.ItemCollection.CloudStickerPacks)
                return .id(id: info.id.id, accessHash: info.accessHash)
            }
--- a/submodules/TelegramCore/Sources/TelegramEngine/Stickers/StickerSetInstallation.swift
+++ b/submodules/TelegramCore/Sources/TelegramEngine/Stickers/StickerSetInstallation.swift
@ -168,12 +168,12 @@ func _internal_installStickerSetInteractively(account: Account, info: StickerPac
        return .generic
    }
    |> mapToSignal { result -> Signal<InstallStickerSetResult, InstallStickerSetError> in
-        let addResult:InstallStickerSetResult
+        let addResult: InstallStickerSetResult
        switch result {
        case .stickerSetInstallResultSuccess:
            addResult = .successful
        case let .stickerSetInstallResultArchive(sets: archived):
-            var coveredSets:[CoveredStickerSet] = []
+            var coveredSets: [CoveredStickerSet] = []
            for archived in archived {
                let apiDocuments:[Api.Document]
                let apiSet:Api.StickerSet
@ -187,6 +187,9 @@ func _internal_installStickerSetInteractively(account: Account, info: StickerPac
                case let .stickerSetFullCovered(set, _, _, documents):
                    apiSet = set
                    apiDocuments = documents
+                case let .stickerSetNoCovered(set):
+                    apiSet = set
+                    apiDocuments = []
                }
                
                let info = StickerPackCollectionInfo(apiSet: apiSet, namespace: Namespaces.ItemCollection.CloudStickerPacks)