mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-07-18 17:21:08 +00:00
686 lines
28 KiB
Swift
686 lines
28 KiB
Swift
import Foundation
|
|
import Postbox
|
|
import SwiftSignalKit
|
|
import TelegramApi
|
|
|
|
private class AdMessagesHistoryContextImpl {
|
|
final class CachedMessage: Equatable, Codable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case opaqueId
|
|
case messageType
|
|
case title
|
|
case text
|
|
case textEntities
|
|
case media
|
|
case contentMedia
|
|
case color
|
|
case backgroundEmojiId
|
|
case url
|
|
case buttonText
|
|
case sponsorInfo
|
|
case additionalInfo
|
|
case canReport
|
|
case minDisplayDuration
|
|
case maxDisplayDuration
|
|
}
|
|
|
|
enum MessageType: Int32, Codable {
|
|
case sponsored = 0
|
|
case recommended = 1
|
|
}
|
|
|
|
public let opaqueId: Data
|
|
public let messageType: MessageType
|
|
public let title: String
|
|
public let text: String
|
|
public let textEntities: [MessageTextEntity]
|
|
public let media: [Media]
|
|
public let contentMedia: [Media]
|
|
public let color: PeerNameColor?
|
|
public let backgroundEmojiId: Int64?
|
|
public let url: String
|
|
public let buttonText: String
|
|
public let sponsorInfo: String?
|
|
public let additionalInfo: String?
|
|
public let canReport: Bool
|
|
public let minDisplayDuration: Int32?
|
|
public let maxDisplayDuration: Int32?
|
|
|
|
public init(
|
|
opaqueId: Data,
|
|
messageType: MessageType,
|
|
title: String,
|
|
text: String,
|
|
textEntities: [MessageTextEntity],
|
|
media: [Media],
|
|
contentMedia: [Media],
|
|
color: PeerNameColor?,
|
|
backgroundEmojiId: Int64?,
|
|
url: String,
|
|
buttonText: String,
|
|
sponsorInfo: String?,
|
|
additionalInfo: String?,
|
|
canReport: Bool,
|
|
minDisplayDuration: Int32?,
|
|
maxDisplayDuration: Int32?
|
|
) {
|
|
self.opaqueId = opaqueId
|
|
self.messageType = messageType
|
|
self.title = title
|
|
self.text = text
|
|
self.textEntities = textEntities
|
|
self.media = media
|
|
self.contentMedia = contentMedia
|
|
self.color = color
|
|
self.backgroundEmojiId = backgroundEmojiId
|
|
self.url = url
|
|
self.buttonText = buttonText
|
|
self.sponsorInfo = sponsorInfo
|
|
self.additionalInfo = additionalInfo
|
|
self.canReport = canReport
|
|
self.minDisplayDuration = minDisplayDuration
|
|
self.maxDisplayDuration = maxDisplayDuration
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: CodingKeys.self)
|
|
|
|
self.opaqueId = try container.decode(Data.self, forKey: .opaqueId)
|
|
|
|
if let messageType = try container.decodeIfPresent(Int32.self, forKey: .messageType) {
|
|
self.messageType = MessageType(rawValue: messageType) ?? .sponsored
|
|
} else {
|
|
self.messageType = .sponsored
|
|
}
|
|
|
|
self.title = try container.decode(String.self, forKey: .title)
|
|
self.text = try container.decode(String.self, forKey: .text)
|
|
self.textEntities = try container.decode([MessageTextEntity].self, forKey: .textEntities)
|
|
|
|
let mediaData = try container.decode([Data].self, forKey: .media)
|
|
self.media = mediaData.compactMap { data -> Media? in
|
|
return PostboxDecoder(buffer: MemoryBuffer(data: data)).decodeRootObject() as? Media
|
|
}
|
|
|
|
let contentMediaData = try container.decode([Data].self, forKey: .contentMedia)
|
|
self.contentMedia = contentMediaData.compactMap { data -> Media? in
|
|
return PostboxDecoder(buffer: MemoryBuffer(data: data)).decodeRootObject() as? Media
|
|
}
|
|
|
|
self.color = try container.decodeIfPresent(Int32.self, forKey: .color).flatMap { PeerNameColor(rawValue: $0) }
|
|
self.backgroundEmojiId = try container.decodeIfPresent(Int64.self, forKey: .backgroundEmojiId)
|
|
|
|
self.url = try container.decode(String.self, forKey: .url)
|
|
self.buttonText = try container.decode(String.self, forKey: .buttonText)
|
|
|
|
self.sponsorInfo = try container.decodeIfPresent(String.self, forKey: .sponsorInfo)
|
|
self.additionalInfo = try container.decodeIfPresent(String.self, forKey: .additionalInfo)
|
|
|
|
self.canReport = try container.decodeIfPresent(Bool.self, forKey: .canReport) ?? false
|
|
|
|
self.minDisplayDuration = try container.decodeIfPresent(Int32.self, forKey: .minDisplayDuration)
|
|
self.maxDisplayDuration = try container.decodeIfPresent(Int32.self, forKey: .maxDisplayDuration)
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
|
|
try container.encode(self.opaqueId, forKey: .opaqueId)
|
|
try container.encode(self.messageType.rawValue, forKey: .messageType)
|
|
try container.encode(self.title, forKey: .title)
|
|
try container.encode(self.text, forKey: .text)
|
|
try container.encode(self.textEntities, forKey: .textEntities)
|
|
|
|
let mediaData = self.media.map { media -> Data in
|
|
let encoder = PostboxEncoder()
|
|
encoder.encodeRootObject(media)
|
|
return encoder.makeData()
|
|
}
|
|
try container.encode(mediaData, forKey: .media)
|
|
|
|
let contentMediaData = self.contentMedia.map { media -> Data in
|
|
let encoder = PostboxEncoder()
|
|
encoder.encodeRootObject(media)
|
|
return encoder.makeData()
|
|
}
|
|
try container.encode(contentMediaData, forKey: .contentMedia)
|
|
|
|
try container.encodeIfPresent(self.color?.rawValue, forKey: .color)
|
|
try container.encodeIfPresent(self.backgroundEmojiId, forKey: .backgroundEmojiId)
|
|
|
|
try container.encode(self.url, forKey: .url)
|
|
try container.encode(self.buttonText, forKey: .buttonText)
|
|
|
|
try container.encodeIfPresent(self.sponsorInfo, forKey: .sponsorInfo)
|
|
try container.encodeIfPresent(self.additionalInfo, forKey: .additionalInfo)
|
|
|
|
try container.encode(self.canReport, forKey: .canReport)
|
|
|
|
try container.encodeIfPresent(self.minDisplayDuration, forKey: .minDisplayDuration)
|
|
try container.encodeIfPresent(self.maxDisplayDuration, forKey: .maxDisplayDuration)
|
|
}
|
|
|
|
public static func ==(lhs: CachedMessage, rhs: CachedMessage) -> Bool {
|
|
if lhs.opaqueId != rhs.opaqueId {
|
|
return false
|
|
}
|
|
if lhs.messageType != rhs.messageType {
|
|
return false
|
|
}
|
|
if lhs.title != rhs.title {
|
|
return false
|
|
}
|
|
if lhs.text != rhs.text {
|
|
return false
|
|
}
|
|
if lhs.textEntities != rhs.textEntities {
|
|
return false
|
|
}
|
|
if lhs.media.count != rhs.media.count {
|
|
return false
|
|
}
|
|
for i in 0 ..< lhs.media.count {
|
|
if !lhs.media[i].isEqual(to: rhs.media[i]) {
|
|
return false
|
|
}
|
|
}
|
|
if lhs.contentMedia.count != rhs.contentMedia.count {
|
|
return false
|
|
}
|
|
for i in 0 ..< lhs.contentMedia.count {
|
|
if !lhs.contentMedia[i].isEqual(to: rhs.contentMedia[i]) {
|
|
return false
|
|
}
|
|
}
|
|
if lhs.url != rhs.url {
|
|
return false
|
|
}
|
|
if lhs.buttonText != rhs.buttonText {
|
|
return false
|
|
}
|
|
if lhs.sponsorInfo != rhs.sponsorInfo {
|
|
return false
|
|
}
|
|
if lhs.additionalInfo != rhs.additionalInfo {
|
|
return false
|
|
}
|
|
if lhs.canReport != rhs.canReport {
|
|
return false
|
|
}
|
|
if lhs.minDisplayDuration != rhs.minDisplayDuration {
|
|
return false
|
|
}
|
|
if lhs.maxDisplayDuration != rhs.maxDisplayDuration {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func toMessage(peerId: PeerId, transaction: Transaction) -> Message? {
|
|
var attributes: [MessageAttribute] = []
|
|
|
|
let mappedMessageType: AdMessageAttribute.MessageType
|
|
switch self.messageType {
|
|
case .sponsored:
|
|
mappedMessageType = .sponsored
|
|
case .recommended:
|
|
mappedMessageType = .recommended
|
|
}
|
|
let adAttribute = AdMessageAttribute(
|
|
opaqueId: self.opaqueId,
|
|
messageType: mappedMessageType,
|
|
url: self.url,
|
|
buttonText: self.buttonText,
|
|
sponsorInfo: self.sponsorInfo,
|
|
additionalInfo: self.additionalInfo,
|
|
canReport: self.canReport,
|
|
hasContentMedia: !self.contentMedia.isEmpty,
|
|
minDisplayDuration: self.minDisplayDuration,
|
|
maxDisplayDuration: self.maxDisplayDuration
|
|
)
|
|
attributes.append(adAttribute)
|
|
if !self.textEntities.isEmpty {
|
|
let entitiesAttribute = TextEntitiesMessageAttribute(entities: self.textEntities)
|
|
attributes.append(entitiesAttribute)
|
|
}
|
|
|
|
var messagePeers = SimpleDictionary<PeerId, Peer>()
|
|
|
|
if let peer = transaction.getPeer(peerId) {
|
|
messagePeers[peer.id] = peer
|
|
}
|
|
|
|
let author: Peer = TelegramChannel(
|
|
id: PeerId(namespace: Namespaces.Peer.CloudChannel, id: PeerId.Id._internalFromInt64Value(1)),
|
|
accessHash: nil,
|
|
title: self.title,
|
|
username: nil,
|
|
photo: [],
|
|
creationDate: 0,
|
|
version: 0,
|
|
participationStatus: .left,
|
|
info: .broadcast(TelegramChannelBroadcastInfo(flags: [])),
|
|
flags: [],
|
|
restrictionInfo: nil,
|
|
adminRights: nil,
|
|
bannedRights: nil,
|
|
defaultBannedRights: nil,
|
|
usernames: [],
|
|
storiesHidden: nil,
|
|
nameColor: self.color ?? .blue,
|
|
backgroundEmojiId: self.backgroundEmojiId,
|
|
profileColor: nil,
|
|
profileBackgroundEmojiId: nil,
|
|
emojiStatus: nil,
|
|
approximateBoostLevel: nil,
|
|
subscriptionUntilDate: nil,
|
|
verificationIconFileId: nil,
|
|
sendPaidMessageStars: nil,
|
|
linkedMonoforumId: nil
|
|
)
|
|
messagePeers[author.id] = author
|
|
|
|
let messageHash = (self.text.hashValue &+ 31 &* peerId.hashValue) &* 31 &+ author.id.hashValue
|
|
let messageStableVersion = UInt32(bitPattern: Int32(truncatingIfNeeded: messageHash))
|
|
|
|
return Message(
|
|
stableId: 0,
|
|
stableVersion: messageStableVersion,
|
|
id: MessageId(peerId: peerId, namespace: Namespaces.Message.Local, id: 0),
|
|
globallyUniqueId: nil,
|
|
groupingKey: nil,
|
|
groupInfo: nil,
|
|
threadId: nil,
|
|
timestamp: Int32.max - 1,
|
|
flags: [.Incoming],
|
|
tags: [],
|
|
globalTags: [],
|
|
localTags: [],
|
|
customTags: [],
|
|
forwardInfo: nil,
|
|
author: author,
|
|
text: self.text,
|
|
attributes: attributes,
|
|
media: !self.contentMedia.isEmpty ? self.contentMedia : self.media,
|
|
peers: messagePeers,
|
|
associatedMessages: SimpleDictionary<MessageId, Message>(),
|
|
associatedMessageIds: [],
|
|
associatedMedia: [:],
|
|
associatedThreadInfo: nil,
|
|
associatedStories: [:]
|
|
)
|
|
}
|
|
}
|
|
|
|
private let queue: Queue
|
|
private let account: Account
|
|
private let peerId: EnginePeer.Id
|
|
private let messageId: EngineMessage.Id?
|
|
|
|
private let maskAsSeenDisposables = DisposableDict<Data>()
|
|
|
|
struct CachedState: Codable, PostboxCoding {
|
|
enum CodingKeys: String, CodingKey {
|
|
case timestamp
|
|
case interPostInterval
|
|
case messages
|
|
}
|
|
|
|
var timestamp: Int32
|
|
var interPostInterval: Int32?
|
|
var messages: [CachedMessage]
|
|
|
|
init(timestamp: Int32, interPostInterval: Int32?, messages: [CachedMessage]) {
|
|
self.timestamp = timestamp
|
|
self.interPostInterval = interPostInterval
|
|
self.messages = messages
|
|
}
|
|
|
|
init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: CodingKeys.self)
|
|
|
|
self.timestamp = try container.decode(Int32.self, forKey: .timestamp)
|
|
self.interPostInterval = try container.decodeIfPresent(Int32.self, forKey: .interPostInterval)
|
|
self.messages = try container.decode([CachedMessage].self, forKey: .messages)
|
|
}
|
|
|
|
func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
|
|
try container.encode(self.timestamp, forKey: .timestamp)
|
|
try container.encodeIfPresent(self.interPostInterval, forKey: .interPostInterval)
|
|
try container.encode(self.messages, forKey: .messages)
|
|
}
|
|
|
|
init(decoder: PostboxDecoder) {
|
|
self.timestamp = decoder.decodeInt32ForKey("timestamp", orElse: 0)
|
|
self.interPostInterval = decoder.decodeOptionalInt32ForKey("interPostInterval")
|
|
if let messagesData = decoder.decodeOptionalDataArrayForKey("messages") {
|
|
self.messages = messagesData.compactMap { data -> CachedMessage? in
|
|
return try? AdaptedPostboxDecoder().decode(CachedMessage.self, from: data)
|
|
}
|
|
} else {
|
|
self.messages = []
|
|
}
|
|
}
|
|
|
|
func encode(_ encoder: PostboxEncoder) {
|
|
encoder.encodeInt32(self.timestamp, forKey: "timestamp")
|
|
if let interPostInterval = self.interPostInterval {
|
|
encoder.encodeInt32(interPostInterval, forKey: "interPostInterval")
|
|
} else {
|
|
encoder.encodeNil(forKey: "interPostInterval")
|
|
}
|
|
encoder.encodeDataArray(self.messages.compactMap { message -> Data? in
|
|
return try? AdaptedPostboxEncoder().encode(message)
|
|
}, forKey: "messages")
|
|
}
|
|
|
|
public static func getCached(postbox: Postbox, peerId: PeerId) -> Signal<CachedState?, NoError> {
|
|
return postbox.transaction { transaction -> CachedState? in
|
|
let key = ValueBoxKey(length: 8)
|
|
key.setInt64(0, value: peerId.toInt64())
|
|
if let entry = transaction.retrieveItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedAdMessageStates, key: key))?.get(CachedState.self) {
|
|
return entry
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
public static func setCached(transaction: Transaction, peerId: PeerId, state: CachedState?) {
|
|
let key = ValueBoxKey(length: 8)
|
|
key.setInt64(0, value: peerId.toInt64())
|
|
let id = ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedAdMessageStates, key: key)
|
|
if let state = state, let entry = CodableEntry(state) {
|
|
transaction.putItemCacheEntry(id: id, entry: entry)
|
|
} else {
|
|
transaction.removeItemCacheEntry(id: id)
|
|
}
|
|
}
|
|
}
|
|
|
|
struct State: Equatable {
|
|
var interPostInterval: Int32?
|
|
var startDelay: Int32?
|
|
var betweenDelay: Int32?
|
|
var messages: [Message]
|
|
|
|
static func ==(lhs: State, rhs: State) -> Bool {
|
|
if lhs.interPostInterval != rhs.interPostInterval {
|
|
return false
|
|
}
|
|
if lhs.startDelay != rhs.startDelay {
|
|
return false
|
|
}
|
|
if lhs.betweenDelay != rhs.betweenDelay {
|
|
return false
|
|
}
|
|
if lhs.messages.count != rhs.messages.count {
|
|
return false
|
|
}
|
|
for i in 0 ..< lhs.messages.count {
|
|
if lhs.messages[i].id != rhs.messages[i].id {
|
|
return false
|
|
}
|
|
if lhs.messages[i].stableId != rhs.messages[i].stableId {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
|
|
let state = Promise<State>()
|
|
private var stateValue: State? {
|
|
didSet {
|
|
if let stateValue = self.stateValue, stateValue != oldValue {
|
|
self.state.set(.single(stateValue))
|
|
}
|
|
}
|
|
}
|
|
|
|
private let disposable = MetaDisposable()
|
|
|
|
init(queue: Queue, account: Account, peerId: EnginePeer.Id, messageId: EngineMessage.Id?) {
|
|
self.queue = queue
|
|
self.account = account
|
|
self.peerId = peerId
|
|
self.messageId = messageId
|
|
|
|
let accountPeerId = account.peerId
|
|
|
|
self.stateValue = State(interPostInterval: nil, messages: [])
|
|
|
|
if messageId == nil {
|
|
self.state.set(CachedState.getCached(postbox: account.postbox, peerId: peerId)
|
|
|> mapToSignal { cachedState -> Signal<State, NoError> in
|
|
if let cachedState = cachedState, cachedState.timestamp >= Int32(Date().timeIntervalSince1970) - 5 * 60 {
|
|
return account.postbox.transaction { transaction -> State in
|
|
return State(interPostInterval: cachedState.interPostInterval, messages: cachedState.messages.compactMap { message -> Message? in
|
|
return message.toMessage(peerId: peerId, transaction: transaction)
|
|
})
|
|
}
|
|
} else {
|
|
return .single(State(interPostInterval: nil, messages: []))
|
|
}
|
|
})
|
|
}
|
|
|
|
let signal: Signal<(interPostInterval: Int32?, startDelay: Int32?, betweenDelay: Int32?, messages: [Message]), NoError> = account.postbox.transaction { transaction -> Api.InputPeer? in
|
|
return transaction.getPeer(peerId).flatMap(apiInputPeer)
|
|
}
|
|
|> mapToSignal { inputPeer -> Signal<(interPostInterval: Int32?, startDelay: Int32?, betweenDelay: Int32?, messages: [Message]), NoError> in
|
|
guard let inputPeer else {
|
|
return .single((nil, nil, nil, []))
|
|
}
|
|
var flags: Int32 = 0
|
|
if let _ = messageId {
|
|
flags |= (1 << 0)
|
|
}
|
|
return account.network.request(Api.functions.messages.getSponsoredMessages(flags: flags, peer: inputPeer, msgId: messageId?.id))
|
|
|> map(Optional.init)
|
|
|> `catch` { _ -> Signal<Api.messages.SponsoredMessages?, NoError> in
|
|
return .single(nil)
|
|
}
|
|
|> mapToSignal { result -> Signal<(interPostInterval: Int32?, startDelay: Int32?, betweenDelay: Int32?, messages: [Message]), NoError> in
|
|
guard let result = result else {
|
|
return .single((nil, nil, nil, []))
|
|
}
|
|
|
|
return account.postbox.transaction { transaction -> (interPostInterval: Int32?, startDelay: Int32?, betweenDelay: Int32?, messages: [Message]) in
|
|
switch result {
|
|
case let .sponsoredMessages(_, postsBetween, startDelay, betweenDelay, messages, chats, users):
|
|
let parsedPeers = AccumulatedPeers(transaction: transaction, chats: chats, users: users)
|
|
updatePeers(transaction: transaction, accountPeerId: accountPeerId, peers: parsedPeers)
|
|
|
|
var parsedMessages: [CachedMessage] = []
|
|
|
|
for message in messages {
|
|
switch message {
|
|
case let .sponsoredMessage(flags, randomId, url, title, message, entities, photo, media, color, buttonText, sponsorInfo, additionalInfo, minDisplayDuration, maxDisplayDuration):
|
|
var parsedEntities: [MessageTextEntity] = []
|
|
if let entities = entities {
|
|
parsedEntities = messageTextEntitiesFromApiEntities(entities)
|
|
}
|
|
|
|
let isRecommended = (flags & (1 << 5)) != 0
|
|
let canReport = (flags & (1 << 12)) != 0
|
|
|
|
var nameColorIndex: Int32?
|
|
var backgroundEmojiId: Int64?
|
|
if let color = color {
|
|
switch color {
|
|
case let .peerColor(_, color, backgroundEmojiIdValue):
|
|
nameColorIndex = color
|
|
backgroundEmojiId = backgroundEmojiIdValue
|
|
}
|
|
}
|
|
|
|
let photo = photo.flatMap { telegramMediaImageFromApiPhoto($0) }
|
|
let contentMedia = textMediaAndExpirationTimerFromApiMedia(media, peerId).media
|
|
|
|
parsedMessages.append(CachedMessage(
|
|
opaqueId: randomId.makeData(),
|
|
messageType: isRecommended ? .recommended : .sponsored,
|
|
title: title,
|
|
text: message,
|
|
textEntities: parsedEntities,
|
|
media: photo.flatMap { [$0] } ?? [],
|
|
contentMedia: contentMedia.flatMap { [$0] } ?? [],
|
|
color: nameColorIndex.flatMap { PeerNameColor(rawValue: $0) },
|
|
backgroundEmojiId: backgroundEmojiId,
|
|
url: url,
|
|
buttonText: buttonText,
|
|
sponsorInfo: sponsorInfo,
|
|
additionalInfo: additionalInfo,
|
|
canReport: canReport,
|
|
minDisplayDuration: minDisplayDuration,
|
|
maxDisplayDuration: maxDisplayDuration
|
|
))
|
|
}
|
|
}
|
|
|
|
if messageId == nil {
|
|
CachedState.setCached(transaction: transaction, peerId: peerId, state: CachedState(timestamp: Int32(Date().timeIntervalSince1970), interPostInterval: postsBetween, messages: parsedMessages))
|
|
}
|
|
|
|
return (postsBetween, startDelay, betweenDelay, parsedMessages.compactMap { message -> Message? in
|
|
return message.toMessage(peerId: peerId, transaction: transaction)
|
|
})
|
|
case .sponsoredMessagesEmpty:
|
|
return (nil, nil, nil, [])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
self.disposable.set((signal
|
|
|> deliverOn(self.queue)).start(next: { [weak self] interPostInterval, startDelay, betweenDelay, messages in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
strongSelf.stateValue = State(interPostInterval: interPostInterval, startDelay: startDelay, betweenDelay: betweenDelay, messages: messages)
|
|
}))
|
|
}
|
|
|
|
deinit {
|
|
self.disposable.dispose()
|
|
self.maskAsSeenDisposables.dispose()
|
|
}
|
|
|
|
func markAsSeen(opaqueId: Data) {
|
|
let signal: Signal<Never, NoError> = self.account.network.request(Api.functions.messages.viewSponsoredMessage(randomId: Buffer(data: opaqueId)))
|
|
|> `catch` { _ -> Signal<Api.Bool, NoError> in
|
|
return .single(.boolFalse)
|
|
}
|
|
|> ignoreValues
|
|
self.maskAsSeenDisposables.set(signal.start(), forKey: opaqueId)
|
|
}
|
|
|
|
func markAction(opaqueId: Data, media: Bool, fullscreen: Bool) {
|
|
_internal_markAdAction(account: self.account, opaqueId: opaqueId, media: media, fullscreen: fullscreen)
|
|
}
|
|
|
|
func remove(opaqueId: Data) {
|
|
if var stateValue = self.stateValue {
|
|
if let index = stateValue.messages.firstIndex(where: { $0.adAttribute?.opaqueId == opaqueId }) {
|
|
stateValue.messages.remove(at: index)
|
|
self.stateValue = stateValue
|
|
}
|
|
}
|
|
|
|
let peerId = self.peerId
|
|
let _ = (self.account.postbox.transaction { transaction -> Void in
|
|
let key = ValueBoxKey(length: 8)
|
|
key.setInt64(0, value: peerId.toInt64())
|
|
let id = ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedAdMessageStates, key: key)
|
|
guard var cachedState = transaction.retrieveItemCacheEntry(id: id)?.get(CachedState.self) else {
|
|
return
|
|
}
|
|
if let index = cachedState.messages.firstIndex(where: { $0.opaqueId == opaqueId }) {
|
|
cachedState.messages.remove(at: index)
|
|
if let entry = CodableEntry(cachedState) {
|
|
transaction.putItemCacheEntry(id: id, entry: entry)
|
|
}
|
|
}
|
|
}).start()
|
|
}
|
|
}
|
|
|
|
public class AdMessagesHistoryContext {
|
|
private let queue = Queue()
|
|
private let impl: QueueLocalObject<AdMessagesHistoryContextImpl>
|
|
public let peerId: EnginePeer.Id
|
|
public let messageId: EngineMessage.Id?
|
|
|
|
public var state: Signal<(interPostInterval: Int32?, messages: [Message], startDelay: Int32?, betweenDelay: Int32?), NoError> {
|
|
return Signal { subscriber in
|
|
let disposable = MetaDisposable()
|
|
|
|
self.impl.with { impl in
|
|
let stateDisposable = impl.state.get().start(next: { state in
|
|
subscriber.putNext((state.interPostInterval, state.messages, state.startDelay, state.betweenDelay))
|
|
})
|
|
disposable.set(stateDisposable)
|
|
}
|
|
|
|
return disposable
|
|
}
|
|
}
|
|
|
|
public init(account: Account, peerId: EnginePeer.Id, messageId: EngineMessage.Id? = nil) {
|
|
self.peerId = peerId
|
|
self.messageId = messageId
|
|
|
|
let queue = self.queue
|
|
self.impl = QueueLocalObject(queue: queue, generate: {
|
|
return AdMessagesHistoryContextImpl(queue: queue, account: account, peerId: peerId, messageId: messageId)
|
|
})
|
|
}
|
|
|
|
public func markAsSeen(opaqueId: Data) {
|
|
self.impl.with { impl in
|
|
impl.markAsSeen(opaqueId: opaqueId)
|
|
}
|
|
}
|
|
|
|
public func markAction(opaqueId: Data, media: Bool, fullscreen: Bool) {
|
|
self.impl.with { impl in
|
|
impl.markAction(opaqueId: opaqueId, media: media, fullscreen: fullscreen)
|
|
}
|
|
}
|
|
|
|
public func remove(opaqueId: Data) {
|
|
self.impl.with { impl in
|
|
impl.remove(opaqueId: opaqueId)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
func _internal_markAdAction(account: Account, opaqueId: Data, media: Bool, fullscreen: Bool) {
|
|
var flags: Int32 = 0
|
|
if media {
|
|
flags |= (1 << 0)
|
|
}
|
|
if fullscreen {
|
|
flags |= (1 << 1)
|
|
}
|
|
let signal = account.network.request(Api.functions.messages.clickSponsoredMessage(flags: flags, randomId: Buffer(data: opaqueId)))
|
|
|> `catch` { _ -> Signal<Api.Bool, NoError> in
|
|
return .single(.boolFalse)
|
|
}
|
|
|> ignoreValues
|
|
let _ = signal.start()
|
|
}
|
|
|
|
func _internal_markAdAsSeen(account: Account, opaqueId: Data) {
|
|
let signal = account.network.request(Api.functions.messages.viewSponsoredMessage(randomId: Buffer(data: opaqueId)))
|
|
|> `catch` { _ -> Signal<Api.Bool, NoError> in
|
|
return .single(.boolFalse)
|
|
}
|
|
|> ignoreValues
|
|
let _ = signal.start()
|
|
}
|