/ - Diff - ChatSecure:Android - Guardian Project Dev (ARCHIVED SITE)

     		D93DDA8F1BA79A2400CD8331 /* OTRMediaFileManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 6354BBE31A96C67400E8EBAC /* OTRMediaFileManager.m */; };
     		D93DDA901BA79A2400CD8331 /* OTRMediaServer.m in Sources */ = {isa = PBXBuildFile; fileRef = 63DDD8AF1A9D3C0400C0A918 /* OTRMediaServer.m */; };
     		D93DDA911BA79A2400CD8331 /* OTRStreamManagementYapStorage.m in Sources */ = {isa = PBXBuildFile; fileRef = 63B916E11B743198003B778F /* OTRStreamManagementYapStorage.m */; };
     		D93DDA921BA79A2400CD8331 /* OTRXMPPMessageYapStorage.m in Sources */ = {isa = PBXBuildFile; fileRef = 637DBB1B1B7D5A23003845B7 /* OTRXMPPMessageYapStorage.m */; };
     		D93DDA931BA79A2400CD8331 /* OTRvCardYapDatabaseStorage.m in Sources */ = {isa = PBXBuildFile; fileRef = 633105341A16D1A300C17BAE /* OTRvCardYapDatabaseStorage.m */; };
     		D93DDA941BA79A2400CD8331 /* OTRXMPPBuddyTimers.m in Sources */ = {isa = PBXBuildFile; fileRef = 633105361A16D1A300C17BAE /* OTRXMPPBuddyTimers.m */; };
     		D93DDA951BA79A2400CD8331 /* OTRXMPPManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 633105381A16D1A300C17BAE /* OTRXMPPManager.m */; };
-...
     		D93DDB431BA79A7200CD8331 /* OTRMediaFileManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 6354BBE21A96C67400E8EBAC /* OTRMediaFileManager.h */; settings = {ATTRIBUTES = (Public, ); }; };
     		D93DDB441BA79A7200CD8331 /* OTRMediaServer.h in Headers */ = {isa = PBXBuildFile; fileRef = 63DDD8AE1A9D3C0400C0A918 /* OTRMediaServer.h */; settings = {ATTRIBUTES = (Public, ); }; };
     		D93DDB451BA79A7200CD8331 /* OTRStreamManagementYapStorage.h in Headers */ = {isa = PBXBuildFile; fileRef = 63B916E01B743198003B778F /* OTRStreamManagementYapStorage.h */; settings = {ATTRIBUTES = (Private, ); }; };
     		D93DDB461BA79A7200CD8331 /* OTRXMPPMessageYapStorage.h in Headers */ = {isa = PBXBuildFile; fileRef = 637DBB1A1B7D5A23003845B7 /* OTRXMPPMessageYapStorage.h */; settings = {ATTRIBUTES = (Private, ); }; };
     		D93DDB471BA79A7200CD8331 /* OTRvCardYapDatabaseStorage.h in Headers */ = {isa = PBXBuildFile; fileRef = 633105331A16D1A300C17BAE /* OTRvCardYapDatabaseStorage.h */; settings = {ATTRIBUTES = (Private, ); }; };
     		D93DDB481BA79A7200CD8331 /* OTRXMPPBuddyTimers.h in Headers */ = {isa = PBXBuildFile; fileRef = 633105351A16D1A300C17BAE /* OTRXMPPBuddyTimers.h */; settings = {ATTRIBUTES = (Private, ); }; };
     		D93DDB491BA79A7200CD8331 /* OTRXMPPManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 633105371A16D1A300C17BAE /* OTRXMPPManager.h */; settings = {ATTRIBUTES = (Public, ); }; };
-...
     		D9ABD71F1ED787EE00219A9C /* OTRHTMLItem.m in Sources */ = {isa = PBXBuildFile; fileRef = D9ABD71D1ED787EE00219A9C /* OTRHTMLItem.m */; };
     		D9ABD72B1ED7886100219A9C /* OTRTextItem.h in Headers */ = {isa = PBXBuildFile; fileRef = D9ABD7291ED7886100219A9C /* OTRTextItem.h */; };
     		D9ABD72C1ED7886100219A9C /* OTRTextItem.m in Sources */ = {isa = PBXBuildFile; fileRef = D9ABD72A1ED7886100219A9C /* OTRTextItem.m */; };
     		D9AC941A1FCD0DE50051B457 /* XMPPManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = D9AC94191FCD0DE50051B457 /* XMPPManager.swift */; };
     		D9AE3A111BA8CBFA00255537 /* OTRAssets.h in Headers */ = {isa = PBXBuildFile; fileRef = D9AE3A101BA8CBFA00255537 /* OTRAssets.h */; settings = {ATTRIBUTES = (Public, ); }; };
     		D9AE3A161BA8CBFA00255537 /* OTRAssets.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = D9AE3A0E1BA8CBFA00255537 /* OTRAssets.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; };
     		D9AE3A1B1BA8CC8600255537 /* OTRSecrets.m in Sources */ = {isa = PBXBuildFile; fileRef = 633105F91A16D1A300C17BAE /* OTRSecrets.m */; };
-...
     		D9ABD71D1ED787EE00219A9C /* OTRHTMLItem.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = OTRHTMLItem.m; sourceTree = "<group>"; };
     		D9ABD7291ED7886100219A9C /* OTRTextItem.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OTRTextItem.h; sourceTree = "<group>"; };
     		D9ABD72A1ED7886100219A9C /* OTRTextItem.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = OTRTextItem.m; sourceTree = "<group>"; };
     		D9AC94191FCD0DE50051B457 /* XMPPManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = XMPPManager.swift; sourceTree = "<group>"; };
     		D9ADE5B71B606642009471FF /* OTRCircleButtonView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OTRCircleButtonView.h; sourceTree = "<group>"; };
     		D9ADE5B81B606642009471FF /* OTRCircleButtonView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = OTRCircleButtonView.m; sourceTree = "<group>"; };
     		D9AE3A0E1BA8CBFA00255537 /* OTRAssets.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = OTRAssets.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-...
     				D9A7BCE61E4554E200888A8E /* OTRXMPPStream.m */,
     				D9A7756D1E43F8A200027864 /* ProxyXMPPStream.h */,
     				D9A7756E1E43F8A200027864 /* ProxyXMPPStream.m */,
     				D9BEF8DF1DCE6E12009945D1 /* OTRXMPPManager_Private.h */,
 D639E11D12124F002B4175 /* OTRStreamManagementDelegate.swift */,
     				633105351A16D1A300C17BAE /* OTRXMPPBuddyTimers.h */,
     				633105361A16D1A300C17BAE /* OTRXMPPBuddyTimers.m */,
     				D9BEF8DF1DCE6E12009945D1 /* OTRXMPPManager_Private.h */,
     				633105371A16D1A300C17BAE /* OTRXMPPManager.h */,
     				633105381A16D1A300C17BAE /* OTRXMPPManager.m */,
     				D9AC94191FCD0DE50051B457 /* XMPPManager.swift */,
     				636985581BC875110083FC53 /* OTRXMPPRoomManager.h */,
     				636985591BC875110083FC53 /* OTRXMPPRoomManager.m */,
     				6331053B1A16D1A300C17BAE /* OTRXMPPTorManager.h */,
-...
     				D93DDBA81BA79AAA00CD8331 /* OTRXMPPServerListViewController.h in Headers */,
     				D93DDB4E1BA79A7300CD8331 /* OTRXMPPServerInfo.h in Headers */,
     				D93DDB931BA79A9400CD8331 /* OTRXMPPPresenceSubscriptionRequest.h in Headers */,
     				D93DDB461BA79A7200CD8331 /* OTRXMPPMessageYapStorage.h in Headers */,
     				D93DDB9F1BA79AA100CD8331 /* OTRXMPPError.h in Headers */,
     				D93DDB481BA79A7200CD8331 /* OTRXMPPBuddyTimers.h in Headers */,
     				D93DDB921BA79A9300CD8331 /* OTRXMPPBuddy.h in Headers */,
-...
     				D98BA36E1EDE47F3004475B6 /* HTMLPreviewView.swift in Sources */,
     				D943AA421E6A0BA3007F3564 /* XMPPAccountCell.swift in Sources */,
     				D93DDA911BA79A2400CD8331 /* OTRStreamManagementYapStorage.m in Sources */,
     				D93DDA921BA79A2400CD8331 /* OTRXMPPMessageYapStorage.m in Sources */,
     				D93DDA931BA79A2400CD8331 /* OTRvCardYapDatabaseStorage.m in Sources */,
     				D93DDA941BA79A2400CD8331 /* OTRXMPPBuddyTimers.m in Sources */,
     				D9A7BCE81E4554E200888A8E /* OTRXMPPStream.m in Sources */,
-...
     				D93DDABC1BA79A2500CD8331 /* OTROpenInFacebookActivity.m in Sources */,
     				D9B9B1331DC7F3AC0007F5A7 /* UserInfoProfileCell.swift in Sources */,
     				D97070A71EEF3909004FEBDE /* MediaDownloadView.swift in Sources */,
     				D9AC941A1FCD0DE50051B457 /* XMPPManager.swift in Sources */,
     				D93DDABD1BA79A2500CD8331 /* OTROpenInTwitterActivity.m in Sources */,
 BAB26D1C863C60005185F3 /* PushMessage.swift in Sources */,
     				D93DDABE1BA79A2500CD8331 /* OTRQRCodeActivity.m in Sources */,

+            }
+        }
         @objc public func showLocalNotification(_ message:OTRMessageProtocol) {
         @objc public func showLocalNotification(_ message:OTRMessageProtocol, transaction: YapDatabaseReadTransaction) {
             var thread:OTRThreadOwner? = nil
             var unreadCount:UInt = 0
             var mediaItem: OTRMediaItem? = nil
             OTRDatabaseManager.sharedInstance().readOnlyDatabaseConnection?.read({ (transaction) -> Void in
                 unreadCount = transaction.numberOfUnreadMessages()
                 thread = message.threadOwner(with: transaction)
                 mediaItem = OTRMediaItem.init(forMessage: message, transaction: transaction)
             })
             unreadCount = transaction.numberOfUnreadMessages()
             thread = message.threadOwner(with: transaction)
             mediaItem = OTRMediaItem.init(forMessage: message, transaction: transaction)
             guard let threadOwner = thread else {
                 return
+            }

     extension FileTransferManager {
         /** creates downloadmessages and then downloads if needed. parent message should already be saved! @warn Do not call from within an existing db transaction! */
         @objc public func createAndDownloadItemsIfNeeded(message: OTRMessageProtocol, readConnection: YapDatabaseConnection, force: Bool) {
             DispatchQueue.global(qos: .default).async {
                 if message.messageMediaItemKey != nil || message.messageText?.count == 0 || message.downloadableURLs.count == 0 {
                     //DDLogVerbose("Download of message not needed \(message.messageKey)")
                     return
+                }
                 var downloads: [OTRDownloadMessage] = []
                 var disableAutomaticURLFetching = false
                 if !force {
                     readConnection.read { (transaction) in
                         downloads = message.existingDownloads(with: transaction)
                         if let thread = message.threadOwner(with: transaction), let account = OTRAccount.fetchObject(withUniqueID: thread.threadAccountIdentifier, transaction: transaction) {
                             disableAutomaticURLFetching = account.disableAutomaticURLFetching
+                        }
+                    }
         @objc public func createAndDownloadItemsIfNeeded(message: OTRMessageProtocol, force: Bool, transaction: YapDatabaseReadWriteTransaction) {
             if message.messageMediaItemKey != nil || message.messageText?.count == 0 || message.downloadableURLs.count == 0 {
                 //DDLogVerbose("Download of message not needed \(message.messageKey)")
                 return
+            }
             var downloads: [OTRDownloadMessage] = []
             var disableAutomaticURLFetching = false
             if !force {
                 downloads = message.existingDownloads(with: transaction)
                 if let thread = message.threadOwner(with: transaction), let account = OTRAccount.fetchObject(withUniqueID: thread.threadAccountIdentifier, transaction: transaction) {
                     disableAutomaticURLFetching = account.disableAutomaticURLFetching
+                }
+            }
             if downloads.count == 0 {
                 downloads = message.downloads()
                 if downloads.count == 0 {
                     downloads = message.downloads()
                     if downloads.count == 0 {
                         return
+                    }
                     self.connection.readWrite({ (transaction) in
                         for download in downloads {
                             if disableAutomaticURLFetching,
                                 let filename = download.downloadableURL?.absoluteString {
                                 let media = OTRMediaItem.incomingItem(withFilename: filename, mimeType: nil)
                                 media.parentObjectKey = download.uniqueId
                                 media.parentObjectCollection = download.messageCollection
                                 media.save(with: transaction)
                                 download.messageMediaItemKey = media.uniqueId
                                 download.messageError = FileTransferError.automaticDownloadsDisabled
+                            }
                             download.save(with: transaction)
+                        }
                         message.touch(with: transaction)
                     })
+                }
                 if disableAutomaticURLFetching {
                     DDLogVerbose("Automatic URL fetching disabled \(message.messageKey)")
                     return
+                }
                 for download in downloads {
                     self.downloadMediaIfNeeded(download)
                     if disableAutomaticURLFetching,
                         let filename = download.downloadableURL?.absoluteString {
                         let media = OTRMediaItem.incomingItem(withFilename: filename, mimeType: nil)
                         media.parentObjectKey = download.uniqueId
                         media.parentObjectCollection = download.messageCollection
                         media.save(with: transaction)
                         download.messageMediaItemKey = media.uniqueId
                         download.messageError = FileTransferError.automaticDownloadsDisabled
+                    }
                     download.save(with: transaction)
+                }
                 message.touch(with: transaction)
+            }
             if disableAutomaticURLFetching {
                 DDLogVerbose("Automatic URL fetching disabled \(message.messageKey)")
                 return
+            }
             for download in downloads {
                 self.downloadMediaIfNeeded(download)
+            }
+        }
-...
                     } else {
                         DDLogError("Failed to refetch download message WTF \(downloadMessage)")
+                    }
                 }, completionQueue: DispatchQueue.main,
                    completionBlock: {
                     UIApplication.shared.showLocalNotification(downloadMessage)
                     UIApplication.shared.showLocalNotification(downloadMessage, transaction: transaction)
                 })
             }, completionQueue: nil)
+        }

         fileprivate func sendDirectMessage(_ message: OTROutgoingMessage,
                                            buddy: OTRXMPPBuddy,
                                            account: OTRAccount,
                                            accountProtocol: OTRXMPPManager,
                                            accountProtocol: XMPPManager,
                                            messageSendingAction:OTRYapMessageSendAction,
                                            completion:@escaping (_ success: Bool, _ retryTimeout: TimeInterval) -> Void) {
             switch message.messageSecurity {
-...
         fileprivate func sendGroupMessage(_ message: OTRXMPPRoomMessage,
                                           thread: OTRThreadOwner,
                                           account: OTRAccount,
                                           accountProtocol: OTRXMPPManager,
                                           accountProtocol: XMPPManager,
                                           messageSendingAction:OTRYapMessageSendAction,
                                           completion:@escaping (_ success: Bool, _ retryTimeout: TimeInterval) -> Void) {
             let roomManager = accountProtocol.roomManager
-...
+            }
             //Get the XMPP procol manager associated with this message and therefore account
             guard let accountProtocol = OTRProtocolManager.sharedInstance().protocol(for: account) as? OTRXMPPManager else {
             guard let accountProtocol = OTRProtocolManager.sharedInstance().protocol(for: account) as? XMPPManager else {
                 completion(true, 0.0)
                 return
+            }
-...
+            }
             //Get the XMPP procol manager associated with this message and therefore account
             guard let accountProtocol = OTRProtocolManager.sharedInstance().protocol(for: account) as? OTRXMPPManager else {
             guard let accountProtocol = OTRProtocolManager.sharedInstance().protocol(for: account) as? XMPPManager else {
                 completion(true, 0.0)
                 return
+            }
-...
+            }
             //Get the XMPP procol manager associated with this message and therefore account
             guard let accountProtocol = OTRProtocolManager.sharedInstance().protocol(for: account) as? OTRXMPPManager else {
             guard let accountProtocol = OTRProtocolManager.sharedInstance().protocol(for: account) as? XMPPManager else {
                 completion(true, 0.0)
                 return
+            }
-...
+            }
+        }
         func sendOMEMOMessage(message:OTROutgoingMessage, accountProtocol:OTRXMPPManager,completion:@escaping MessageQueueHandlerCompletion) {
         func sendOMEMOMessage(message:OTROutgoingMessage, accountProtocol:XMPPManager,completion:@escaping MessageQueueHandlerCompletion) {
             guard let text = message.text, text.count > 0 else {
                 completion(true, 0.0)
                 return

                 account = [OTRAccount fetchObjectWithUniqueID:buddy.accountUniqueId transaction:transaction];
                 xmpp = (OTRXMPPManager*) [[OTRProtocolManager sharedInstance] protocolForAccount:account];
                 [xmpp sendDeliveryReceiptForMessage:originalMessage];
             } completionBlock:^{
                 [xmpp.fileTransferManager createAndDownloadItemsIfNeededWithMessage:originalMessage readConnection:OTRDatabaseManager.shared.readOnlyDatabaseConnection force:NO];
                 [[UIApplication sharedApplication] showLocalNotification:originalMessage];
                 [xmpp.fileTransferManager createAndDownloadItemsIfNeededWithMessage:originalMessage force:NO transaction:transaction];
                 [[UIApplication sharedApplication] showLocalNotification:originalMessage transaction:transaction];
             }];
+        }

         @objc open weak var omemoModuleQueue:DispatchQueue?
         @objc open var callbackQueue:DispatchQueue
         @objc open let workQueue:DispatchQueue
         @objc open let messageStorage: MessageStorage
         fileprivate var myJID:XMPPJID? {
             get {
                 return omemoModule?.xmppStream?.myJID
-...
          - parameter accountYapKey: The accounts unique yap key
          - parameter databaseConnection: A yap database connection on which all operations will be completed on
      `  */
         @objc public required init(accountYapKey:String,  databaseConnection:YapDatabaseConnection) throws {
         @objc public required init(accountYapKey:String,  databaseConnection:YapDatabaseConnection,
                                    messageStorage: MessageStorage) throws {
             try self.signalEncryptionManager = OTRAccountSignalEncryptionManager(accountKey: accountYapKey,databaseConnection: databaseConnection)
             self.omemoStorageManager = OTROMEMOStorageManager(accountKey: accountYapKey, accountCollection: OTRAccount.collection, databaseConnection: databaseConnection)
             self.accountYapKey = accountYapKey
-...
             self.outstandingXMPPStanzaResponseBlocks = [:]
             self.callbackQueue = DispatchQueue(label: "OTROMEMOSignalCoordinator-callback", attributes: [])
             self.workQueue = DispatchQueue(label: "OTROMEMOSignalCoordinator-work", attributes: [])
             self.messageStorage = messageStorage
+        }
         /**
-...
+            }
+        }
         open func processKeyData(_ keyData: [OMEMOKeyData], iv: Data, senderDeviceId: UInt32, fromJID: XMPPJID, payload: Data?, message: XMPPMessage) {
         open func processKeyData(_ keyData: [OMEMOKeyData], iv: Data, senderDeviceId: UInt32, forJID: XMPPJID, payload: Data?, delayed: Date?, forwarded: Bool, isIncoming: Bool, message: XMPPMessage) {
             let aesGcmBlockLength = 16
             guard let encryptedPayload = payload, encryptedPayload.count > 0 else {
             guard let encryptedPayload = payload, encryptedPayload.count > 0, let myJID = self.myJID else {
                 return
+            }
             var addressJID = forJID.bareJID
             if !isIncoming {
                 addressJID = myJID.bareJID
+            }
             let rid = self.signalEncryptionManager.registrationId
             //Could have multiple matching device id. This is extremely rare but possible that the sender has another device that collides with our device id.
             var unencryptedKeyData: Data?
             for key in keyData {
                 if key.deviceId == rid {
                     let keyData = key.data
                     do {
                         unencryptedKeyData = try self.signalEncryptionManager.decryptFromAddress(keyData, name: fromJID.bare, deviceId: senderDeviceId)
                         // have successfully decripted the AES key. We should break and use it to decrypt the payload
                         break
                     } catch let error {
                         DDLogError("Error decrypting: \(error)")
                         let nsError = error as NSError
                         if nsError.domain == SignalErrorDomain, nsError.code == SignalError.duplicateMessage.rawValue {
                             // duplicate messages are benign and can be ignored
                             return
+                        }
                         let buddyAddress = SignalAddress(name: fromJID.bare, deviceId: Int32(senderDeviceId))
                         if self.signalEncryptionManager.storage.sessionRecordExists(for: buddyAddress) {
                             // Session is corrupted
                             let _ = self.signalEncryptionManager.storage.deleteSessionRecord(for: buddyAddress)
                             DDLogError("Session exists and is possibly corrupted. Deleting...")
+                        }
             for key in keyData where key.deviceId == rid {
                 let keyData = key.data
                 do {
                     unencryptedKeyData = try self.signalEncryptionManager.decryptFromAddress(keyData, name: addressJID.bare, deviceId: senderDeviceId)
                     // have successfully decripted the AES key. We should break and use it to decrypt the payload
                     break
                 } catch let error {
                     DDLogError("Error decrypting OMEMO message for \(addressJID): \(error) \(message)")
                     let nsError = error as NSError
                     if nsError.domain == SignalErrorDomain, nsError.code == SignalError.duplicateMessage.rawValue {
                         // duplicate messages are benign and can be ignored
                         DDLogInfo("Ignoring duplicate OMEMO message: \(message)")
                         return
+                    }
                     let buddyAddress = SignalAddress(name: addressJID.bare, deviceId: Int32(senderDeviceId))
                     if self.signalEncryptionManager.storage.sessionRecordExists(for: buddyAddress) {
                         // Session is corrupted
                         let _ = self.signalEncryptionManager.storage.deleteSessionRecord(for: buddyAddress)
                         DDLogError("Session exists and is possibly corrupted. Deleting...")
+                    }
                     return
+                }
+            }
-...
+            }
             do {
                 guard let messageBody = try OTRSignalEncryptionHelper.decryptData(encryptedBody, key: aesKey, iv: iv, authTag: tag) else {
                     return
+                }
                 let messageString = String(data: messageBody, encoding: String.Encoding.utf8)
                 var databaseMessage:OTRBaseMessage = OTRIncomingMessage()
                 guard let ourJID = self.myJID else {
                 guard let messageBody = try OTRSignalEncryptionHelper.decryptData(encryptedBody, key: aesKey, iv: iv, authTag: tag),
                 let messageString = String(data: messageBody, encoding: String.Encoding.utf8),
                 messageString.count > 0 else {
                     return
+                }
                 var relatedBuddyUsername: String? = fromJID.bare
                 var innerMessage = message
                 if message.isTrustedMessageCarbon(forMyJID: ourJID),
                     let forwarded = message.messageCarbonForwarded {
                     //This came from another of our devices this is really going to be an outgoing message
                     innerMessage = forwarded
                     if (message.isReceivedMessageCarbon) {
                         relatedBuddyUsername = innerMessage.from?.bare
                     } else {
                         relatedBuddyUsername = innerMessage.to?.bare
                         let outgoingMessage = OTROutgoingMessage()!
                         outgoingMessage.dateSent = Date()
                         databaseMessage = outgoingMessage
+                    }
+                }
                 var xmpp: OTRXMPPManager? = nil
                 var account: OTRAccount? = nil
                 self.databaseConnection.asyncReadWrite({ (transaction) in
                     guard let buddyUsernmae = relatedBuddyUsername, let jid = XMPPJID(string: buddyUsernmae), let buddy = OTRXMPPBuddy.fetchBuddy(jid: jid, accountUniqueId: self.accountYapKey, transaction: transaction) else {
                 let preSave: MessageStorage.PreSave = { message, transaction in
                     guard let buddy = OTRXMPPBuddy.fetchBuddy(jid: forJID, accountUniqueId: self.accountYapKey, transaction: transaction) else {
                         return
+                    }
                     databaseMessage.text = messageString
                     databaseMessage.buddyUniqueId = buddy.uniqueId
                     let deviceNumber = NSNumber(value: senderDeviceId as UInt32)
                     let deviceYapKey = OTROMEMODevice.yapKey(withDeviceId: deviceNumber, parentKey: buddy.uniqueId, parentCollection: OTRBuddy.collection)
                     databaseMessage.messageSecurityInfo = OTRMessageEncryptionInfo.init(omemoDevice: deviceYapKey, collection: OTROMEMODevice.collection)
                     if let id = innerMessage.elementID {
                         databaseMessage.messageId = id
+                    }
                     message.messageSecurityInfo = OTRMessageEncryptionInfo.init(omemoDevice: deviceYapKey, collection: OTROMEMODevice.collection)
                     databaseMessage.save(with: transaction)
                     message.save(with: transaction)
                     // Should we be using the date of the xmpp message?
                     buddy.lastMessageId = databaseMessage.uniqueId
                     buddy.lastMessageId = message.uniqueId
                     buddy.save(with: transaction)
                     //Update device last received message
-...
+                    }
                     let newDevice = OTROMEMODevice(deviceId: device.deviceId, trustLevel: device.trustLevel, parentKey: device.parentKey, parentCollection: device.parentCollection, publicIdentityKeyData: device.publicIdentityKeyData, lastSeenDate: Date())
                     newDevice.save(with: transaction)
                     // Send delivery receipt
                     account = OTRAccount.fetchObject(withUniqueID: buddy.accountUniqueId, transaction: transaction)
                     if let account = account {
                         xmpp = OTRProtocolManager.sharedInstance().protocol(for: account) as? OTRXMPPManager
                     } else {
                         return
+                    }
                     if let incomingMessage = databaseMessage as? OTRIncomingMessage {
                         xmpp?.sendDeliveryReceipt(for: incomingMessage)
+                    }
                     }, completionQueue: DispatchQueue.main,
                        completionBlock: {
                         guard let _ = databaseMessage.text else {
                             return
+                        }
                         xmpp?.fileTransferManager.createAndDownloadItemsIfNeeded(message: databaseMessage, readConnection: OTRDatabaseManager.shared.readOnlyDatabaseConnection ?? self.databaseConnection, force: false)
                         UIApplication.shared.showLocalNotification(databaseMessage)
                 })
                 // Display local notification
+                }
             } catch {
                 if forwarded {
                     self.messageStorage.handleForwardedMessage(message, forJID: forJID, body: messageString, accountId: self.accountYapKey, delayed: delayed, isIncoming: isIncoming, preSave: preSave)
                 } else {
                     self.messageStorage.handleDirectMessage(message, body: messageString, accountId: self.accountYapKey, preSave: preSave)
+                }
             } catch let error {
                 DDLogError("Message decryption error: \(error)")
                 return
+            }
+        }
+    }
-...
+        }
         public func omemo(_ omemo: OMEMOModule, receivedKeyData keyData: [OMEMOKeyData], iv: Data, senderDeviceId: UInt32, from fromJID: XMPPJID, payload: Data?, message: XMPPMessage) {
             self.processKeyData(keyData, iv: iv, senderDeviceId: senderDeviceId, fromJID: fromJID, payload: payload, message: message)
             self.processKeyData(keyData, iv: iv, senderDeviceId: senderDeviceId, forJID: fromJID, payload: payload, delayed: nil, forwarded: false, isIncoming: true, message: message)
+        }
         public func omemo(_ omemo: OMEMOModule, receivedForwardedKeyData keyData: [OMEMOKeyData], iv: Data, senderDeviceId: UInt32, for forJID: XMPPJID, payload: Data?, isIncoming: Bool, delayed: Date?, forwardedMessage: XMPPMessage, originalMessage: XMPPMessage) {
             self.processKeyData(keyData, iv: iv, senderDeviceId: senderDeviceId, forJID: forJID, payload: payload, delayed: delayed, forwarded: true, isIncoming: isIncoming, message: forwardedMessage)
+        }
+    }

         open func storeBuddyDevices(_ devices:[NSNumber], buddyUsername:String, completion:(()->Void)?) {
             self.databaseConnection.asyncReadWrite { (transaction) in
                 // Fetch the buddy from the database.
                 var buddy: OTRXMPPBuddy? = nil
                 if let jid = XMPPJID(string: buddyUsername) {
                     buddy = OTRXMPPBuddy.fetchBuddy(jid: jid, accountUniqueId: self.accountKey, transaction: transaction)
                 guard let jid = XMPPJID(string: buddyUsername), let buddy = OTRXMPPBuddy.fetchBuddy(jid: jid, accountUniqueId: self.accountKey, transaction: transaction) else {
                     // If this is teh first launch the buddy will not be in the buddy list becuase the roster comes in after device list from PEP.
                     DDLogWarn("Could not find buddy to store devices \(buddyUsername)")
                     return
+                }
                 // If this is teh first launch the buddy will not be in the buddy list becuase the roster comes in after device list from PEP.
                 // So we create a buddy witht the minimial information we have in order to save the device list.
                 if (buddy == nil) {
                     buddy = OTRXMPPBuddy()
                     buddy?.username = buddyUsername
                     buddy?.accountUniqueId = self.accountKey
                     buddy?.save(with: transaction)
+                }
                 if let bud = buddy {
                     self.storeDevices(devices, parentYapKey: bud.uniqueId, parentYapCollection: type(of: bud).collection, transaction: transaction)
                     if let completion = completion {
                         completion()
+                    }
+                }
                 self.storeDevices(devices, parentYapKey: buddy.uniqueId, parentYapCollection: buddy.threadCollection, transaction: transaction)
                 completion?()
+            }
+        }
+    }

      */
     public class ServerCheck: NSObject, OTRServerCapabilitiesDelegate, XMPPPushDelegate {
         @objc public weak var xmpp: OTRXMPPManager?
         @objc public weak var xmpp: XMPPManager?
         @objc public let push: PushController
         @objc public var result = ServerCheckResult()
-...
+        }
         @objc public init(xmpp: OTRXMPPManager, push: PushController) {
         @objc public init(xmpp: XMPPManager, push: PushController) {
             self.push = push
             self.xmpp = xmpp
             super.init()

     @class OTRXMPPAccount;
     @class OTROMEMOSignalCoordinator;
     @class XMPPPushModule, ServerCheck, FileTransferManager;
     @class XMPPPushModule, ServerCheck, FileTransferManager, MessageStorage;
     NS_ASSUME_NONNULL_BEGIN
     NS_SWIFT_NAME(XMPPManager)
     @interface OTRXMPPManager : NSObject <XMPPRosterDelegate, XMPPStreamDelegate, NSFetchedResultsControllerDelegate, OTRProtocol>
     @property (nonatomic, strong, readonly) OTRXMPPAccount *account;
-...
     @property (nonatomic, strong, readonly) XMPPPushModule *xmppPushModule;
     @property (nonatomic, strong, readonly) ServerCheck *serverCheck;
     @property (nonatomic, strong, readonly) FileTransferManager *fileTransferManager;
     @property (nonatomic, strong, readonly) YapDatabaseConnection *databaseConnection;
     @property (nonatomic, strong, readonly) MessageStorage *messageStorage;
     /** Useful for showing error messages related to connection, like SSL certs. Only safe for access from main queue. */
     @property (nonatomic, readonly, nullable) NSError *lastConnectionError;

         _fileTransferManager = [[FileTransferManager alloc] initWithConnection:self.databaseConnection serverCapabilities:self.serverCapabilities sessionConfiguration:sessionConfiguration];
         // Message storage
         _messageStorage = [[MessageStorage alloc] initWithConnection:self.databaseConnection capabilities:self.xmppCapabilities dispatchQueue:nil];
         _messageStorage = [[MessageStorage alloc] initWithConnection:self.databaseConnection capabilities:self.xmppCapabilities fileTransfer:self.fileTransferManager dispatchQueue:nil];
         [self.messageStorage activate:self.xmppStream];
         //Stream Management
-...
         //OMEMO
         if ([[OTRAppDelegate appDelegate].theme enableOMEMO]) {
             self.omemoSignalCoordinator = [[OTROMEMOSignalCoordinator alloc] initWithAccountYapKey:self.account.uniqueId databaseConnection:self.databaseConnection error:nil];
             self.omemoSignalCoordinator = [[OTROMEMOSignalCoordinator alloc] initWithAccountYapKey:self.account.uniqueId databaseConnection:self.databaseConnection messageStorage:self.messageStorage error:nil];
             _omemoModule = [[OMEMOModule alloc] initWithOMEMOStorage:self.omemoSignalCoordinator xmlNamespace:OMEMOModuleNamespaceConversationsLegacy];
             [self.omemoModule addDelegate:self.omemoSignalCoordinator delegateQueue:self.workQueue];
             [self.omemoModule activate:self.xmppStream];
-...
         // Fetch latest vCard from server so we can update nickname
         //[self.xmppvCardTempModule fetchvCardTempForJID:self.JID ignoreStorage:YES];
         // Testing MAM
         [self.messageStorage.archiving retrieveMessageArchiveWithFields:nil withResultSet:nil];
         // [self.messageStorage.archiving retrieveMessageArchiveWithFields:nil withResultSet:nil];
+    }
     - (void)xmppStream:(XMPPStream *)sender didNotAuthenticate:(NSXMLElement *)error

     #import "OTRXMPPManager.h"
     #import "OTRCertificatePinning.h"
     #import "OTRXMPPMessageYapStorage.h"
     #import "OTRXMPPBuddyManager.h"
     #import <ChatSecureCore/ChatSecureCore-Swift.h>
     #import "OTRYapDatabaseRosterStorage.h"
-...
     @property (nonatomic, strong, readonly) XMPPStreamManagement *streamManagement;
     @property (nonatomic, strong, readonly) MessageStorage *messageStorage;
     @property (nonatomic, strong, readonly) OTRXMPPBuddyManager* xmppBuddyManager;
     @property (nonatomic, strong, readonly) OMEMOModule *omemoModule;
     @property (nonatomic, strong, nullable) OTRXMPPChangePasswordManager *changePasswordManager;
     @property (nonatomic, strong, readonly) YapDatabaseConnection *databaseConnection;
     @property (nonatomic, strong, readonly) XMPPMessageDeliveryReceipts *deliveryReceipts;
     @property (nonatomic, strong, readonly) OTRXMPPMessageStatusModule *messageStatusModule;
     @property (nonatomic, strong, readonly) OTRStreamManagementDelegate *streamManagementDelegate;

     import XMPPFramework
     import CocoaLumberjack
     @objc public class MessageStorage: XMPPModule {
         /// This gets called before a message is saved, if additional processing needs to be done elsewhere
         public typealias PreSave = (_ message: OTRBaseMessage, _ transaction: YapDatabaseReadWriteTransaction) -> Void
         // MARK: Properties
         private let connection: YapDatabaseConnection
-...
         @objc public let capabilities: XMPPCapabilities
         @objc public let carbons: XMPPMessageCarbons
         @objc public let archiving: XMPPMessageArchiveManagement
         @objc public let fileTransfer: FileTransferManager
         // MARK: Init
         deinit {
-...
         /// Capabilities must be activated elsewhere
         @objc public init(connection: YapDatabaseConnection,
                           capabilities: XMPPCapabilities,
                           fileTransfer: FileTransferManager,
                           dispatchQueue: DispatchQueue? = nil) {
             self.connection = connection
             self.capabilities = capabilities
             self.carbons = XMPPMessageCarbons(dispatchQueue: dispatchQueue)
             self.archiving = XMPPMessageArchiveManagement(dispatchQueue: dispatchQueue)
             self.fileTransfer = fileTransfer
             super.init(dispatchQueue: dispatchQueue)
             self.carbons.addDelegate(self, delegateQueue: self.moduleQueue)
             self.archiving.addDelegate(self, delegateQueue: self.moduleQueue)
-...
             OTRBuddyCache.shared.setChatState(chatState, for: buddy)
+        }
         /// Marks a previously sent outgoing message as delivered
         /// Marks a previously sent outgoing message as delivered.
         private func handleDeliveryResponse(message: XMPPMessage, transaction: YapDatabaseReadWriteTransaction) {
             guard message.hasReceiptResponse,
                 !message.isErrorMessage,
                 let responseId = message.receiptResponseID else {
                     return
+            }
             OTROutgoingMessage.receivedDeliveryReceipt(forMessageId: responseId, transaction: transaction)
             var _deliveredMessage: OTROutgoingMessage? = nil
             transaction.enumerateMessages(elementId: responseId, originId: responseId, stanzaId: nil) { (message, stop) in
                 if let message = message as? OTROutgoingMessage {
                     _deliveredMessage = message
                     stop.pointee = true
+                }
+            }
             if _deliveredMessage == nil {
                 DDLogVerbose("Outgoing message not found for receipt: \(message)")
                 // This can happen with MAM + OMEMO where the decryption
                 // for the OMEMO message makes it come in after the receipt
                 // To solve this, we need to make a placeholder message...
                 // TODO.......
+            }
             guard let deliveredMessage = _deliveredMessage,
                 deliveredMessage.isDelivered == false,
                 deliveredMessage.dateDelivered == nil else {
                 return
+            }
             if let deliveredMessage = deliveredMessage.copyAsSelf() {
                 deliveredMessage.isDelivered = true
                 deliveredMessage.dateDelivered = Date()
                 deliveredMessage.save(with: transaction)
+            }
+        }
         /// It is a violation of the XMPP spec to discard messages with duplicate stanza elementIds. We must use XEP-0359 stanza-id only.
-...
+        }
         /// Handles both MAM and Carbons
         private func handleForwardedMessage(_ xmppMessage: XMPPMessage,
         public func handleForwardedMessage(_ xmppMessage: XMPPMessage,
                                             forJID: XMPPJID,
                                             body: String?,
                                             accountId: String,
                                             delayed: Date?,
                                             isIncoming: Bool) {
             guard xmppMessage.isMessageWithBody,
                 !xmppMessage.isErrorMessage,
                 let messageBody = xmppMessage.body,
                 OTRKit.stringStarts(withOTRPrefix: messageBody) else {
                                             isIncoming: Bool,
                                             preSave: PreSave? = nil ) {
             guard !xmppMessage.isErrorMessage else {
                 DDLogWarn("Discarding forwarded message: \(xmppMessage)")
                 return
+            }
             //Sent Message Carbons are sent by our account to another
             //So from is our JID and to is buddy
             var _jid: XMPPJID? = nil
             if isIncoming {
                 _jid = xmppMessage.from
             } else {
                 _jid = xmppMessage.to
+            }
             guard let jid = _jid else {
             // Ignore OTR text
             if let messageBody = xmppMessage.body, messageBody.isOtrText {
                 return
+            }
             connection.asyncReadWrite { (transaction) in
                 guard let account = OTRXMPPAccount.fetchObject(withUniqueID: accountId, transaction: transaction),
                     let buddy = OTRXMPPBuddy.fetchBuddy(jid: jid, accountUniqueId: accountId, transaction: transaction) else {
                     let buddy = OTRXMPPBuddy.fetchBuddy(jid: forJID, accountUniqueId: accountId, transaction: transaction) else {
                         return
+                }
                 var message: OTRBaseMessage? = nil
                 var _message: OTRBaseMessage? = nil
                 if isIncoming {
                     self.handleChatState(message: xmppMessage, buddy: buddy)
                     self.handleDeliveryResponse(message: xmppMessage, transaction: transaction)
                     message = OTRIncomingMessage(xmppMessage: xmppMessage, account: account, buddy: buddy, capabilities: self.capabilities)
                     self.handleChatState(message: xmppMessage, buddy: buddy)
                     _message = OTRIncomingMessage(xmppMessage: xmppMessage, body: body, account: account, buddy: buddy, capabilities: self.capabilities)
                 } else {
                     message = OTROutgoingMessage(xmppMessage: xmppMessage, account: account, buddy: buddy, capabilities: self.capabilities)
                     let outgoing = OTROutgoingMessage(xmppMessage: xmppMessage, body: body, account: account, buddy: buddy, capabilities: self.capabilities)
                     outgoing.dateSent = delayed ?? Date()
                     _message = outgoing
+                }
                 guard let stanzaId = message?.stanzaId,
                     !self.isDuplicate(xmppMessage: xmppMessage, stanzaId: stanzaId, buddyUniqueId: buddy.uniqueId, transaction: transaction) else {
                         DDLogWarn("Duplicate forwarded message received: \(xmppMessage)")
                         return
                 guard let message = _message else {
                     DDLogWarn("Discarding empty message: \(xmppMessage)")
                     return
+                }
                 // Bail out if we receive duplicate messages identified by XEP-0359
                 if let stanzaId = message.stanzaId,
                 self.isDuplicate(xmppMessage: xmppMessage, stanzaId: stanzaId, buddyUniqueId: buddy.uniqueId, transaction: transaction) {
                     DDLogWarn("Duplicate forwarded message received: \(xmppMessage)")
                     return
+                }
                 if let delayed = delayed {
                     message?.date = delayed
                     message.date = delayed
+                }
                 preSave?(message, transaction)
                 message.save(with: transaction)
                 if let incoming = message as? OTRIncomingMessage {
                     self.finishHandlingIncomingMessage(incoming, account: account, transaction: transaction)
+                }
                 message?.save(with: transaction)
+            }
+        }
         /// Inserts direct message into database
         private func handleDirectMessage(_ message: XMPPMessage, accountId: String) {
             connection.asyncReadWrite { (transaction) in
         public func handleDirectMessage(_ message: XMPPMessage,
                                         body: String?,
                                         accountId: String,
                                         preSave: PreSave? = nil) {
             var incomingMessage: OTRIncomingMessage? = nil
             connection.asyncReadWrite({ (transaction) in
                 guard let account = OTRXMPPAccount.fetchObject(withUniqueID: accountId, transaction: transaction),
                     let fromJID = message.from,
                     let buddy = OTRXMPPBuddy.fetchBuddy(jid: fromJID, accountUniqueId: accountId, transaction: transaction)
                     else {
                         return
+                }
                 // Update ChatState
                 self.handleChatState(message: message, buddy: buddy)
-...
                     return
+                }
                 let incoming = OTRIncomingMessage(xmppMessage: message, account: account, buddy: buddy, capabilities: self.capabilities)
                 incomingMessage = OTRIncomingMessage(xmppMessage: message, body: body, account: account, buddy: buddy, capabilities: self.capabilities)
                 // Check for duplicates
                 if let stanzaId = incoming.stanzaId,
                 if let stanzaId = incomingMessage?.stanzaId,
                     self.isDuplicate(xmppMessage: message, stanzaId: stanzaId, buddyUniqueId: buddy.uniqueId, transaction: transaction) {
                     DDLogWarn("Duplicate message received: \(message)")
                     return
+                }
                 guard let incoming = incomingMessage, let text = incoming.text, text.count > 0 else {
                     // discard empty message text
                     return
+                }
                 // TODO: Replace this so we aren't passing everything through OTRKit
                 if let text = incoming.text {
                 if text.isOtrText {
                     OTRProtocolManager.shared.encryptionManager.otrKit.decodeMessage(text, username: buddy.username, accountName: account.username, protocol: kOTRProtocolTypeXMPP, tag: incoming)
                 } else {
                     preSave?(incoming, transaction)
                     incoming.save(with: transaction)
                     self.finishHandlingIncomingMessage(incoming, account: account, transaction: transaction)
+                }
             })
+        }
         private func finishHandlingIncomingMessage(_ message: OTRIncomingMessage, account: OTRXMPPAccount, transaction: YapDatabaseReadWriteTransaction) {
             guard let xmpp = OTRProtocolManager.shared.protocol(for: account) as? XMPPManager else {
                 return
+            }
             xmpp.sendDeliveryReceipt(for: message)
             self.fileTransfer.createAndDownloadItemsIfNeeded(message: message, force: false, transaction: transaction)
             UIApplication.shared.showLocalNotification(message, transaction: transaction)
+        }
+    }
-...
                 !message.isMessageCarbon,
                 // We handle MAM elsewhere as well
                 message.mamResult == nil,
                 // OMEMO messages cannot be processed here
                 !message.omemo_hasEncryptedElement(.conversationsLegacy),
                 let accountId = sender.accountId else {
                 return
+            }
             handleDirectMessage(message, accountId: accountId)
             handleDirectMessage(message, body: nil, accountId: accountId)
+        }
+    }
     extension MessageStorage: XMPPMessageCarbonsDelegate {
         public func xmppMessageCarbons(_ xmppMessageCarbons: XMPPMessageCarbons, didReceive message: XMPPMessage, outgoing isOutgoing: Bool) {
             guard let accountId = xmppMessageCarbons.xmppStream?.accountId else {
             guard let accountId = xmppMessageCarbons.xmppStream?.accountId,
             !message.omemo_hasEncryptedElement(.conversationsLegacy) else {
                 return
+            }
             handleForwardedMessage(message, accountId: accountId, delayed: nil, isIncoming: !isOutgoing)
             var _forJID: XMPPJID? = nil
             if !isOutgoing {
                 _forJID = message.from
             } else {
                 _forJID = message.to
+            }
             guard let forJID = _forJID else { return }
             handleForwardedMessage(message, forJID: forJID, body: nil, accountId: accountId, delayed: nil, isIncoming: !isOutgoing)
+        }
+    }
     extension MessageStorage: XMPPMessageArchiveManagementDelegate {
         public func xmppMessageArchiveManagement(_ xmppMessageArchiveManagement: XMPPMessageArchiveManagement, didFailToReceiveMessages error: XMPPIQ) {
             DDLogError("Failed to receive messages \(error)")
+        }
         public func xmppMessageArchiveManagement(_ xmppMessageArchiveManagement: XMPPMessageArchiveManagement, didReceiveMAMMessage message: XMPPMessage) {
             guard let accountId = xmppMessageArchiveManagement.xmppStream?.accountId,
                 let myJID = xmppMessageArchiveManagement.xmppStream?.myJID,
                 let result = message.mamResult,
                 let forwarded = result.forwardedMessage,
                 let delayed = result.forwardedStanzaDelayedDeliveryDate,
                 let from = forwarded.from else {
                 let from = forwarded.from,
                 !forwarded.omemo_hasEncryptedElement(.conversationsLegacy) else {
                     DDLogVerbose("Discarding incoming MAM message \(message)")
                     return
+            }
             let delayed = result.forwardedStanzaDelayedDeliveryDate
             let isIncoming = !from.isEqual(to: myJID, options: .bare)
             handleForwardedMessage(forwarded, accountId: accountId, delayed: delayed, isIncoming: isIncoming)
             var _forJID: XMPPJID? = nil
             if isIncoming {
                 _forJID = forwarded.from
             } else {
                 _forJID = forwarded.to
+            }
             guard let forJID = _forJID else { return }
             handleForwardedMessage(forwarded, forJID: forJID, body: nil, accountId: accountId, delayed: delayed, isIncoming: isIncoming)
+        }
+    }
-...
+        }
+    }
     extension String {
         /// https://otr.cypherpunks.ca/Protocol-v3-4.0.0.html
         static let OTRWhitespaceStart = String(bytes: [0x20,0x09,0x20,0x20,0x09,0x09,0x09,0x09,0x20,0x09,0x20,0x09,0x20,0x09,0x20,0x20], encoding: .utf8)!
         /// for separately handling OTR messages
         var isOtrText: Bool {
             return self.contains("?OTR") || self.contains(String.OTRWhitespaceStart)
+        }
+    }
     extension OTRBaseMessage {
         convenience init(xmppMessage: XMPPMessage, account: OTRXMPPAccount, buddy: OTRXMPPBuddy, capabilities: XMPPCapabilities) {
         /// You can override message body, for example if this is an encrypted message
         convenience init(xmppMessage: XMPPMessage, body: String?, account: OTRXMPPAccount, buddy: OTRXMPPBuddy, capabilities: XMPPCapabilities) {
             self.init()
             self.messageText = xmppMessage.body
             self.messageText = body ?? xmppMessage.body
             self.buddyUniqueId = buddy.uniqueId
             if let delayed = xmppMessage.delayedDeliveryDate {
                 self.messageDate = delayed
-...
+            }
+        }
+    }
     extension NSCopying {
         /// Creates a deep copy of the object
         func copyAsSelf() -> Self? {
             return self.copy() as? Self
+        }
+    }

             [databaseRoom saveWithTransaction:transaction];
             [databaseMessage saveWithTransaction:transaction];
         } completionBlock:^{
             if(databaseMessage) {
                 OTRXMPPManager *xmpp = (OTRXMPPManager*)[OTRProtocolManager.shared protocolForAccount:account];
                 [xmpp.fileTransferManager createAndDownloadItemsIfNeededWithMessage:databaseMessage readConnection:OTRDatabaseManager.shared.readOnlyDatabaseConnection force:NO];
                 [xmpp.fileTransferManager createAndDownloadItemsIfNeededWithMessage:databaseMessage force:NO transaction:transaction];
                 // If delayedDeliveryDate is set we are retrieving history. Don't show
                 // notifications in that case. Also, don't show notifications for archived
                 // rooms.
                 if (!message.delayedDeliveryDate && !databaseRoom.isArchived) {
                     [[UIApplication sharedApplication] showLocalNotification:databaseMessage];
                     [[UIApplication sharedApplication] showLocalNotification:databaseMessage transaction:transaction];
+                }
+            }
         }];

     @interface OTRYapDatabaseRosterStorage ()
     @property (nonatomic, strong, readonly, nonnull) YapDatabaseConnection *readConnection;
     @property (nonatomic, strong, readonly, nonnull) YapDatabaseConnection *writeConnection;
     @property (nonatomic, strong, readonly, nonnull) YapDatabaseConnection *connection;
     @end
-...
     -(instancetype)init
+    {
         if (self = [super init]) {
             _readConnection = OTRDatabaseManager.shared.readOnlyDatabaseConnection;
             _writeConnection = OTRDatabaseManager.shared.readWriteDatabaseConnection;
             _connection = OTRDatabaseManager.shared.readWriteDatabaseConnection;
+        }
         return self;
+    }
-...
+    }
     /** When created, it is still unsaved and must be manually saved within a yap transaction. */
     - (nullable OTRXMPPBuddy *)createBuddyWithJID:(XMPPJID *)jid stream:(XMPPStream *)stream {
     - (nullable OTRXMPPBuddy *)fetchOrCreateBuddyWithJID:(XMPPJID *)jid stream:(XMPPStream *)stream {
         if ([stream.myJID isEqualToJID:jid options:XMPPJIDCompareBare]) {
             DDLogWarn(@"Adding self to roster: %@", jid);
+        }
         NSString *accountUniqueId = [self accountUniqueIdForStream:stream];
         OTRXMPPBuddy *buddy = [[OTRXMPPBuddy alloc] init];
         __block OTRXMPPBuddy *buddy = nil;
         [self.connection readWithBlock:^(YapDatabaseReadTransaction * _Nonnull transaction) {
             buddy = [self fetchBuddyWithJID:jid stream:stream transaction:transaction];
         }];
         if (!buddy) {
             buddy = [[OTRXMPPBuddy alloc] init];
+        }
         buddy.username = [jid bare];
         buddy.accountUniqueId = accountUniqueId;
         return buddy;
+    }
     - (nullable OTRXMPPBuddy*) createBuddyFromRosterItem:(NSXMLElement *)rosterItem stream:(XMPPStream *)stream {
     - (nullable OTRXMPPBuddy*) fetchOrCreateBuddyFromRosterItem:(NSXMLElement *)rosterItem stream:(XMPPStream *)stream {
         NSString *jidStr = [rosterItem attributeStringValueForName:@"jid"];
         XMPPJID *jid = [[XMPPJID jidWithString:jidStr] bareJID];
         return [self createBuddyWithJID:jid stream:stream];
         return [self fetchOrCreateBuddyWithJID:jid stream:stream];
+    }
-...
     - (BOOL)existsBuddyWithJID:(XMPPJID *)jid xmppStram:(XMPPStream *)stream
+    {
         __block BOOL result = NO;
         [self.readConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
         [self.connection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
             OTRBuddy *buddy = [self fetchBuddyWithJID:jid stream:stream transaction:transaction];
             if (buddy) {
                 result = YES;
-...
         if (!item) { return; }
         BOOL newlyCreatedBuddy = NO;
         if (!buddy) {
             buddy = [self createBuddyFromRosterItem:item stream:stream];
             buddy = [self fetchOrCreateBuddyFromRosterItem:item stream:stream];
             if (!buddy) {
                 return;
+            }
-...
             return;
+        }
         [self.writeConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
         [self.connection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
             [newBuddy saveWithTransaction:transaction];
         }];
-...
+        }
         __block OTRXMPPBuddy *buddy = nil;
         [self.readConnection readWithBlock:^(YapDatabaseReadTransaction * _Nonnull transaction) {
         [self.connection readWithBlock:^(YapDatabaseReadTransaction * _Nonnull transaction) {
             buddy = [self fetchBuddyWithJID:jid stream:stream transaction:transaction];
         }];
         NSString *subscription = [item attributeStringValueForName:@"subscription"];
         if ([subscription isEqualToString:@"remove"])
+        {
             if (buddy) {
                 [self.writeConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
                 [self.connection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
                     [transaction removeObjectForKey:buddy.uniqueId inCollection:[OTRXMPPBuddy collection]];
                 }];
+            }
-...
     - (void)handlePresence:(XMPPPresence *)presence xmppStream:(XMPPStream *)stream
+    {
         __block OTRXMPPBuddy *buddy = nil;
         [self.readConnection readWithBlock:^(YapDatabaseReadTransaction * _Nonnull transaction) {
         [self.connection readWithBlock:^(YapDatabaseReadTransaction * _Nonnull transaction) {
             buddy = [self fetchBuddyWithJID:[presence from] stream:stream transaction:transaction];
         }];
         BOOL newlyCreatedBuddy = NO;
         if (!buddy) {
             buddy = [self createBuddyWithJID:[presence from] stream:stream];
             buddy = [self fetchOrCreateBuddyWithJID:[presence from] stream:stream];
             if (!buddy) {
                 return;
+            }
-...
         // If this contact is pending approval but you see their presence
         // then they're not pending anymore
         if (newStatus != OTRThreadStatusOffline && newBuddy.pendingApproval) {
             [self.writeConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
             [self.connection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
                 OTRXMPPBuddy *buddy = [[OTRXMPPBuddy fetchObjectWithUniqueID:newBuddy.uniqueId transaction:transaction] copy];
                 if (!buddy) { return; }
                 buddy.pendingApproval = NO;
-...
         // Save if it's a new buddy
         if (newlyCreatedBuddy) {
             [self.writeConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
             [self.connection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
                 [newBuddy saveWithTransaction:transaction];
             }];
+        }
-...
     - (NSArray *)jidsForXMPPStream:(XMPPStream *)stream
+    {
         __block NSMutableArray *jidArray = [NSMutableArray array];
         [self.readConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
         [self.connection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
             [transaction enumerateKeysAndObjectsInCollection:[OTRXMPPBuddy collection] usingBlock:^(NSString *key, id object, BOOL *stop) {
                 if ([object isKindOfClass:[OTRXMPPBuddy class]]) {
                     OTRXMPPBuddy *buddy = (OTRXMPPBuddy *)object;

     //
     //  XMPPManager.swift
     //  ChatSecureCore
     //
     //  Created by Chris Ballinger on 11/27/17.
     //  Copyright © 2017 Chris Ballinger. All rights reserved.
     //
     import Foundation
     import XMPPFramework
     extension XMPPMessageArchiveManagement {
         public func fetchHistory(archiveJID: XMPPJID? = nil, userJID: XMPPJID? = nil, since: Date? = nil) {
             var fields: [XMLElement] = []
             if let userJID = userJID {
                 let with = XMPPMessageArchiveManagement.field(withVar: "with", type: nil, andValue: userJID.bare)
                 fields.append(with)
+            }
             if let since = since {
                 let xmppDateString = (since as NSDate).xmppDateTimeString
                 let start = XMPPMessageArchiveManagement.field(withVar: "start", type: nil, andValue: xmppDateString)
                 fields.append(start)
+            }
             retrieveMessageArchive(at: archiveJID, withFields: fields, with: nil)
+        }
+    }
     /// Formerly known in Obj-C as OTRXMPPManager
     public extension XMPPManager {
         /** Fetches history for a thread after the most recent message */
         @objc public func fetchHistoryForThread(_ thread: OTRThreadOwner, transaction: YapDatabaseReadTransaction) {
             var archiveJID: XMPPJID? = nil
             var userJID: XMPPJID? = nil
             if let buddy = thread as? OTRXMPPBuddy,
                 let buddyJID = buddy.bareJID {
                 archiveJID = account.bareJID
                 userJID = buddyJID
             } else if let room = thread as? OTRXMPPRoom {
                 archiveJID = room.roomJID
+            }
             let lastMessageDate = thread.lastMessage(with: transaction)?.messageDate
             messageStorage.archiving.fetchHistory(archiveJID: archiveJID, userJID: userJID, since: lastMessageDate)
+        }
+    }

         @objc public var needsMigration: Bool {
             guard let jid = bareJID else { return false }
             if OTRServerDeprecation.isDeprecated(server: jid.domain) {
                 if !autologin, let xmpp = OTRProtocolManager.shared.protocol(for: self) as? OTRXMPPManager,
                 if !autologin, let xmpp = OTRProtocolManager.shared.protocol(for: self) as? XMPPManager,
                     xmpp.connectionStatus == .disconnected {
                     return false // May have migrated
+                }

ChatSecure/Classes/Model/Yap Storage/OTROutgoingMessage.h
24	24	/** Mark message as deliverd via XEP-0184.*/
25	25	@property (nonatomic, getter = isDelivered) BOOL delivered;
26	26
27		+ (void)receivedDeliveryReceiptForMessageId:(nonnull NSString )messageId transaction:(nonnull YapDatabaseReadWriteTransaction)transaction;
28
29	27	@end
30	28	NS_ASSUME_NONNULL_END

     @implementation OTROutgoingMessage
     + (void)receivedDeliveryReceiptForMessageId:(NSString *)messageId transaction:(YapDatabaseReadWriteTransaction*)transaction
+    {
         __block OTROutgoingMessage *deliveredMessage = nil;
         [transaction enumerateMessagesWithElementId:messageId originId:messageId stanzaId:nil block:^(id<OTRMessageProtocol> _Nonnull message, BOOL * _Null_unspecified stop) {
             if ([message isKindOfClass:[self class]]) {
                 deliveredMessage = (OTROutgoingMessage *)message;
                 *stop = YES;
+            }
         }];
         // OTRDATA Media messages are not delivered until the transfer is complete. This is handled in the OTREncryptionManager.
         if (deliveredMessage.mediaItemUniqueId.length > 0 &&
             deliveredMessage.text.length == 0) {
             return;
+        }
         if (deliveredMessage) {
             deliveredMessage = [deliveredMessage copy];
             deliveredMessage.delivered = YES;
             deliveredMessage.dateDelivered = [NSDate date];
             [deliveredMessage saveWithTransaction:transaction];
+        }
+    }
     #pragma MARK - OTRMessageProtocol
     - (BOOL)isMessageIncoming

             if matchingBuddies.count > 1 {
                 DDLogWarn("WARN: More than one OTRXMPPBuddy matching query \(query) \(jid) \(accountUniqueId): \(matchingBuddies.count)")
+            }
             #if DEBUG
                 if matchingBuddies.count == 0 {
                     DDLogWarn("WARN: No OTRXMPPBuddy matching query \(jid) \(accountUniqueId)")
                     let buddy = slowLookup(jid: jid, accountUniqueId: accountUniqueId, transaction: transaction)
                     if buddy != nil {
                         DDLogWarn("WARN: Found buddy using O(n) lookup that wasn't found in secondary index: \(jid) \(accountUniqueId)")
+                    }
+                }
             #endif
     //        #if DEBUG
     //            if matchingBuddies.count == 0 {
     //                DDLogWarn("WARN: No OTRXMPPBuddy matching query \(jid) \(accountUniqueId)")
     //                let buddy = slowLookup(jid: jid, accountUniqueId: accountUniqueId, transaction: transaction)
     //                if buddy != nil {
     //                    DDLogWarn("WARN: Found buddy using O(n) lookup that wasn't found in secondary index: \(jid) \(accountUniqueId)")
     //                }
     //            }
     //        #endif
             return matchingBuddies.first
+        }
+    }

         var detailCells: [DetailCellInfo] = []
         let DetailCellIdentifier = "DetailCellIdentifier"
         let xmpp: OTRXMPPManager
         let xmpp: XMPPManager
         @objc public init(account: OTRXMPPAccount, xmpp: OTRXMPPManager, longLivedReadConnection: YapDatabaseConnection, writeConnection: YapDatabaseConnection) {
         @objc public init(account: OTRXMPPAccount, xmpp: XMPPManager, longLivedReadConnection: YapDatabaseConnection, writeConnection: YapDatabaseConnection) {
             self.account = account
             self.longLivedReadConnection = longLivedReadConnection
             self.writeConnection = writeConnection
-...
             let cancel = UIAlertAction(title: CANCEL_STRING(), style: .cancel)
             let delete = UIAlertAction(title: DELETE_ACCOUNT_BUTTON_STRING(), style: .destructive) { (action) in
                 let protocols = OTRProtocolManager.sharedInstance()
                 if let xmpp = protocols.protocol(for: account) as? OTRXMPPManager,
                 if let xmpp = protocols.protocol(for: account) as? XMPPManager,
                     xmpp.connectionStatus != .disconnected {
                     xmpp.disconnect()
+                }
-...
             let cancel = UIAlertAction(title: CANCEL_STRING(), style: .cancel)
             let logout = UIAlertAction(title: LOGOUT_STRING(), style: .destructive) { (action) in
                 let protocols = OTRProtocolManager.sharedInstance()
                 if let xmpp = protocols.protocol(for: account) as? OTRXMPPManager,
                 if let xmpp = protocols.protocol(for: account) as? XMPPManager,
                     xmpp.connectionStatus != .disconnected {
                     xmpp.disconnect()
+                }

             [self scrollToBottomAnimated:animated];
         });
         self.loadingMessages = NO;
         [self fetchMessageHistory];
+    }
     - (void)viewWillAppear:(BOOL)animated
-...
     #pragma - mark Setters & getters
     - (void) fetchMessageHistory {
         [self.readOnlyDatabaseConnection asyncReadWithBlock:^(YapDatabaseReadTransaction * _Nonnull transaction) {
             id<OTRThreadOwner> thread = [self threadObjectWithTransaction:transaction];
             OTRXMPPManager *xmpp = [self xmppManagerWithTransaction:transaction];
             [xmpp fetchHistoryForThread:thread transaction:transaction];
         }];
+    }
     - (OTRAttachmentPicker *)attachmentPicker
+    {
         if (!_attachmentPicker) {
-...
                 account = [OTRAccount fetchObjectWithUniqueID:buddy.accountUniqueId transaction:transaction];
             }];
             //Update UI now
             if (buddy.chatState == OTRChatStateComposing || buddy.chatState == OTRChatStatePaused) {
                 self.showTypingIndicator = YES;

ChatSecure/Classes/View Controllers/OTRRoomOccupantsViewController.swift
303	303
304	304	/** Do not call this within a yap transaction! */
305	305	fileprivate func xmppRoom() -> XMPPRoom? {
306		var xmpp: OTRXMPPManager? = nil
	306	var xmpp: XMPPManager? = nil
307	307	self.readConnection?.read { transaction in
308	308	if let account = self.room?.account(with: transaction) {
309		xmpp = OTRProtocolManager.shared.protocol(for: account) as? OTRXMPPManager
	309	xmpp = OTRProtocolManager.shared.protocol(for: account) as? XMPPManager
310	310	}
311	311	}
312	312	guard let room = self.room,
...	...
318	318	}
319	319
320	320	fileprivate func xmppRoomManager() -> OTRXMPPRoomManager? {
321		var xmpp: OTRXMPPManager? = nil
	321	var xmpp: XMPPManager? = nil
322	322	self.readConnection?.read { transaction in
323	323	if let account = self.room?.account(with: transaction) {
324		xmpp = OTRProtocolManager.shared.protocol(for: account) as? OTRXMPPManager
	324	xmpp = OTRProtocolManager.shared.protocol(for: account) as? XMPPManager
325	325	}
326	326	}
327	327	return xmpp?.roomManager

                 return nil
+            }
             guard let xmpp = OTRProtocolManager.sharedInstance().protocol(for: acct) as? OTRXMPPManager else {
             guard let xmpp = OTRProtocolManager.sharedInstance().protocol(for: acct) as? XMPPManager else {
                 return nil
+            }
             return xmpp.omemoSignalCoordinator
-...
             yourProfileRow.value = account
             yourProfileSection.addFormRow(yourProfileRow)
             guard let xmpp = OTRProtocolManager.sharedInstance().protocol(for: account) as? OTRXMPPManager else {
             guard let xmpp = OTRProtocolManager.sharedInstance().protocol(for: account) as? XMPPManager else {
                 return form
+            }
             guard let myBundle = xmpp.omemoSignalCoordinator?.fetchMyBundle() else {

             self.downloadAction = { [weak self] view, sender in
                 self?.downloadButton.isEnabled = false
                 var xmpp: OTRXMPPManager? = nil
                 var xmpp: XMPPManager? = nil
                 OTRDatabaseManager.shared.readOnlyDatabaseConnection?.read { transaction in
                     guard let thread = message.threadOwner(with: transaction) else { return }
                     guard let account = thread.account(with: transaction) else { return }
                     xmpp = OTRProtocolManager.shared.protocol(for: account) as? OTRXMPPManager
                     xmpp = OTRProtocolManager.shared.protocol(for: account) as? XMPPManager
                     xmpp?.fileTransferManager.downloadMediaIfNeeded(message)
+                }
+            }

Submodules/XMPPFramework
1		Subproject commit efa1f9d3b8334aa3d4636eb238ff3b363c2697ac
	1	Subproject commit f5f1cea4d4553fed05fe388a747c73398ca7568a

Core Apps » ChatSecure:Android

Revision 8d76e2e3