ehealthsolutions/element-x-ios
3
0
Fork 0
mirror of https://github.com/Novaloop-AG/element-x-ios.git synced 2026-11-04 10:33:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

pr suggestions

Browse Source
This commit is contained in:
Mauro Romito
2026-04-03 10:43:10 +02:00
committed by Mauro
parent df5570281b
commit d9a480b1c6
6 changed files with 57 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ElementX/Sources/Application/Settings/AppSettings.swift
+1 -1
View File
@@ -66,6 +66,7 @@ final class AppSettings {
case elementCallBaseURLOverride case elementCallBaseURLOverride
case voiceMessagePlaybackSpeed case voiceMessagePlaybackSpeed
case liveLocationSharingTimeoutDatesByRoomID
// Feature flags // Feature flags
case publicSearchEnabled case publicSearchEnabled
@@ -80,7 +81,6 @@ final class AppSettings {
case focusEventOnNotificationTap case focusEventOnNotificationTap
case linkNewDeviceEnabled case linkNewDeviceEnabled
case liveLocationSharingEnabled case liveLocationSharingEnabled
case liveLocationSharingTimeoutDatesByRoomID
case floatingTimelineDateEnabled case floatingTimelineDateEnabled
// Doug's tweaks 🔧 // Doug's tweaks 🔧
ElementX/Sources/Mocks/Generated/GeneratedMocks.swift
+48 -48
View File
@@ -10064,15 +10064,15 @@ class JoinedRoomProxyMock: JoinedRoomProxyProtocol, @unchecked Sendable {
} }
//MARK: - startLiveLocationShare //MARK: - startLiveLocationShare
var startLiveLocationShareDurationMillisUnderlyingCallsCount = 0 var startLiveLocationShareDurationUnderlyingCallsCount = 0
var startLiveLocationShareDurationMillisCallsCount: Int { var startLiveLocationShareDurationCallsCount: Int {
get { get {
if Thread.isMainThread { if Thread.isMainThread {
return startLiveLocationShareDurationMillisUnderlyingCallsCount return startLiveLocationShareDurationUnderlyingCallsCount
} else { } else {
var returnValue: Int? = nil var returnValue: Int? = nil
DispatchQueue.main.sync { DispatchQueue.main.sync {
returnValue = startLiveLocationShareDurationMillisUnderlyingCallsCount returnValue = startLiveLocationShareDurationUnderlyingCallsCount
} }
return returnValue! return returnValue!
@@ -10080,29 +10080,29 @@ class JoinedRoomProxyMock: JoinedRoomProxyProtocol, @unchecked Sendable {
} }
set { set {
if Thread.isMainThread { if Thread.isMainThread {
startLiveLocationShareDurationMillisUnderlyingCallsCount = newValue startLiveLocationShareDurationUnderlyingCallsCount = newValue
} else { } else {
DispatchQueue.main.sync { DispatchQueue.main.sync {
startLiveLocationShareDurationMillisUnderlyingCallsCount = newValue startLiveLocationShareDurationUnderlyingCallsCount = newValue
} }
} }
} }
} }
var startLiveLocationShareDurationMillisCalled: Bool { var startLiveLocationShareDurationCalled: Bool {
return startLiveLocationShareDurationMillisCallsCount > 0 return startLiveLocationShareDurationCallsCount > 0
} }
var startLiveLocationShareDurationMillisReceivedDurationMillis: UInt64? var startLiveLocationShareDurationReceivedDuration: Duration?
var startLiveLocationShareDurationMillisReceivedInvocations: [UInt64] = [] var startLiveLocationShareDurationReceivedInvocations: [Duration] = []
var startLiveLocationShareDurationMillisUnderlyingReturnValue: Result<Void, RoomProxyError>! var startLiveLocationShareDurationUnderlyingReturnValue: Result<Void, RoomProxyError>!
var startLiveLocationShareDurationMillisReturnValue: Result<Void, RoomProxyError>! { var startLiveLocationShareDurationReturnValue: Result<Void, RoomProxyError>! {
get { get {
if Thread.isMainThread { if Thread.isMainThread {
return startLiveLocationShareDurationMillisUnderlyingReturnValue return startLiveLocationShareDurationUnderlyingReturnValue
} else { } else {
var returnValue: Result<Void, RoomProxyError>? = nil var returnValue: Result<Void, RoomProxyError>? = nil
DispatchQueue.main.sync { DispatchQueue.main.sync {
returnValue = startLiveLocationShareDurationMillisUnderlyingReturnValue returnValue = startLiveLocationShareDurationUnderlyingReturnValue
} }
return returnValue! return returnValue!
@@ -10110,26 +10110,26 @@ class JoinedRoomProxyMock: JoinedRoomProxyProtocol, @unchecked Sendable {
} }
set { set {
if Thread.isMainThread { if Thread.isMainThread {
startLiveLocationShareDurationMillisUnderlyingReturnValue = newValue startLiveLocationShareDurationUnderlyingReturnValue = newValue
} else { } else {
DispatchQueue.main.sync { DispatchQueue.main.sync {
startLiveLocationShareDurationMillisUnderlyingReturnValue = newValue startLiveLocationShareDurationUnderlyingReturnValue = newValue
} }
} }
} }
} }
var startLiveLocationShareDurationMillisClosure: ((UInt64) async -> Result<Void, RoomProxyError>)? var startLiveLocationShareDurationClosure: ((Duration) async -> Result<Void, RoomProxyError>)?
func startLiveLocationShare(durationMillis: UInt64) async -> Result<Void, RoomProxyError> { func startLiveLocationShare(duration: Duration) async -> Result<Void, RoomProxyError> {
startLiveLocationShareDurationMillisCallsCount += 1 startLiveLocationShareDurationCallsCount += 1
startLiveLocationShareDurationMillisReceivedDurationMillis = durationMillis startLiveLocationShareDurationReceivedDuration = duration
DispatchQueue.main.async { DispatchQueue.main.async {
self.startLiveLocationShareDurationMillisReceivedInvocations.append(durationMillis) self.startLiveLocationShareDurationReceivedInvocations.append(duration)
} }
if let startLiveLocationShareDurationMillisClosure = startLiveLocationShareDurationMillisClosure { if let startLiveLocationShareDurationClosure = startLiveLocationShareDurationClosure {
return await startLiveLocationShareDurationMillisClosure(durationMillis) return await startLiveLocationShareDurationClosure(duration)
} else { } else {
return startLiveLocationShareDurationMillisReturnValue return startLiveLocationShareDurationReturnValue
} }
} }
//MARK: - sendLiveLocation //MARK: - sendLiveLocation
@@ -11442,15 +11442,15 @@ class LiveLocationManagerMock: LiveLocationManagerProtocol, @unchecked Sendable
} }
//MARK: - startLiveLocation //MARK: - startLiveLocation
var startLiveLocationRoomIDDurationMillisUnderlyingCallsCount = 0 var startLiveLocationRoomIDDurationUnderlyingCallsCount = 0
var startLiveLocationRoomIDDurationMillisCallsCount: Int { var startLiveLocationRoomIDDurationCallsCount: Int {
get { get {
if Thread.isMainThread { if Thread.isMainThread {
return startLiveLocationRoomIDDurationMillisUnderlyingCallsCount return startLiveLocationRoomIDDurationUnderlyingCallsCount
} else { } else {
var returnValue: Int? = nil var returnValue: Int? = nil
DispatchQueue.main.sync { DispatchQueue.main.sync {
returnValue = startLiveLocationRoomIDDurationMillisUnderlyingCallsCount returnValue = startLiveLocationRoomIDDurationUnderlyingCallsCount
} }
return returnValue! return returnValue!
@@ -11458,29 +11458,29 @@ class LiveLocationManagerMock: LiveLocationManagerProtocol, @unchecked Sendable
} }
set { set {
if Thread.isMainThread { if Thread.isMainThread {
startLiveLocationRoomIDDurationMillisUnderlyingCallsCount = newValue startLiveLocationRoomIDDurationUnderlyingCallsCount = newValue
} else { } else {
DispatchQueue.main.sync { DispatchQueue.main.sync {
startLiveLocationRoomIDDurationMillisUnderlyingCallsCount = newValue startLiveLocationRoomIDDurationUnderlyingCallsCount = newValue
} }
} }
} }
} }
var startLiveLocationRoomIDDurationMillisCalled: Bool { var startLiveLocationRoomIDDurationCalled: Bool {
return startLiveLocationRoomIDDurationMillisCallsCount > 0 return startLiveLocationRoomIDDurationCallsCount > 0
} }
var startLiveLocationRoomIDDurationMillisReceivedArguments: (roomID: String, durationMillis: UInt64)? var startLiveLocationRoomIDDurationReceivedArguments: (roomID: String, duration: Duration)?
var startLiveLocationRoomIDDurationMillisReceivedInvocations: [(roomID: String, durationMillis: UInt64)] = [] var startLiveLocationRoomIDDurationReceivedInvocations: [(roomID: String, duration: Duration)] = []
var startLiveLocationRoomIDDurationMillisUnderlyingReturnValue: Result<Void, LiveLocationManagerError>! var startLiveLocationRoomIDDurationUnderlyingReturnValue: Result<Void, LiveLocationManagerError>!
var startLiveLocationRoomIDDurationMillisReturnValue: Result<Void, LiveLocationManagerError>! { var startLiveLocationRoomIDDurationReturnValue: Result<Void, LiveLocationManagerError>! {
get { get {
if Thread.isMainThread { if Thread.isMainThread {
return startLiveLocationRoomIDDurationMillisUnderlyingReturnValue return startLiveLocationRoomIDDurationUnderlyingReturnValue
} else { } else {
var returnValue: Result<Void, LiveLocationManagerError>? = nil var returnValue: Result<Void, LiveLocationManagerError>? = nil
DispatchQueue.main.sync { DispatchQueue.main.sync {
returnValue = startLiveLocationRoomIDDurationMillisUnderlyingReturnValue returnValue = startLiveLocationRoomIDDurationUnderlyingReturnValue
} }
return returnValue! return returnValue!
@@ -11488,26 +11488,26 @@ class LiveLocationManagerMock: LiveLocationManagerProtocol, @unchecked Sendable
} }
set { set {
if Thread.isMainThread { if Thread.isMainThread {
startLiveLocationRoomIDDurationMillisUnderlyingReturnValue = newValue startLiveLocationRoomIDDurationUnderlyingReturnValue = newValue
} else { } else {
DispatchQueue.main.sync { DispatchQueue.main.sync {
startLiveLocationRoomIDDurationMillisUnderlyingReturnValue = newValue startLiveLocationRoomIDDurationUnderlyingReturnValue = newValue
} }
} }
} }
} }
var startLiveLocationRoomIDDurationMillisClosure: ((String, UInt64) async -> Result<Void, LiveLocationManagerError>)? var startLiveLocationRoomIDDurationClosure: ((String, Duration) async -> Result<Void, LiveLocationManagerError>)?
func startLiveLocation(roomID: String, durationMillis: UInt64) async -> Result<Void, LiveLocationManagerError> { func startLiveLocation(roomID: String, duration: Duration) async -> Result<Void, LiveLocationManagerError> {
startLiveLocationRoomIDDurationMillisCallsCount += 1 startLiveLocationRoomIDDurationCallsCount += 1
startLiveLocationRoomIDDurationMillisReceivedArguments = (roomID: roomID, durationMillis: durationMillis) startLiveLocationRoomIDDurationReceivedArguments = (roomID: roomID, duration: duration)
DispatchQueue.main.async { DispatchQueue.main.async {
self.startLiveLocationRoomIDDurationMillisReceivedInvocations.append((roomID: roomID, durationMillis: durationMillis)) self.startLiveLocationRoomIDDurationReceivedInvocations.append((roomID: roomID, duration: duration))
} }
if let startLiveLocationRoomIDDurationMillisClosure = startLiveLocationRoomIDDurationMillisClosure { if let startLiveLocationRoomIDDurationClosure = startLiveLocationRoomIDDurationClosure {
return await startLiveLocationRoomIDDurationMillisClosure(roomID, durationMillis) return await startLiveLocationRoomIDDurationClosure(roomID, duration)
} else { } else {
return startLiveLocationRoomIDDurationMillisReturnValue return startLiveLocationRoomIDDurationReturnValue
} }
} }
//MARK: - stopLiveLocation //MARK: - stopLiveLocation
ElementX/Sources/Services/Location/LiveLocationManager.swift
+3 -3
View File
@@ -59,20 +59,20 @@ class LiveLocationManager: NSObject, LiveLocationManagerProtocol, CLLocationMana
return true return true
} }
func startLiveLocation(roomID: String, durationMillis: UInt64) async -> Result<Void, LiveLocationManagerError> { func startLiveLocation(roomID: String, duration: Duration) async -> Result<Void, LiveLocationManagerError> {
guard case .joined(let roomProxy) = await clientProxy.roomForIdentifier(roomID) else { guard case .joined(let roomProxy) = await clientProxy.roomForIdentifier(roomID) else {
MXLog.error("Failed to resolve joined room for identifier: \(roomID)") MXLog.error("Failed to resolve joined room for identifier: \(roomID)")
return .failure(.roomNotJoined) return .failure(.roomNotJoined)
} }
let result = await roomProxy.startLiveLocationShare(durationMillis: durationMillis) let result = await roomProxy.startLiveLocationShare(duration: duration)
guard case .success = result else { guard case .success = result else {
MXLog.error("Failed to start live location share in room: \(roomID)") MXLog.error("Failed to start live location share in room: \(roomID)")
return .failure(.startFailed) return .failure(.startFailed)
} }
let timeoutDate = Date().addingTimeInterval(TimeInterval(durationMillis) / 1000.0) let timeoutDate = Date().addingTimeInterval(TimeInterval(duration.seconds))
appSettings.liveLocationSharingTimeoutDatesByRoomID[roomID] = timeoutDate appSettings.liveLocationSharingTimeoutDatesByRoomID[roomID] = timeoutDate
return .success(()) return .success(())
ElementX/Sources/Services/Location/LiveLocationManagerProtocol.swift
+2 -2
View File
@@ -30,8 +30,8 @@ protocol LiveLocationManagerProtocol: AnyObject {
/// ///
/// - Parameters: /// - Parameters:
/// - roomID: The identifier of the room to share live location in. /// - 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. /// - duration: How long the live location should be shared.
func startLiveLocation(roomID: String, durationMillis: UInt64) async -> Result<Void, LiveLocationManagerError> func startLiveLocation(roomID: String, duration: Duration) async -> Result<Void, LiveLocationManagerError>
/// Stops sharing live location in a room. /// Stops sharing live location in a room.
/// ///
ElementX/Sources/Services/Room/JoinedRoomProxy.swift
+2 -2
View File
@@ -754,9 +754,9 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol {
// MARK: - Live Location // MARK: - Live Location
func startLiveLocationShare(durationMillis: UInt64) async -> Result<Void, RoomProxyError> { func startLiveLocationShare(duration: Duration) async -> Result<Void, RoomProxyError> {
do { do {
try await room.startLiveLocationShare(durationMillis: durationMillis) try await room.startLiveLocationShare(durationMillis: UInt64(duration.seconds * 1000))
return .success(()) return .success(())
} catch { } catch {
MXLog.error("Failed starting live location share with error: \(error)") MXLog.error("Failed starting live location share with error: \(error)")
ElementX/Sources/Services/Room/RoomProxyProtocol.swift
+1 -1
View File
@@ -197,7 +197,7 @@ protocol JoinedRoomProxyProtocol: RoomProxyProtocol {
// MARK: - Live Location // MARK: - Live Location
func startLiveLocationShare(durationMillis: UInt64) async -> Result<Void, RoomProxyError> func startLiveLocationShare(duration: Duration) async -> Result<Void, RoomProxyError>
func sendLiveLocation(geoURI: GeoURI) async -> Result<Void, RoomProxyError> func sendLiveLocation(geoURI: GeoURI) async -> Result<Void, RoomProxyError>
func stopLiveLocationShare() async -> Result<Void, RoomProxyError> func stopLiveLocationShare() async -> Result<Void, RoomProxyError>
} }