Check Application state before sending RR (#1960)

* check the state

* better handling

* protocol to mock the application state

* test improvement

ElementX/Sources/Mocks/ApplicationMock.swift

@@ -0,0 +1,73 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import UIKit
+
+extension ApplicationMock {
+    static var `default`: ApplicationProtocol {
+        ApplicationMock(withState: .active,
+                        backgroundTimeRemaining: 10,
+                        allowTasks: true)
+    }
+
+    static var mockBroken: ApplicationProtocol {
+        ApplicationMock(withState: .inactive,
+                        backgroundTimeRemaining: 0,
+                        allowTasks: false)
+    }
+
+    static var mockAboutToSuspend: ApplicationProtocol {
+        ApplicationMock(withState: .background,
+                        backgroundTimeRemaining: 2,
+                        allowTasks: false)
+    }
+    
+    private static var bgTaskIdentifier = 0
+
+    convenience init(withState applicationState: UIApplication.State,
+                     backgroundTimeRemaining: TimeInterval,
+                     allowTasks: Bool) {
+        self.init()
+        
+        underlyingApplicationState = applicationState
+        underlyingBackgroundTimeRemaining = backgroundTimeRemaining
+        
+        beginBackgroundTaskExpirationHandlerClosure = { [weak self] handler in
+            guard let self else {
+                return .invalid
+            }
+            
+            guard allowTasks else {
+                return .invalid
+            }
+            
+            return beginBackgroundTask(withName: nil, expirationHandler: handler)
+        }
+        
+        beginBackgroundTaskWithNameExpirationHandlerClosure = { _, handler in
+            guard allowTasks else {
+                return .invalid
+            }
+            Self.bgTaskIdentifier += 1
+
+            let identifier = UIBackgroundTaskIdentifier(rawValue: Self.bgTaskIdentifier)
+            DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
+                handler?()
+            }
+            return identifier
+        }
+    }
+}

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -279,6 +279,85 @@ class AppLockServiceMock: AppLockServiceProtocol {
         }
     }
 }
+class ApplicationMock: ApplicationProtocol {
+    var backgroundTimeRemaining: TimeInterval {
+        get { return underlyingBackgroundTimeRemaining }
+        set(value) { underlyingBackgroundTimeRemaining = value }
+    }
+    var underlyingBackgroundTimeRemaining: TimeInterval!
+    var applicationState: UIApplication.State {
+        get { return underlyingApplicationState }
+        set(value) { underlyingApplicationState = value }
+    }
+    var underlyingApplicationState: UIApplication.State!
+
+    //MARK: - beginBackgroundTask
+
+    var beginBackgroundTaskExpirationHandlerCallsCount = 0
+    var beginBackgroundTaskExpirationHandlerCalled: Bool {
+        return beginBackgroundTaskExpirationHandlerCallsCount > 0
+    }
+    var beginBackgroundTaskExpirationHandlerReturnValue: UIBackgroundTaskIdentifier!
+    var beginBackgroundTaskExpirationHandlerClosure: (((() -> Void)?) -> UIBackgroundTaskIdentifier)?
+
+    func beginBackgroundTask(expirationHandler handler: (() -> Void)?) -> UIBackgroundTaskIdentifier {
+        beginBackgroundTaskExpirationHandlerCallsCount += 1
+        if let beginBackgroundTaskExpirationHandlerClosure = beginBackgroundTaskExpirationHandlerClosure {
+            return beginBackgroundTaskExpirationHandlerClosure(handler)
+        } else {
+            return beginBackgroundTaskExpirationHandlerReturnValue
+        }
+    }
+    //MARK: - beginBackgroundTask
+
+    var beginBackgroundTaskWithNameExpirationHandlerCallsCount = 0
+    var beginBackgroundTaskWithNameExpirationHandlerCalled: Bool {
+        return beginBackgroundTaskWithNameExpirationHandlerCallsCount > 0
+    }
+    var beginBackgroundTaskWithNameExpirationHandlerReturnValue: UIBackgroundTaskIdentifier!
+    var beginBackgroundTaskWithNameExpirationHandlerClosure: ((String?, (() -> Void)?) -> UIBackgroundTaskIdentifier)?
+
+    func beginBackgroundTask(withName taskName: String?, expirationHandler handler: (() -> Void)?) -> UIBackgroundTaskIdentifier {
+        beginBackgroundTaskWithNameExpirationHandlerCallsCount += 1
+        if let beginBackgroundTaskWithNameExpirationHandlerClosure = beginBackgroundTaskWithNameExpirationHandlerClosure {
+            return beginBackgroundTaskWithNameExpirationHandlerClosure(taskName, handler)
+        } else {
+            return beginBackgroundTaskWithNameExpirationHandlerReturnValue
+        }
+    }
+    //MARK: - endBackgroundTask
+
+    var endBackgroundTaskCallsCount = 0
+    var endBackgroundTaskCalled: Bool {
+        return endBackgroundTaskCallsCount > 0
+    }
+    var endBackgroundTaskReceivedIdentifier: UIBackgroundTaskIdentifier?
+    var endBackgroundTaskReceivedInvocations: [UIBackgroundTaskIdentifier] = []
+    var endBackgroundTaskClosure: ((UIBackgroundTaskIdentifier) -> Void)?
+
+    func endBackgroundTask(_ identifier: UIBackgroundTaskIdentifier) {
+        endBackgroundTaskCallsCount += 1
+        endBackgroundTaskReceivedIdentifier = identifier
+        endBackgroundTaskReceivedInvocations.append(identifier)
+        endBackgroundTaskClosure?(identifier)
+    }
+    //MARK: - open
+
+    var openCallsCount = 0
+    var openCalled: Bool {
+        return openCallsCount > 0
+    }
+    var openReceivedUrl: URL?
+    var openReceivedInvocations: [URL] = []
+    var openClosure: ((URL) -> Void)?
+
+    func open(_ url: URL) {
+        openCallsCount += 1
+        openReceivedUrl = url
+        openReceivedInvocations.append(url)
+        openClosure?(url)
+    }
+}
 class AudioConverterMock: AudioConverterProtocol {
 
     //MARK: - convertToOpusOgg