ThePain/Swiftgram
1
0
Fork 0
mirror of https://github.com/Swiftgram/Telegram-iOS.git synced 2025-12-04 13:38:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Automatically cache uploaded avatar sizes

Browse Source
This commit is contained in:
Peter 2019-01-15 19:20:04 +04:00
parent 0341c221f6
commit ae844e1a20
4 changed files with 143 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
TelegramCore/Authorization.swift
View File

@ -444,7 +444,7 @@ public func signUpWithName(account: UnauthorizedAccount, firstName: String, last
let resource = LocalFileMediaResource(fileId: arc4random64()) let resource = LocalFileMediaResource(fileId: arc4random64())
account.postbox.mediaBox.storeResourceData(resource.id, data: avatarData) account.postbox.mediaBox.storeResourceData(resource.id, data: avatarData)
return updatePeerPhotoInternal(postbox: account.postbox, network: account.network, stateManager: nil, accountPeerId: user.id, peer: .single(user), photo: uploadedPeerPhoto(postbox: account.postbox, network: account.network, resource: resource)) return updatePeerPhotoInternal(postbox: account.postbox, network: account.network, stateManager: nil, accountPeerId: user.id, peer: .single(user), photo: uploadedPeerPhoto(postbox: account.postbox, network: account.network, resource: resource), mapResourceToAvatarSizes: { _, _ in .single([:]) })
|> `catch` { _ -> Signal<UpdatePeerPhotoStatus, SignUpError> in |> `catch` { _ -> Signal<UpdatePeerPhotoStatus, SignUpError> in
return .complete() return .complete()
} }

8
TelegramCore/CreateGroup.swift
View File

@ -21,8 +21,8 @@ public func createGroup(account: Account, title: String, peerIds: [PeerId]) -> S
} }
return account.network.request(Api.functions.messages.createChat(users: inputUsers, title: title)) return account.network.request(Api.functions.messages.createChat(users: inputUsers, title: title))
|> map(Optional.init) |> map(Optional.init)
|> `catch` { _ in |> `catch` { _ -> Signal<Api.Updates?, NoError> in
return Signal<Api.Updates?, NoError>.single(nil) return .single(nil)
} }
|> mapToSignal { updates -> Signal<PeerId?, NoError> in |> mapToSignal { updates -> Signal<PeerId?, NoError> in
if let updates = updates { if let updates = updates {
@ -36,9 +36,9 @@ public func createGroup(account: Account, title: String, peerIds: [PeerId]) -> S
|> map { _ in |> map { _ in
return peerId return peerId
} }
|> timeout(5.0, queue: Queue.concurrentDefaultQueue(), alternate: .single(nil)) } else {
return .single(nil)
} }
return .single(nil)
} else { } else {
return .single(nil) return .single(nil)
} }

52
TelegramCore/Holes.swift
View File

@ -39,7 +39,7 @@ enum FetchMessageHistoryHoleSource {
} }
} }
func withResolvedAssociatedMessages(postbox: Postbox, source: FetchMessageHistoryHoleSource, storeMessages: [StoreMessage], _ f: @escaping (Transaction, [Peer], [StoreMessage]) -> Void) -> Signal<Void, NoError> { func withResolvedAssociatedMessages(postbox: Postbox, source: FetchMessageHistoryHoleSource, peers: [PeerId: Peer], storeMessages: [StoreMessage], _ f: @escaping (Transaction, [Peer], [StoreMessage]) -> Void) -> Signal<Void, NoError> {
return postbox.transaction { transaction -> Signal<Void, NoError> in return postbox.transaction { transaction -> Signal<Void, NoError> in
var storedIds = Set<MessageId>() var storedIds = Set<MessageId>()
var referencedIds = Set<MessageId>() var referencedIds = Set<MessageId>()
@ -53,7 +53,7 @@ func withResolvedAssociatedMessages(postbox: Postbox, source: FetchMessageHistor
} }
} }
referencedIds.subtract(storedIds) referencedIds.subtract(storedIds)
referencedIds = transaction.filterStoredMessageIds(referencedIds) referencedIds.subtract(transaction.filterStoredMessageIds(referencedIds))
if referencedIds.isEmpty { if referencedIds.isEmpty {
f(transaction, [], []) f(transaction, [], [])
@ -61,7 +61,7 @@ func withResolvedAssociatedMessages(postbox: Postbox, source: FetchMessageHistor
} else { } else {
var signals: [Signal<([Api.Message], [Api.Chat], [Api.User]), NoError>] = [] var signals: [Signal<([Api.Message], [Api.Chat], [Api.User]), NoError>] = []
for (peerId, messageIds) in messagesIdsGroupedByPeerId(referencedIds) { for (peerId, messageIds) in messagesIdsGroupedByPeerId(referencedIds) {
if let peer = transaction.getPeer(peerId) { if let peer = transaction.getPeer(peerId) ?? peers[peerId] {
var signal: Signal<Api.messages.Messages, MTRpcError>? var signal: Signal<Api.messages.Messages, MTRpcError>?
if peerId.namespace == Namespaces.Peer.CloudUser || peerId.namespace == Namespaces.Peer.CloudGroup { if peerId.namespace == Namespaces.Peer.CloudUser || peerId.namespace == Namespaces.Peer.CloudGroup {
signal = source.request(Api.functions.messages.getMessages(id: messageIds.map({ Api.InputMessage.inputMessageID(id: $0.id) }))) signal = source.request(Api.functions.messages.getMessages(id: messageIds.map({ Api.InputMessage.inputMessageID(id: $0.id) })))
@ -282,6 +282,22 @@ func fetchMessageHistoryHole(accountPeerId: PeerId, source: FetchMessageHistoryH
chats = [] chats = []
users = [] users = []
} }
var peers: [Peer] = []
var peerPresences: [PeerId: PeerPresence] = [:]
for chat in chats {
if let groupOrChannel = parseTelegramGroupOrChannel(chat: chat) {
peers.append(groupOrChannel)
}
}
for user in users {
let telegramUser = TelegramUser(user: user)
peers.append(telegramUser)
if let presence = TelegramUserPresence(apiUser: user) {
peerPresences[telegramUser.id] = presence
}
}
var updatedMaxIndex: MessageIndex? var updatedMaxIndex: MessageIndex?
if let maxIndexResult = maxIndexResult { if let maxIndexResult = maxIndexResult {
let maxIndexMessages: [Api.Message] let maxIndexMessages: [Api.Message]
@ -317,7 +333,7 @@ func fetchMessageHistoryHole(accountPeerId: PeerId, source: FetchMessageHistoryH
} }
} }
return withResolvedAssociatedMessages(postbox: postbox, source: source, storeMessages: storeMessages, { transaction, additionalPeers, additionalMessages in return withResolvedAssociatedMessages(postbox: postbox, source: source, peers: Dictionary(peers.map({ ($0.id, $0) }), uniquingKeysWith: { lhs, _ in lhs }), storeMessages: storeMessages, { transaction, additionalPeers, additionalMessages in
let fillDirection: HoleFillDirection let fillDirection: HoleFillDirection
switch direction { switch direction {
case .UpperToLower: case .UpperToLower:
@ -337,22 +353,7 @@ func fetchMessageHistoryHole(accountPeerId: PeerId, source: FetchMessageHistoryH
transaction.fillMultipleHoles(hole, fillType: HoleFill(complete: completeFill, direction: fillDirection), tagMask: tagMask, messages: storeMessages) transaction.fillMultipleHoles(hole, fillType: HoleFill(complete: completeFill, direction: fillDirection), tagMask: tagMask, messages: storeMessages)
let _ = transaction.addMessages(additionalMessages, location: .Random) let _ = transaction.addMessages(additionalMessages, location: .Random)
var peers: [Peer] = additionalPeers updatePeers(transaction: transaction, peers: peers + additionalPeers, update: { _, updated -> Peer in
var peerPresences: [PeerId: PeerPresence] = [:]
for chat in chats {
if let groupOrChannel = parseTelegramGroupOrChannel(chat: chat) {
peers.append(groupOrChannel)
}
}
for user in users {
let telegramUser = TelegramUser(user: user)
peers.append(telegramUser)
if let presence = TelegramUserPresence(apiUser: user) {
peerPresences[telegramUser.id] = presence
}
}
updatePeers(transaction: transaction, peers: peers, update: { _, updated -> Peer in
return updated return updated
}) })
updatePeerPresences(transaction: transaction, accountPeerId: accountPeerId, peerPresences: peerPresences) updatePeerPresences(transaction: transaction, accountPeerId: accountPeerId, peerPresences: peerPresences)
@ -574,16 +575,15 @@ func fetchChatListHole(postbox: Postbox, network: Network, accountPeerId: PeerId
transaction.replaceChatListHole(groupId: groupId, index: hole.index, hole: nil) transaction.replaceChatListHole(groupId: groupId, index: hole.index, hole: nil)
} }
} }
return withResolvedAssociatedMessages(postbox: postbox, source: .network(network), storeMessages: fetchedChats.storeMessages, { transaction, additionalPeers, additionalMessages in return withResolvedAssociatedMessages(postbox: postbox, source: .network(network), peers: Dictionary(fetchedChats.peers.map({ ($0.id, $0) }), uniquingKeysWith: { lhs, _ in lhs }), storeMessages: fetchedChats.storeMessages, { transaction, additionalPeers, additionalMessages in
for peer in fetchedChats.peers { updatePeers(transaction: transaction, peers: fetchedChats.peers + additionalPeers, update: { _, updated -> Peer in
updatePeers(transaction: transaction, peers: [peer], update: { _, updated -> Peer in return updated
return updated })
})
}
updatePeerPresences(transaction: transaction, accountPeerId: accountPeerId, peerPresences: fetchedChats.peerPresences) updatePeerPresences(transaction: transaction, accountPeerId: accountPeerId, peerPresences: fetchedChats.peerPresences)
transaction.updateCurrentPeerNotificationSettings(fetchedChats.notificationSettings) transaction.updateCurrentPeerNotificationSettings(fetchedChats.notificationSettings)
let _ = transaction.addMessages(fetchedChats.storeMessages, location: .UpperHistoryBlock) let _ = transaction.addMessages(fetchedChats.storeMessages, location: .UpperHistoryBlock)
let _ = transaction.addMessages(additionalMessages, location: .Random)
transaction.resetIncomingReadStates(fetchedChats.readStates) transaction.resetIncomingReadStates(fetchedChats.readStates)
transaction.replaceChatListHole(groupId: groupId, index: hole.index, hole: fetchedChats.lowerNonPinnedIndex.flatMap(ChatListHole.init)) transaction.replaceChatListHole(groupId: groupId, index: hole.index, hole: fetchedChats.lowerNonPinnedIndex.flatMap(ChatListHole.init))

222
TelegramCore/PeerPhotoUpdater.swift
View File

@ -19,8 +19,8 @@ public enum UploadPeerPhotoError {
case generic case generic
} }
public func updateAccountPhoto(account: Account, resource: MediaResource?) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> { public func updateAccountPhoto(account: Account, resource: MediaResource?, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
return updatePeerPhoto(postbox: account.postbox, network: account.network, stateManager: account.stateManager, accountPeerId: account.peerId, peerId: account.peerId, photo: resource.flatMap({ uploadedPeerPhoto(postbox: account.postbox, network: account.network, resource: $0) })) return updatePeerPhoto(postbox: account.postbox, network: account.network, stateManager: account.stateManager, accountPeerId: account.peerId, peerId: account.peerId, photo: resource.flatMap({ uploadedPeerPhoto(postbox: account.postbox, network: account.network, resource: $0) }), mapResourceToAvatarSizes: mapResourceToAvatarSizes)
} }
public struct UploadedPeerPhotoData { public struct UploadedPeerPhotoData {
@ -43,125 +43,138 @@ public func uploadedPeerPhoto(postbox: Postbox, network: Network, resource: Medi
} }
} }
public func updatePeerPhoto(postbox: Postbox, network: Network, stateManager: AccountStateManager?, accountPeerId: PeerId, peerId: PeerId, photo: Signal<UploadedPeerPhotoData, NoError>?) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> { public func updatePeerPhoto(postbox: Postbox, network: Network, stateManager: AccountStateManager?, accountPeerId: PeerId, peerId: PeerId, photo: Signal<UploadedPeerPhotoData, NoError>?, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
return updatePeerPhotoInternal(postbox: postbox, network: network, stateManager: stateManager, accountPeerId: accountPeerId, peer: postbox.loadedPeerWithId(peerId), photo: photo) return updatePeerPhotoInternal(postbox: postbox, network: network, stateManager: stateManager, accountPeerId: accountPeerId, peer: postbox.loadedPeerWithId(peerId), photo: photo, mapResourceToAvatarSizes: mapResourceToAvatarSizes)
} }
public func updatePeerPhotoInternal(postbox: Postbox, network: Network, stateManager: AccountStateManager?, accountPeerId: PeerId, peer: Signal<Peer, NoError>, photo: Signal<UploadedPeerPhotoData, NoError>?) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> { public func updatePeerPhotoInternal(postbox: Postbox, network: Network, stateManager: AccountStateManager?, accountPeerId: PeerId, peer: Signal<Peer, NoError>, photo: Signal<UploadedPeerPhotoData, NoError>?, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
return peer return peer
|> mapError {_ in return .generic} |> mapError {_ in return .generic}
|> mapToSignal { peer -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in |> mapToSignal { peer -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in
if let photo = photo { if let photo = photo {
return photo return photo
|> mapError { _ -> UploadPeerPhotoError in return .generic } |> mapError { _ -> UploadPeerPhotoError in return .generic }
|> mapToSignal { result -> Signal<(UpdatePeerPhotoStatus, MediaResource?), UploadPeerPhotoError> in |> mapToSignal { result -> Signal<(UpdatePeerPhotoStatus, MediaResource?), UploadPeerPhotoError> in
switch result.content { switch result.content {
case .error: case .error:
return .fail(.generic) return .fail(.generic)
case let .result(resultData): case let .result(resultData):
switch resultData { switch resultData {
case let .progress(progress): case let .progress(progress):
return .single((.progress(progress), result.resource)) return .single((.progress(progress), result.resource))
case let .inputFile(file): case let .inputFile(file):
if peer is TelegramUser { if peer is TelegramUser {
return network.request(Api.functions.photos.uploadProfilePhoto(file: file)) return network.request(Api.functions.photos.uploadProfilePhoto(file: file))
|> mapError {_ in return UploadPeerPhotoError.generic} |> mapError {_ in return UploadPeerPhotoError.generic}
|> mapToSignal { photo -> Signal<(UpdatePeerPhotoStatus, MediaResource?), UploadPeerPhotoError> in |> mapToSignal { photo -> Signal<(UpdatePeerPhotoStatus, MediaResource?), UploadPeerPhotoError> in
let representations: [TelegramMediaImageRepresentation] let representations: [TelegramMediaImageRepresentation]
switch photo { switch photo {
case let .photo(photo: apiPhoto, users: _): case let .photo(photo: apiPhoto, users: _):
switch apiPhoto { switch apiPhoto {
case .photoEmpty: case .photoEmpty:
representations = [] representations = []
case let .photo(photo): case let .photo(photo):
var sizes = photo.sizes var sizes = photo.sizes
if sizes.count == 3 { if sizes.count == 3 {
sizes.remove(at: 1) sizes.remove(at: 1)
} }
representations = telegramMediaImageRepresentationsFromApiSizes(sizes).1 representations = telegramMediaImageRepresentationsFromApiSizes(sizes).1
if let resource = result.resource as? LocalFileReferenceMediaResource { if let resource = result.resource as? LocalFileReferenceMediaResource {
if let data = try? Data(contentsOf: URL(fileURLWithPath: resource.localFilePath)) { if let data = try? Data(contentsOf: URL(fileURLWithPath: resource.localFilePath)) {
for representation in representations { for representation in representations {
postbox.mediaBox.storeResourceData(representation.resource.id, data: data) postbox.mediaBox.storeResourceData(representation.resource.id, data: data)
}
} }
} }
}
}
return postbox.transaction { transaction -> (UpdatePeerPhotoStatus, MediaResource?) in
if let peer = transaction.getPeer(peer.id) {
updatePeers(transaction: transaction, peers: [peer], update: { (_, peer) -> Peer? in
if let peer = peer as? TelegramUser {
return peer.withUpdatedPhoto(representations)
} else {
return peer
}
})
}
return (.complete(representations), result.resource)
} |> mapError {_ in return UploadPeerPhotoError.generic}
}
} else {
let request: Signal<Api.Updates, MTRpcError>
if let peer = peer as? TelegramGroup {
request = network.request(Api.functions.messages.editChatPhoto(chatId: peer.id.id, photo: .inputChatUploadedPhoto(file: file)))
} else if let peer = peer as? TelegramChannel, let inputChannel = apiInputChannel(peer) {
request = network.request(Api.functions.channels.editPhoto(channel: inputChannel, photo: .inputChatUploadedPhoto(file: file)))
} else {
assertionFailure()
request = .complete()
}
return request |> mapError {_ in return UploadPeerPhotoError.generic} |> mapToSignal { updates -> Signal<(UpdatePeerPhotoStatus, MediaResource?), UploadPeerPhotoError> in
stateManager?.addUpdates(updates)
for chat in updates.chats {
if chat.peerId == peer.id {
if let groupOrChannel = parseTelegramGroupOrChannel(chat: chat) {
return postbox.transaction { transaction -> (UpdatePeerPhotoStatus, MediaResource?) in
updatePeers(transaction: transaction, peers: [groupOrChannel], update: { _, updated in
return updated
})
return (.complete(groupOrChannel.profileImageRepresentations), result.resource)
} |> mapError { _ in return .generic }
} }
}
}
}
}
return postbox.transaction { transaction -> (UpdatePeerPhotoStatus, MediaResource?) in
if let peer = transaction.getPeer(peer.id) {
updatePeers(transaction: transaction, peers: [peer], update: { (_, peer) -> Peer? in
if let peer = peer as? TelegramUser {
return peer.withUpdatedPhoto(representations)
} else {
return peer
}
})
}
return (.complete(representations), result.resource)
} |> mapError {_ in return UploadPeerPhotoError.generic}
}
} else {
let request: Signal<Api.Updates, MTRpcError>
if let peer = peer as? TelegramGroup {
request = network.request(Api.functions.messages.editChatPhoto(chatId: peer.id.id, photo: .inputChatUploadedPhoto(file: file)))
} else if let peer = peer as? TelegramChannel, let inputChannel = apiInputChannel(peer) {
request = network.request(Api.functions.channels.editPhoto(channel: inputChannel, photo: .inputChatUploadedPhoto(file: file)))
} else {
assertionFailure()
request = .complete()
}
return request
|> mapError {_ in return UploadPeerPhotoError.generic}
|> mapToSignal { updates -> Signal<(UpdatePeerPhotoStatus, MediaResource?), UploadPeerPhotoError> in
guard let chat = updates.chats.first, chat.peerId == peer.id, let groupOrChannel = parseTelegramGroupOrChannel(chat: chat) else {
stateManager?.addUpdates(updates)
return .fail(.generic) return .fail(.generic)
} }
}
default: return mapResourceToAvatarSizes(result.resource, groupOrChannel.profileImageRepresentations)
return .fail(.generic) |> introduceError(UploadPeerPhotoError.self)
} |> mapToSignal { generatedData -> Signal<(UpdatePeerPhotoStatus, MediaResource?), UploadPeerPhotoError> in
} stateManager?.addUpdates(updates)
}
|> map { result, resource -> UpdatePeerPhotoStatus in for (index, data) in generatedData {
switch result { if index >= 0 && index < groupOrChannel.profileImageRepresentations.count {
case let .complete(representations): postbox.mediaBox.storeResourceData(groupOrChannel.profileImageRepresentations[index].resource.id, data: data)
if let resource = resource as? LocalFileReferenceMediaResource { } else {
if let data = try? Data(contentsOf: URL(fileURLWithPath: resource.localFilePath)) { assertionFailure()
for representation in representations { }
postbox.mediaBox.storeResourceData(representation.resource.id, data: data) }
return postbox.transaction { transaction -> (UpdatePeerPhotoStatus, MediaResource?) in
updatePeers(transaction: transaction, peers: [groupOrChannel], update: { _, updated in
return updated
})
return (.complete(groupOrChannel.profileImageRepresentations), result.resource)
}
|> mapError { _ in return .generic }
}
} }
} }
} default:
default: return .fail(.generic)
break }
}
return result
} }
}
|> map { result, resource -> UpdatePeerPhotoStatus in
switch result {
case let .complete(representations):
if let resource = resource as? LocalFileReferenceMediaResource {
if let data = try? Data(contentsOf: URL(fileURLWithPath: resource.localFilePath)) {
for representation in representations {
postbox.mediaBox.storeResourceData(representation.resource.id, data: data)
}
}
}
default:
break
}
return result
}
} else { } else {
if let _ = peer as? TelegramUser { if let _ = peer as? TelegramUser {
return network.request(Api.functions.photos.updateProfilePhoto(id: Api.InputPhoto.inputPhotoEmpty)) return network.request(Api.functions.photos.updateProfilePhoto(id: Api.InputPhoto.inputPhotoEmpty))
|> `catch` { _ -> Signal<Api.UserProfilePhoto, UploadPeerPhotoError> in |> `catch` { _ -> Signal<Api.UserProfilePhoto, UploadPeerPhotoError> in
return .fail(.generic) return .fail(.generic)
} }
|> mapToSignal { _ -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in |> mapToSignal { _ -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in
return .single(.complete([])) return .single(.complete([]))
} }
} else { } else {
let request: Signal<Api.Updates, MTRpcError> let request: Signal<Api.Updates, MTRpcError>
if let peer = peer as? TelegramGroup { if let peer = peer as? TelegramGroup {
@ -173,7 +186,9 @@ public func updatePeerPhotoInternal(postbox: Postbox, network: Network, stateMan
request = .complete() request = .complete()
} }
return request |> mapError {_ in return UploadPeerPhotoError.generic} |> mapToSignal { updates -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in return request
|> mapError {_ in return UploadPeerPhotoError.generic}
|> mapToSignal { updates -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in
stateManager?.addUpdates(updates) stateManager?.addUpdates(updates)
for chat in updates.chats { for chat in updates.chats {
if chat.peerId == peer.id { if chat.peerId == peer.id {
@ -183,7 +198,8 @@ public func updatePeerPhotoInternal(postbox: Postbox, network: Network, stateMan
return updated return updated
}) })
return .complete(groupOrChannel.profileImageRepresentations) return .complete(groupOrChannel.profileImageRepresentations)
} |> mapError { _ in return .generic } }
|> mapError { _ in return .generic }
} }
} }
} }