public static void HandleException(Exception ex) { AppCenterHelper.Error("AsyncErrorHandler HandleException", ex); #if DEBUG Debug.WriteLine(ex); #endif }
async void handleApplicationTapped(object sender, ItemTappedEventArgs e) { try { if (!isBusy) { isBusy = true; if (e.Item == null) { return; } var selectedApplication = e.Item as Workbench.Client.Models.Application; //Reset the IsInitiator property App.ViewModel.IsUserInitiator = false; await App.ViewModel.SetCurrentApplication(selectedApplication.Id.ToString()); await App.ViewModel.RefreshWorkflowsForSelectedApplication(selectedApplication.Id.ToString()); } } catch (Exception ex) { AppCenterHelper.Report(ex); } finally { isBusy = false; } }
public async Task <bool> LoginAsync() { if (IsBusy) { return(false); } IsBusy = true; IsAnimationVisible = true; try { var response = await executeLoginAsync(); IsAnimationVisible = false; return(response); } catch (Exception e) { AppCenterHelper.Report(e); await App.Current.MainPage.DisplayAlert("Error", $"executeLoginAsync: {e.Message}", "OK"); } finally { IsBusy = false; IsAnimationVisible = false; } return(false); }
protected override async void ViewIsAppearing(object sender, EventArgs e) { AppCenterHelper.Track("DeviceTwinPageModel - ViewIsAppearing"); await OutputDeviceTwin(); base.ViewIsAppearing(sender, e); }
private void MonitorProximityBeacons() { _monitoringV2ManagerImmediate.StartMonitoring(BeaconsImmediate.Select(x => x.Key).ToArray()); _monitoringV2ManagerImmediate.EnterdDesiredRange += (object sender, MonitoringV2ManagerEnterdDesiredRangeEventArgs e) => { switch (BeaconsImmediate[e.Identifier]) { case "Bedroom": _settings.AtBedroom = true; break; } AppCenterHelper.Track($"LocationBeacon EnterdDesiredRange: {BeaconsImmediate[e.Identifier]}"); }; _monitoringV2ManagerImmediate.ExitedDesiredRange += (object sender, MonitoringV2ManagerExitedDesiredRangeEventArgs e) => { switch (BeaconsImmediate[e.Identifier]) { case "Bedroom": _settings.AtBedroom = false; break; } AppCenterHelper.Track($"LocationBeacon ExitedDesiredRange: {BeaconsImmediate[e.Identifier]}"); }; }
protected override async void OnStart() { AppCenterHelper.Start(); AppCenterHelper.TrackEvent("App Started"); #if DEBUG var res = await LocalDbHelper.Instance.GetAllSavedEnvironmentsAsync(); if (res.Count == 0) { /* The following can be used when debugging to input a sample environment * * var environment = new BlockchainEnvironment * { * ResourceId = "YOUR RESOURCE ID", * ClientId = "YOUR CLIENT ID", * ReturnUrl = "YOUR RETURN URI", * SiteUrl = "YOUR API ENDPOINT", * TenantId = "YOUR AD TENANT INFORMATION", * NickName = "A NICKNAME FOR THE ENV" * }; * * await LocalDbHelper.Instance.SaveEnvironmentAsync(environment); */ } #endif }
public async Task <LoginResponse> LoginAsync(string authority, string resource, string clientId, string returnUri, bool isRefresh = false) { var authContext = new AuthenticationContext(authority); if (authContext.TokenCache.ReadItems().Any()) { authContext = new AuthenticationContext(authContext.TokenCache.ReadItems().First().Authority); } try { AuthenticationResult authResult; if (isRefresh) { authResult = await authContext.AcquireTokenSilentAsync(resource, clientId); } else { var controller = ViewControllerHelpers.GetVisibleViewController(); var uri = new Uri(returnUri); var platformParams = new PlatformParameters(controller); authResult = await authContext.AcquireTokenAsync(resource, clientId, uri, platformParams); } var result = new LoginResponse { AuthHeader = authResult.CreateAuthorizationHeader(), AccessToken = authResult.AccessToken, AccessTokenType = authResult.AccessTokenType, ExpiresOn = authResult.ExpiresOn, ExtendedLifetimeToken = authResult.ExtendedLifeTimeToken, IdToken = authResult.IdToken, TenantId = authResult.TenantId }; result.Profile.DisplayableId = authResult.UserInfo.DisplayableId; result.Profile.FamilyName = authResult.UserInfo.FamilyName; result.Profile.GivenName = authResult.UserInfo.GivenName; result.Profile.UniqueId = authResult.UserInfo.UniqueId; return(result); } catch (Exception e) { var _controller = ViewControllerHelpers.GetVisibleViewController(); var alert = UIAlertController.Create("Error", e.Message, UIAlertControllerStyle.Alert); alert.AddAction(UIAlertAction.Create("Cancel", UIAlertActionStyle.Cancel, null)); _controller.BeginInvokeOnMainThread(() => { _controller.PresentViewController(alert, true, null); }); AppCenterHelper.Report(e); clearTokenFromCache(authority); return(null); } }
//--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- private void SetAnalytics(bool value) { if (SetProperty(ref _Analytics, value, nameof(Analytics))) { Settings.setSetting(SettingsConsts.DISABLE_ANALYTICS, !value); Task.Run(async() => await AppCenterHelper.SetAnalyticsEnabledAsync(value)); } }
protected override async void ViewIsAppearing(object sender, EventArgs e) { await _azureIoTHub.GetDeviceTwin(); AppCenterHelper.Track("SecurityPageModel - ViewIsAppearing"); base.ViewIsAppearing(sender, e); }
private void SetCrashreports(bool value) { if (SetProperty(ref _Crashreports, value, nameof(Crashreports))) { Settings.setSetting(SettingsConsts.DISABLE_CRASH_REPORTING, !value); Task.Run(async() => await AppCenterHelper.SetCrashesEnabledAsync(value)); } }
private async Task OccupantStateUpdated() { var occupantState = GetOccupantState(); _settings.OccupantState = occupantState; await _azureIoTHub.UpdateOccupantState(occupantState); AppCenterHelper.Track(nameof(OccupantStateUpdated)); }
public App() { InitializeComponent(); if (appCenterHelper == null) { appCenterHelper = new AppCenterHelper(); } MainPage = new MainPage(); }
private async Task ShowReportCrashIfNeeded() { if (await Crashes.IsEnabledAsync() && await Crashes.HasCrashedInLastSessionAsync()) { ErrorReport crashReport = await Crashes.GetLastSessionCrashReportAsync(); Logger.Error("Detected a crash in the last session: " + crashReport.StackTrace); ReportLastCrashDialog dialog = new ReportLastCrashDialog(AppCenterHelper.GenerateCrashReport(crashReport)); await UiUtils.ShowDialogAsync(dialog); } }
public override void WillPresentNotification(UNUserNotificationCenter center, UNNotification notification, Action <UNNotificationPresentationOptions> completionHandler) { // Do something with the notification AppCenterHelper.Track("DidReceiveRemoteNotification - Active Notification"); // Will also call '// App Active' in AppDelegate // Tell system to display the notification anyway or use // `None` to say we have handled the display locally. completionHandler(UNNotificationPresentationOptions.Alert); }
public async Task GetDeviceTwin() { var twin = await _registryManager.GetTwinAsync(DeviceId); AppCenterHelper.Track(nameof(GetDeviceTwin)); // Update DeviceTwin _deviceTwin.ApplianceConnected = twin.ConnectionState == DeviceConnectionState.Connected; try { var reportedPropertyForRelayState = twin.Properties.Reported["RelayState"]; RelayState relayState = JsonConvert.DeserializeObject <RelayState>(reportedPropertyForRelayState.ToJson()); _deviceTwin.LightsGarden = relayState.LightsGarden; _deviceTwin.AlarmStrobe = relayState.AlarmStrobe; _deviceTwin.AlarmSiren = relayState.AlarmSiren; } catch (Exception ex) { AppCenterHelper.Error("Error updating RelayState", ex); } try { var reportedPropertyOccupantState = twin.Properties.Reported[nameof(_deviceTwin.Occupant)]; var occupant = JsonConvert.DeserializeObject <OccupantState>(reportedPropertyOccupantState.ToJson()); _deviceTwin.Occupant = occupant; } catch (Exception ex) { AppCenterHelper.Error("Error updating Occupant", ex); } try { var reportedPropertyArmedState = twin.Properties.Reported[nameof(ArmedState)]; var armedState = JsonConvert.DeserializeObject <ArmedState>(reportedPropertyArmedState.ToJson()); _deviceTwin.ArmedState = armedState; } catch (Exception ex) { AppCenterHelper.Error("Error updating ArmedState", ex); } try { _deviceTwin.GarageDoorOpen = (bool)twin.Properties.Reported["GarageDoorOpen"]; } catch (Exception ex) { AppCenterHelper.Error("Error updating GarageDoorOpen", ex); } }
private void MonitorSecureBeacons() { _secureBeaconManager.AuthorizationStatusChanged += (object sender, SecureBeaconManagerAuthorizationStatusChangedEventArgs e) => { StartMonitorinBeacons(); }; _secureBeaconManager.EnteredRegion += (object sender, SecureBeaconManagerEnteredRegionEventArgs e) => { switch (e.Region.Identifier) { case nameof(MySecureBeacon): // Do stuff break; } AppCenterHelper.Track($"SecureBeacon EnteredRegion: {e.Region.Identifier}"); }; _secureBeaconManager.ExitedRegion += (object sender, SecureBeaconManagerExitedRegionEventArgs e) => { switch (e.Region.Identifier) { case nameof(MySecureBeacon): // Do stuff break; } AppCenterHelper.Track($"SecureBeacon ExitedRegion: {e.Region.Identifier}"); }; _secureBeaconManager.DeterminedState += (object sender, SecureBeaconManagerDeterminedStateEventArgs e) => { switch (e.Region.Identifier) { case nameof(MySecureBeacon): // Do stuff break; } AppCenterHelper.Track($"SecureBeacon DeterminedState: {e.Region.Identifier}"); }; try { StartMonitorinBeacons(); } catch (Exception ex) { AppCenterHelper.Error(nameof(MonitorSecureBeacons), ex); } }
public override void DidReceiveNotificationResponse(UNUserNotificationCenter center, UNNotificationResponse response, Action completionHandler) { // User Tapped if (response.IsDefaultAction) { var userInfo = response.Notification.Request.Content?.UserInfo; if (userInfo != null) { AppCenterHelper.Track("DidReceiveNotificationResponse - User Tapped"); } } completionHandler(); }
public void MonitorHomeGeolocation() { LocationService.Instance.AuthorizationChanged += (s, e) => { if (e.Status == CLAuthorizationStatus.AuthorizedAlways) { LocationService.Instance.StartMonitoring(HomeRegion); } }; // https://medium.com/@mizutori/tracking-highly-accurate-location-in-ios-vol-3-7cd827a84e4d LocationService.Instance.RequestAlwaysAuthorization(); LocationService.Instance.AllowsBackgroundLocationUpdates = true; LocationService.Instance.PausesLocationUpdatesAutomatically = false; LocationService.Instance.DesiredAccuracy = CLLocation.AccurracyBestForNavigation; LocationService.Instance.DistanceFilter = CLLocationDistance.FilterNone; LocationService.Instance.RegionEntered += async(object sender, CLRegionEventArgs e) => { if (e.Region is CLCircularRegion && e.Region.Identifier == "Microsoft Melbourne") { _settings.AtHome = true; AppCenterHelper.Track("Microsoft Melbourne Entered"); } }; LocationService.Instance.RegionLeft += async(object sender, CLRegionEventArgs e) => { if (e.Region is CLCircularRegion && e.Region.Identifier == "Microsoft Melbourne") { _settings.AtHome = false; AppCenterHelper.Track("Microsoft Melbourne Left"); } }; LocationService.Instance.DidDetermineState += (object sender, CLRegionStateDeterminedEventArgs e) => { if (e.Region is CLCircularRegion && e.Region.Identifier == "Microsoft Melbourne") { _settings.AtHome = e.State == CLRegionState.Inside; AppCenterHelper.Track("Microsoft Melbourne Determine State"); } }; try { LocationService.Instance.StartMonitoring(HomeRegion); } catch (Exception ex) { AppCenterHelper.Error(nameof(MonitorHomeGeolocation), ex); } }
public async Task <LoginResponse> LoginAsync(string authority, string resource, string clientId, string returnUri, bool isRefresh = false) { var authContext = new AuthenticationContext(authority); if (authContext.TokenCache.ReadItems().Any()) { authContext = new AuthenticationContext(authContext.TokenCache.ReadItems().First().Authority); } var uri = new Uri(returnUri); var platformParams = new PlatformParameters((Android.App.Activity)Xamarin.Forms.Forms.Context); try { AuthenticationResult authResult; if (isRefresh) { authResult = await authContext.AcquireTokenSilentAsync(resource, clientId); } else { authResult = await authContext.AcquireTokenAsync(resource, clientId, uri, platformParams).ConfigureAwait(false); } var result = new LoginResponse { AuthHeader = authResult.CreateAuthorizationHeader(), AccessToken = authResult.AccessToken, AccessTokenType = authResult.AccessTokenType, ExpiresOn = authResult.ExpiresOn, ExtendedLifetimeToken = authResult.ExtendedLifeTimeToken, IdToken = authResult.IdToken, TenantId = authResult.TenantId }; result.Profile.DisplayableId = authResult.UserInfo.DisplayableId; result.Profile.FamilyName = authResult.UserInfo.FamilyName; result.Profile.GivenName = authResult.UserInfo.GivenName; result.Profile.UniqueId = authResult.UserInfo.UniqueId; return(result); } catch (Exception e) { AppCenterHelper.Report(e); clearTokenFromCache(authority); return(null); } }
public async Task LoadContractInstanceAsync() { IsBusy = true; try { Blocks = new List <BlockModel>(); DisplayActions = false; var res = await GatewayApi.Instance.GetContractByIdAsync(ContractInstance.Id.ToString()); if (res != default(Contract) || res != null) { ContractInstance = res; assembleBlocks(); } assembleUsers(); var actions = await GatewayApi.Instance.GetWorkflowActionsAsync(ContractInstance.Id.ToString()); if (actions != null) { Actions = new List <WorkflowFunction>(actions); if (Actions?.Count > 0) { DisplayActions = true; } else { DisplayActions = false; } } else { DisplayActions = false; } } catch (Exception e) { AppCenterHelper.Report(e); } finally { IsBusy = false; } }
public async Task UpdateOccupantState(OccupantState occupantState) { using (await Lock.LockAsync()) { switch (Config.Person) { case "Occupant": if (_deviceTwin.Occupant.GetHashCode() == occupantState.GetHashCode()) { AppCenterHelper.Track("UpdateOccupantState passed"); return; } break; } dynamic desiredState; switch (Config.Person) { case "Occupant": default: desiredState = new { Occupant = occupantState }; break; } var patch = new { properties = new { desired = desiredState } }; // TODO: This can fail, add in resiliency var updatedTwin = await _registryManager.UpdateTwinAsync(DeviceId, JsonConvert.SerializeObject(patch), "*"); await GetDeviceTwin(); AppCenterHelper.Track("Updated Occupant State"); } }
async Task configureFirstEnvironment() { try { addingNewEnvironment = true; var prompt = new PromptConfig { IsCancellable = true, Message = $"Please enter the URL that contains your environment configuration JSON", OkText = "Ok", Title = "Add Environment" }; var URLResults = await UserDialogs.Instance.PromptAsync(prompt); if (!string.IsNullOrEmpty(URLResults?.Value)) { using (var httpclient = new HttpClient()) { var results = await httpclient.GetStringAsync(URLResults?.Value); if (!string.IsNullOrEmpty(results)) { var environment = JsonConvert.DeserializeObject <BlockchainEnvironment>(results); await LocalDbHelper.Instance.SaveEnvironmentAsync(environment); Device.BeginInvokeOnMainThread(async() => { await LoginAsync(); }); } else { await UserDialogs.Instance.AlertAsync("Unable to get environment data, please ensure you entered a valid URL", "Error", "OK"); } } } } catch (Exception e) { AppCenterHelper.Report(e); await UserDialogs.Instance.AlertAsync("Unable to get environment data, please ensure you entered a valid URL", "Error", "OK"); } }
protected override void OnElementChanged(VisualElementChangedEventArgs e) { base.OnElementChanged(e); if (e.OldElement != null || Element == null) { return; } try { SetAppTheme(); } catch (Exception ex) { AppCenterHelper.TrackError(ex); } }
public void clearTokenFromCache(string authority) { try { Android.Webkit.CookieManager.Instance.RemoveAllCookies(null); var authContext = new AuthenticationContext(authority); authContext.TokenCache.Clear(); var editor = SharedPreferences.Edit(); editor.Remove(SharedPreferencesKey); } catch (Exception ex) { // log the error AppCenterHelper.Report(ex); System.Diagnostics.Debug.WriteLine(ex.Message); } }
private async Task <bool> InvokeMethodWithResponseState(string method, bool currentState) { AppCenterHelper.Track($"SecurityPageModel - {method}"); var response = await ResilientCall.ExecuteWithRetry( () => _azureIoTHub.InvokeMethod(method)); if (response.Outcome == OutcomeType.Successful && response.Result.Status == 200) { var stateResponse = JsonConvert.DeserializeObject <StateResponse>(response.Result.ResponsePayload); return(stateResponse.State); } // Error ShowError(); AppCenterHelper.Error(method, response.FinalException); return(currentState); }
private async Task LoadAppAsync() { // Setup listening for theme changes: ThemeUtils.SetupThemeListener(); // Setup listener for window activated changes: UiUtils.SetupWindowActivatedListener(); // Setup window: UiUtils.SetupWindow(Application.Current); // Perform app update tasks if necessary: await AppUpdateHelper.OnAppStartAsync(); // Setup App Center crashes, push: AppCenterHelper.SetupAppCenter(); await ShowReportCrashIfNeeded(); // Register background tasks: Logger.Info("Registering background tasks..."); // TODO: Add background tasks here Logger.Info("Finished registering background tasks."); // Show initial start dialog: /*if (!Settings.getSettingBoolean(SettingsConsts.HIDE_INITIAL_START_DIALOG_ALPHA)) * { * InitialStartDialog initialStartDialog = new InitialStartDialog(); * await UiUtils.ShowDialogAsync(initialStartDialog); * } * * // Show what's new dialog: * if (!Settings.getSettingBoolean(SettingsConsts.HIDE_WHATS_NEW_DIALOG)) * { * WhatsNewDialog whatsNewDialog = new WhatsNewDialog(); * await UiUtils.ShowDialogAsync(whatsNewDialog); * }*/ EvaluateActivationArgs(); }
public void RequestBeaconStates() { var monitoredBeacons = new Dictionary <string, MonitoringState>(); foreach (var id in BeaconsImmediate.Keys) { var state = _monitoringV2ManagerImmediate.StateForBeacon(id); monitoredBeacons.Add(BeaconsImmediate[id], state); } foreach (var monitoredBeacon in monitoredBeacons) { switch (monitoredBeacon.Key) { case "Bedroom": _settings.AtBedroom = monitoredBeacon.Value == MonitoringState.InsideZone; break; } } _secureBeaconManager.RequestState(MySecureBeacon); AppCenterHelper.Track(nameof(RequestBeaconStates)); }
protected override void OnCreate(Bundle savedInstanceState) { var eventUploadIntent = new Intent(this, typeof(EventUploadReceiver)); _eventUploadPendingIntent = PendingIntent.GetBroadcast(this, 0, eventUploadIntent, PendingIntentFlags.UpdateCurrent); var alarmIntent = new Intent(this, typeof(LockAlarmReceiver)); _vaultTimeoutAlarmPendingIntent = PendingIntent.GetBroadcast(this, 0, alarmIntent, PendingIntentFlags.UpdateCurrent); var clearClipboardIntent = new Intent(this, typeof(ClearClipboardAlarmReceiver)); _clearClipboardPendingIntent = PendingIntent.GetBroadcast(this, 0, clearClipboardIntent, PendingIntentFlags.UpdateCurrent); var policy = new StrictMode.ThreadPolicy.Builder().PermitAll().Build(); StrictMode.SetThreadPolicy(policy); _deviceActionService = ServiceContainer.Resolve <IDeviceActionService>("deviceActionService"); _messagingService = ServiceContainer.Resolve <IMessagingService>("messagingService"); _broadcasterService = ServiceContainer.Resolve <IBroadcasterService>("broadcasterService"); _userService = ServiceContainer.Resolve <IUserService>("userService"); _appIdService = ServiceContainer.Resolve <IAppIdService>("appIdService"); _storageService = ServiceContainer.Resolve <IStorageService>("storageService"); _eventService = ServiceContainer.Resolve <IEventService>("eventService"); TabLayoutResource = Resource.Layout.Tabbar; ToolbarResource = Resource.Layout.Toolbar; UpdateTheme(ThemeManager.GetTheme(true)); base.OnCreate(savedInstanceState); if (!CoreHelpers.InDebugMode()) { Window.AddFlags(Android.Views.WindowManagerFlags.Secure); } #if !FDROID var appCenterHelper = new AppCenterHelper(_appIdService, _userService); var appCenterTask = appCenterHelper.InitAsync(); #endif Xamarin.Essentials.Platform.Init(this, savedInstanceState); Xamarin.Forms.Forms.Init(this, savedInstanceState); _appOptions = GetOptions(); LoadApplication(new App.App(_appOptions)); _broadcasterService.Subscribe(_activityKey, (message) => { if (message.Command == "scheduleVaultTimeoutTimer") { var alarmManager = GetSystemService(AlarmService) as AlarmManager; var vaultTimeoutMinutes = (int)message.Data; var vaultTimeoutMs = vaultTimeoutMinutes * 60000; var triggerMs = Java.Lang.JavaSystem.CurrentTimeMillis() + vaultTimeoutMs + 10; alarmManager.Set(AlarmType.RtcWakeup, triggerMs, _vaultTimeoutAlarmPendingIntent); } else if (message.Command == "cancelVaultTimeoutTimer") { var alarmManager = GetSystemService(AlarmService) as AlarmManager; alarmManager.Cancel(_vaultTimeoutAlarmPendingIntent); } else if (message.Command == "startEventTimer") { StartEventAlarm(); } else if (message.Command == "stopEventTimer") { var task = StopEventAlarmAsync(); } else if (message.Command == "finishMainActivity") { Xamarin.Forms.Device.BeginInvokeOnMainThread(() => Finish()); } else if (message.Command == "listenYubiKeyOTP") { ListenYubiKey((bool)message.Data); } else if (message.Command == "updatedTheme") { RestartApp(); } else if (message.Command == "exit") { ExitApp(); } else if (message.Command == "copiedToClipboard") { var task = ClearClipboardAlarmAsync(message.Data as Tuple <string, int?, bool>); } }); }
async Task <bool> executeLoginAsync() { var localEnvironments = await LocalDbHelper.Instance.GetAllSavedEnvironmentsAsync(); if (localEnvironments.Count <= 0) { System.Diagnostics.Debug.WriteLine("################### NO LOCAL ENVIRONMENTS FOUND"); await configureFirstEnvironment(); return(false); } BlockchainEnvironment environment = localEnvironments[0]; var authService = ServiceContainer.Resolve <IAuthentication>(); var loginResponse = await authService.LoginAsync( $"https://login.windows.net/{environment.TenantId}", environment.ResourceId, environment.ClientId, environment.ReturnUrl); if (loginResponse != null) { AppCenterHelper.TrackEvent("Logged in", new Dictionary <string, string>() { { "username", loginResponse.Profile.DisplayableId } }); Settings.AccessToken = loginResponse.AccessToken; #if DEBUG Settings.AccessTokenExpiration = new DateTimeOffset(DateTime.UtcNow.AddMinutes(2)); GatewayApi.Instance.AccessTokenExpiration = new DateTimeOffset(DateTime.UtcNow.AddMinutes(2)); #else Settings.AccessTokenExpiration = loginResponse.ExpiresOn; GatewayApi.Instance.AccessTokenExpiration = loginResponse.ExpiresOn; #endif GatewayApi.Instance.SetAuthToken(loginResponse.AccessToken); App.LOGGED_OUT = false; Device.BeginInvokeOnMainThread(async() => { if (App.Current.MainPage.Navigation.ModalStack.Count == 0) { await App.Current.MainPage.Navigation.PushModalAsync(App.Master); } App.ViewModel.WorkbenchEnvironments = localEnvironments; App.ViewModel.SelectedEnvironment = environment; }); return(true); } else { await App.Logout(); return(false); } }
protected override void OnCreate(Bundle savedInstanceState) { var eventUploadIntent = new Intent(this, typeof(EventUploadReceiver)); _eventUploadPendingIntent = PendingIntent.GetBroadcast(this, 0, eventUploadIntent, PendingIntentFlags.UpdateCurrent); var policy = new StrictMode.ThreadPolicy.Builder().PermitAll().Build(); StrictMode.SetThreadPolicy(policy); _deviceActionService = ServiceContainer.Resolve <IDeviceActionService>("deviceActionService"); _messagingService = ServiceContainer.Resolve <IMessagingService>("messagingService"); _broadcasterService = ServiceContainer.Resolve <IBroadcasterService>("broadcasterService"); _stateService = ServiceContainer.Resolve <IStateService>("stateService"); _appIdService = ServiceContainer.Resolve <IAppIdService>("appIdService"); _eventService = ServiceContainer.Resolve <IEventService>("eventService"); TabLayoutResource = Resource.Layout.Tabbar; ToolbarResource = Resource.Layout.Toolbar; // this needs to be called here before base.OnCreate(...) Intent?.Validate(); base.OnCreate(savedInstanceState); if (!CoreHelpers.InDebugMode()) { Window.AddFlags(Android.Views.WindowManagerFlags.Secure); } #if !DEBUG && !FDROID var appCenterHelper = new AppCenterHelper(_appIdService, _stateService); var appCenterTask = appCenterHelper.InitAsync(); #endif var toplayout = Window?.DecorView?.RootView; if (toplayout != null) { toplayout.FilterTouchesWhenObscured = true; } Xamarin.Essentials.Platform.Init(this, savedInstanceState); Xamarin.Forms.Forms.Init(this, savedInstanceState); _appOptions = GetOptions(); LoadApplication(new App.App(_appOptions)); _broadcasterService.Subscribe(_activityKey, (message) => { if (message.Command == "startEventTimer") { StartEventAlarm(); } else if (message.Command == "stopEventTimer") { var task = StopEventAlarmAsync(); } else if (message.Command == "finishMainActivity") { Xamarin.Forms.Device.BeginInvokeOnMainThread(() => Finish()); } else if (message.Command == "listenYubiKeyOTP") { ListenYubiKey((bool)message.Data); } else if (message.Command == "updatedTheme") { Xamarin.Forms.Device.BeginInvokeOnMainThread(() => AppearanceAdjustments()); } else if (message.Command == "exit") { ExitApp(); } }); }