sharee.bike-App/TINKLib/ViewModel/Bikes/Bike/BluetoothLock/RequestHandler/BookedOpen.cs

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Serilog;
using TINK.Model;
using TINK.Model.Bikes.BikeInfoNS.BluetoothLock;
using TINK.Model.Connector;
using TINK.Model.Device;
using TINK.Model.User;
using TINK.MultilingualResources;
using TINK.Repository.Exception;
using TINK.Repository.Request;
using TINK.Services.BluetoothLock;
using TINK.Services.BluetoothLock.Exception;
using TINK.Services.Geolocation;
using TINK.Services.Logging;
using TINK.View;

namespace TINK.ViewModel.Bikes.Bike.BluetoothLock.RequestHandler
{
	public class BookedOpen : Base, IRequestHandler
	{
		/// <param name="bikesViewModel">View model to be used for progress report and unlocking/ locking view.</param>
		public BookedOpen(
		   IBikeInfoMutable selectedBike,
		   Func<bool> isConnectedDelegate,
		   Func<bool, IConnector> connectorFactory,
		   IGeolocationService geolocation,
		   ILocksService lockService,
		   Func<IPollingUpdateTaskManager> viewUpdateManager,
		   ISmartDevice smartDevice,
		   IViewService viewService,
		   IBikesViewModel bikesViewModel,
		   IUser activeUser) : base(
			   selectedBike,
			   AppResources.ActionCloseAndReturn,  // Copri button text: "Schloss schließen & Miete beenden"
			   true, // Show button to allow user to return bike.
			   isConnectedDelegate,
			   connectorFactory,
			   geolocation,
			   lockService,
			   viewUpdateManager,
			   smartDevice,
			   viewService,
			   bikesViewModel,
			   activeUser)
		{
			LockitButtonText = AppResources.ActionClose; // BT button text "Schließen".
			IsLockitButtonVisible = true; // Show button to allow user to lock bike.
		}

		/// <summary> Close lock and return bike.</summary>
		public async Task<IRequestHandler> HandleRequestOption1() => await CloseLockAndReturnBike();

		/// <summary> Close lock in order to pause ride and update COPRI lock state.</summary>
		public async Task<IRequestHandler> HandleRequestOption2() => await CloseLock();

		/// <summary> Close lock and return bike.</summary>
		public async Task<IRequestHandler> CloseLockAndReturnBike()
		{
			// Prevent concurrent interaction
			BikesViewModel.IsIdle = false;

			// Start getting geolocation.
			BikesViewModel.ActionText = AppResources.ActivityTextQueryLocationStart;
			var ctsLocation = new CancellationTokenSource();
			Task<IGeolocation> currentLocationTask = null;
			var timeStamp = DateTime.Now;
			try
			{
				currentLocationTask = GeolocationService.GetAsync(ctsLocation.Token, timeStamp);
			}
			catch (Exception ex)
			{
				// No location information available.
				Log.ForContext<BookedOpen>().Information("Returning bike {Bike} is not possible. Start query location failed. {Exception}", SelectedBike, ex);

				BikesViewModel.ActionText = string.Empty;
				await ViewService.DisplayAlert(
					AppResources.MessageErrorQueryLocationStartTitle,
					$"{AppResources.MessageErrorQueryLocationMessage}\r\n{ex.Message}",
					AppResources.MessageAnswerOk);

				BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
				await ViewUpdateManager().StartUpdateAyncPeridically(); // Restart polling again.

				BikesViewModel.ActionText = string.Empty;
				BikesViewModel.IsIdle = true; // Unlock GUI                
				return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, GeolocationService, LockService, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
			}

			// Ask whether to really return bike?
			var result = await ViewService.DisplayAlert(
				string.Empty,
				string.Format(AppResources.QuestionCloseLockAndReturnBike, SelectedBike.GetFullDisplayName()),
				AppResources.MessageAnswerYes,
				AppResources.MessageAnswerNo);

			if (result == false)
			{
				// User aborted closing and returning bike process
				Log.ForContext<BookedOpen>().Information("User selected booked bike {l_oId} in order to close and return but action was canceled.", SelectedBike.Id);

				// Cancel getting geolocation.
				ctsLocation.Cancel();
				BikesViewModel.ActionText = AppResources.ActivityTextQueryLocationCancelWait;
				try
				{
					await Task.WhenAny(new List<Task> { currentLocationTask ?? Task.CompletedTask });
				}
				catch (Exception ex)
				{
					// No location information available.
					Log.ForContext<BookedOpen>().Information("Canceling query location failed on abort returning opened bike failed. {Exception}", SelectedBike, ex);
				}

				BikesViewModel.IsIdle = true;
				return this;
			}

			// Start of closing lock and returing bike sequence.
			Log.ForContext<BookedOpen>().Information("Request to return bike {bike} detected.", SelectedBike);

			// Clear logging memory sink to avoid passing log data not related to returning of bike to backend.
			// Log data is passed to backend when calling CopriCallsHttps.DoReturn().
			MemoryStackSink.ClearMessages();

			// Stop polling before returning bike.
			BikesViewModel.ActionText = AppResources.ActivityTextOneMomentPlease;
			await ViewUpdateManager().StopUpdatePeridically();

			// Notify COPRI about start returning bike sequence: "request=booking_update ... &lock_state=locking ..."
			BikesViewModel.ActionText = AppResources.ActivityTextStartReturningBike;
			IsConnected = IsConnectedDelegate();
			try
			{
				await ConnectorFactory(IsConnected).Command.StartReturningBike(
					SelectedBike);
			}
			catch (Exception exception)
			{
				BikesViewModel.ActionText = string.Empty;
				if (exception is WebConnectFailureException)
				{
					// Copri server is not reachable.
					Log.ForContext<BookedOpen>().Information("User selected booked bike {bike} but returning failed (Copri server not reachable).", SelectedBike);

					await ViewService.DisplayAdvancedAlert(
						AppResources.ErrorReturnBikeNoWebTitle,
						string.Format("{0}\r\n{1}", AppResources.ErrorReturnBikeNoWebMessage, WebConnectFailureException.GetHintToPossibleExceptionsReasons),
						exception.Message,
						AppResources.MessageAnswerOk);
				}
				else
				{
					Log.ForContext<BookedOpen>().Error("User selected booked bike {bike} but returning failed. {@l_oException}", SelectedBike.Id, exception);

					await ViewService.DisplayAlert(
						AppResources.ErrorReturnBikeTitle,
						exception.Message,
						AppResources.MessageAnswerOk);
				}

				BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
				await ViewUpdateManager().StartUpdateAyncPeridically();

				BikesViewModel.ActionText = string.Empty;
				BikesViewModel.IsIdle = true;
				return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, GeolocationService, LockService, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
			}

			// Close lock
			BikesViewModel.ActionText = AppResources.ActivityTextClosingLock;
			try
			{
				SelectedBike.LockInfo.State = (await LockService[SelectedBike.LockInfo.Id].CloseAsync())
					?.GetLockingState() ?? LockingState.UnknownDisconnected;
			}
			catch (Exception exception)
			{
				BikesViewModel.ActionText = string.Empty;

				SelectedBike.LockInfo.State = exception is StateAwareException stateAwareException
					? stateAwareException.State
					: LockingState.UnknownDisconnected;

				// Signal cts to  cancel getting geolocation.
				ctsLocation.Cancel();
				Task updateLockingStateTask = Task.CompletedTask;
				IsConnected = IsConnectedDelegate();
				try
				{
					updateLockingStateTask = ConnectorFactory(IsConnected).Command.UpdateLockingStateAsync(
						SelectedBike);
				}
				catch (Exception innerExceptionStartUpdateLockingState)
				{
					// No location information available/ updating state failed.
					Log.ForContext<BookedOpen>().Information("Start update locking state failed on lock operating error. {Exception}", SelectedBike, innerExceptionStartUpdateLockingState);
				}

				if (exception is OutOfReachException)
				{
					Log.ForContext<BookedOpen>().Debug("Lock can not be closed. Lock is out of reach. {Exception}", exception);

					await ViewService.DisplayAlert(
						AppResources.ErrorCloseLockTitle,
						AppResources.ErrorCloseLockOutOfReachMessage,
						AppResources.MessageAnswerOk);
				}
				else if (exception is CouldntCloseMovingException)
				{
					Log.ForContext<BookedOpen>().Debug("Lock can not be closed. Lock is out of reach. {Exception}", exception);

					await ViewService.DisplayAlert(
						AppResources.ErrorCloseLockTitle,
						AppResources.ErrorCloseLockMovingMessage,
						AppResources.MessageAnswerOk);
				}
				else if (exception is CouldntCloseBoldBlockedException)
				{
					Log.ForContext<BookedOpen>().Debug("Lock can not be closed. Lock is out of reach. {Exception}", exception);

					await ViewService.DisplayAlert(
						AppResources.ErrorCloseLockTitle,
						AppResources.ErrorCloseLockBoldBlockedMessage,
						AppResources.MessageAnswerOk);
				}
				else
				{
					Log.ForContext<BookedOpen>().Error("Lock can not be closed. {Exception}", exception);

					await ViewService.DisplayAlert(
						AppResources.ErrorCloseLockTitle,
						exception.Message,
						AppResources.MessageAnswerOk);
				}

				// Wait until cancel getting geolocation has completed.
				BikesViewModel.ActionText = AppResources.ActivityTextQueryLocationCancelWait;
				try
				{
					await Task.WhenAll(new List<Task> { currentLocationTask ?? Task.CompletedTask, updateLockingStateTask });
				}
				catch (Exception innerExWhenAll)
				{
					// No location information available/ updating state failed.
					Log.ForContext<BookedOpen>().Information("Canceling query location/ updating lock state failed on closing lock error. {Exception}", SelectedBike, innerExWhenAll);
				}

				BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
				await ViewUpdateManager().StartUpdateAyncPeridically(); // Restart polling again.

				BikesViewModel.ActionText = string.Empty;
				BikesViewModel.IsIdle = true; // Unlock GUI                
				return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, GeolocationService, LockService, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
			}

			// Check locking state.
			if (SelectedBike.LockInfo.State != LockingState.Closed)
			{
				Log.ForContext<BookedOpen>().Error($"Lock can not be closed. Invalid locking state state {SelectedBike.LockInfo.State} detected.");

				BikesViewModel.ActionText = string.Empty;


				// Signal cts to  cancel getting geolocation.
				ctsLocation.Cancel();

				// Notify COPRI about closing failure: "request=booking_update ... &lock_state=unlocked ..."
				Task updateLockingStateTask = Task.CompletedTask;
				IsConnected = IsConnectedDelegate();
				try
				{
					updateLockingStateTask = ConnectorFactory(IsConnected).Command.UpdateLockingStateAsync(
						SelectedBike);
				}
				catch (Exception innerExceptionStartUpdateLockingState)
				{
					// No location information available/ updating state failed.
					Log.ForContext<BookedOpen>().Information("Start update locking state failed on unexpected state. {Exception}", SelectedBike, innerExceptionStartUpdateLockingState);
				}

				await ViewService.DisplayAlert(
					AppResources.ErrorCloseLockTitle,
					SelectedBike.LockInfo.State == LockingState.Open
						? AppResources.ErrorCloseLockStillOpenMessage
						: string.Format(AppResources.ErrorCloseLockUnexpectedStateMessage, SelectedBike.LockInfo.State),
					AppResources.MessageAnswerOk);

				// Wait until cancel getting geolocation has completed.
				BikesViewModel.ActionText = AppResources.ActivityTextQueryLocationCancelWait;
				try
				{
					await Task.WhenAll(new List<Task> { currentLocationTask ?? Task.CompletedTask, updateLockingStateTask });
				}
				catch (Exception innerExWhenAll)
				{
					// No location information available.
					Log.ForContext<BookedOpen>().Information("Canceling query location/ updating lock state failed failed on unexpected lock state failed. {Exception}", SelectedBike, innerExWhenAll);
				}

				BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
				await ViewUpdateManager().StartUpdateAyncPeridically(); // Restart polling again.

				BikesViewModel.ActionText = string.Empty;
				BikesViewModel.IsIdle = true; // Unlock GUI                
				return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, GeolocationService, LockService, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
			}

			// Get geolocation information.
			BikesViewModel.ActionText = AppResources.ActivityTextQueryLocation;
			IGeolocation currentLocation = null;
			try
			{
				var task = await Task.WhenAny(new List<Task> { currentLocationTask });
				currentLocation = currentLocationTask.Result;
			}
			catch (Exception ex)
			{
				// No location information available.
				Log.ForContext<BookedOpen>().Information("Returning bike {Bike} is not possible. Query location failed. {Exception}", SelectedBike, ex);

				BikesViewModel.ActionText = string.Empty;
				await ViewService.DisplayAdvancedAlert(
					AppResources.MessageErrorQueryLocationTitle,
					AppResources.MessageErrorQueryLocationMessage,
					ex.GetErrorMessage(),
					AppResources.MessageAnswerOk);

				BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
				await ViewUpdateManager().StartUpdateAyncPeridically(); // Restart polling again.

				BikesViewModel.ActionText = string.Empty;
				BikesViewModel.IsIdle = true; // Unlock GUI                
				return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, GeolocationService, LockService, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
			}

			// Notify COPRI about end of rental: "request=booking_update ... "&state=available" ... &lock_state=locked ..."
			BikesViewModel.ActionText = AppResources.ActivityTextReturningBike;
			IsConnected = IsConnectedDelegate();

			var feedBackUri = SelectedBike?.OperatorUri;
			LocationDto currentLocationDto = null;
			BookingFinishedModel bookingFinished;
			try
			{
				currentLocationDto = currentLocation != null
					? new LocationDto.Builder
						{
							Latitude = currentLocation.Latitude,
							Longitude = currentLocation.Longitude,
							Accuracy = currentLocation.Accuracy ?? double.NaN,
							Age = timeStamp.Subtract(currentLocation.Timestamp.DateTime),
						}.Build()
					: null;

				bookingFinished = await ConnectorFactory(IsConnected).Command.DoReturn(
					SelectedBike,
					currentLocationDto,
					SmartDevice);
				// If canceling bike succedes remove bike because it is not ready to be booked again
				IsRemoveBikeRequired = true;
			}
			catch (Exception exception)
			{
				BikesViewModel.ActionText = string.Empty;
				if (exception is WebConnectFailureException)
				{
					// Copri server is not reachable.
					Log.ForContext<BookedOpen>().Information(
						"User selected booked bike {bike} but returning failed (Copri server not reachable).", SelectedBike);

					await ViewService.DisplayAdvancedAlert(
						AppResources.ErrorReturnBikeNoWebTitle,
						string.Format("{0}\r\n{1}", AppResources.ErrorReturnBikeNoWebMessage, WebConnectFailureException.GetHintToPossibleExceptionsReasons),
						exception.Message,
						AppResources.MessageAnswerOk);
				}
				else if (exception is NotAtStationException notAtStationException)
				{
					// COPRI returned an error.
					Log.ForContext<BookedOpen>().Information(
						"User selected booked bike {bike} but returning failed. COPRI returned out of GEO fencing error. Postion send to COPRI {@position}.",
						SelectedBike,
						currentLocationDto);

					await ViewService.DisplayAlert(
						AppResources.ErrorReturnBikeTitle,
						string.Format(AppResources.ErrorReturnBikeNotAtStationMessage, notAtStationException.StationNr, notAtStationException.Distance),
						AppResources.MessageAnswerOk);
				}
				else if (exception is NoGPSDataException)
				{
					// COPRI returned an error.
					Log.ForContext<BookedOpen>().Information("User selected booked bike {bike} but returning failed. COPRI returned an no GPS- data error.", SelectedBike);

					await ViewService.DisplayAlert(
						AppResources.ErrorReturnBikeTitle,
						string.Format(AppResources.ErrorReturnBikeLockOpenNoGPSMessage),
						AppResources.MessageAnswerOk);
				}
				else if (exception is ResponseException copriException)
				{
					// Copri server is not reachable.
					Log.ForContext<BookedOpen>().Information("User selected booked bike {bike} but returning failed. COPRI returned an error.", SelectedBike);

					await ViewService.DisplayAdvancedAlert(
						"Statusfehler beim Zurückgeben des Rads!",
						copriException.Message,
						copriException.Response,
						AppResources.MessageAnswerOk);
				}
				else
				{
					Log.ForContext<BookedOpen>().Error("User selected booked bike {bike} but returning failed. {@l_oException}", SelectedBike.Id, exception);

					await ViewService.DisplayAlert(
						AppResources.ErrorReturnBikeTitle,
						exception.Message,
						AppResources.MessageAnswerOk);
				}

				BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
				await ViewUpdateManager().StartUpdateAyncPeridically();

				BikesViewModel.ActionText = string.Empty;
				BikesViewModel.IsIdle = true;
				return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, GeolocationService, LockService, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
			}

			Log.ForContext<BookedOpen>().Information("User returned bike {bike} successfully.", SelectedBike);

			// Disconnect lock.
			BikesViewModel.ActionText = AppResources.ActivityTextDisconnectingLock;
			try
			{
				SelectedBike.LockInfo.State = await LockService.DisconnectAsync(SelectedBike.LockInfo.Id, SelectedBike.LockInfo.Guid);
			}
			catch (Exception exception)
			{
				Log.ForContext<BookedOpen>().Error("Lock can not be disconnected. {Exception}", exception);

				BikesViewModel.ActionText = AppResources.ActivityTextErrorDisconnect;
			}

#if !USERFEEDBACKDLG_OFF
			// Do get Feedback
			var feedback = await ViewService.DisplayUserFeedbackPopup(
				SelectedBike.Drive?.Battery,
				bookingFinished?.Co2Saving);
			IsConnected = IsConnectedDelegate();
			try
			{
				await ConnectorFactory(IsConnected).Command.DoSubmitFeedback(
					 new UserFeedbackDto
					 {
						 BikeId = SelectedBike.Id,
						 CurrentChargeBars = feedback.CurrentChargeBars,
						 IsBikeBroken = feedback.IsBikeBroken,
						 Message = feedback.Message
					 },
					feedBackUri);
			}
			catch (Exception exception)
			{
				BikesViewModel.ActionText = string.Empty;

				if (exception is ResponseException copriException)
				{
					// Copri server is not reachable.
					Log.ForContext<BookedOpen>().Information("Submitting feedback for bike {bike} failed. COPRI returned an error.", SelectedBike);
				}
				else
				{
					Log.ForContext<BookedOpen>().Error("Submitting feedback for bike {bike} failed. {@l_oException}", SelectedBike.Id, exception);
				}

				await ViewService.DisplayAlert(
					AppResources.ErrorReturnSubmitFeedbackTitle,
					AppResources.ErrorReturnSubmitFeedbackMessage,
					AppResources.MessageAnswerOk);

				BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
				await ViewUpdateManager().StartUpdateAyncPeridically();

				BikesViewModel.ActionText = string.Empty;
				BikesViewModel.IsIdle = true;
				return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, GeolocationService, LockService, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
			}
#endif

			if (bookingFinished != null && bookingFinished.MiniSurvey.Questions.Count > 0)
			{
				await ViewService.PushModalAsync(ViewTypes.MiniSurvey);
			}

			BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
			await ViewUpdateManager().StartUpdateAyncPeridically();
			BikesViewModel.ActionText = string.Empty;
			BikesViewModel.IsIdle = true;
			return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, GeolocationService, LockService, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
		}

		/// <summary> Close lock in order to pause ride and update COPRI lock state.</summary>
		public async Task<IRequestHandler> CloseLock()
		{
			// Unlock bike.
			BikesViewModel.IsIdle = false;
			Log.ForContext<BookedOpen>().Information("User request to lock bike {bike} in order to pause ride.", SelectedBike);

			// Clear logging memory sink to avoid passing log data not related to returning of bike to backend.
			// Log data is passed to backend when calling CopriCallsHttps.DoReturn().
			MemoryStackSink.ClearMessages();

			// Start getting geolocation.
			BikesViewModel.ActionText = AppResources.ActivityTextQueryLocationStart;
			var ctsLocation = new CancellationTokenSource();
			Task<IGeolocation> currentLocationTask = null;
			var timeStamp = DateTime.Now;
			try
			{
				currentLocationTask = GeolocationService.GetAsync(ctsLocation.Token, timeStamp);
			}
			catch (Exception ex)
			{
				// No location information available.
				Log.ForContext<BookedOpen>().Information("Closing lock of bike {Bike} is not possible. Starting query location failed. {Exception}", SelectedBike, ex);

				BikesViewModel.ActionText = AppResources.ActivityTextErrorQueryLocationQuery;
			}

			// Stop polling before returning bike.
			BikesViewModel.ActionText = AppResources.ActivityTextOneMomentPlease;
			await ViewUpdateManager().StopUpdatePeridically();

			// Close lock
			BikesViewModel.ActionText = AppResources.ActivityTextClosingLock;
			try
			{
				SelectedBike.LockInfo.State = (await LockService[SelectedBike.LockInfo.Id].CloseAsync())?.GetLockingState() ?? LockingState.UnknownDisconnected;
			}
			catch (Exception exception)
			{
				BikesViewModel.ActionText = string.Empty;

				// Signal cts to  cancel getting geolocation.
				ctsLocation.Cancel();

				if (exception is OutOfReachException)
				{
					Log.ForContext<BookedOpen>().Debug("Lock can not be closed. {Exception}", exception);
					await ViewService.DisplayAlert(
						AppResources.ErrorCloseLockTitle,
						AppResources.ErrorCloseLockOutOfReachMessage,
						AppResources.MessageAnswerOk);
				}
				else if (exception is CouldntCloseMovingException)
				{
					Log.ForContext<BookedOpen>().Debug("Lock can not be closed. Lock is out of reach. {Exception}", exception);

					await ViewService.DisplayAlert(
						AppResources.ErrorCloseLockTitle,
						AppResources.ErrorCloseLockMovingMessage,
						AppResources.MessageAnswerOk);
				}
				else if (exception is CouldntCloseBoldBlockedException)
				{
					Log.ForContext<BookedOpen>().Debug("Lock can not be closed. Lock is out of reach. {Exception}", exception);

					await ViewService.DisplayAlert(
						AppResources.ErrorCloseLockTitle,
						AppResources.ErrorCloseLockBoldBlockedMessage,
						AppResources.MessageAnswerOk);
				}
				else
				{
					Log.ForContext<BookedOpen>().Error("Lock can not be closed. {Exception}", exception);
					await ViewService.DisplayAlert(
						AppResources.ErrorCloseLockTitle,
						exception.Message,
						AppResources.MessageAnswerOk);
				}

				// Update current state from exception
				SelectedBike.LockInfo.State = exception is StateAwareException stateAwareException
					? stateAwareException.State
					: LockingState.UnknownDisconnected;

				// Wait until cancel getting geolocation has completed.
				BikesViewModel.ActionText = AppResources.ActivityTextQueryLocationCancelWait;
				try
				{
					await Task.WhenAny(new List<Task> { currentLocationTask ?? Task.CompletedTask });
				}
				catch (Exception ex)
				{
					// No location information available.
					Log.ForContext<BookedOpen>().Information("Canceling query location failed on closing lock error. {Exception}", SelectedBike, ex);
				}

				BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
				await ViewUpdateManager().StartUpdateAyncPeridically();

				BikesViewModel.ActionText = string.Empty;
				BikesViewModel.IsIdle = true;
				return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, GeolocationService, LockService, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
			}

			// Get geoposition.
			BikesViewModel.ActionText = AppResources.ActivityTextQueryLocation;
			IGeolocation currentLocation = null;
			try
			{
				await Task.WhenAny(new List<Task> { currentLocationTask });
				currentLocation = currentLocationTask.Result;
			}
			catch (Exception ex)
			{
				// No location information available.
				Log.ForContext<BookedOpen>().Information("Getting geolocation when closing lock of bike {Bike} failed. {Exception}", SelectedBike, ex);

				BikesViewModel.ActionText = AppResources.ActivityTextErrorQueryLocationWhenAny;
			}

			// Keep geolocation where closing action occurred.
			SelectedBike.LockInfo.Location = currentLocation;

			// Lock list to avoid multiple taps while copri action is pending.
			BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdatingLockingState;

			IsConnected = IsConnectedDelegate();

			try
			{
				await ConnectorFactory(IsConnected).Command.UpdateLockingStateAsync(
					SelectedBike,
					currentLocation != null
						? new LocationDto.Builder
						{
							Latitude = currentLocation.Latitude,
							Longitude = currentLocation.Longitude,
							Accuracy = currentLocation.Accuracy ?? double.NaN,
							Age = timeStamp.Subtract(currentLocation.Timestamp.DateTime),
						}.Build()
						: null);
			}
			catch (Exception exception)
			{
				if (exception is WebConnectFailureException)
				{
					// Copri server is not reachable.
					Log.ForContext<BookedOpen>().Information("User locked bike {bike} in order to pause ride but updating failed (Copri server not reachable).", SelectedBike);

					BikesViewModel.ActionText = AppResources.ActivityTextErrorNoWebUpdateingLockstate;
				}
				else if (exception is ResponseException copriException)
				{
					// Copri server is not reachable.
					Log.ForContext<BookedOpen>().Information("User locked bike {bike} in order to pause ride but updating failed. Message: {Message} Details: {Details}", SelectedBike, copriException.Message, copriException.Response);

					BikesViewModel.ActionText = AppResources.ActivityTextErrorStatusUpdateingLockstate;
				}
				else
				{
					Log.ForContext<BookedOpen>().Error("User locked bike {bike} in order to pause ride but updating failed. {@l_oException}", SelectedBike.Id, exception);

					BikesViewModel.ActionText = AppResources.ActivityTextErrorConnectionUpdateingLockstate;
				}
			}

			Log.ForContext<BookedOpen>().Information("User paused ride using {bike} successfully.", SelectedBike);
			BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
			await ViewUpdateManager().StartUpdateAyncPeridically();
			BikesViewModel.ActionText = string.Empty;
			BikesViewModel.IsIdle = true;
			return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, GeolocationService, LockService, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
		}
	}
}