Image viewer

ElementX/Sources/Screens/FilePreview/View/FilePreviewScreen.swift

@@ -19,16 +19,11 @@ import SwiftUI
 import UIKit
 
 struct FilePreviewScreen: View {
-    @Environment(\.colorScheme) private var colorScheme
-
-    var counterColor: Color {
-        colorScheme == .light ? .element.secondaryContent : .element.tertiaryContent
-    }
-
     @ObservedObject var context: FilePreviewViewModel.Context
 
     var body: some View {
         PreviewController(fileURL: context.viewState.fileURL, title: context.viewState.title)
+            .ignoresSafeArea()
     }
 }
 

ElementX/Sources/Screens/MediaPlayer/MediaPlayerModels.swift → ElementX/Sources/Screens/Other/ActivityCoordinator.swift

@@ -14,17 +14,14 @@
 // limitations under the License.
 //
 
-import Foundation
+import SwiftUI
 
-enum MediaPlayerViewModelAction {
-    case cancel
-}
-
-struct MediaPlayerViewState: BindableState {
-    let mediaURL: URL
-    let autoplay: Bool
-}
-
-enum MediaPlayerViewAction {
-    case cancel
+struct ActivityCoordinator: CoordinatorProtocol {
+    let items: [Any]
+
+    func toPresentable() -> AnyView {
+        return AnyView(UIActivityViewControllerWrapper(activityItems: items)
+            .presentationDetents([.medium])
+            .ignoresSafeArea())
+    }
 }

ElementX/Sources/Screens/RoomScreen/RoomScreenCoordinator.swift

@@ -66,13 +66,25 @@ final class RoomScreenCoordinator: CoordinatorProtocol {
     // MARK: - Private
 
     private func displayVideo(for videoURL: URL) {
-        let params = VideoPlayerCoordinatorParameters(videoURL: videoURL)
+        let params = VideoPlayerCoordinatorParameters(videoURL: videoURL, isModallyPresented: false)
         let coordinator = VideoPlayerCoordinator(parameters: params)
-        coordinator.callback = { [weak self] _ in
-            self?.navigationController.pop()
-        }
 
-        navigationController.push(coordinator)
+        if params.isModallyPresented {
+            coordinator.callback = { [weak self] _ in
+                self?.navigationController.dismissSheet()
+            }
+
+            let controller = NavigationController()
+            controller.setRootCoordinator(coordinator)
+
+            navigationController.presentSheet(controller)
+        } else {
+            coordinator.callback = { [weak self] _ in
+                self?.navigationController.pop()
+            }
+
+            navigationController.push(coordinator)
+        }
     }
 
     private func displayFile(for fileURL: URL, with title: String?) {

ElementX/Sources/Screens/VideoPlayer/VideoPlayerCoordinator.swift

@@ -19,6 +19,7 @@ import SwiftUI
 
 struct VideoPlayerCoordinatorParameters {
     let videoURL: URL
+    let isModallyPresented: Bool
 }
 
 enum VideoPlayerCoordinatorAction {
@@ -34,7 +35,8 @@ final class VideoPlayerCoordinator: CoordinatorProtocol {
     init(parameters: VideoPlayerCoordinatorParameters) {
         self.parameters = parameters
 
-        viewModel = VideoPlayerViewModel(videoURL: parameters.videoURL)
+        viewModel = VideoPlayerViewModel(videoURL: parameters.videoURL,
+                                         isModallyPresented: parameters.isModallyPresented)
     }
 
     // MARK: - Public
@@ -51,6 +53,10 @@ final class VideoPlayerCoordinator: CoordinatorProtocol {
             }
         }
     }
+
+    func stop() {
+        deconfigureAudioSession(.sharedInstance())
+    }
 
     func toPresentable() -> AnyView {
         AnyView(VideoPlayerScreen(context: viewModel.context))
@@ -62,10 +68,18 @@ final class VideoPlayerCoordinator: CoordinatorProtocol {
         do {
             try session.setCategory(.playback,
                                     mode: .default,
-                                    options: [.defaultToSpeaker, .allowBluetooth, .allowBluetoothA2DP])
+                                    options: [.allowBluetooth, .allowBluetoothA2DP])
             try session.setActive(true)
         } catch {
             MXLog.debug("Configure audio session failed: \(error)")
         }
     }
+
+    private func deconfigureAudioSession(_ session: AVAudioSession) {
+        do {
+            try session.setActive(false, options: .notifyOthersOnDeactivation)
+        } catch {
+            MXLog.debug("Deconfigure audio session failed: \(error)")
+        }
+    }
 }

ElementX/Sources/Screens/VideoPlayer/VideoPlayerModels.swift

@@ -21,8 +21,9 @@ enum VideoPlayerViewModelAction {
 }
 
 struct VideoPlayerViewState: BindableState {
-    var videoURL: URL
-    var autoplay: Bool
+    let videoURL: URL
+    let autoplay: Bool
+    let isModallyPresented: Bool
 }
 
 enum VideoPlayerViewAction {

ElementX/Sources/Screens/VideoPlayer/VideoPlayerViewModel.swift

@@ -21,9 +21,10 @@ typealias VideoPlayerViewModelType = StateStoreViewModel<VideoPlayerViewState, V
 class VideoPlayerViewModel: VideoPlayerViewModelType, VideoPlayerViewModelProtocol {
     var callback: ((VideoPlayerViewModelAction) -> Void)?
 
-    init(videoURL: URL, autoplay: Bool = true) {
+    init(videoURL: URL, autoplay: Bool = true, isModallyPresented: Bool = true) {
         super.init(initialViewState: VideoPlayerViewState(videoURL: videoURL,
-                                                          autoplay: autoplay))
+                                                          autoplay: autoplay,
+                                                          isModallyPresented: isModallyPresented))
     }
 
     override func process(viewAction: VideoPlayerViewAction) async {

ElementX/Sources/Screens/VideoPlayer/View/VideoPlayerScreen.swift

@@ -22,25 +22,33 @@ struct VideoPlayerScreen: View {
 
     var body: some View {
         VideoPlayer(player: player())
-            .ignoresSafeArea()
+            .background(Color.black.ignoresSafeArea())
             .navigationBarTitleDisplayMode(.inline)
             .navigationBarBackButtonHidden()
-            .toolbar {
-                ToolbarItem(placement: .navigationBarLeading) {
-                    Button {
-                        context.send(viewAction: .cancel)
-                    } label: {
-                        Image(systemName: "chevron.backward")
-                            .foregroundColor(.white)
-                            .fontWeight(.semibold)
-                    }
+            .toolbar { toolbar }
+            .onSwipeGesture(minimumDistance: 3.0, down: {
+                if context.viewState.isModallyPresented {
+                    context.send(viewAction: .cancel)
+                }
+            }, right: {
+                if !context.viewState.isModallyPresented {
+                    context.send(viewAction: .cancel)
                 }
-            }
-            .onSwipeGesture(minimumDistance: 3.0, right: {
-                context.send(viewAction: .cancel)
             })
     }
 
+    @ToolbarContentBuilder
+    var toolbar: some ToolbarContent {
+        ToolbarItem(placement: .cancellationAction) {
+            Button { context.send(viewAction: .cancel) } label: {
+                Image(systemName: context.viewState.isModallyPresented ? "xmark" : "chevron.backward")
+                    .foregroundColor(.white)
+                    .fontWeight(.semibold)
+            }
+            .accessibilityIdentifier("dismissButton")
+        }
+    }
+
     private func player() -> AVPlayer {
         let player = AVPlayer(url: context.viewState.videoURL)
         if context.viewState.autoplay {