Merge pull request #6016 from vector-im/maximee/5982_ls_static_share_viewer

[Location Sharing] Add separate screen for viewing static shared location

Author: MaximeEvrard42

Riot/Assets/en.lproj/Vector.strings

@@ -2139,6 +2139,7 @@ Tap the + to start adding people.";
 "live_location_sharing_banner_stop" = "Stop";
 "location_sharing_static_share_title" = "Send my current location";
 "location_sharing_pin_drop_share_title" = "Send this location";
+"location_sharing_live_map_callout_title" = "Share location";
 
 // MARK: - MatrixKit
 

Riot/Generated/Strings.swift

@@ -2759,6 +2759,10 @@ public class VectorL10n: NSObject {
   public static var locationSharingInvalidAuthorizationSettings: String { 
     return VectorL10n.tr("Vector", "location_sharing_invalid_authorization_settings") 
   }
+  /// Share location
+  public static var locationSharingLiveMapCalloutTitle: String { 
+    return VectorL10n.tr("Vector", "location_sharing_live_map_callout_title") 
+  }
   /// Share live location
   public static var locationSharingLiveShareTitle: String { 
     return VectorL10n.tr("Vector", "location_sharing_live_share_title") 

Riot/Modules/Room/RoomCoordinator.swift

@@ -246,8 +246,54 @@ final class RoomCoordinator: NSObject, RoomCoordinatorProtocol {
 
         completion?()
     }
+    
+    private func showLocationCoordinatorWithEvent(_ event: MXEvent, bubbleData: MXKRoomBubbleCellDataStoring) {
+        guard #available(iOS 14.0, *) else {
+            return
+        }
+        
+        guard let navigationRouter = self.navigationRouter,
+              let mediaManager = mxSession?.mediaManager,
+              let locationContent = event.location else {
+                  MXLog.error("[RoomCoordinator] Invalid location showing coordinator parameters. Returning.")
+                  return
+              }
+        
+        let avatarData = AvatarInput(mxContentUri: bubbleData.senderAvatarUrl,
+                                     matrixItemId: bubbleData.senderId,
+                                     displayName: bubbleData.senderDisplayName)
+        
+        
+        let location = CLLocationCoordinate2D(latitude: locationContent.latitude, longitude: locationContent.longitude)
+        let coordinateType = locationContent.assetType
+        
+        guard let locationSharingCoordinatetype = coordinateType.locationSharingCoordinateType() else {
+            fatalError("[LocationSharingCoordinator] event asset type is not supported: \(coordinateType)")
+        }
+        
+        let parameters = StaticLocationViewingCoordinatorParameters(mediaManager: mediaManager,
+                                                                    avatarData: avatarData,
+                                                                    location: location,
+                                                                    coordinateType: locationSharingCoordinatetype)
+        
+        let coordinator = StaticLocationViewingCoordinator(parameters: parameters)
+        
+        coordinator.completion = { [weak self, weak coordinator] in
+            guard let self = self, let coordinator = coordinator else {
+                return
+            }
+            
+            self.navigationRouter?.dismissModule(animated: true, completion: nil)
+            self.remove(childCoordinator: coordinator)
+        }
+        
+        add(childCoordinator: coordinator)
+        
+        navigationRouter.present(coordinator, animated: true)
+        coordinator.start()
+    }
 
-    private func startLocationCoordinatorWithEvent(_ event: MXEvent? = nil, bubbleData: MXKRoomBubbleCellDataStoring? = nil) {
+    private func startLocationCoordinator() {
         guard #available(iOS 14.0, *) else {
             return
         }
@@ -259,29 +305,13 @@ final class RoomCoordinator: NSObject, RoomCoordinatorProtocol {
             return
         }
 
-        var avatarData: AvatarInputProtocol
-        if event != nil, let bubbleData = bubbleData {
-            avatarData = AvatarInput(mxContentUri: bubbleData.senderAvatarUrl,
-                                     matrixItemId: bubbleData.senderId,
-                                     displayName: bubbleData.senderDisplayName)
-        } else {
-            avatarData = AvatarInput(mxContentUri: user.avatarUrl,
+        let avatarData = AvatarInput(mxContentUri: user.avatarUrl,
                                      matrixItemId: user.userId,
                                      displayName: user.displayname)
-        }
-        
-        var location: CLLocationCoordinate2D?
-        var coordinateType: MXEventAssetType = .user
-        if let locationContent = event?.location {
-            location = CLLocationCoordinate2D(latitude: locationContent.latitude, longitude: locationContent.longitude)
-            coordinateType = locationContent.assetType
-        }
 
         let parameters = LocationSharingCoordinatorParameters(roomDataSource: roomViewController.roomDataSource,
                                                               mediaManager: mediaManager,
-                                                              avatarData: avatarData,
-                                                              location: location,
-                                                              coordinateType: coordinateType)
+                                                              avatarData: avatarData)
 
         let coordinator = LocationSharingCoordinator(parameters: parameters)
 
@@ -411,11 +441,11 @@ extension RoomCoordinator: RoomViewControllerDelegate {
     }
 
     func roomViewControllerDidRequestLocationSharingFormPresentation(_ roomViewController: RoomViewController) {
-        startLocationCoordinatorWithEvent()
+        startLocationCoordinator()
     }
 
     func roomViewController(_ roomViewController: RoomViewController, didRequestLocationPresentationFor event: MXEvent, bubbleData: MXKRoomBubbleCellDataStoring) {
-        startLocationCoordinatorWithEvent(event, bubbleData: bubbleData)
+        showLocationCoordinatorWithEvent(event, bubbleData: bubbleData)
     }
 
     func roomViewController(_ roomViewController: RoomViewController, locationShareActivityViewControllerFor event: MXEvent) -> UIActivityViewController? {

RiotSwiftUI/Modules/Room/LocationSharing/Coordinator/LocationSharingCoordinator.swift

@@ -23,8 +23,6 @@ struct LocationSharingCoordinatorParameters {
     let roomDataSource: MXKRoomDataSource
     let mediaManager: MXMediaManager
     let avatarData: AvatarInputProtocol
-    let location: CLLocationCoordinate2D?
-    let coordinateType: MXEventAssetType
 }
 
 // Map between type from MatrixSDK and type from SwiftUI target, as we don't want
@@ -79,16 +77,8 @@ final class LocationSharingCoordinator: Coordinator, Presentable {
     init(parameters: LocationSharingCoordinatorParameters) {
         self.parameters = parameters
 
-        // TODO: Make this check before creating LocationSharingCoordinator
-        // Use LocationSharingCoordinateType in parameters
-        guard let locationSharingCoordinatetype = parameters.coordinateType.locationSharingCoordinateType() else {
-            fatalError("[LocationSharingCoordinator] event asset type is not supported: \(parameters.coordinateType)")
-        }
-        
         let viewModel = LocationSharingViewModel(mapStyleURL: BuildSettings.tileServerMapStyleURL,
                                                  avatarData: parameters.avatarData,
-                                                 location: parameters.location,
-                                                 coordinateType: locationSharingCoordinatetype,
                                                  isLiveLocationSharingEnabled: BuildSettings.liveLocationSharingEnabled)
         let view = LocationSharingView(context: viewModel.context)
             .addDependency(AvatarService.instantiate(mediaManager: parameters.mediaManager))
@@ -111,14 +101,7 @@ final class LocationSharingCoordinator: Coordinator, Presentable {
             case .cancel:
                 self.completion?()
             case .share(let latitude, let longitude, let coordinateType):
-                
-                // Show share sheet on existing location display
-                if let location = self.parameters.location {
-                    self.presentShareLocationActivity(with: location)
-                } else {
-                    self.shareStaticLocation(latitude: latitude, longitude: longitude, coordinateType: coordinateType)
-                }
-                
+                self.shareStaticLocation(latitude: latitude, longitude: longitude, coordinateType: coordinateType)
             case .shareLiveLocation(let timeout):
                 self.startLiveLocationSharing(with: timeout)
             }

RiotSwiftUI/Modules/Room/LocationSharing/Coordinator/ShareLocationActivityController.swift

@@ -0,0 +1,29 @@
+// 
+// Copyright 2022 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 Foundation
+import CoreLocation
+
+/// Build a UIActivityViewController to share a location
+class ShareLocationActivityControllerBuilder {
+    
+    func build(with location: CLLocationCoordinate2D) -> UIActivityViewController {
+        return UIActivityViewController(activityItems: [ShareToMapsAppActivity.urlForMapsAppType(.apple, location: location)],
+                                        applicationActivities: [ShareToMapsAppActivity(type: .apple, location: location),
+                                                                ShareToMapsAppActivity(type: .google, location: location),
+                                                                ShareToMapsAppActivity(type: .osm, location: location)])
+    }
+}

RiotSwiftUI/Modules/Room/LocationSharing/LocationSharingModels.swift

@@ -55,9 +55,6 @@ struct LocationSharingViewState: BindableState {
     /// Current user avatarData
     let userAvatarData: AvatarInputProtocol
 
-    /// Shared annotation to display existing location
-    let sharedAnnotation: LocationAnnotation?
-    
     /// Map annotations to display on map
     var annotations: [LocationAnnotation]
 
@@ -77,14 +74,6 @@ struct LocationSharingViewState: BindableState {
     /// Used to hide live location sharing features until is finished
     var isLiveLocationSharingEnabled: Bool = false
 
-    var shareButtonVisible: Bool {
-        return self.displayExistingLocation == false
-    }
-    
-    var displayExistingLocation: Bool {
-        return sharedAnnotation != nil
-    }
-    
     var shareButtonEnabled: Bool {
         !showLoadingIndicator
     }

RiotSwiftUI/Modules/Room/LocationSharing/LocationSharingScreenState.swift

@@ -21,24 +21,16 @@ import CoreLocation
 @available(iOS 14.0, *)
 enum MockLocationSharingScreenState: MockScreenState, CaseIterable {
     case shareUserLocation
-    case displayExistingLocation
 
     var screenType: Any.Type {
         LocationSharingView.self
     }
 
     var screenView: ([Any], AnyView)  {
 
-        var location: CLLocationCoordinate2D?
-        if self == .displayExistingLocation {
-            location = CLLocationCoordinate2D(latitude: 51.4932641, longitude: -0.257096)
-        }
-        
         let mapStyleURL = URL(string: "https://api.maptiler.com/maps/streets/style.json?key=fU3vlMsMn4Jb6dnEIFsx")!
         let viewModel = LocationSharingViewModel(mapStyleURL: mapStyleURL,
                                                  avatarData: AvatarInput(mxContentUri: "", matrixItemId: "alice:matrix.org", displayName: "Alice"),
-                                                 location: location,
-                                                 coordinateType: .user,
                                                  isLiveLocationSharingEnabled: true)
         return ([viewModel],
                 AnyView(LocationSharingView(context: viewModel.context)

RiotSwiftUI/Modules/Room/LocationSharing/LocationSharingViewModel.swift

@@ -41,38 +41,12 @@ class LocationSharingViewModel: LocationSharingViewModelType, LocationSharingVie
 
     // MARK: - Setup
 
-    init(mapStyleURL: URL, avatarData: AvatarInputProtocol, location: CLLocationCoordinate2D? = nil, coordinateType: LocationSharingCoordinateType, isLiveLocationSharingEnabled: Bool = false) {
-        
-        var sharedAnnotation: LocationAnnotation?
-        var annotations: [LocationAnnotation] = []
-        var highlightedAnnotation: LocationAnnotation?
-        var showsUserLocation: Bool = false
-        
-        // Displaying an existing location
-        if let sharedCoordinate = location {
-            let sharedLocationAnnotation: LocationAnnotation
-            switch coordinateType {
-            case .user:
-                sharedLocationAnnotation = UserLocationAnnotation(avatarData: avatarData, coordinate: sharedCoordinate)
-            case .pin:
-                sharedLocationAnnotation = PinLocationAnnotation(coordinate: sharedCoordinate)
-            }
-            
-            annotations.append(sharedLocationAnnotation)
-            highlightedAnnotation = sharedLocationAnnotation
-            
-            sharedAnnotation = sharedLocationAnnotation
-        } else {
-            // Share current location
-            showsUserLocation = true
-        }
-        
+    init(mapStyleURL: URL, avatarData: AvatarInputProtocol, isLiveLocationSharingEnabled: Bool = false) {
         let viewState = LocationSharingViewState(mapStyleURL: mapStyleURL,
                                                  userAvatarData: avatarData,
-                                                 sharedAnnotation: sharedAnnotation,
-                                                 annotations: annotations,
-                                                 highlightedAnnotation: highlightedAnnotation,
-                                                 showsUserLocation: showsUserLocation,
+                                                 annotations: [],
+                                                 highlightedAnnotation: nil,
+                                                 showsUserLocation: true,
                                                  isLiveLocationSharingEnabled: isLiveLocationSharingEnabled)
 
         super.init(initialViewState: viewState)
@@ -90,12 +64,6 @@ class LocationSharingViewModel: LocationSharingViewModelType, LocationSharingVie
         case .cancel:
             completion?(.cancel)
         case .share:
-            // Share existing location
-            if let location = state.sharedAnnotation?.coordinate {
-                completion?(.share(latitude: location.latitude, longitude: location.longitude, coordinateType: .user))
-                return
-            }
-            
             // Share current user location
             guard let location = state.bindings.userLocation else {
                 processError(.failedLocatingUser)

RiotSwiftUI/Modules/Room/LocationSharing/MapViewErrorAlertInfoBuilder.swift

@@ -0,0 +1,51 @@
+// 
+// Copyright 2022 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 Foundation
+
+struct MapViewErrorAlertInfoBuilder {
+    
+    func build(with error: LocationSharingViewError, dimissalCallback: (() -> Void)?) -> AlertInfo<LocationSharingAlertType>? {
+        
+        let alertInfo: AlertInfo<LocationSharingAlertType>?
+        
+        switch error {
+        case .failedLoadingMap:
+            alertInfo = AlertInfo(id: .mapLoadingError,
+                                                 title: VectorL10n.locationSharingLoadingMapErrorTitle(AppInfo.current.displayName),
+                                                 primaryButton: (VectorL10n.ok, dimissalCallback))
+        case .failedLocatingUser:
+            alertInfo = AlertInfo(id: .userLocatingError,
+                                                 title: VectorL10n.locationSharingLocatingUserErrorTitle(AppInfo.current.displayName),
+                                                 primaryButton: (VectorL10n.ok, dimissalCallback))
+        case .invalidLocationAuthorization:
+            alertInfo = AlertInfo(id: .authorizationError,
+                                                 title: VectorL10n.locationSharingInvalidAuthorizationErrorTitle(AppInfo.current.displayName),
+                                                 primaryButton: (VectorL10n.locationSharingInvalidAuthorizationNotNow, dimissalCallback),
+                                                 secondaryButton: (VectorL10n.locationSharingInvalidAuthorizationSettings, {
+                if let applicationSettingsURL = URL(string:UIApplication.openSettingsURLString) {
+                    UIApplication.shared.open(applicationSettingsURL)
+                }
+            }))
+        default:
+            alertInfo = nil
+        }
+        
+        return alertInfo
+    }
+    
+}
+

RiotSwiftUI/Modules/Room/LocationSharing/Test/UI/LocationSharingUITests.swift

@@ -36,14 +36,6 @@ class LocationSharingUITests: XCTestCase {
         XCTAssertTrue(app.otherElements["Map"].exists)
     }
 
-    func testInitialExistingLocation() {
-        goToScreenWithIdentifier(MockLocationSharingScreenState.displayExistingLocation.title)
-        
-        XCTAssertTrue(app.buttons["Cancel"].exists)
-        XCTAssertTrue(app.buttons["LocationSharingView.shareButton"].exists)
-        XCTAssertTrue(app.otherElements["Map"].exists)
-    }
-    
     // Need a delay when showing the map otherwise the simulator breaks
     private func goToScreenWithIdentifier(_ identifier: String) {
         app.goToScreenWithIdentifier(identifier)