mirror of
https://github.com/GLEGram/GLEGram-iOS.git
synced 2026-04-23 19:36:26 +02:00
Leeksov
4647310322
Based on Swiftgram 12.5 (Telegram iOS 12.5). All GLEGram features ported and organized in GLEGram/ folder. Features: Ghost Mode, Saved Deleted Messages, Content Protection Bypass, Font Replacement, Fake Profile, Chat Export, Plugin System, and more. See CHANGELOG_12.5.md for full details.
2092 lines
89 KiB
Markdown
2092 lines
89 KiB
Markdown
# GLEGram: описание функций и полный исходный код
|
||
|
||
Документ описывает реализацию в репозитории. Раздел про текст «Чаты» в шапке **не включён** (по запросу). Во всех примерах ниже приведён **полный** фрагмент или файл **без сокращений** (`...` не используется).
|
||
|
||
---
|
||
|
||
## 1. Двойное дно
|
||
|
||
**Смысл:** скрытые аккаунты, отдельные пароли в Keychain, при разблокировке приложения разные коды ведут к разным сценариям (основной пароль Telegram, «секретный» пароль, переключение на скрытый аккаунт по совпадению пароля). Флаги `isDoubleBottomOn` / `inDoubleBottom` хранятся в UserDefaults (`VarSystemNGSettings`). Экран настроек в Swiftgram — `doubleBottomSettingsController`; проверки при вводе пароля приложения — в `AppDelegate` (`additionalPasscodeCheck`, `onUnlockWithPasscode`).
|
||
|
||
### `Nicegram/NGData/Sources/SystemNGSettings.swift` (полностью)
|
||
|
||
```swift
|
||
// From Nicegram NGData/Sources/NGSettings.swift – only SystemNGSettings for Double Bottom
|
||
import Foundation
|
||
|
||
public class SystemNGSettings {
|
||
let UD = UserDefaults.standard
|
||
|
||
public init() {}
|
||
|
||
public var dbReset: Bool {
|
||
get {
|
||
return UD.bool(forKey: "ng_db_reset")
|
||
}
|
||
set {
|
||
UD.set(newValue, forKey: "ng_db_reset")
|
||
}
|
||
}
|
||
|
||
public var isDoubleBottomOn: Bool {
|
||
get {
|
||
return UD.bool(forKey: "isDoubleBottomOn")
|
||
}
|
||
set {
|
||
UD.set(newValue, forKey: "isDoubleBottomOn")
|
||
}
|
||
}
|
||
|
||
public var inDoubleBottom: Bool {
|
||
get {
|
||
return UD.bool(forKey: "inDoubleBottom")
|
||
}
|
||
set {
|
||
UD.set(newValue, forKey: "inDoubleBottom")
|
||
}
|
||
}
|
||
}
|
||
|
||
public var VarSystemNGSettings = SystemNGSettings()
|
||
```
|
||
|
||
### `Swiftgram/SGSettingsUI/Sources/DoubleBottomPasscodeStore.swift` (полностью)
|
||
|
||
```swift
|
||
// MARK: Swiftgram – Keychain storage for hidden-account passcodes (Double Bottom)
|
||
import Foundation
|
||
import Security
|
||
|
||
private let serviceName = "SwiftgramDoubleBottom"
|
||
|
||
/// Key for the single "secret" passcode (second password). When user unlocks with this, only one account is shown.
|
||
private let secretPasscodeAccountKey = "secret"
|
||
|
||
public enum DoubleBottomPasscodeStore {
|
||
// MARK: - Secret passcode (second password → show only 1 account)
|
||
|
||
public static func setSecretPasscode(_ passcode: String) {
|
||
let data = passcode.data(using: .utf8)!
|
||
let query: [String: Any] = [
|
||
kSecClass as String: kSecClassGenericPassword,
|
||
kSecAttrService as String: serviceName,
|
||
kSecAttrAccount as String: secretPasscodeAccountKey
|
||
]
|
||
var addQuery = query
|
||
addQuery[kSecValueData as String] = data
|
||
var status = SecItemAdd(addQuery as CFDictionary, nil)
|
||
if status == errSecDuplicateItem {
|
||
SecItemDelete(query as CFDictionary)
|
||
status = SecItemAdd(addQuery as CFDictionary, nil)
|
||
}
|
||
}
|
||
|
||
public static func secretPasscodeMatches(_ passcode: String) -> Bool {
|
||
guard let stored = secretPasscode() else { return false }
|
||
return stored == passcode
|
||
}
|
||
|
||
public static func hasSecretPasscode() -> Bool {
|
||
return secretPasscode() != nil
|
||
}
|
||
|
||
public static func removeSecretPasscode() {
|
||
let query: [String: Any] = [
|
||
kSecClass as String: kSecClassGenericPassword,
|
||
kSecAttrService as String: serviceName,
|
||
kSecAttrAccount as String: secretPasscodeAccountKey
|
||
]
|
||
SecItemDelete(query as CFDictionary)
|
||
}
|
||
|
||
private static func secretPasscode() -> String? {
|
||
let query: [String: Any] = [
|
||
kSecClass as String: kSecClassGenericPassword,
|
||
kSecAttrService as String: serviceName,
|
||
kSecAttrAccount as String: secretPasscodeAccountKey,
|
||
kSecReturnData as String: true,
|
||
kSecMatchLimit as String: kSecMatchLimitOne
|
||
]
|
||
var result: AnyObject?
|
||
let status = SecItemCopyMatching(query as CFDictionary, &result)
|
||
guard status == errSecSuccess, let data = result as? Data, let string = String(data: data, encoding: .utf8) else {
|
||
return nil
|
||
}
|
||
return string
|
||
}
|
||
|
||
// MARK: - Per-account passcodes (hidden accounts)
|
||
|
||
public static func setPasscode(_ passcode: String, forAccountId accountId: Int64) {
|
||
let account = "\(accountId)"
|
||
let data = passcode.data(using: .utf8)!
|
||
let query: [String: Any] = [
|
||
kSecClass as String: kSecClassGenericPassword,
|
||
kSecAttrService as String: serviceName,
|
||
kSecAttrAccount as String: account
|
||
]
|
||
var addQuery = query
|
||
addQuery[kSecValueData as String] = data
|
||
var status = SecItemAdd(addQuery as CFDictionary, nil)
|
||
if status == errSecDuplicateItem {
|
||
SecItemDelete(query as CFDictionary)
|
||
status = SecItemAdd(addQuery as CFDictionary, nil)
|
||
}
|
||
}
|
||
|
||
public static func passcode(forAccountId accountId: Int64) -> String? {
|
||
let query: [String: Any] = [
|
||
kSecClass as String: kSecClassGenericPassword,
|
||
kSecAttrService as String: serviceName,
|
||
kSecAttrAccount as String: "\(accountId)",
|
||
kSecReturnData as String: true,
|
||
kSecMatchLimit as String: kSecMatchLimitOne
|
||
]
|
||
var result: AnyObject?
|
||
let status = SecItemCopyMatching(query as CFDictionary, &result)
|
||
guard status == errSecSuccess, let data = result as? Data, let string = String(data: data, encoding: .utf8) else {
|
||
return nil
|
||
}
|
||
return string
|
||
}
|
||
|
||
public static func removePasscode(forAccountId accountId: Int64) {
|
||
let query: [String: Any] = [
|
||
kSecClass as String: kSecClassGenericPassword,
|
||
kSecAttrService as String: serviceName,
|
||
kSecAttrAccount as String: "\(accountId)"
|
||
]
|
||
SecItemDelete(query as CFDictionary)
|
||
}
|
||
|
||
/// Returns the account id whose passcode matches the given value, or nil.
|
||
public static func accountId(matchingPasscode passcode: String, candidateIds: [Int64]) -> Int64? {
|
||
for id in candidateIds {
|
||
if Self.passcode(forAccountId: id) == passcode {
|
||
return id
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
}
|
||
```
|
||
|
||
### `Swiftgram/SGSettingsUI/Sources/DoubleBottomSettingsController.swift` (полностью)
|
||
|
||
```swift
|
||
// MARK: Swiftgram – Double Bottom (full logic from Nicegram NGDoubleBottom/DoubleBottomListController)
|
||
// Ref: https://github.com/nicegram/Nicegram-iOS/blob/master/Nicegram/NGDoubleBottom/Sources/DoubleBottomListController.swift
|
||
import Foundation
|
||
import UIKit
|
||
import Display
|
||
import SwiftSignalKit
|
||
import Postbox
|
||
import TelegramCore
|
||
import TelegramPresentationData
|
||
import ItemListUI
|
||
import PresentationDataUtils
|
||
import AccountContext
|
||
import PasscodeUI
|
||
import SGSimpleSettings
|
||
import TelegramStringFormatting
|
||
|
||
// MARK: - Section (Nicegram: DoubleBottomControllerSection)
|
||
|
||
private enum DoubleBottomControllerSection: Int32 {
|
||
case isOn = 0
|
||
}
|
||
|
||
// MARK: - Entry (Nicegram: isOn + info)
|
||
|
||
private enum DoubleBottomEntry: ItemListNodeEntry {
|
||
case isOn(String, Bool, Bool) // title, value, enabled
|
||
case info(String)
|
||
|
||
var section: ItemListSectionId { DoubleBottomControllerSection.isOn.rawValue }
|
||
|
||
var stableId: Int32 {
|
||
switch self {
|
||
case .isOn: return 1000
|
||
case .info: return 1100
|
||
}
|
||
}
|
||
|
||
static func < (lhs: DoubleBottomEntry, rhs: DoubleBottomEntry) -> Bool {
|
||
lhs.stableId < rhs.stableId
|
||
}
|
||
|
||
static func == (lhs: DoubleBottomEntry, rhs: DoubleBottomEntry) -> Bool {
|
||
switch (lhs, rhs) {
|
||
case let (.isOn(lhsText, lhsBool, _), .isOn(rhsText, rhsBool, _)):
|
||
return lhsText == rhsText && lhsBool == rhsBool
|
||
case let (.info(lhsText), .info(rhsText)):
|
||
return lhsText == rhsText
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
|
||
let args = arguments as! DoubleBottomArguments
|
||
switch self {
|
||
case let .isOn(text, value, enabled):
|
||
return ItemListSwitchItem(
|
||
presentationData: presentationData,
|
||
title: text,
|
||
value: value,
|
||
enabled: enabled,
|
||
sectionId: section,
|
||
style: .blocks,
|
||
updated: { value in
|
||
args.updated(value)
|
||
}
|
||
)
|
||
case let .info(text):
|
||
return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: section)
|
||
}
|
||
}
|
||
}
|
||
|
||
// MARK: - Arguments (Nicegram: DoubleBottomControllerArguments)
|
||
|
||
private final class DoubleBottomArguments {
|
||
let context: AccountContext
|
||
let updated: (Bool) -> Void
|
||
init(context: AccountContext, updated: @escaping (Bool) -> Void) {
|
||
self.context = context
|
||
self.updated = updated
|
||
}
|
||
}
|
||
|
||
// MARK: - Controller (logic from Nicegram DoubleBottomListController)
|
||
|
||
public func doubleBottomSettingsController(context: AccountContext) -> ViewController {
|
||
let lang = context.sharedContext.currentPresentationData.with { $0 }.strings.baseLanguageCode
|
||
let title = lang == "ru" ? "Двойное дно" : "Double Bottom"
|
||
let toggleTitle = lang == "ru" ? "Двойное дно" : "Double Bottom"
|
||
let noticeText = lang == "ru"
|
||
? "Скрытые аккаунты и вход по паролю. Разные пароли открывают разные профили."
|
||
: "Hidden accounts and passcode access. Different passwords open different profiles."
|
||
|
||
let arguments = DoubleBottomArguments(context: context, updated: { value in
|
||
if value {
|
||
SGSimpleSettings.shared.doubleBottomEnabled = true
|
||
let setupController = PasscodeSetupController(context: context, mode: .setup(change: false, .digits6))
|
||
setupController.complete = { passcode, _ in
|
||
DoubleBottomPasscodeStore.setSecretPasscode(passcode)
|
||
setupController.dismiss()
|
||
}
|
||
context.sharedContext.presentGlobalController(setupController, nil)
|
||
} else {
|
||
SGSimpleSettings.shared.doubleBottomEnabled = false
|
||
DoubleBottomPasscodeStore.removeSecretPasscode()
|
||
DoubleBottomViewingSecretStore.setViewingWithSecretPasscode(false)
|
||
let accountManager = context.sharedContext.accountManager
|
||
// Remove secret passcodes from Keychain for previously hidden accounts
|
||
let _ = (accountManager.accountRecords()
|
||
|> take(1)
|
||
|> deliverOnMainQueue).start(next: { view in
|
||
for record in view.records where record.attributes.contains(where: { $0.isHiddenAccountAttribute }) {
|
||
DoubleBottomPasscodeStore.removePasscode(forAccountId: record.id.int64)
|
||
}
|
||
})
|
||
// Nicegram: single transaction – keep device passcode, remove HiddenAccount from all records
|
||
let _ = accountManager.transaction { transaction in
|
||
let challengeData = transaction.getAccessChallengeData()
|
||
let challenge: PostboxAccessChallengeData
|
||
switch challengeData {
|
||
case .numericalPassword(let value):
|
||
challenge = .numericalPassword(value: value)
|
||
case .plaintextPassword(let value):
|
||
challenge = .plaintextPassword(value: value)
|
||
case .none:
|
||
challenge = .none
|
||
}
|
||
transaction.setAccessChallengeData(challenge)
|
||
for record in transaction.getRecords() {
|
||
transaction.updateRecord(record.id) { current in
|
||
guard let current = current else { return nil }
|
||
var attributes = current.attributes
|
||
attributes.removeAll { $0.isHiddenAccountAttribute }
|
||
return AccountRecord(id: current.id, attributes: attributes, temporarySessionId: current.temporarySessionId)
|
||
}
|
||
}
|
||
}.start()
|
||
}
|
||
})
|
||
|
||
let transactionStatus = context.sharedContext.accountManager.transaction { transaction -> (Bool, Bool) in
|
||
let records = transaction.getRecords()
|
||
let publicCount = records.filter { record in
|
||
let attrs = record.attributes
|
||
let hiddenOrLoggedOut = attrs.contains(where: { $0.isHiddenAccountAttribute || $0.isLoggedOutAccountAttribute })
|
||
return !hiddenOrLoggedOut
|
||
}.count
|
||
let hasMoreThanOnePublic = publicCount > 1
|
||
let hasMainPasscode = transaction.getAccessChallengeData() != .none
|
||
return (hasMoreThanOnePublic, hasMainPasscode)
|
||
}
|
||
|
||
let signal: Signal<(ItemListControllerState, (ItemListNodeState, DoubleBottomArguments)), NoError> = combineLatest(context.sharedContext.presentationData, transactionStatus)
|
||
|> map { presentationData, contextStatus -> (ItemListControllerState, (ItemListNodeState, DoubleBottomArguments)) in
|
||
let isOn = SGSimpleSettings.shared.doubleBottomEnabled
|
||
let enabled = isOn || (contextStatus.0 && contextStatus.1)
|
||
let entries: [DoubleBottomEntry] = [
|
||
.isOn(toggleTitle, isOn, enabled),
|
||
.info(noticeText)
|
||
]
|
||
let controllerState = ItemListControllerState(
|
||
presentationData: ItemListPresentationData(presentationData),
|
||
title: .text(title),
|
||
leftNavigationButton: nil,
|
||
rightNavigationButton: nil,
|
||
backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back)
|
||
)
|
||
let listState = ItemListNodeState(
|
||
presentationData: ItemListPresentationData(presentationData),
|
||
entries: entries,
|
||
style: .blocks,
|
||
ensureVisibleItemTag: nil,
|
||
footerItem: nil,
|
||
initialScrollToItem: nil
|
||
)
|
||
return (controllerState, (listState, arguments))
|
||
}
|
||
|
||
return ItemListController(context: context, state: signal)
|
||
}
|
||
|
||
// MARK: - Passcode check (Nicegram: check(passcode:challengeData:) for device passcode validation)
|
||
|
||
public func doubleBottomCheckPasscode(_ passcode: String, challengeData: PostboxAccessChallengeData) -> Bool {
|
||
let passcodeType: PasscodeEntryFieldType
|
||
switch challengeData {
|
||
case let .numericalPassword(value):
|
||
passcodeType = value.count == 6 ? .digits6 : .digits4
|
||
default:
|
||
passcodeType = .alphanumeric
|
||
}
|
||
switch challengeData {
|
||
case .none:
|
||
return true
|
||
case let .numericalPassword(code):
|
||
if passcodeType == .alphanumeric {
|
||
return false
|
||
}
|
||
return passcode == normalizeArabicNumeralString(code, type: .western)
|
||
case let .plaintextPassword(code):
|
||
if passcodeType != .alphanumeric {
|
||
return false
|
||
}
|
||
return passcode == code
|
||
}
|
||
}
|
||
```
|
||
|
||
### `submodules/TelegramUI/Sources/AppDelegate.swift` — класс кэша и хуки разблокировки (полные строки файла)
|
||
|
||
```swift
|
||
#if canImport(SGSettingsUI)
|
||
private final class DoubleBottomHiddenIdsCache {
|
||
var hiddenIds: [Int64] = []
|
||
var disposable: Disposable?
|
||
|
||
init(accountManager: AccountManager<TelegramAccountManagerTypes>) {
|
||
self.disposable = (accountManager.accountRecords()
|
||
|> deliverOnMainQueue).start(next: { [weak self] view in
|
||
self?.hiddenIds = view.records
|
||
.filter { $0.attributes.contains(where: { $0.isHiddenAccountAttribute }) }
|
||
.map { $0.id.int64 }
|
||
})
|
||
}
|
||
}
|
||
#endif
|
||
```
|
||
|
||
```swift
|
||
#if canImport(SGSettingsUI)
|
||
let doubleBottomHiddenIdsCache = DoubleBottomHiddenIdsCache(accountManager: accountManager)
|
||
appLockContext.additionalPasscodeCheck = { passcode in
|
||
guard VarSystemNGSettings.isDoubleBottomOn else { return false }
|
||
if DoubleBottomPasscodeStore.secretPasscodeMatches(passcode) { return true }
|
||
let ids = doubleBottomHiddenIdsCache.hiddenIds
|
||
if !ids.isEmpty, DoubleBottomPasscodeStore.accountId(matchingPasscode: passcode, candidateIds: ids) != nil { return true }
|
||
return false
|
||
}
|
||
appLockContext.onUnlockWithPasscode = { [weak sharedContext] passcode in
|
||
guard let sharedContext = sharedContext, VarSystemNGSettings.isDoubleBottomOn else { return }
|
||
let _ = (accountManager.accessChallengeData()
|
||
|> take(1)
|
||
|> deliverOnMainQueue).start(next: { [weak sharedContext] challengeView in
|
||
guard let sharedContext = sharedContext else { return }
|
||
let challengeData = challengeView.data
|
||
if doubleBottomCheckPasscode(passcode, challengeData: challengeData) {
|
||
DoubleBottomViewingSecretStore.setViewingWithSecretPasscode(false)
|
||
} else if DoubleBottomPasscodeStore.secretPasscodeMatches(passcode) {
|
||
DoubleBottomViewingSecretStore.setViewingWithSecretPasscode(true)
|
||
} else {
|
||
let _ = (accountManager.accountRecords()
|
||
|> take(1)
|
||
|> deliverOnMainQueue).start(next: { view in
|
||
let hiddenIds = view.records
|
||
.filter { $0.attributes.contains(where: { $0.isHiddenAccountAttribute }) }
|
||
.map { $0.id.int64 }
|
||
guard !hiddenIds.isEmpty,
|
||
let matchedId = DoubleBottomPasscodeStore.accountId(matchingPasscode: passcode, candidateIds: hiddenIds) else { return }
|
||
sharedContext.switchToAccount(id: AccountRecordId(rawValue: matchedId))
|
||
})
|
||
}
|
||
})
|
||
}
|
||
#endif
|
||
```
|
||
|
||
Точка входа в настройках GLEGram (пункты меню, не вся функция `gleGramAppearanceEntries`):
|
||
|
||
```swift
|
||
entries.append(.header(id: id.count, section: .doubleBottom, text: (lang == "ru" ? "ДВОЙНОЕ ДНО" : "DOUBLE BOTTOM"), badge: nil))
|
||
entries.append(.disclosure(id: id.count, section: .doubleBottom, link: .doubleBottomSettings, text: (lang == "ru" ? "Двойное дно" : "Double Bottom")))
|
||
entries.append(.notice(id: id.count, section: .doubleBottom, text: (lang == "ru" ? "Скрытые аккаунты и вход по паролю. Разные пароли открывают разные профили." : "Hidden accounts and passcode access. Different passwords open different profiles.")))
|
||
```
|
||
|
||
---
|
||
|
||
## 2. Пароль при заходе в чат
|
||
|
||
**Смысл:** список защищённых peer id в UserDefaults; при открытии чата показывается `UIAlertController` с полем пароля; проверка либо через `doubleBottomCheckPasscode` (код Telegram на устройстве), либо через отдельный пароль в Keychain (`ProtectedChatsStore`).
|
||
|
||
### `Swiftgram/SGSettingsUI/Sources/ProtectedChatsStore.swift` (полностью)
|
||
|
||
См. файл в репозитории — ниже идентичное содержимое.
|
||
|
||
```swift
|
||
// MARK: Swiftgram – Password for selected chats/folders
|
||
import Foundation
|
||
import Security
|
||
|
||
private let enabledKey = "sg_protected_chats_enabled"
|
||
private let peerIdsKey = "sg_protected_chat_peer_ids"
|
||
private let folderIdsKey = "sg_protected_folder_ids"
|
||
private let useDevicePasscodeKey = "sg_protected_chats_use_device_passcode"
|
||
private let serviceName = "SwiftgramProtectedChats"
|
||
private let customPasscodeAccount = "chats"
|
||
|
||
public enum ProtectedChatsStore {
|
||
public static var isEnabled: Bool {
|
||
get { UserDefaults.standard.bool(forKey: enabledKey) }
|
||
set { UserDefaults.standard.set(newValue, forKey: enabledKey) }
|
||
}
|
||
|
||
public static var useDevicePasscode: Bool {
|
||
get { UserDefaults.standard.object(forKey: useDevicePasscodeKey) as? Bool ?? true }
|
||
set { UserDefaults.standard.set(newValue, forKey: useDevicePasscodeKey) }
|
||
}
|
||
|
||
public static var protectedPeerIds: Set<Int64> {
|
||
get {
|
||
let list = UserDefaults.standard.array(forKey: peerIdsKey) as? [Int64] ?? []
|
||
return Set(list)
|
||
}
|
||
set {
|
||
UserDefaults.standard.set(Array(newValue), forKey: peerIdsKey)
|
||
}
|
||
}
|
||
|
||
public static var protectedFolderIds: Set<Int32> {
|
||
get {
|
||
let list = UserDefaults.standard.array(forKey: folderIdsKey) as? [Int32] ?? []
|
||
return Set(list)
|
||
}
|
||
set {
|
||
UserDefaults.standard.set(Array(newValue), forKey: folderIdsKey)
|
||
}
|
||
}
|
||
|
||
public static func addProtectedPeer(_ peerId: Int64) {
|
||
var set = protectedPeerIds
|
||
set.insert(peerId)
|
||
protectedPeerIds = set
|
||
}
|
||
|
||
public static func removeProtectedPeer(_ peerId: Int64) {
|
||
var set = protectedPeerIds
|
||
set.remove(peerId)
|
||
protectedPeerIds = set
|
||
}
|
||
|
||
public static func addProtectedFolder(_ folderId: Int32) {
|
||
var set = protectedFolderIds
|
||
set.insert(folderId)
|
||
protectedFolderIds = set
|
||
}
|
||
|
||
public static func removeProtectedFolder(_ folderId: Int32) {
|
||
var set = protectedFolderIds
|
||
set.remove(folderId)
|
||
protectedFolderIds = set
|
||
}
|
||
|
||
public static func isProtected(peerId: Int64) -> Bool {
|
||
isEnabled && protectedPeerIds.contains(peerId)
|
||
}
|
||
|
||
public static func isProtected(folderId: Int32) -> Bool {
|
||
isEnabled && protectedFolderIds.contains(folderId)
|
||
}
|
||
|
||
// MARK: - Custom passcode (when not using device passcode)
|
||
|
||
public static func setCustomPasscode(_ passcode: String) {
|
||
let data = passcode.data(using: .utf8)!
|
||
let query: [String: Any] = [
|
||
kSecClass as String: kSecClassGenericPassword,
|
||
kSecAttrService as String: serviceName,
|
||
kSecAttrAccount as String: customPasscodeAccount
|
||
]
|
||
var addQuery = query
|
||
addQuery[kSecValueData as String] = data
|
||
var status = SecItemAdd(addQuery as CFDictionary, nil)
|
||
if status == errSecDuplicateItem {
|
||
SecItemDelete(query as CFDictionary)
|
||
status = SecItemAdd(addQuery as CFDictionary, nil)
|
||
}
|
||
}
|
||
|
||
public static func customPasscodeMatches(_ passcode: String) -> Bool {
|
||
guard let stored = getCustomPasscode() else { return false }
|
||
return stored == passcode
|
||
}
|
||
|
||
public static func hasCustomPasscode() -> Bool {
|
||
getCustomPasscode() != nil
|
||
}
|
||
|
||
public static func removeCustomPasscode() {
|
||
let query: [String: Any] = [
|
||
kSecClass as String: kSecClassGenericPassword,
|
||
kSecAttrService as String: serviceName,
|
||
kSecAttrAccount as String: customPasscodeAccount
|
||
]
|
||
SecItemDelete(query as CFDictionary)
|
||
}
|
||
|
||
private static func getCustomPasscode() -> String? {
|
||
let query: [String: Any] = [
|
||
kSecClass as String: kSecClassGenericPassword,
|
||
kSecAttrService as String: serviceName,
|
||
kSecAttrAccount as String: customPasscodeAccount,
|
||
kSecReturnData as String: true,
|
||
kSecMatchLimit as String: kSecMatchLimitOne
|
||
]
|
||
var result: AnyObject?
|
||
let status = SecItemCopyMatching(query as CFDictionary, &result)
|
||
guard status == errSecSuccess, let data = result as? Data, let string = String(data: data, encoding: .utf8) else {
|
||
return nil
|
||
}
|
||
return string
|
||
}
|
||
}
|
||
```
|
||
|
||
### `Swiftgram/SGSettingsUI/Sources/ProtectedChatsSettingsController.swift` (полностью)
|
||
|
||
```swift
|
||
// MARK: Swiftgram – Password for selected chats/folders settings
|
||
import Foundation
|
||
import UIKit
|
||
import Display
|
||
import SwiftSignalKit
|
||
import TelegramCore
|
||
import TelegramPresentationData
|
||
import ItemListUI
|
||
import PresentationDataUtils
|
||
import AccountContext
|
||
import PasscodeUI
|
||
|
||
private enum ProtectedChatsEntry: ItemListNodeEntry {
|
||
case enabled(String, Bool)
|
||
case useDevicePasscode(String, Bool)
|
||
case setCustomPasscode(String)
|
||
case addChat(String)
|
||
case protectedPeer(id: Int64, title: String)
|
||
case notice(String)
|
||
|
||
var section: ItemListSectionId {
|
||
switch self {
|
||
case .enabled, .useDevicePasscode, .setCustomPasscode, .notice: return 0
|
||
case .addChat, .protectedPeer: return 1
|
||
}
|
||
}
|
||
|
||
var stableId: Int {
|
||
switch self {
|
||
case .enabled: return 0
|
||
case .useDevicePasscode: return 1
|
||
case .setCustomPasscode: return 2
|
||
case .addChat: return 3
|
||
case .protectedPeer(let id, _): return 100 + Int(id % 100000)
|
||
case .notice: return 200
|
||
}
|
||
}
|
||
|
||
static func < (lhs: ProtectedChatsEntry, rhs: ProtectedChatsEntry) -> Bool {
|
||
lhs.stableId < rhs.stableId
|
||
}
|
||
|
||
func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
|
||
let args = arguments as! ProtectedChatsArguments
|
||
let lang = presentationData.strings.baseLanguageCode
|
||
switch self {
|
||
case let .enabled(title, value):
|
||
return ItemListSwitchItem(presentationData: presentationData, title: title, value: value, sectionId: section, style: .blocks, updated: { args.toggleEnabled($0) })
|
||
case let .useDevicePasscode(title, value):
|
||
return ItemListSwitchItem(presentationData: presentationData, title: title, value: value, sectionId: section, style: .blocks, updated: { args.toggleUseDevicePasscode($0) })
|
||
case let .setCustomPasscode(title):
|
||
return ItemListDisclosureItem(presentationData: presentationData, title: title, label: "", sectionId: section, style: .blocks, action: { args.setCustomPasscode() })
|
||
case let .addChat(title):
|
||
return ItemListDisclosureItem(presentationData: presentationData, title: title, label: "", sectionId: section, style: .blocks, action: { args.addChat() })
|
||
case let .protectedPeer(_, title):
|
||
return ItemListDisclosureItem(presentationData: presentationData, title: title, label: lang == "ru" ? "Удалить" : "Remove", sectionId: section, style: .blocks, action: { [self] in
|
||
if case let .protectedPeer(peerId, _) = self { args.removePeer(peerId) }
|
||
})
|
||
case let .notice(text):
|
||
return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: section)
|
||
}
|
||
}
|
||
}
|
||
|
||
private final class ProtectedChatsArguments {
|
||
let context: AccountContext
|
||
let toggleEnabled: (Bool) -> Void
|
||
let toggleUseDevicePasscode: (Bool) -> Void
|
||
let setCustomPasscode: () -> Void
|
||
let addChat: () -> Void
|
||
let removePeer: (Int64) -> Void
|
||
|
||
init(context: AccountContext, toggleEnabled: @escaping (Bool) -> Void, toggleUseDevicePasscode: @escaping (Bool) -> Void, setCustomPasscode: @escaping () -> Void, addChat: @escaping () -> Void, removePeer: @escaping (Int64) -> Void) {
|
||
self.context = context
|
||
self.toggleEnabled = toggleEnabled
|
||
self.toggleUseDevicePasscode = toggleUseDevicePasscode
|
||
self.setCustomPasscode = setCustomPasscode
|
||
self.addChat = addChat
|
||
self.removePeer = removePeer
|
||
}
|
||
}
|
||
|
||
public func protectedChatsSettingsController(context: AccountContext) -> ViewController {
|
||
let lang = context.sharedContext.currentPresentationData.with { $0 }.strings.baseLanguageCode
|
||
let title = lang == "ru" ? "Пароль для чатов" : "Password for chats"
|
||
|
||
let statePromise = Promise<[(Int64, String)]>()
|
||
let peerTitles: [(Int64, String)] = ProtectedChatsStore.protectedPeerIds.map { ($0, "Chat \($0)") }
|
||
statePromise.set(.single(peerTitles))
|
||
|
||
var pushControllerImpl: ((ViewController) -> Void)?
|
||
|
||
let arguments = ProtectedChatsArguments(
|
||
context: context,
|
||
toggleEnabled: { value in
|
||
ProtectedChatsStore.isEnabled = value
|
||
},
|
||
toggleUseDevicePasscode: { value in
|
||
ProtectedChatsStore.useDevicePasscode = value
|
||
},
|
||
setCustomPasscode: {
|
||
let setup = PasscodeSetupController(context: context, mode: .setup(change: false, .digits6))
|
||
setup.complete = { passcode, _ in
|
||
ProtectedChatsStore.setCustomPasscode(passcode)
|
||
ProtectedChatsStore.useDevicePasscode = false
|
||
_ = (setup.navigationController as? NavigationController)?.popViewController(animated: true)
|
||
}
|
||
pushControllerImpl?(setup)
|
||
},
|
||
addChat: {
|
||
let filter: ChatListNodePeersFilter = [.onlyWriteable, .excludeDisabled, .doNotSearchMessages]
|
||
let controller = context.sharedContext.makePeerSelectionController(PeerSelectionControllerParams(
|
||
context: context,
|
||
filter: filter,
|
||
hasContactSelector: false,
|
||
hasGlobalSearch: true,
|
||
title: lang == "ru" ? "Выберите чат" : "Select chat"
|
||
))
|
||
controller.peerSelected = { [weak controller] peer, _ in
|
||
let peerId = peer.id.toInt64()
|
||
ProtectedChatsStore.addProtectedPeer(peerId)
|
||
statePromise.set(.single(ProtectedChatsStore.protectedPeerIds.map { ($0, "Chat \($0)") }))
|
||
_ = (controller?.navigationController as? NavigationController)?.popViewController(animated: true)
|
||
}
|
||
pushControllerImpl?(controller)
|
||
},
|
||
removePeer: { peerId in
|
||
ProtectedChatsStore.removeProtectedPeer(peerId)
|
||
statePromise.set(.single(ProtectedChatsStore.protectedPeerIds.map { ($0, "Chat \($0)") }))
|
||
}
|
||
)
|
||
|
||
let signal = combineLatest(
|
||
context.sharedContext.presentationData,
|
||
statePromise.get()
|
||
)
|
||
|> map { presentationData, peerTitles -> (ItemListControllerState, (ItemListNodeState, ProtectedChatsArguments)) in
|
||
let enabled = ProtectedChatsStore.isEnabled
|
||
let useDevice = ProtectedChatsStore.useDevicePasscode
|
||
let lang = presentationData.strings.baseLanguageCode
|
||
|
||
var entries: [ProtectedChatsEntry] = []
|
||
entries.append(.enabled(lang == "ru" ? "Пароль для чатов" : "Password for chats", enabled))
|
||
if enabled {
|
||
entries.append(.useDevicePasscode(lang == "ru" ? "Использовать пароль Telegram" : "Use Telegram passcode", useDevice))
|
||
if !useDevice {
|
||
entries.append(.setCustomPasscode(lang == "ru" ? "Установить отдельный пароль" : "Set separate passcode"))
|
||
}
|
||
entries.append(.notice(lang == "ru" ? "При открытии выбранных чатов будет запрашиваться пароль." : "Opening selected chats will require passcode."))
|
||
}
|
||
|
||
entries.append(.addChat(lang == "ru" ? "Добавить чат" : "Add chat"))
|
||
for (id, t) in peerTitles.sorted(by: { $0.0 < $1.0 }) {
|
||
entries.append(.protectedPeer(id: id, title: t))
|
||
}
|
||
|
||
let controllerState = ItemListControllerState(
|
||
presentationData: ItemListPresentationData(presentationData),
|
||
title: .text(title),
|
||
leftNavigationButton: nil,
|
||
rightNavigationButton: nil,
|
||
backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back)
|
||
)
|
||
let listState = ItemListNodeState(
|
||
presentationData: ItemListPresentationData(presentationData),
|
||
entries: entries,
|
||
style: .blocks,
|
||
ensureVisibleItemTag: nil,
|
||
footerItem: nil,
|
||
initialScrollToItem: nil
|
||
)
|
||
return (controllerState, (listState, arguments))
|
||
}
|
||
|
||
let signalTyped: Signal<(ItemListControllerState, (ItemListNodeState, ProtectedChatsArguments)), NoError> = signal
|
||
let controller = ItemListController(context: context, state: signalTyped)
|
||
pushControllerImpl = { [weak controller] (vc: ViewController) in
|
||
(controller?.navigationController as? NavigationController)?.pushViewController(vc)
|
||
}
|
||
return controller
|
||
}
|
||
```
|
||
|
||
### `submodules/TelegramUI/Sources/SharedAccountContext.swift` — проверка при открытии чата (полный фрагмент)
|
||
|
||
```swift
|
||
public func isChatProtected(peerId: PeerId) -> Bool {
|
||
#if canImport(SGSettingsUI)
|
||
return ProtectedChatsStore.isEnabled && ProtectedChatsStore.isProtected(peerId: peerId.toInt64())
|
||
#else
|
||
return false
|
||
#endif
|
||
}
|
||
```
|
||
|
||
```swift
|
||
public func navigateToChatController(_ params: NavigateToChatControllerParams) {
|
||
if case let .peer(peer) = params.chatLocation {
|
||
let accountId = params.context.account.peerId.toInt64()
|
||
let peerId = peer.id.toInt64()
|
||
SGPluginHooks.willOpenChatRunner?(accountId, peerId)
|
||
if let eventResult = SGPluginHooks.emitEvent("chat.willOpen", ["accountId": accountId, "peerId": peerId, "subject": params.subject.map { String(describing: $0) } ?? ""]), eventResult["cancel"] as? Bool == true {
|
||
return
|
||
}
|
||
}
|
||
#if canImport(SGSettingsUI)
|
||
/// Saved Messages «Chats» tab opens dialogs as `.replyThread` with `peerId == account` and real peer id in `threadId`.
|
||
let peerIdValue: Int64 = {
|
||
switch params.chatLocation {
|
||
case let .peer(peer):
|
||
return peer.id.toInt64()
|
||
case let .replyThread(message):
|
||
if message.peerId == params.context.account.peerId,
|
||
!message.isForumPost, !message.isChannelPost, !message.isMonoforumPost {
|
||
return message.threadId
|
||
}
|
||
return message.peerId.toInt64()
|
||
}
|
||
}()
|
||
if ProtectedChatsStore.isEnabled && ProtectedChatsStore.isProtected(peerId: peerIdValue) {
|
||
let presentationData = params.context.sharedContext.currentPresentationData.with { $0 }
|
||
let strings = presentationData.strings
|
||
let useDevice = ProtectedChatsStore.useDevicePasscode
|
||
let title = presentationData.strings.baseLanguageCode == "ru" ? "Введите пароль" : "Enter passcode"
|
||
let message = presentationData.strings.baseLanguageCode == "ru" ? "Этот чат защищён паролем." : "This chat is protected with a passcode."
|
||
var textField: UITextField?
|
||
let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
|
||
alert.addTextField { field in
|
||
field.isSecureTextEntry = true
|
||
field.placeholder = presentationData.strings.baseLanguageCode == "ru" ? "Пароль" : "Passcode"
|
||
textField = field
|
||
}
|
||
let cancelTitle = strings.Common_Cancel
|
||
let okTitle = strings.Common_OK
|
||
alert.addAction(UIAlertAction(title: cancelTitle, style: .cancel) { _ in })
|
||
alert.addAction(UIAlertAction(title: okTitle, style: .default) { [weak self] _ in
|
||
guard let self = self, let entered = textField?.text, !entered.isEmpty else { return }
|
||
let accountManager = self.accountManager
|
||
let proceed: () -> Void = {
|
||
DispatchQueue.main.async {
|
||
navigateToChatControllerImpl(params)
|
||
}
|
||
}
|
||
if useDevice {
|
||
let _ = (accountManager.accessChallengeData()
|
||
|> take(1)
|
||
|> deliverOnMainQueue).start(next: { view in
|
||
if doubleBottomCheckPasscode(entered, challengeData: view.data) {
|
||
alert.dismiss(animated: true, completion: proceed)
|
||
} else {
|
||
let err = UIAlertController(title: nil, message: presentationData.strings.baseLanguageCode == "ru" ? "Неверный пароль" : "Wrong passcode", preferredStyle: .alert)
|
||
err.addAction(UIAlertAction(title: strings.Common_OK, style: .default) { _ in })
|
||
alert.present(err, animated: true)
|
||
}
|
||
})
|
||
} else {
|
||
if ProtectedChatsStore.customPasscodeMatches(entered) {
|
||
alert.dismiss(animated: true, completion: proceed)
|
||
} else {
|
||
let err = UIAlertController(title: nil, message: presentationData.strings.baseLanguageCode == "ru" ? "Неверный пароль" : "Wrong passcode", preferredStyle: .alert)
|
||
err.addAction(UIAlertAction(title: strings.Common_OK, style: .default) { _ in })
|
||
alert.present(err, animated: true)
|
||
}
|
||
}
|
||
})
|
||
if let top = params.navigationController.viewControllers.last {
|
||
top.present(alert, animated: true)
|
||
} else {
|
||
navigateToChatControllerImpl(params)
|
||
}
|
||
return
|
||
}
|
||
#endif
|
||
navigateToChatControllerImpl(params)
|
||
}
|
||
```
|
||
|
||
Пункты в GLEGram (фрагмент `GLEGramSettingsController.swift`):
|
||
|
||
```swift
|
||
entries.append(.header(id: id.count, section: .protectedChats, text: (lang == "ru" ? "ПАРОЛЬ ДЛЯ ЧАТОВ" : "PASSWORD FOR CHATS"), badge: nil))
|
||
entries.append(.disclosure(id: id.count, section: .protectedChats, link: .protectedChatsSettings, text: (lang == "ru" ? "Пароль при заходе в чат" : "Password when entering chat")))
|
||
entries.append(.notice(id: id.count, section: .protectedChats, text: (lang == "ru" ? "Выберите чаты и/или папки, при открытии которых нужно вводить пароль (пароль Telegram или отдельный)." : "Select chats and/or folders that require a passcode to open (device passcode or a separate one).")))
|
||
```
|
||
|
||
---
|
||
|
||
## 3. Смена голоса (Voice Morpher)
|
||
|
||
**Смысл:** локальная обработка OGG голосовых сообщений: декодирование Opus → `AVAudioEngine` (тон, скорость, искажение) → снова OGG. Настройки и пресеты — `VoiceMorpherManager`; вызов нативного процессора — `VoiceMorpherEngine` → `VoiceMorpherProcessor`.
|
||
|
||
### Пункты в GLEGram (`Swiftgram/SGSettingsUI/Sources/GLEGramSettingsController.swift`)
|
||
|
||
```swift
|
||
// MARK: Voice Morpher (Privacy tab) — ghostgram-style local processing
|
||
entries.append(.header(id: id.count, section: .voiceChanger, text: (lang == "ru" ? "СМЕНА ГОЛОСА" : "VOICE MORPHER"), badge: nil))
|
||
let vm = VoiceMorpherManager.shared
|
||
entries.append(.toggle(id: id.count, section: .voiceChanger, settingName: .voiceChangerEnabled, value: vm.isEnabled, text: (lang == "ru" ? "Изменять голос при записи" : "Change voice when recording"), enabled: true))
|
||
let ru = lang == "ru"
|
||
let displayedPreset: VoiceMorpherManager.VoicePreset = {
|
||
if !vm.isEnabled { return .disabled }
|
||
if vm.selectedPresetId == 0 { return .anonymous }
|
||
return vm.selectedPreset
|
||
}()
|
||
let presetTitle = displayedPreset.title(langIsRu: ru)
|
||
entries.append(.disclosure(id: id.count, section: .voiceChanger, link: .voiceChangerVoicePicker, text: (ru ? "Эффект: \(presetTitle)" : "Effect: \(presetTitle)")))
|
||
entries.append(.notice(id: id.count, section: .voiceChanger, text: (ru
|
||
? "Локально: OGG → эффекты iOS (тон, искажение) → снова OGG. Без серверов. Как в ghostgram iOS."
|
||
: "On-device: OGG → iOS audio effects (pitch, distortion) → OGG. No servers. Same approach as ghostgram iOS.")))
|
||
```
|
||
|
||
### `submodules/TelegramCore/Sources/VoiceMorpher/VoiceMorpherManager.swift` (полностью)
|
||
|
||
```swift
|
||
import Foundation
|
||
|
||
/// GLEGram / ghostgram-style: local voice morphing for outgoing voice messages (UserDefaults).
|
||
public final class VoiceMorpherManager {
|
||
public static let shared = VoiceMorpherManager()
|
||
|
||
public enum VoicePreset: Int, CaseIterable {
|
||
case disabled = 0
|
||
case anonymous = 1
|
||
case female = 2
|
||
case male = 3
|
||
case child = 4
|
||
case robot = 5
|
||
|
||
public func title(langIsRu: Bool) -> String {
|
||
switch self {
|
||
case .disabled:
|
||
return langIsRu ? "Выключено" : "Off"
|
||
case .anonymous:
|
||
return langIsRu ? "Аноним" : "Anonymous"
|
||
case .female:
|
||
return langIsRu ? "Женский" : "Female"
|
||
case .male:
|
||
return langIsRu ? "Мужской" : "Male"
|
||
case .child:
|
||
return langIsRu ? "Ребёнок" : "Child"
|
||
case .robot:
|
||
return langIsRu ? "Робот" : "Robot"
|
||
}
|
||
}
|
||
|
||
public func subtitle(langIsRu: Bool) -> String {
|
||
switch self {
|
||
case .disabled:
|
||
return langIsRu ? "Без изменений" : "Unchanged"
|
||
case .anonymous:
|
||
return langIsRu ? "Искажённый голос" : "Distorted voice"
|
||
case .female:
|
||
return langIsRu ? "Выше тон" : "Higher pitch"
|
||
case .male:
|
||
return langIsRu ? "Ниже тон" : "Lower pitch"
|
||
case .child:
|
||
return langIsRu ? "Детский тон" : "Child-like"
|
||
case .robot:
|
||
return langIsRu ? "Металлический эффект" : "Metallic effect"
|
||
}
|
||
}
|
||
}
|
||
|
||
private enum Keys {
|
||
static let isEnabled = "VoiceMorpher.isEnabled"
|
||
static let selectedPreset = "VoiceMorpher.selectedPreset"
|
||
}
|
||
|
||
private let defaults = UserDefaults.standard
|
||
|
||
public var isEnabled: Bool {
|
||
get { defaults.bool(forKey: Keys.isEnabled) }
|
||
set {
|
||
defaults.set(newValue, forKey: Keys.isEnabled)
|
||
notifyChanged()
|
||
}
|
||
}
|
||
|
||
public var selectedPresetId: Int {
|
||
get { defaults.integer(forKey: Keys.selectedPreset) }
|
||
set {
|
||
defaults.set(newValue, forKey: Keys.selectedPreset)
|
||
notifyChanged()
|
||
}
|
||
}
|
||
|
||
public var selectedPreset: VoicePreset {
|
||
VoicePreset(rawValue: selectedPresetId) ?? .disabled
|
||
}
|
||
|
||
public var effectivePreset: VoicePreset {
|
||
guard isEnabled else { return .disabled }
|
||
return selectedPreset
|
||
}
|
||
|
||
public static let settingsChangedNotification = Notification.Name("VoiceMorpherSettingsChanged")
|
||
|
||
private func notifyChanged() {
|
||
NotificationCenter.default.post(name: Self.settingsChangedNotification, object: nil)
|
||
}
|
||
|
||
private init() {}
|
||
}
|
||
```
|
||
|
||
### `submodules/TelegramUI/Sources/VoiceMorpher/VoiceMorpherEngine.swift` (полностью)
|
||
|
||
```swift
|
||
import Foundation
|
||
import OpusBinding
|
||
import TelegramCore
|
||
|
||
/// Local OGG voice morphing (ghostgram-style): decode → AVAudioEngine effects → encode.
|
||
public final class VoiceMorpherEngine {
|
||
public static let shared = VoiceMorpherEngine()
|
||
|
||
private init() {}
|
||
|
||
public func processOggData(
|
||
_ inputData: Data,
|
||
completion: @escaping (Swift.Result<Data, Error>) -> Void
|
||
) {
|
||
let preset = VoiceMorpherManager.shared.effectivePreset
|
||
|
||
guard preset != .disabled else {
|
||
completion(.success(inputData))
|
||
return
|
||
}
|
||
|
||
let objcPreset: VoiceMorpherPreset
|
||
switch preset {
|
||
case .disabled:
|
||
objcPreset = .disabled
|
||
case .anonymous:
|
||
objcPreset = .anonymous
|
||
case .female:
|
||
objcPreset = .female
|
||
case .male:
|
||
objcPreset = .male
|
||
case .child:
|
||
objcPreset = .child
|
||
case .robot:
|
||
objcPreset = .robot
|
||
}
|
||
|
||
VoiceMorpherProcessor.processOggData(inputData, preset: objcPreset) { outputData, error in
|
||
if let error {
|
||
completion(.failure(error))
|
||
} else if let outputData {
|
||
completion(.success(outputData))
|
||
} else {
|
||
completion(.failure(VoiceMorpherError.processingFailed))
|
||
}
|
||
}
|
||
}
|
||
|
||
public enum VoiceMorpherError: Error, LocalizedError {
|
||
case processingFailed
|
||
|
||
public var errorDescription: String? {
|
||
switch self {
|
||
case .processingFailed:
|
||
return "Voice morphing processing failed"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
### `submodules/OpusBinding/PublicHeaders/OpusBinding/VoiceMorpherProcessor.h` (полностью)
|
||
|
||
```objc
|
||
#import <AVFoundation/AVFoundation.h>
|
||
#import <Foundation/Foundation.h>
|
||
|
||
NS_ASSUME_NONNULL_BEGIN
|
||
|
||
/// VoiceMorpherProcessor - Processes OGG/Opus audio with voice effects
|
||
/// Decodes OGG -> applies effects -> re-encodes to OGG
|
||
@interface VoiceMorpherProcessor : NSObject
|
||
|
||
typedef NS_ENUM(NSInteger, VoiceMorpherPreset) {
|
||
VoiceMorpherPresetDisabled = 0,
|
||
VoiceMorpherPresetAnonymous = 1,
|
||
VoiceMorpherPresetFemale = 2,
|
||
VoiceMorpherPresetMale = 3,
|
||
VoiceMorpherPresetChild = 4,
|
||
VoiceMorpherPresetRobot = 5
|
||
};
|
||
|
||
/// Process OGG audio data with voice morphing effect
|
||
+ (void)processOggData:(NSData *)inputData
|
||
preset:(VoiceMorpherPreset)preset
|
||
completion:(void (^)(NSData *_Nullable outputData,
|
||
NSError *_Nullable error))completion;
|
||
|
||
+ (float)pitchShiftForPreset:(VoiceMorpherPreset)preset;
|
||
+ (float)rateForPreset:(VoiceMorpherPreset)preset;
|
||
|
||
@end
|
||
|
||
NS_ASSUME_NONNULL_END
|
||
```
|
||
|
||
### `submodules/OpusBinding/Sources/VoiceMorpherProcessor.m` (полностью)
|
||
|
||
```objc
|
||
#import "VoiceMorpherProcessor.h"
|
||
#import "OggOpusReader.h"
|
||
#import "TGDataItem.h"
|
||
#import "TGOggOpusWriter.h"
|
||
|
||
@implementation VoiceMorpherProcessor
|
||
|
||
+ (float)pitchShiftForPreset:(VoiceMorpherPreset)preset {
|
||
switch (preset) {
|
||
case VoiceMorpherPresetDisabled:
|
||
return 0;
|
||
case VoiceMorpherPresetAnonymous:
|
||
return -200;
|
||
case VoiceMorpherPresetFemale:
|
||
return 600; // More feminine - higher pitch
|
||
case VoiceMorpherPresetMale:
|
||
return -300;
|
||
case VoiceMorpherPresetChild:
|
||
return 600;
|
||
case VoiceMorpherPresetRobot:
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
+ (float)rateForPreset:(VoiceMorpherPreset)preset {
|
||
switch (preset) {
|
||
case VoiceMorpherPresetDisabled:
|
||
return 1.0;
|
||
case VoiceMorpherPresetAnonymous:
|
||
return 0.95;
|
||
case VoiceMorpherPresetFemale:
|
||
return 1.08; // Slightly faster for feminine effect
|
||
case VoiceMorpherPresetMale:
|
||
return 0.95;
|
||
case VoiceMorpherPresetChild:
|
||
return 1.1;
|
||
case VoiceMorpherPresetRobot:
|
||
return 1.0;
|
||
}
|
||
}
|
||
|
||
+ (void)processOggData:(NSData *)inputData
|
||
preset:(VoiceMorpherPreset)preset
|
||
completion:
|
||
(void (^)(NSData *_Nullable, NSError *_Nullable))completion {
|
||
|
||
if (preset == VoiceMorpherPresetDisabled) {
|
||
completion(inputData, nil);
|
||
return;
|
||
}
|
||
|
||
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
|
||
^{
|
||
NSError *error = nil;
|
||
NSData *result = [self processOggDataSync:inputData
|
||
preset:preset
|
||
error:&error];
|
||
|
||
// Call completion on background thread to avoid deadlock
|
||
// when caller uses semaphore on main thread
|
||
completion(result, error);
|
||
});
|
||
}
|
||
|
||
+ (NSData *_Nullable)processOggDataSync:(NSData *)inputData
|
||
preset:(VoiceMorpherPreset)preset
|
||
error:(NSError **)error {
|
||
// Save input OGG to temp file for decoding
|
||
NSString *tempInputPath = [NSTemporaryDirectory()
|
||
stringByAppendingPathComponent:
|
||
[NSString
|
||
stringWithFormat:@"vm_in_%lld.ogg", (long long)[[NSDate date]
|
||
timeIntervalSince1970] *
|
||
1000]];
|
||
|
||
[inputData writeToFile:tempInputPath atomically:YES];
|
||
|
||
// Decode OGG to PCM
|
||
OggOpusReader *reader = [[OggOpusReader alloc] initWithPath:tempInputPath];
|
||
if (!reader) {
|
||
if (error) {
|
||
*error = [NSError
|
||
errorWithDomain:@"VoiceMorpher"
|
||
code:1
|
||
userInfo:@{
|
||
NSLocalizedDescriptionKey : @"Failed to open OGG file"
|
||
}];
|
||
}
|
||
[[NSFileManager defaultManager] removeItemAtPath:tempInputPath error:nil];
|
||
return nil;
|
||
}
|
||
|
||
// Opus outputs 16-bit stereo at 48kHz
|
||
NSMutableData *pcmData = [[NSMutableData alloc] init];
|
||
int16_t buffer[5760 * 2]; // Max frame size * channels
|
||
int32_t samplesRead;
|
||
|
||
while ((samplesRead = [reader read:buffer
|
||
bufSize:sizeof(buffer) / sizeof(buffer[0])]) > 0) {
|
||
[pcmData appendBytes:buffer length:samplesRead * sizeof(int16_t)];
|
||
}
|
||
|
||
[[NSFileManager defaultManager] removeItemAtPath:tempInputPath error:nil];
|
||
|
||
if (pcmData.length == 0) {
|
||
if (error) {
|
||
*error =
|
||
[NSError errorWithDomain:@"VoiceMorpher"
|
||
code:2
|
||
userInfo:@{
|
||
NSLocalizedDescriptionKey : @"No PCM data decoded"
|
||
}];
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
// Apply voice effects using AVAudioEngine
|
||
NSData *processedPcm = [self applyEffectsToPcmData:pcmData
|
||
preset:preset
|
||
error:error];
|
||
if (!processedPcm) {
|
||
return nil;
|
||
}
|
||
|
||
// Encode processed PCM back to OGG
|
||
TGDataItem *dataItem = [[TGDataItem alloc] init];
|
||
TGOggOpusWriter *writer = [[TGOggOpusWriter alloc] init];
|
||
|
||
if (![writer beginWithDataItem:dataItem]) {
|
||
if (error) {
|
||
*error = [NSError
|
||
errorWithDomain:@"VoiceMorpher"
|
||
code:4
|
||
userInfo:@{
|
||
NSLocalizedDescriptionKey : @"Failed to begin OGG encoding"
|
||
}];
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
// Write PCM data in frames (960 samples = 20ms at 48kHz)
|
||
const int frameSize = 960 * sizeof(int16_t);
|
||
const uint8_t *bytes = processedPcm.bytes;
|
||
NSUInteger remaining = processedPcm.length;
|
||
NSUInteger offset = 0;
|
||
|
||
while (remaining >= frameSize) {
|
||
[writer writeFrame:(uint8_t *)(bytes + offset) frameByteCount:frameSize];
|
||
offset += frameSize;
|
||
remaining -= frameSize;
|
||
}
|
||
|
||
if (remaining > 0) {
|
||
uint8_t lastFrame[frameSize];
|
||
memset(lastFrame, 0, frameSize);
|
||
memcpy(lastFrame, bytes + offset, remaining);
|
||
[writer writeFrame:lastFrame frameByteCount:frameSize];
|
||
}
|
||
|
||
return [dataItem data];
|
||
}
|
||
|
||
+ (NSData *_Nullable)applyEffectsToPcmData:(NSData *)pcmData
|
||
preset:(VoiceMorpherPreset)preset
|
||
error:(NSError **)error {
|
||
NSUInteger sampleCount = pcmData.length / sizeof(int16_t);
|
||
const int16_t *int16Samples = (const int16_t *)pcmData.bytes;
|
||
|
||
float *floatSamples = (float *)malloc(sampleCount * sizeof(float));
|
||
if (!floatSamples) {
|
||
if (error) {
|
||
*error = [NSError
|
||
errorWithDomain:@"VoiceMorpher"
|
||
code:5
|
||
userInfo:@{
|
||
NSLocalizedDescriptionKey : @"Memory allocation failed"
|
||
}];
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
// Convert int16 to float (-1.0 to 1.0 range)
|
||
for (NSUInteger i = 0; i < sampleCount; i++) {
|
||
floatSamples[i] = (float)int16Samples[i] / 32768.0f;
|
||
}
|
||
|
||
// Create audio format (mono, 48kHz, float)
|
||
AVAudioFormat *format =
|
||
[[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
|
||
sampleRate:48000
|
||
channels:1
|
||
interleaved:NO];
|
||
|
||
AVAudioFrameCount frameCount = (AVAudioFrameCount)sampleCount;
|
||
AVAudioPCMBuffer *inputBuffer =
|
||
[[AVAudioPCMBuffer alloc] initWithPCMFormat:format
|
||
frameCapacity:frameCount];
|
||
inputBuffer.frameLength = frameCount;
|
||
|
||
memcpy(inputBuffer.floatChannelData[0], floatSamples,
|
||
sampleCount * sizeof(float));
|
||
free(floatSamples);
|
||
|
||
// Create engine and nodes
|
||
AVAudioEngine *engine = [[AVAudioEngine alloc] init];
|
||
AVAudioPlayerNode *playerNode = [[AVAudioPlayerNode alloc] init];
|
||
AVAudioUnitTimePitch *pitchNode = [[AVAudioUnitTimePitch alloc] init];
|
||
|
||
pitchNode.pitch = [self pitchShiftForPreset:preset];
|
||
pitchNode.rate = [self rateForPreset:preset];
|
||
|
||
[engine attachNode:playerNode];
|
||
[engine attachNode:pitchNode];
|
||
[engine connect:playerNode to:pitchNode format:format];
|
||
|
||
AVAudioNode *lastNode = pitchNode;
|
||
|
||
if (preset == VoiceMorpherPresetRobot) {
|
||
AVAudioUnitDistortion *distortion = [[AVAudioUnitDistortion alloc] init];
|
||
[distortion loadFactoryPreset:AVAudioUnitDistortionPresetSpeechRadioTower];
|
||
distortion.wetDryMix = 40;
|
||
[engine attachNode:distortion];
|
||
[engine connect:pitchNode to:distortion format:format];
|
||
lastNode = distortion;
|
||
} else if (preset == VoiceMorpherPresetAnonymous) {
|
||
AVAudioUnitDistortion *distortion = [[AVAudioUnitDistortion alloc] init];
|
||
[distortion
|
||
loadFactoryPreset:AVAudioUnitDistortionPresetSpeechCosmicInterference];
|
||
distortion.wetDryMix = 30;
|
||
[engine attachNode:distortion];
|
||
[engine connect:pitchNode to:distortion format:format];
|
||
lastNode = distortion;
|
||
}
|
||
|
||
[engine connect:lastNode to:engine.mainMixerNode format:format];
|
||
|
||
__block NSMutableData *outputData = [[NSMutableData alloc] init];
|
||
|
||
[engine.mainMixerNode
|
||
installTapOnBus:0
|
||
bufferSize:4096
|
||
format:format
|
||
block:^(AVAudioPCMBuffer *buffer, AVAudioTime *when) {
|
||
float *samples = buffer.floatChannelData[0];
|
||
AVAudioFrameCount count = buffer.frameLength;
|
||
|
||
int16_t *int16Buffer =
|
||
(int16_t *)malloc(count * sizeof(int16_t));
|
||
for (AVAudioFrameCount i = 0; i < count; i++) {
|
||
float sample = samples[i];
|
||
if (sample > 1.0f)
|
||
sample = 1.0f;
|
||
if (sample < -1.0f)
|
||
sample = -1.0f;
|
||
int16Buffer[i] = (int16_t)(sample * 32767.0f);
|
||
}
|
||
|
||
[outputData appendBytes:int16Buffer
|
||
length:count * sizeof(int16_t)];
|
||
free(int16Buffer);
|
||
}];
|
||
|
||
NSError *startError = nil;
|
||
[engine startAndReturnError:&startError];
|
||
if (startError) {
|
||
if (error) {
|
||
*error = startError;
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
[playerNode scheduleBuffer:inputBuffer
|
||
atTime:nil
|
||
options:0
|
||
completionHandler:nil];
|
||
[playerNode play];
|
||
|
||
float rate = [self rateForPreset:preset];
|
||
NSTimeInterval duration = (double)sampleCount / 48000.0 / rate + 0.5;
|
||
[NSThread sleepForTimeInterval:duration];
|
||
|
||
[playerNode stop];
|
||
[engine.mainMixerNode removeTapOnBus:0];
|
||
[engine stop];
|
||
|
||
return outputData;
|
||
}
|
||
|
||
@end
|
||
```
|
||
|
||
---
|
||
|
||
## 4. Поиск во вкладке сохранённых удалённых сообщений
|
||
|
||
**Смысл:** экран `savedDeletedMessagesListController` строит записи через `savedDeletedListEntries`, поле поиска — первая строка; `filterSavedDeletedListEntries` отфильтровывает секции без совпадений по запросу (имя чата, текст сообщения, дата, подписи кнопок).
|
||
|
||
### `Swiftgram/SGSettingsUI/Sources/SavedDeletedMessagesListController.swift` (полностью)
|
||
|
||
Файл приведён целиком в репозитории (292 строки). Ниже — полная копия без изменений.
|
||
|
||
```swift
|
||
// MARK: Swiftgram – Saved Deleted Messages List
|
||
import Foundation
|
||
import UIKit
|
||
import Display
|
||
import SwiftSignalKit
|
||
import Postbox
|
||
import TelegramCore
|
||
import TelegramPresentationData
|
||
import ItemListUI
|
||
import PresentationDataUtils
|
||
import AccountContext
|
||
#if canImport(SGDeletedMessages)
|
||
import SGDeletedMessages
|
||
#endif
|
||
|
||
// MARK: - Entry
|
||
|
||
private enum SavedDeletedListEntry: ItemListNodeEntry {
|
||
case search(id: Int, query: String)
|
||
case empty(id: Int, text: String)
|
||
case peerHeader(id: Int, sectionIndex: Int32, text: String)
|
||
case messageRow(id: Int, sectionIndex: Int32, text: String, dateText: String, peerId: PeerId, messageId: MessageId, searchableText: String)
|
||
case deleteAction(id: Int, sectionIndex: Int32, text: String, peerId: PeerId)
|
||
|
||
var stableId: Int {
|
||
switch self {
|
||
case .search(let id, _): return id
|
||
case .empty(let id, _): return id
|
||
case .peerHeader(let id, _, _): return id
|
||
case .messageRow(let id, _, _, _, _, _, _): return id
|
||
case .deleteAction(let id, _, _, _): return id
|
||
}
|
||
}
|
||
|
||
var section: ItemListSectionId {
|
||
switch self {
|
||
case .search(_, _): return 0
|
||
case .empty: return 0
|
||
case .peerHeader(_, let s, _): return s
|
||
case .messageRow(_, let s, _, _, _, _, _): return s
|
||
case .deleteAction(_, let s, _, _): return s
|
||
}
|
||
}
|
||
|
||
static func < (lhs: SavedDeletedListEntry, rhs: SavedDeletedListEntry) -> Bool {
|
||
lhs.stableId < rhs.stableId
|
||
}
|
||
|
||
static func == (lhs: SavedDeletedListEntry, rhs: SavedDeletedListEntry) -> Bool {
|
||
switch (lhs, rhs) {
|
||
case let (.search(a, q1), .search(b, q2)): return a == b && q1 == q2
|
||
case let (.empty(a, t1), .empty(b, t2)): return a == b && t1 == t2
|
||
case let (.peerHeader(a, s1, t1), .peerHeader(b, s2, t2)): return a == b && s1 == s2 && t1 == t2
|
||
case let (.messageRow(a, s1, t1, d1, p1, m1, _), .messageRow(b, s2, t2, d2, p2, m2, _)): return a == b && s1 == s2 && t1 == t2 && d1 == d2 && p1 == p2 && m1 == m2
|
||
case let (.deleteAction(a, s1, t1, p1), .deleteAction(b, s2, t2, p2)): return a == b && s1 == s2 && t1 == t2 && p1 == p2
|
||
default: return false
|
||
}
|
||
}
|
||
|
||
func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
|
||
let args = arguments as! SavedDeletedListArguments
|
||
switch self {
|
||
case .search(_, let query):
|
||
return ItemListSingleLineInputItem(presentationData: presentationData, systemStyle: .glass, title: NSAttributedString(string: "🔍"), text: query, placeholder: presentationData.strings.Common_Search, type: .regular(capitalization: false, autocorrection: false), spacing: 0.0, clearType: .always, tag: nil, sectionId: section, textUpdated: { args.searchUpdated($0) }, action: {})
|
||
case .empty(_, let text):
|
||
return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: section)
|
||
case .peerHeader(_, _, let text):
|
||
return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: section)
|
||
case .messageRow(_, _, let text, let dateText, let peerId, let messageId, _):
|
||
return ItemListDisclosureItem(presentationData: presentationData, title: text, label: dateText, sectionId: section, style: .blocks, action: {
|
||
args.openMessage(peerId, messageId)
|
||
})
|
||
case .deleteAction(_, _, let text, let peerId):
|
||
return ItemListActionItem(presentationData: presentationData, title: text, kind: .destructive, alignment: .natural, sectionId: section, style: .blocks, action: {
|
||
args.deleteMessagesForPeer(peerId)
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
// MARK: - Arguments
|
||
|
||
private final class SearchQueryRef {
|
||
var value: String = ""
|
||
}
|
||
|
||
private final class SavedDeletedListArguments {
|
||
let searchQueryRef: SearchQueryRef
|
||
var searchQuery: String { searchQueryRef.value }
|
||
let searchUpdated: (String) -> Void
|
||
let deleteMessagesForPeer: (PeerId) -> Void
|
||
let openMessage: (PeerId, MessageId) -> Void
|
||
init(searchQueryRef: SearchQueryRef, searchUpdated: @escaping (String) -> Void, deleteMessagesForPeer: @escaping (PeerId) -> Void, openMessage: @escaping (PeerId, MessageId) -> Void) {
|
||
self.searchQueryRef = searchQueryRef
|
||
self.searchUpdated = searchUpdated
|
||
self.deleteMessagesForPeer = deleteMessagesForPeer
|
||
self.openMessage = openMessage
|
||
}
|
||
}
|
||
|
||
// MARK: - Date formatting
|
||
|
||
private let dateFormatter: DateFormatter = {
|
||
let f = DateFormatter()
|
||
f.dateStyle = .medium
|
||
f.timeStyle = .short
|
||
return f
|
||
}()
|
||
|
||
// MARK: - Entries builder (full list, no filter — like GLEGram settings)
|
||
|
||
#if canImport(SGDeletedMessages)
|
||
private func savedDeletedListEntries(
|
||
data: [(peer: Peer?, peerId: PeerId, messages: [Message])],
|
||
lang: String
|
||
) -> [SavedDeletedListEntry] {
|
||
var entries: [SavedDeletedListEntry] = []
|
||
var id = 0
|
||
|
||
entries.append(.search(id: id, query: ""))
|
||
id += 1
|
||
|
||
if data.isEmpty {
|
||
let text = (lang == "ru" ? "Нет сохранённых удалённых сообщений." : "No saved deleted messages.")
|
||
entries.append(.empty(id: id, text: text))
|
||
return entries
|
||
}
|
||
|
||
var sectionIndex: Int32 = 0
|
||
for group in data {
|
||
let peerName: String
|
||
if let peer = group.peer {
|
||
peerName = peer.debugDisplayTitle
|
||
} else {
|
||
peerName = "Peer \(group.peerId.id._internalGetInt64Value())"
|
||
}
|
||
sectionIndex += 1
|
||
let countStr = lang == "ru" ? "\(group.messages.count) сообщ." : "\(group.messages.count) msg"
|
||
entries.append(.peerHeader(id: id, sectionIndex: sectionIndex, text: "\(peerName.uppercased()) (\(countStr))"))
|
||
id += 1
|
||
|
||
for message in group.messages {
|
||
let text = message.text.isEmpty
|
||
? (lang == "ru" ? "[медиа]" : "[media]")
|
||
: String(message.text.prefix(120)).replacingOccurrences(of: "\n", with: " ")
|
||
let searchableText = (message.text + " " + (message.sgDeletedAttribute.originalText ?? "")).trimmingCharacters(in: .whitespacesAndNewlines)
|
||
let date = dateFormatter.string(from: Date(timeIntervalSince1970: TimeInterval(message.timestamp)))
|
||
entries.append(.messageRow(id: id, sectionIndex: sectionIndex, text: text, dateText: date, peerId: group.peerId, messageId: message.id, searchableText: searchableText))
|
||
id += 1
|
||
}
|
||
|
||
let deleteText = lang == "ru" ? "Удалить все для этого чата" : "Delete all for this chat"
|
||
entries.append(.deleteAction(id: id, sectionIndex: sectionIndex, text: deleteText, peerId: group.peerId))
|
||
id += 1
|
||
}
|
||
|
||
return entries
|
||
}
|
||
|
||
/// Filter by search query — same logic as filterSGItemListUIEntrires in GLEGram settings: two-pass, keep search, keep sections that have matches.
|
||
private func filterSavedDeletedListEntries(_ entries: [SavedDeletedListEntry], by searchQuery: String?, lang: String) -> [SavedDeletedListEntry] {
|
||
guard let query = searchQuery?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased(), !query.isEmpty else {
|
||
return entries
|
||
}
|
||
var sectionIdsWithMatches: Set<Int32> = []
|
||
for entry in entries {
|
||
switch entry {
|
||
case .search(_, _), .empty:
|
||
break
|
||
case .peerHeader(_, let s, let text):
|
||
if text.lowercased().contains(query) { sectionIdsWithMatches.insert(s) }
|
||
case .messageRow(_, let s, _, let dateText, _, _, let searchableText):
|
||
if searchableText.lowercased().contains(query) || dateText.lowercased().contains(query) { sectionIdsWithMatches.insert(s) }
|
||
case .deleteAction(_, let s, let text, _):
|
||
if text.lowercased().contains(query) { sectionIdsWithMatches.insert(s) }
|
||
}
|
||
}
|
||
var filtered: [SavedDeletedListEntry] = []
|
||
for entry in entries {
|
||
switch entry {
|
||
case .search(_, _):
|
||
filtered.append(entry)
|
||
case .empty:
|
||
continue
|
||
case .peerHeader(_, let s, _), .messageRow(_, let s, _, _, _, _, _), .deleteAction(_, let s, _, _):
|
||
if sectionIdsWithMatches.contains(s) {
|
||
filtered.append(entry)
|
||
}
|
||
}
|
||
}
|
||
if filtered.count == 1, case .search(_, _) = filtered[0] {
|
||
filtered.append(.empty(id: Int.max, text: lang == "ru" ? "Ничего не найдено." : "No results."))
|
||
}
|
||
return filtered
|
||
}
|
||
#endif
|
||
|
||
// MARK: - Controller
|
||
|
||
public func savedDeletedMessagesListController(context: AccountContext) -> ViewController {
|
||
#if canImport(SGDeletedMessages)
|
||
var presentControllerImpl: ((ViewController, ViewControllerPresentationArguments?) -> Void)?
|
||
var pushControllerImpl: ((ViewController) -> Void)?
|
||
let reloadPromise = ValuePromise(true, ignoreRepeated: false)
|
||
let searchQueryPromise = ValuePromise("", ignoreRepeated: false)
|
||
let searchQueryRef = SearchQueryRef()
|
||
|
||
let arguments = SavedDeletedListArguments(
|
||
searchQueryRef: searchQueryRef,
|
||
searchUpdated: { value in
|
||
searchQueryRef.value = value
|
||
searchQueryPromise.set(value)
|
||
},
|
||
deleteMessagesForPeer: { peerId in
|
||
let presentationData = context.sharedContext.currentPresentationData.with { $0 }
|
||
let lang = presentationData.strings.baseLanguageCode
|
||
let title = lang == "ru" ? "Удалить" : "Delete"
|
||
let text = lang == "ru" ? "Удалить все сохранённые удалённые сообщения для этого чата?" : "Delete all saved deleted messages for this chat?"
|
||
let alert = textAlertController(
|
||
context: context,
|
||
title: title,
|
||
text: text,
|
||
actions: [
|
||
TextAlertAction(type: .destructiveAction, title: presentationData.strings.Common_Delete, action: {
|
||
let _ = (SGDeletedMessages.getAllSavedDeletedMessages(postbox: context.account.postbox)
|
||
|> mapToSignal { groups -> Signal<Void, NoError> in
|
||
var idsToDelete: [MessageId] = []
|
||
for group in groups where group.peerId == peerId {
|
||
idsToDelete.append(contentsOf: group.messages.map { $0.id })
|
||
}
|
||
return SGDeletedMessages.deleteSavedDeletedMessages(ids: idsToDelete, postbox: context.account.postbox)
|
||
}
|
||
|> deliverOnMainQueue).start(completed: {
|
||
reloadPromise.set(true)
|
||
})
|
||
}),
|
||
TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_Cancel, action: {})
|
||
]
|
||
)
|
||
presentControllerImpl?(alert, nil)
|
||
},
|
||
openMessage: { peerId, messageId in
|
||
let chatController = context.sharedContext.makeChatController(context: context, chatLocation: .peer(id: peerId), subject: .message(id: .id(messageId), highlight: nil, timecode: nil, setupReply: false), botStart: nil, mode: .standard(.default), params: nil)
|
||
pushControllerImpl?(chatController)
|
||
}
|
||
)
|
||
|
||
let dataSignal = reloadPromise.get()
|
||
|> mapToSignal { _ -> Signal<[(peer: Peer?, peerId: PeerId, messages: [Message])], NoError> in
|
||
return SGDeletedMessages.getAllSavedDeletedMessages(postbox: context.account.postbox)
|
||
}
|
||
|
||
let signal = combineLatest(dataSignal, searchQueryPromise.get(), context.sharedContext.presentationData)
|
||
|> map { data, searchQuery, presentationData -> (ItemListControllerState, (ItemListNodeState, SavedDeletedListArguments)) in
|
||
let lang = presentationData.strings.baseLanguageCode
|
||
let title = lang == "ru" ? "Сохранённые удалённые" : "Saved Deleted"
|
||
let controllerState = ItemListControllerState(
|
||
presentationData: ItemListPresentationData(presentationData),
|
||
title: .text(title),
|
||
leftNavigationButton: nil,
|
||
rightNavigationButton: nil,
|
||
backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back)
|
||
)
|
||
let allEntries = savedDeletedListEntries(data: data, lang: lang)
|
||
let entriesWithQuery = allEntries.map { entry -> SavedDeletedListEntry in
|
||
if case .search(let id, _) = entry { return .search(id: id, query: searchQuery) }
|
||
return entry
|
||
}
|
||
let entries = filterSavedDeletedListEntries(entriesWithQuery, by: searchQuery, lang: lang)
|
||
let listState = ItemListNodeState(
|
||
presentationData: ItemListPresentationData(presentationData),
|
||
entries: entries,
|
||
style: .blocks,
|
||
ensureVisibleItemTag: nil,
|
||
initialScrollToItem: nil
|
||
)
|
||
return (controllerState, (listState, arguments))
|
||
}
|
||
|
||
let controller = ItemListController(context: context, state: signal)
|
||
presentControllerImpl = { [weak controller] c, a in
|
||
controller?.present(c, in: PresentationContextType.window(PresentationSurfaceLevel.root), with: a)
|
||
}
|
||
pushControllerImpl = { [weak controller] c in
|
||
controller?.navigationController?.pushViewController(c, animated: true)
|
||
}
|
||
return controller
|
||
#else
|
||
return ViewController(navigationBarPresentationData: nil)
|
||
#endif
|
||
}
|
||
```
|
||
|
||
### `Swiftgram/SGDeletedMessages/Sources/SGDeletedMessages.swift` (полностью)
|
||
|
||
```swift
|
||
import Foundation
|
||
import Postbox
|
||
import SwiftSignalKit
|
||
import SGSimpleSettings
|
||
#if canImport(SGLogging)
|
||
import SGLogging
|
||
#endif
|
||
|
||
// Local constants to avoid circular dependency with TelegramCore (SyncCore_Namespaces).
|
||
// Namespaces.Message.Cloud = 0
|
||
private let messageNamespaceCloud: Int32 = 0
|
||
// Namespaces.Message.SavedDeleted = 1338
|
||
private let messageNamespaceSavedDeleted: Int32 = 1338
|
||
|
||
public struct SGDeletedMessages {
|
||
public static var showDeletedMessages: Bool {
|
||
get {
|
||
return SGSimpleSettings.shared.showDeletedMessages
|
||
}
|
||
set {
|
||
SGSimpleSettings.shared.showDeletedMessages = newValue
|
||
}
|
||
}
|
||
|
||
private static func savedDeletedId(for originalId: MessageId) -> MessageId {
|
||
return MessageId(peerId: originalId.peerId, namespace: messageNamespaceSavedDeleted, id: originalId.id)
|
||
}
|
||
|
||
/// AyuGram-style: create a local SavedDeleted snapshot (separate namespace) and return `true` if saved.
|
||
private static func saveSnapshotIfPossible(
|
||
originalId: MessageId,
|
||
transaction: Transaction,
|
||
shouldSave: ((MessageId, Message) -> Bool)?,
|
||
transformAttributes: ((Message, inout [MessageAttribute]) -> Void)?,
|
||
transformMedia: ((Message, [Media]) -> [Media])?
|
||
) -> Bool {
|
||
// If we're deleting an already-saved snapshot, don't re-save it.
|
||
if originalId.namespace == messageNamespaceSavedDeleted {
|
||
return false
|
||
}
|
||
|
||
guard let message = transaction.getMessage(originalId) else {
|
||
// No local copy -> can't save (AyuGram behavior).
|
||
return false
|
||
}
|
||
|
||
if let shouldSave, !shouldSave(originalId, message) {
|
||
return false
|
||
}
|
||
|
||
let snapshotId = savedDeletedId(for: originalId)
|
||
if transaction.messageExists(id: snapshotId) {
|
||
return true
|
||
}
|
||
|
||
let storeForwardInfo = message.forwardInfo.flatMap(StoreMessageForwardInfo.init)
|
||
var attributes = message.attributes
|
||
var hasDeletedAttribute = false
|
||
for attribute in attributes {
|
||
if let deletedAttribute = attribute as? SGDeletedMessageAttribute {
|
||
deletedAttribute.isDeleted = true
|
||
if deletedAttribute.originalText == nil {
|
||
deletedAttribute.originalText = message.text
|
||
}
|
||
deletedAttribute.originalNamespace = originalId.namespace
|
||
deletedAttribute.originalId = originalId.id
|
||
hasDeletedAttribute = true
|
||
break
|
||
}
|
||
}
|
||
if !hasDeletedAttribute {
|
||
attributes.append(SGDeletedMessageAttribute(isDeleted: true, originalText: message.text, originalNamespace: originalId.namespace, originalId: originalId.id))
|
||
}
|
||
|
||
transformAttributes?(message, &attributes)
|
||
|
||
let media: [Media]
|
||
if let transformMedia {
|
||
media = transformMedia(message, message.media)
|
||
} else {
|
||
media = message.media
|
||
}
|
||
|
||
// Important: this is a local-only snapshot, so we don't keep a globallyUniqueId
|
||
// (to avoid collisions with the original message).
|
||
let storeMessage = StoreMessage(
|
||
id: snapshotId,
|
||
customStableId: nil,
|
||
globallyUniqueId: nil,
|
||
groupingKey: message.groupingKey,
|
||
threadId: message.threadId,
|
||
timestamp: message.timestamp,
|
||
flags: StoreMessageFlags(message.flags),
|
||
tags: message.tags,
|
||
globalTags: message.globalTags,
|
||
localTags: message.localTags,
|
||
forwardInfo: storeForwardInfo,
|
||
authorId: message.author?.id,
|
||
text: message.text,
|
||
attributes: attributes,
|
||
media: media
|
||
)
|
||
let _ = transaction.addMessages([storeMessage], location: .UpperHistoryBlock)
|
||
#if canImport(SGLogging)
|
||
SGLogger.shared.log("SGDeletedMessages", "saveSnapshotIfPossible: saved snapshot \(snapshotId) for original \(originalId)")
|
||
#endif
|
||
return true
|
||
}
|
||
|
||
/// AyuGram-style: save snapshots (when possible).
|
||
/// Returns the set of message ids for which a snapshot exists (created or already present).
|
||
public static func saveSnapshots(
|
||
ids: [MessageId],
|
||
transaction: Transaction,
|
||
shouldSave: ((MessageId, Message) -> Bool)? = nil,
|
||
transformAttributes: ((Message, inout [MessageAttribute]) -> Void)? = nil,
|
||
transformMedia: ((Message, [Media]) -> [Media])? = nil
|
||
) -> Set<MessageId> {
|
||
guard showDeletedMessages, !ids.isEmpty else { return Set() }
|
||
|
||
var result = Set<MessageId>()
|
||
result.reserveCapacity(ids.count)
|
||
|
||
for id in ids {
|
||
if saveSnapshotIfPossible(originalId: id, transaction: transaction, shouldSave: shouldSave, transformAttributes: transformAttributes, transformMedia: transformMedia) {
|
||
result.insert(id)
|
||
}
|
||
}
|
||
return result
|
||
}
|
||
|
||
/// AyuGram-style: for delete-by-global-id pipelines, save snapshots for locally-present messages.
|
||
public static func saveSnapshotsForGlobalIds(
|
||
_ globalIds: [Int32],
|
||
transaction: Transaction,
|
||
shouldSave: ((MessageId, Message) -> Bool)? = nil,
|
||
transformAttributes: ((Message, inout [MessageAttribute]) -> Void)? = nil,
|
||
transformMedia: ((Message, [Media]) -> [Media])? = nil
|
||
) {
|
||
guard showDeletedMessages else { return }
|
||
for globalId in globalIds {
|
||
if let id = transaction.messageIdsForGlobalIds([globalId]).first {
|
||
_ = saveSnapshotIfPossible(originalId: id, transaction: transaction, shouldSave: shouldSave, transformAttributes: transformAttributes, transformMedia: transformMedia)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// AyuGram-style: save snapshots (when possible) and return ids to physically delete.
|
||
/// If the id itself is already a SavedDeleted snapshot, it will be deleted (no resave).
|
||
public static func saveSnapshotsAndReturnIdsToDelete(ids: [MessageId], transaction: Transaction) -> [MessageId] {
|
||
_ = saveSnapshots(ids: ids, transaction: transaction, shouldSave: nil, transformAttributes: nil, transformMedia: nil)
|
||
return ids
|
||
}
|
||
|
||
/// Check if message is marked as deleted (using extension like Nicegram)
|
||
public static func isMessageDeleted(_ message: Message) -> Bool {
|
||
return message.sgDeletedAttribute.isDeleted
|
||
}
|
||
|
||
/// Get original text from message attribute (for edit history, using extension like Nicegram)
|
||
public static func getOriginalText(_ message: Message) -> String? {
|
||
return message.sgDeletedAttribute.originalText
|
||
}
|
||
|
||
/// Returns the combined on-disk size (in bytes) of the saved-deleted-attachments folder.
|
||
public static func storageSizeBytes(mediaBoxBasePath: String) -> Int64 {
|
||
let attachmentsPath = mediaBoxBasePath + "/saved-deleted-attachments"
|
||
guard let enumerator = FileManager.default.enumerator(
|
||
at: URL(fileURLWithPath: attachmentsPath),
|
||
includingPropertiesForKeys: [.fileSizeKey],
|
||
options: [.skipsHiddenFiles]
|
||
) else { return 0 }
|
||
var total: Int64 = 0
|
||
for case let url as URL in enumerator {
|
||
total += Int64((try? url.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0)
|
||
}
|
||
return total
|
||
}
|
||
|
||
/// Fetch all saved deleted messages grouped by peer.
|
||
public static func getAllSavedDeletedMessages(
|
||
postbox: Postbox
|
||
) -> Signal<[(peer: Peer?, peerId: PeerId, messages: [Message])], NoError> {
|
||
return postbox.transaction { transaction -> [(peer: Peer?, peerId: PeerId, messages: [Message])] in
|
||
var result: [(peer: Peer?, peerId: PeerId, messages: [Message])] = []
|
||
let allPeerIds = transaction.chatListGetAllPeerIds()
|
||
for peerId in allPeerIds {
|
||
var messages: [Message] = []
|
||
transaction.scanMessageAttributes(peerId: peerId, namespace: messageNamespaceSavedDeleted, limit: Int.max) { messageId, _ in
|
||
if let message = transaction.getMessage(messageId) {
|
||
messages.append(message)
|
||
}
|
||
return true
|
||
}
|
||
if !messages.isEmpty {
|
||
messages.sort { $0.timestamp > $1.timestamp }
|
||
let peer = transaction.getPeer(peerId)
|
||
result.append((peer: peer, peerId: peerId, messages: messages))
|
||
}
|
||
}
|
||
result.sort { ($0.messages.first?.timestamp ?? 0) > ($1.messages.first?.timestamp ?? 0) }
|
||
return result
|
||
}
|
||
}
|
||
|
||
/// Delete specific saved deleted messages by their IDs.
|
||
public static func deleteSavedDeletedMessages(
|
||
ids: [MessageId],
|
||
postbox: Postbox
|
||
) -> Signal<Void, NoError> {
|
||
return postbox.transaction { transaction -> Void in
|
||
if !ids.isEmpty {
|
||
transaction.deleteMessages(ids, forEachMedia: { _ in })
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Clear all saved deleted messages (actually delete them). Returns the number of deleted messages.
|
||
public static func clearAllDeletedMessages(
|
||
postbox: Postbox
|
||
) -> Signal<Int, NoError> {
|
||
return postbox.transaction { transaction -> Int in
|
||
// Remove saved attachment copies (AyuGram-style "Saved Attachments").
|
||
let attachmentsPath = postbox.mediaBox.basePath + "/saved-deleted-attachments"
|
||
let _ = try? FileManager.default.removeItem(atPath: attachmentsPath)
|
||
let _ = try? FileManager.default.createDirectory(atPath: attachmentsPath, withIntermediateDirectories: true, attributes: nil)
|
||
|
||
// All messages in the SavedDeleted namespace (1338) are snapshots — no attribute check needed.
|
||
var messageIdsToDelete: [MessageId] = []
|
||
let allPeerIds = transaction.chatListGetAllPeerIds()
|
||
for peerId in allPeerIds {
|
||
transaction.scanMessageAttributes(peerId: peerId, namespace: messageNamespaceSavedDeleted, limit: Int.max) { messageId, _ in
|
||
messageIdsToDelete.append(messageId)
|
||
return true
|
||
}
|
||
}
|
||
|
||
let count = messageIdsToDelete.count
|
||
if !messageIdsToDelete.isEmpty {
|
||
transaction.deleteMessages(messageIdsToDelete, forEachMedia: { _ in })
|
||
}
|
||
|
||
return count
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 5. Ответ на удалённое сообщение: цитата оформляется сущностью `.Pre`
|
||
|
||
**Смысл:** если ответ идёт на сообщение с признаком «удалённое» (`sgDeletedAttribute.isDeleted`), вместо обычного `ReplyMessageAttribute` текст исходного сообщения вставляется **перед** вашим текстом с переводом строки, а диапазон цитаты помечается `MessageTextEntity` с типом `.Pre(language: nil)` (в клиентах Telegram это отображается как моноширинный / «блок кода» блок — визуальное выделение цитаты).
|
||
|
||
### `submodules/TelegramCore/Sources/PendingMessages/EnqueueMessage.swift` — полный фрагмент `if let replyToMessageId = replyToMessageId { ... }`
|
||
|
||
```swift
|
||
if let replyToMessageId = replyToMessageId {
|
||
#if canImport(SGDeletedMessages)
|
||
let useDeletedCitation: Bool = {
|
||
if let replyMessage = transaction.getMessage(replyToMessageId.messageId) {
|
||
return replyMessage.sgDeletedAttribute.isDeleted
|
||
}
|
||
return false
|
||
}()
|
||
#else
|
||
let useDeletedCitation = false
|
||
#endif
|
||
if useDeletedCitation {
|
||
#if canImport(SGDeletedMessages)
|
||
if let replyMessage = transaction.getMessage(replyToMessageId.messageId) {
|
||
let quoteText = replyMessage.sgDeletedAttribute.originalText ?? replyMessage.text
|
||
let citationPrefix = quoteText + "\n"
|
||
effectiveText = citationPrefix + text
|
||
let offset = citationPrefix.count
|
||
let citationEntities = [MessageTextEntity(range: 0..<offset, type: .Pre(language: nil))]
|
||
var foundEntities = false
|
||
for i in attributes.indices {
|
||
if let entityAttr = attributes[i] as? TextEntitiesMessageAttribute {
|
||
let shifted = entityAttr.entities.map { MessageTextEntity(range: $0.range.lowerBound + offset ..< $0.range.upperBound + offset, type: $0.type) }
|
||
attributes[i] = TextEntitiesMessageAttribute(entities: citationEntities + shifted)
|
||
foundEntities = true
|
||
break
|
||
}
|
||
}
|
||
if !foundEntities {
|
||
attributes.append(TextEntitiesMessageAttribute(entities: citationEntities))
|
||
}
|
||
}
|
||
#endif
|
||
} else {
|
||
var threadMessageId: MessageId?
|
||
var quote = replyToMessageId.quote
|
||
let isQuote = quote != nil
|
||
if let replyMessage = transaction.getMessage(replyToMessageId.messageId) {
|
||
if replyMessage.id.namespace == Namespaces.Message.Cloud, let threadId = replyMessage.threadId {
|
||
threadMessageId = MessageId(peerId: replyMessage.id.peerId, namespace: Namespaces.Message.Cloud, id: Int32(clamping: threadId))
|
||
}
|
||
if quote == nil, replyToMessageId.messageId.peerId != peerId {
|
||
let nsText = replyMessage.text as NSString
|
||
var replyMedia: Media?
|
||
for m in replyMessage.media {
|
||
switch m {
|
||
case _ as TelegramMediaImage, _ as TelegramMediaFile:
|
||
replyMedia = m
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
quote = EngineMessageReplyQuote(text: replyMessage.text, offset: nil, entities: messageTextEntitiesInRange(entities: replyMessage.textEntitiesAttribute?.entities ?? [], range: NSRange(location: 0, length: nsText.length), onlyQuoteable: true), media: replyMedia)
|
||
}
|
||
}
|
||
attributes.append(ReplyMessageAttribute(messageId: replyToMessageId.messageId, threadMessageId: threadMessageId, quote: quote, isQuote: isQuote, todoItemId: replyToMessageId.todoItemId))
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 6. Добавление «чужих» подарков в свой профиль (локально, только у вас)
|
||
|
||
**Смысл:** в профиле **другого** пользователя по долгому нажатию на уникальный подарок появляется пункт «Добавить в свой профиль (только вы увидите)». Slug подарка сохраняется в `SGSimpleSettings.customProfileGiftSlugs` и `customProfileGiftShownSlugs`; в своём профиле можно удалить запись из списка.
|
||
|
||
### Фрагмент `submodules/TelegramUI/Components/PeerInfo/PeerInfoVisualMediaPaneNode/Sources/PeerInfoGiftsPaneNode.swift`
|
||
|
||
```swift
|
||
#if canImport(SGSimpleSettings)
|
||
let isMyProfile = self.peerId == self.context.account.peerId
|
||
if !isMyProfile, case let .unique(uniqueGift) = gift.gift {
|
||
let slug = uniqueGift.slug
|
||
let alreadyAdded = SGSimpleSettings.shared.customProfileGiftSlugs.contains(slug)
|
||
if !alreadyAdded {
|
||
let addTitle = presentationData.strings.baseLanguageCode == "ru" ? "Добавить в свой профиль (только вы увидите)" : "Add to my profile (only you will see)"
|
||
items.append(.action(ContextMenuActionItem(text: addTitle, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Add"), color: theme.contextMenu.primaryColor) }, action: { [weak self] c, _ in
|
||
var slugs = SGSimpleSettings.shared.customProfileGiftSlugs
|
||
if !slugs.contains(slug) {
|
||
slugs.append(slug)
|
||
SGSimpleSettings.shared.customProfileGiftSlugs = slugs
|
||
}
|
||
var shown = SGSimpleSettings.shared.customProfileGiftShownSlugs
|
||
if !shown.contains(slug) {
|
||
shown.append(slug)
|
||
SGSimpleSettings.shared.customProfileGiftShownSlugs = shown
|
||
}
|
||
self?.giftsListView.triggerCustomShownRefresh()
|
||
c?.dismiss(completion: nil)
|
||
})))
|
||
items.append(.separator)
|
||
}
|
||
} else if isMyProfile, case let .slug(slug) = gift.reference {
|
||
let removeTitle = presentationData.strings.baseLanguageCode == "ru" ? "Удалить из профиля" : "Remove from profile"
|
||
items.append(.action(ContextMenuActionItem(text: removeTitle, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Delete"), color: theme.contextMenu.destructiveColor) }, action: { [weak self] _, _ in
|
||
var slugs = SGSimpleSettings.shared.customProfileGiftSlugs
|
||
slugs.removeAll { $0 == slug }
|
||
SGSimpleSettings.shared.customProfileGiftSlugs = slugs
|
||
var shown = SGSimpleSettings.shared.customProfileGiftShownSlugs
|
||
shown.removeAll { $0 == slug }
|
||
SGSimpleSettings.shared.customProfileGiftShownSlugs = shown
|
||
self?.giftsListView.triggerCustomShownRefresh()
|
||
})))
|
||
items.append(.separator)
|
||
}
|
||
#endif
|
||
```
|
||
|
||
### Ключи и свойства в `Swiftgram/SGSimpleSettings/Sources/SimpleSettings.swift`
|
||
|
||
```swift
|
||
case customProfileGiftSlugs
|
||
case customProfileGiftShownSlugs
|
||
case pinnedCustomProfileGiftSlugs
|
||
case localProfileGiftStatusFileId
|
||
```
|
||
|
||
```swift
|
||
@UserDefault(key: Keys.customProfileGiftSlugs.rawValue)
|
||
public var customProfileGiftSlugs: [String]
|
||
|
||
/// Slugs of custom gifts that are shown on profile (worn). Persisted locally so "Show/Hide" state doesn't reset.
|
||
@UserDefault(key: Keys.customProfileGiftShownSlugs.rawValue)
|
||
public var customProfileGiftShownSlugs: [String]
|
||
|
||
@UserDefault(key: Keys.pinnedCustomProfileGiftSlugs.rawValue)
|
||
public var pinnedCustomProfileGiftSlugs: [String]
|
||
|
||
/// When set, show this fileId as emoji status on my profile (so gift status doesn't disappear).
|
||
@UserDefault(key: Keys.localProfileGiftStatusFileId.rawValue)
|
||
public var localProfileGiftStatusFileId: String
|
||
```
|
||
|
||
---
|
||
|
||
*Файл: `GLEGram-features.md` в корне репозитория.*
|