mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-16 05:55:20 +00:00
ab5881de15
Fixed crash on profile photo removal Fixed several auto-download issues Fixed network usage calculation for videos Fixed several UI issues
577 lines
29 KiB
Swift
577 lines
29 KiB
Swift
import Foundation
|
|
import Display
|
|
import SwiftSignalKit
|
|
import Postbox
|
|
import TelegramCore
|
|
|
|
enum AutomaticDownloadCategory {
|
|
case photo
|
|
case video
|
|
case file
|
|
case voiceMessage
|
|
case videoMessage
|
|
}
|
|
|
|
private enum ConnectionType {
|
|
case cellular
|
|
case wifi
|
|
}
|
|
|
|
private enum PeerType {
|
|
case contact
|
|
case otherPrivate
|
|
case group
|
|
case channel
|
|
}
|
|
|
|
private final class AutodownloadMediaCategoryControllerArguments {
|
|
let toggle: (ConnectionType, PeerType) -> Void
|
|
let adjustSize: (Int32) -> Void
|
|
|
|
init(toggle: @escaping (ConnectionType, PeerType) -> Void, adjustSize: @escaping (Int32) -> Void) {
|
|
self.toggle = toggle
|
|
self.adjustSize = adjustSize
|
|
}
|
|
}
|
|
|
|
private enum AutodownloadMediaCategorySection: Int32 {
|
|
case cellular
|
|
case wifi
|
|
case size
|
|
}
|
|
|
|
private enum AutodownloadMediaCategoryEntry: ItemListNodeEntry {
|
|
case cellularHeader(PresentationTheme, String)
|
|
case cellularContacts(PresentationTheme, String, Bool)
|
|
case cellularOtherPrivate(PresentationTheme, String, Bool)
|
|
case cellularGroups(PresentationTheme, String, Bool)
|
|
case cellularChannels(PresentationTheme, String, Bool)
|
|
|
|
case wifiHeader(PresentationTheme, String)
|
|
case wifiContacts(PresentationTheme, String, Bool)
|
|
case wifiOtherPrivate(PresentationTheme, String, Bool)
|
|
case wifiGroups(PresentationTheme, String, Bool)
|
|
case wifiChannels(PresentationTheme, String, Bool)
|
|
|
|
case sizeHeader(PresentationTheme, String)
|
|
case sizeItem(PresentationTheme, String, Int32)
|
|
|
|
var section: ItemListSectionId {
|
|
switch self {
|
|
case .cellularHeader, .cellularContacts, .cellularOtherPrivate, .cellularGroups, .cellularChannels:
|
|
return AutodownloadMediaCategorySection.cellular.rawValue
|
|
case .wifiHeader, .wifiContacts, .wifiOtherPrivate, .wifiGroups, .wifiChannels:
|
|
return AutodownloadMediaCategorySection.wifi.rawValue
|
|
case .sizeHeader, .sizeItem:
|
|
return AutodownloadMediaCategorySection.size.rawValue
|
|
}
|
|
}
|
|
|
|
var stableId: Int32 {
|
|
switch self {
|
|
case .cellularHeader:
|
|
return 0
|
|
case .cellularContacts:
|
|
return 1
|
|
case .cellularOtherPrivate:
|
|
return 2
|
|
case .cellularGroups:
|
|
return 3
|
|
case .cellularChannels:
|
|
return 4
|
|
case .wifiHeader:
|
|
return 5
|
|
case .wifiContacts:
|
|
return 6
|
|
case .wifiOtherPrivate:
|
|
return 7
|
|
case .wifiGroups:
|
|
return 8
|
|
case .wifiChannels:
|
|
return 9
|
|
case .sizeHeader:
|
|
return 10
|
|
case .sizeItem:
|
|
return 11
|
|
}
|
|
}
|
|
|
|
static func ==(lhs: AutodownloadMediaCategoryEntry, rhs: AutodownloadMediaCategoryEntry) -> Bool {
|
|
switch lhs {
|
|
case let .cellularHeader(lhsTheme, lhsText):
|
|
if case let .cellularHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .cellularContacts(lhsTheme, lhsText, lhsValue):
|
|
if case let .cellularContacts(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .cellularOtherPrivate(lhsTheme, lhsText, lhsValue):
|
|
if case let .cellularOtherPrivate(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .cellularGroups(lhsTheme, lhsText, lhsValue):
|
|
if case let .cellularGroups(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .cellularChannels(lhsTheme, lhsText, lhsValue):
|
|
if case let .cellularChannels(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .wifiHeader(lhsTheme, lhsText):
|
|
if case let .wifiHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .wifiContacts(lhsTheme, lhsText, lhsValue):
|
|
if case let .wifiContacts(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .wifiOtherPrivate(lhsTheme, lhsText, lhsValue):
|
|
if case let .wifiOtherPrivate(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .wifiGroups(lhsTheme, lhsText, lhsValue):
|
|
if case let .wifiGroups(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .wifiChannels(lhsTheme, lhsText, lhsValue):
|
|
if case let .wifiChannels(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .sizeHeader(lhsTheme, lhsText):
|
|
if case let .sizeHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
case let .sizeItem(lhsTheme, lhsText, lhsValue):
|
|
if case let .sizeItem(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
static func <(lhs: AutodownloadMediaCategoryEntry, rhs: AutodownloadMediaCategoryEntry) -> Bool {
|
|
return lhs.stableId < rhs.stableId
|
|
}
|
|
|
|
func item(_ arguments: AutodownloadMediaCategoryControllerArguments) -> ListViewItem {
|
|
switch self {
|
|
case let .cellularHeader(theme, text):
|
|
return ItemListSectionHeaderItem(theme: theme, text: text, sectionId: self.section)
|
|
case let .cellularContacts(theme, text, value):
|
|
return ItemListSwitchItem(theme: theme, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
|
|
arguments.toggle(.cellular, .contact)
|
|
})
|
|
case let .cellularOtherPrivate(theme, text, value):
|
|
return ItemListSwitchItem(theme: theme, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
|
|
arguments.toggle(.cellular, .otherPrivate)
|
|
})
|
|
case let .cellularGroups(theme, text, value):
|
|
return ItemListSwitchItem(theme: theme, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
|
|
arguments.toggle(.cellular, .group)
|
|
})
|
|
case let .cellularChannels(theme, text, value):
|
|
return ItemListSwitchItem(theme: theme, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
|
|
arguments.toggle(.cellular, .channel)
|
|
})
|
|
case let .wifiHeader(theme, text):
|
|
return ItemListSectionHeaderItem(theme: theme, text: text, sectionId: self.section)
|
|
case let .wifiContacts(theme, text, value):
|
|
return ItemListSwitchItem(theme: theme, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
|
|
arguments.toggle(.wifi, .contact)
|
|
})
|
|
case let .wifiOtherPrivate(theme, text, value):
|
|
return ItemListSwitchItem(theme: theme, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
|
|
arguments.toggle(.wifi, .otherPrivate)
|
|
})
|
|
case let .wifiGroups(theme, text, value):
|
|
return ItemListSwitchItem(theme: theme, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
|
|
arguments.toggle(.wifi, .group)
|
|
})
|
|
case let .wifiChannels(theme, text, value):
|
|
return ItemListSwitchItem(theme: theme, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
|
|
arguments.toggle(.wifi, .channel)
|
|
})
|
|
case let .sizeHeader(theme, text):
|
|
return ItemListSectionHeaderItem(theme: theme, text: text, sectionId: self.section)
|
|
case let .sizeItem(theme, text, value):
|
|
return AutodownloadSizeLimitItem(theme: theme, text: text, value: value, sectionId: self.section, updated: { value in
|
|
arguments.adjustSize(value)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct AutodownloadMediaCategoryControllerState: Equatable {
|
|
}
|
|
|
|
private struct AutomaticDownloadPeers {
|
|
let contacts: Bool
|
|
let otherPrivate: Bool
|
|
let groups: Bool
|
|
let channels: Bool
|
|
}
|
|
|
|
private func autodownloadMediaCategoryControllerEntries(presentationData: PresentationData, category: AutomaticDownloadCategory, settings: AutomaticMediaDownloadSettings) -> [AutodownloadMediaCategoryEntry] {
|
|
var entries: [AutodownloadMediaCategoryEntry] = []
|
|
|
|
let cellular: AutomaticDownloadPeers
|
|
let wifi: AutomaticDownloadPeers
|
|
let size: Int32
|
|
|
|
switch category {
|
|
case .photo:
|
|
cellular = AutomaticDownloadPeers(
|
|
contacts: settings.peers.contacts.photo.cellular,
|
|
otherPrivate: settings.peers.otherPrivate.photo.cellular,
|
|
groups: settings.peers.groups.photo.cellular,
|
|
channels: settings.peers.channels.photo.cellular
|
|
)
|
|
wifi = AutomaticDownloadPeers(
|
|
contacts: settings.peers.contacts.photo.wifi,
|
|
otherPrivate: settings.peers.otherPrivate.photo.wifi,
|
|
groups: settings.peers.groups.photo.wifi,
|
|
channels: settings.peers.channels.photo.wifi
|
|
)
|
|
size = settings.peers.contacts.photo.sizeLimit
|
|
case .video:
|
|
cellular = AutomaticDownloadPeers(
|
|
contacts: settings.peers.contacts.video.cellular,
|
|
otherPrivate: settings.peers.otherPrivate.video.cellular,
|
|
groups: settings.peers.groups.video.cellular,
|
|
channels: settings.peers.channels.video.cellular
|
|
)
|
|
wifi = AutomaticDownloadPeers(
|
|
contacts: settings.peers.contacts.video.wifi,
|
|
otherPrivate: settings.peers.otherPrivate.video.wifi,
|
|
groups: settings.peers.groups.video.wifi,
|
|
channels: settings.peers.channels.video.wifi
|
|
)
|
|
size = settings.peers.contacts.video.sizeLimit
|
|
case .file:
|
|
cellular = AutomaticDownloadPeers(
|
|
contacts: settings.peers.contacts.file.cellular,
|
|
otherPrivate: settings.peers.otherPrivate.file.cellular,
|
|
groups: settings.peers.groups.file.cellular,
|
|
channels: settings.peers.channels.file.cellular
|
|
)
|
|
wifi = AutomaticDownloadPeers(
|
|
contacts: settings.peers.contacts.file.wifi,
|
|
otherPrivate: settings.peers.otherPrivate.file.wifi,
|
|
groups: settings.peers.groups.file.wifi,
|
|
channels: settings.peers.channels.file.wifi
|
|
)
|
|
size = settings.peers.contacts.file.sizeLimit
|
|
case .voiceMessage:
|
|
cellular = AutomaticDownloadPeers(
|
|
contacts: settings.peers.contacts.voiceMessage.cellular,
|
|
otherPrivate: settings.peers.otherPrivate.voiceMessage.cellular,
|
|
groups: settings.peers.groups.voiceMessage.cellular,
|
|
channels: settings.peers.channels.voiceMessage.cellular
|
|
)
|
|
wifi = AutomaticDownloadPeers(
|
|
contacts: settings.peers.contacts.voiceMessage.wifi,
|
|
otherPrivate: settings.peers.otherPrivate.voiceMessage.wifi,
|
|
groups: settings.peers.groups.voiceMessage.wifi,
|
|
channels: settings.peers.channels.voiceMessage.wifi
|
|
)
|
|
size = settings.peers.contacts.voiceMessage.sizeLimit
|
|
case .videoMessage:
|
|
cellular = AutomaticDownloadPeers(
|
|
contacts: settings.peers.contacts.videoMessage.cellular,
|
|
otherPrivate: settings.peers.otherPrivate.videoMessage.cellular,
|
|
groups: settings.peers.groups.videoMessage.cellular,
|
|
channels: settings.peers.channels.videoMessage.cellular
|
|
)
|
|
wifi = AutomaticDownloadPeers(
|
|
contacts: settings.peers.contacts.videoMessage.wifi,
|
|
otherPrivate: settings.peers.otherPrivate.videoMessage.wifi,
|
|
groups: settings.peers.groups.videoMessage.wifi,
|
|
channels: settings.peers.channels.videoMessage.wifi
|
|
)
|
|
size = settings.peers.contacts.videoMessage.sizeLimit
|
|
}
|
|
|
|
entries.append(.cellularHeader(presentationData.theme, presentationData.strings.AutoDownloadSettings_Cellular))
|
|
entries.append(.cellularContacts(presentationData.theme, presentationData.strings.AutoDownloadSettings_Contacts, cellular.contacts))
|
|
entries.append(.cellularOtherPrivate(presentationData.theme, presentationData.strings.AutoDownloadSettings_PrivateChats, cellular.otherPrivate))
|
|
entries.append(.cellularGroups(presentationData.theme, presentationData.strings.AutoDownloadSettings_GroupChats, cellular.groups))
|
|
entries.append(.cellularChannels(presentationData.theme, presentationData.strings.AutoDownloadSettings_Channels, cellular.channels))
|
|
|
|
entries.append(.wifiHeader(presentationData.theme, presentationData.strings.AutoDownloadSettings_WiFi))
|
|
entries.append(.wifiContacts(presentationData.theme, presentationData.strings.AutoDownloadSettings_Contacts, wifi.contacts))
|
|
entries.append(.wifiOtherPrivate(presentationData.theme, presentationData.strings.AutoDownloadSettings_PrivateChats, wifi.otherPrivate))
|
|
entries.append(.wifiGroups(presentationData.theme, presentationData.strings.AutoDownloadSettings_GroupChats, wifi.groups))
|
|
entries.append(.wifiChannels(presentationData.theme, presentationData.strings.AutoDownloadSettings_Channels, wifi.channels))
|
|
|
|
switch category {
|
|
case .file, .video:
|
|
entries.append(.sizeHeader(presentationData.theme, presentationData.strings.AutoDownloadSettings_LimitBySize))
|
|
let text: String
|
|
if size == Int32.max {
|
|
text = presentationData.strings.AutoDownloadSettings_Unlimited
|
|
} else {
|
|
text = presentationData.strings.AutoDownloadSettings_UpTo(dataSizeString(Int(size))).0
|
|
}
|
|
entries.append(.sizeItem(presentationData.theme, text, size))
|
|
default:
|
|
break
|
|
}
|
|
|
|
return entries
|
|
}
|
|
|
|
func autodownloadMediaCategoryController(account: Account, category: AutomaticDownloadCategory) -> ViewController {
|
|
let arguments = AutodownloadMediaCategoryControllerArguments(toggle: { connection, type in
|
|
let _ = updateMediaDownloadSettingsInteractively(postbox: account.postbox, { settings in
|
|
var settings = settings
|
|
switch category {
|
|
case .photo:
|
|
switch type {
|
|
case .contact:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.contacts.photo.cellular = !settings.peers.contacts.photo.cellular
|
|
case .wifi:
|
|
settings.peers.contacts.photo.wifi = !settings.peers.contacts.photo.wifi
|
|
}
|
|
case .otherPrivate:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.otherPrivate.photo.cellular = !settings.peers.otherPrivate.photo.cellular
|
|
case .wifi:
|
|
settings.peers.otherPrivate.photo.wifi = !settings.peers.otherPrivate.photo.wifi
|
|
}
|
|
case .group:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.groups.photo.cellular = !settings.peers.groups.photo.cellular
|
|
case .wifi:
|
|
settings.peers.groups.photo.wifi = !settings.peers.groups.photo.wifi
|
|
}
|
|
case .channel:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.channels.photo.cellular = !settings.peers.channels.photo.cellular
|
|
case .wifi:
|
|
settings.peers.channels.photo.wifi = !settings.peers.channels.photo.wifi
|
|
}
|
|
}
|
|
case .video:
|
|
switch type {
|
|
case .contact:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.contacts.video.cellular = !settings.peers.contacts.video.cellular
|
|
case .wifi:
|
|
settings.peers.contacts.video.wifi = !settings.peers.contacts.video.wifi
|
|
}
|
|
case .otherPrivate:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.otherPrivate.video.cellular = !settings.peers.otherPrivate.video.cellular
|
|
case .wifi:
|
|
settings.peers.otherPrivate.video.wifi = !settings.peers.otherPrivate.video.wifi
|
|
}
|
|
case .group:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.groups.video.cellular = !settings.peers.groups.video.cellular
|
|
case .wifi:
|
|
settings.peers.groups.video.wifi = !settings.peers.groups.video.wifi
|
|
}
|
|
case .channel:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.channels.video.cellular = !settings.peers.channels.video.cellular
|
|
case .wifi:
|
|
settings.peers.channels.video.wifi = !settings.peers.channels.video.wifi
|
|
}
|
|
}
|
|
case .file:
|
|
switch type {
|
|
case .contact:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.contacts.file.cellular = !settings.peers.contacts.file.cellular
|
|
case .wifi:
|
|
settings.peers.contacts.file.wifi = !settings.peers.contacts.file.wifi
|
|
}
|
|
case .otherPrivate:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.otherPrivate.file.cellular = !settings.peers.otherPrivate.file.cellular
|
|
case .wifi:
|
|
settings.peers.otherPrivate.file.wifi = !settings.peers.otherPrivate.file.wifi
|
|
}
|
|
case .group:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.groups.file.cellular = !settings.peers.groups.file.cellular
|
|
case .wifi:
|
|
settings.peers.groups.file.wifi = !settings.peers.groups.file.wifi
|
|
}
|
|
case .channel:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.channels.file.cellular = !settings.peers.channels.file.cellular
|
|
case .wifi:
|
|
settings.peers.channels.file.wifi = !settings.peers.channels.file.wifi
|
|
}
|
|
}
|
|
case .voiceMessage:
|
|
switch type {
|
|
case .contact:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.contacts.voiceMessage.cellular = !settings.peers.contacts.voiceMessage.cellular
|
|
case .wifi:
|
|
settings.peers.contacts.voiceMessage.wifi = !settings.peers.contacts.voiceMessage.wifi
|
|
}
|
|
case .otherPrivate:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.otherPrivate.voiceMessage.cellular = !settings.peers.otherPrivate.voiceMessage.cellular
|
|
case .wifi:
|
|
settings.peers.otherPrivate.voiceMessage.wifi = !settings.peers.otherPrivate.voiceMessage.wifi
|
|
}
|
|
case .group:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.groups.voiceMessage.cellular = !settings.peers.groups.voiceMessage.cellular
|
|
case .wifi:
|
|
settings.peers.groups.voiceMessage.wifi = !settings.peers.groups.voiceMessage.wifi
|
|
}
|
|
case .channel:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.channels.voiceMessage.cellular = !settings.peers.channels.voiceMessage.cellular
|
|
case .wifi:
|
|
settings.peers.channels.voiceMessage.wifi = !settings.peers.channels.voiceMessage.wifi
|
|
}
|
|
}
|
|
case .videoMessage:
|
|
switch type {
|
|
case .contact:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.contacts.videoMessage.cellular = !settings.peers.contacts.videoMessage.cellular
|
|
case .wifi:
|
|
settings.peers.contacts.videoMessage.wifi = !settings.peers.contacts.videoMessage.wifi
|
|
}
|
|
case .otherPrivate:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.otherPrivate.videoMessage.cellular = !settings.peers.otherPrivate.videoMessage.cellular
|
|
case .wifi:
|
|
settings.peers.otherPrivate.videoMessage.wifi = !settings.peers.otherPrivate.videoMessage.wifi
|
|
}
|
|
case .group:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.groups.videoMessage.cellular = !settings.peers.groups.videoMessage.cellular
|
|
case .wifi:
|
|
settings.peers.groups.videoMessage.wifi = !settings.peers.groups.videoMessage.wifi
|
|
}
|
|
case .channel:
|
|
switch connection {
|
|
case .cellular:
|
|
settings.peers.channels.videoMessage.cellular = !settings.peers.channels.videoMessage.cellular
|
|
case .wifi:
|
|
settings.peers.channels.videoMessage.wifi = !settings.peers.channels.videoMessage.wifi
|
|
}
|
|
}
|
|
}
|
|
return settings
|
|
}).start()
|
|
}, adjustSize: { size in
|
|
let _ = updateMediaDownloadSettingsInteractively(postbox: account.postbox, { settings in
|
|
var settings = settings
|
|
switch category {
|
|
case .photo:
|
|
settings.peers.contacts.photo.sizeLimit = size
|
|
settings.peers.otherPrivate.photo.sizeLimit = size
|
|
settings.peers.groups.photo.sizeLimit = size
|
|
settings.peers.channels.photo.sizeLimit = size
|
|
case .video:
|
|
settings.peers.contacts.video.sizeLimit = size
|
|
settings.peers.otherPrivate.video.sizeLimit = size
|
|
settings.peers.groups.video.sizeLimit = size
|
|
settings.peers.channels.video.sizeLimit = size
|
|
case .file:
|
|
settings.peers.contacts.file.sizeLimit = size
|
|
settings.peers.otherPrivate.file.sizeLimit = size
|
|
settings.peers.groups.file.sizeLimit = size
|
|
settings.peers.channels.file.sizeLimit = size
|
|
case .videoMessage:
|
|
settings.peers.contacts.videoMessage.sizeLimit = size
|
|
settings.peers.otherPrivate.videoMessage.sizeLimit = size
|
|
settings.peers.groups.videoMessage.sizeLimit = size
|
|
settings.peers.channels.videoMessage.sizeLimit = size
|
|
case .voiceMessage:
|
|
settings.peers.contacts.voiceMessage.sizeLimit = size
|
|
settings.peers.otherPrivate.voiceMessage.sizeLimit = size
|
|
settings.peers.groups.voiceMessage.sizeLimit = size
|
|
settings.peers.channels.voiceMessage.sizeLimit = size
|
|
}
|
|
return settings
|
|
}).start()
|
|
})
|
|
|
|
let signal = combineLatest((account.applicationContext as! TelegramApplicationContext).presentationData, account.postbox.preferencesView(keys: [ApplicationSpecificPreferencesKeys.automaticMediaDownloadSettings])) |> deliverOnMainQueue
|
|
|> map { presentationData, prefs -> (ItemListControllerState, (ItemListNodeState<AutodownloadMediaCategoryEntry>, AutodownloadMediaCategoryEntry.ItemGenerationArguments)) in
|
|
let automaticMediaDownloadSettings: AutomaticMediaDownloadSettings
|
|
if let value = prefs.values[ApplicationSpecificPreferencesKeys.automaticMediaDownloadSettings] as? AutomaticMediaDownloadSettings {
|
|
automaticMediaDownloadSettings = value
|
|
} else {
|
|
automaticMediaDownloadSettings = AutomaticMediaDownloadSettings.defaultSettings
|
|
}
|
|
|
|
let title: String
|
|
switch category {
|
|
case .photo:
|
|
title = presentationData.strings.AutoDownloadSettings_PhotosTitle
|
|
case .video:
|
|
title = presentationData.strings.AutoDownloadSettings_VideosTitle
|
|
case .file:
|
|
title = presentationData.strings.AutoDownloadSettings_DocumentsTitle
|
|
case .voiceMessage:
|
|
title = presentationData.strings.AutoDownloadSettings_VoiceMessagesTitle
|
|
case .videoMessage:
|
|
title = presentationData.strings.AutoDownloadSettings_VideoMessagesTitle
|
|
}
|
|
|
|
let controllerState = ItemListControllerState(theme: presentationData.theme, title: .text(title), leftNavigationButton: nil, rightNavigationButton: nil, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: false)
|
|
let listState = ItemListNodeState(entries: autodownloadMediaCategoryControllerEntries(presentationData: presentationData, category: category, settings: automaticMediaDownloadSettings), style: .blocks, emptyStateItem: nil, animateChanges: false)
|
|
|
|
return (controllerState, (listState, arguments))
|
|
}
|
|
|
|
let controller = ItemListController(account: account, state: signal)
|
|
return controller
|
|
}
|
|
|