implement the start, send and stop functions

ElementX/Sources/Services/Location/LiveLocationManager.swift

@@ -15,6 +15,15 @@ class LiveLocationManager: NSObject, LiveLocationManagerProtocol, CLLocationMana
     
     private let authorizationStatusSubject: CurrentValueSubject<CLAuthorizationStatus, Never>
     
+    /// Cached joined room proxies keyed by room ID, kept in sync with the active sessions dictionary.
+    private var activeRoomProxies = [String: JoinedRoomProxyProtocol]()
+    
+    /// The running task that iterates over live location updates.
+    @CancellableTask
+    private var locationUpdatesTask: Task<Void, Never>?
+    
+    private var cancellables = Set<AnyCancellable>()
+    
     var authorizationStatus: CurrentValuePublisher<CLAuthorizationStatus, Never> {
         authorizationStatusSubject.asCurrentValuePublisher()
     }
@@ -33,6 +42,11 @@ class LiveLocationManager: NSObject, LiveLocationManagerProtocol, CLLocationMana
         super.init()
         
         locationManager.delegate = self
+        locationManager.allowsBackgroundLocationUpdates = true
+        locationManager.desiredAccuracy = kCLLocationAccuracyNearestTenMeters
+        locationManager.pausesLocationUpdatesAutomatically = false
+        
+        setupSubscriptions()
     }
     
     // MARK: - LiveLocationManagerProtocol
@@ -45,6 +59,39 @@ class LiveLocationManager: NSObject, LiveLocationManagerProtocol, CLLocationMana
         return true
     }
     
+    func startLiveLocation(roomID: String, durationMillis: UInt64) async -> Result<Void, LiveLocationManagerError> {
+        guard case .joined(let roomProxy) = await clientProxy.roomForIdentifier(roomID) else {
+            MXLog.error("Failed to resolve joined room for identifier: \(roomID)")
+            return .failure(.roomNotJoined)
+        }
+        
+        let result = await roomProxy.startLiveLocationShare(durationMillis: durationMillis)
+        
+        guard case .success = result else {
+            MXLog.error("Failed to start live location share in room: \(roomID)")
+            return .failure(.startFailed)
+        }
+        
+        let timeoutDate = Date().addingTimeInterval(TimeInterval(durationMillis) / 1000.0)
+        appSettings.liveLocationSharingTimeoutDatesByRoomID[roomID] = timeoutDate
+        
+        return .success(())
+    }
+    
+    func stopLiveLocation(roomID: String) async {
+        // Best effort: send the stop event to the room regardless of tracking state.
+        if let roomProxy = await resolveRoomProxy(for: roomID) {
+            let result = await roomProxy.stopLiveLocationShare()
+            if case .failure(let error) = result {
+                MXLog.error("Failed to stop live location share in room \(roomID): \(error)")
+            }
+        }
+        
+        // Always clean up locally.
+        appSettings.liveLocationSharingTimeoutDatesByRoomID.removeValue(forKey: roomID)
+        activeRoomProxies.removeValue(forKey: roomID)
+    }
+    
     // MARK: - CLLocationManagerDelegate
     
     func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
@@ -53,6 +100,114 @@ class LiveLocationManager: NSObject, LiveLocationManagerProtocol, CLLocationMana
         if manager.authorizationStatus == .notDetermined {
             appSettings.hasRequestedLocationAlwaysLocationAuthorization = false
         }
+        
+        // If authorization was revoked, stop all active sessions.
+        if manager.authorizationStatus != .authorizedAlways {
+            stopAllSessions()
+        }
+        
         authorizationStatusSubject.send(manager.authorizationStatus)
     }
+    
+    // MARK: - Private
+    
+    private func setupSubscriptions() {
+        appSettings.$liveLocationSharingTimeoutDatesByRoomID
+            .removeDuplicates()
+            .sink { [weak self] sessions in
+                guard let self else { return }
+                syncActiveRoomProxies(with: sessions)
+                
+                if sessions.isEmpty {
+                    locationUpdatesTask = nil
+                } else {
+                    startLocationUpdatesIfNeeded()
+                }
+            }
+            .store(in: &cancellables)
+        
+        appSettings.$liveLocationSharingEnabled
+            .filter { !$0 }
+            .sink { [weak self] _ in
+                guard let self else { return }
+                appSettings.liveLocationSharingTimeoutDatesByRoomID.removeAll()
+                activeRoomProxies.removeAll()
+                locationUpdatesTask = nil
+            }
+            .store(in: &cancellables)
+    }
+    
+    private func syncActiveRoomProxies(with sessions: [String: Date]) {
+        // Remove proxies for rooms no longer in the dictionary.
+        let activeRoomIDs = Set(sessions.keys)
+        for roomID in activeRoomProxies.keys where !activeRoomIDs.contains(roomID) {
+            activeRoomProxies.removeValue(forKey: roomID)
+        }
+    }
+    
+    private func startLocationUpdatesIfNeeded() {
+        guard locationUpdatesTask == nil else { return }
+        
+        locationUpdatesTask = Task { [weak self] in
+            do {
+                for try await update in CLLocationUpdate.liveUpdates() {
+                    guard let self, !Task.isCancelled else { break }
+                    
+                    await self.sendLocationToActiveRooms(update)
+                }
+            } catch {
+                MXLog.error("Live location updates failed with error: \(error)")
+                self?.stopAllSessions()
+            }
+        }
+    }
+    
+    private func sendLocationToActiveRooms(_ update: CLLocationUpdate) async {
+        let sessions = appSettings.liveLocationSharingTimeoutDatesByRoomID
+        let geoURI = update.location.map { GeoURI(coordinate: $0.coordinate, uncertainty: $0.horizontalAccuracy) }
+        
+        for (roomID, timeoutDate) in sessions {
+            if Date() >= timeoutDate {
+                MXLog.info("Live location session expired for room: \(roomID)")
+                await stopLiveLocation(roomID: roomID)
+                continue
+            }
+            
+            guard let geoURI else { continue }
+            
+            let roomProxy = await resolveRoomProxy(for: roomID)
+            guard let roomProxy else {
+                MXLog.error("Failed to resolve room proxy for live location update in room: \(roomID)")
+                continue
+            }
+            
+            let result = await roomProxy.sendLiveLocation(geoURI: geoURI)
+            if case .failure(let error) = result {
+                MXLog.error("Failed to send live location update to room \(roomID): \(error)")
+            }
+        }
+    }
+    
+    private func resolveRoomProxy(for roomID: String) async -> JoinedRoomProxyProtocol? {
+        if let cached = activeRoomProxies[roomID] {
+            return cached
+        }
+        
+        guard case .joined(let roomProxy) = await clientProxy.roomForIdentifier(roomID) else {
+            return nil
+        }
+        
+        activeRoomProxies[roomID] = roomProxy
+        return roomProxy
+    }
+    
+    private func stopAllSessions() {
+        let roomIDs = Array(appSettings.liveLocationSharingTimeoutDatesByRoomID.keys)
+        Task { [weak self] in
+            guard let self else { return }
+            for roomID in roomIDs {
+                await stopLiveLocation(roomID: roomID)
+            }
+        }
+    }
 }

ElementX/Sources/Services/Location/LiveLocationManagerProtocol.swift

@@ -9,6 +9,11 @@ import Combine
 import CoreLocation
 import Foundation
 
+enum LiveLocationManagerError: Error {
+    case roomNotJoined
+    case startFailed
+}
+
 // sourcery: AutoMockable
 protocol LiveLocationManagerProtocol: AnyObject {
     /// Publishes the current location authorization status.
@@ -20,4 +25,18 @@ protocol LiveLocationManagerProtocol: AnyObject {
     ///            `false` if the request was already made before and iOS would silently ignore it.
     @discardableResult
     func requestAlwaysAuthorizationIfPossible() -> Bool
+    
+    /// Starts sharing live location in a room.
+    ///
+    /// - Parameters:
+    ///   - roomID: The identifier of the room to share live location in.
+    ///   - durationMillis: The duration in milliseconds for how long the live location should be shared.
+    func startLiveLocation(roomID: String, durationMillis: UInt64) async -> Result<Void, LiveLocationManagerError>
+    
+    /// Stops sharing live location in a room.
+    ///
+    /// Sends a stop event to the room (best effort) and removes it from the tracked sessions.
+    /// Can also be used to stop a live location share started by another device.
+    /// - Parameter roomID: The identifier of the room to stop sharing live location in.
+    func stopLiveLocation(roomID: String) async
 }

ElementX/Sources/Services/Room/JoinedRoomProxy.swift

@@ -751,6 +751,38 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol {
             return .failure(.sdkError(error))
         }
     }
+    
+    // MARK: - Live Location
+    
+    func startLiveLocationShare(durationMillis: UInt64) async -> Result<Void, RoomProxyError> {
+        do {
+            try await room.startLiveLocationShare(durationMillis: durationMillis)
+            return .success(())
+        } catch {
+            MXLog.error("Failed starting live location share with error: \(error)")
+            return .failure(.sdkError(error))
+        }
+    }
+    
+    func sendLiveLocation(geoURI: GeoURI) async -> Result<Void, RoomProxyError> {
+        do {
+            try await room.sendLiveLocation(geoUri: geoURI.string)
+            return .success(())
+        } catch {
+            MXLog.error("Failed sending live location with error: \(error)")
+            return .failure(.sdkError(error))
+        }
+    }
+    
+    func stopLiveLocationShare() async -> Result<Void, RoomProxyError> {
+        do {
+            try await room.stopLiveLocationShare()
+            return .success(())
+        } catch {
+            MXLog.error("Failed stopping live location share with error: \(error)")
+            return .failure(.sdkError(error))
+        }
+    }
 
     // MARK: - Private
     

ElementX/Sources/Services/Room/RoomProxyProtocol.swift

@@ -194,6 +194,12 @@ protocol JoinedRoomProxyProtocol: RoomProxyProtocol {
     func saveDraft(_ draft: ComposerDraft, threadRootEventID: String?) async -> Result<Void, RoomProxyError>
     func loadDraft(threadRootEventID: String?) async -> Result<ComposerDraft?, RoomProxyError>
     func clearDraft(threadRootEventID: String?) async -> Result<Void, RoomProxyError>
+    
+    // MARK: - Live Location
+    
+    func startLiveLocationShare(durationMillis: UInt64) async -> Result<Void, RoomProxyError>
+    func sendLiveLocation(geoURI: GeoURI) async -> Result<Void, RoomProxyError>
+    func stopLiveLocationShare() async -> Result<Void, RoomProxyError>
 }
 
 extension JoinedRoomProxyProtocol {