async Task DoAsyncWork()
{
if (await ExposureNotification.IsEnabledAsync())
{
await ExposureNotification.UpdateKeysFromServer();
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.SetTheme(Resource.Style.MainTheme);
base.OnCreate(savedInstanceState);
// Override WorkRequest configuration
// Must be run before being scheduled with `ExposureNotification.Init()` in `App.OnInitialized()`
var repeatInterval = TimeSpan.FromHours(6);
Action <PeriodicWorkRequest.Builder> requestBuilder = b =>
b.SetConstraints(new Constraints.Builder()
.SetRequiresBatteryNotLow(true)
.SetRequiredNetworkType(NetworkType.Connected)
.Build());
ExposureNotification.ConfigureBackgroundWorkRequest(repeatInterval, requestBuilder);
Xamarin.Forms.Forms.SetFlags("RadioButton_Experimental");
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
Xamarin.Forms.Forms.Init(this, savedInstanceState);
Xamarin.Forms.FormsMaterial.Init(this, savedInstanceState);
FFImageLoading.Forms.Platform.CachedImageRenderer.Init(enableFastRenderer: true);
global::FFImageLoading.ImageService.Instance.Initialize(new FFImageLoading.Config.Configuration());
UserDialogs.Init(this);
//NotificationCenter.CreateNotificationChannel();
LoadApplication(new App());
//NotificationCenter.NotifyNotificationTapped(base.Intent);
}
public async Task <bool> StartExposureNotification()
{
loggerService.StartMethod();
try
{
var enabled = await ExposureNotification.IsEnabledAsync();
if (!enabled)
{
await ExposureNotification.StartAsync();
}
loggerService.EndMethod();
return(true);
}
catch (Exception ex)
{
loggerService.Exception("Error enabling notifications.", ex);
loggerService.EndMethod();
return(false);
}
finally
{
}
}
public async Task FetchExposureKeyAsync()
{
loggerService.StartMethod();
await ExposureNotification.UpdateKeysFromServer();
loggerService.EndMethod();
}
public async Task <bool> StopExposureNotification()
{
if (await Xamarin.ExposureNotifications.ExposureNotification.IsEnabledAsync())
{
await ExposureNotification.StopAsync();
}
return(true);
}
private static void UseMockExposureNotificationImplementationIfNeeded()
{
#if USE_MOCK
// For debug mode, set the mock api provider to interact
// with some fake data
ExposureNotification.OverrideNativeImplementation(new Services.TestNativeImplementation());
#endif
}
public async Task <string> UpdateStatusMessageAsync()
{
loggerService.StartMethod();
ExposureNotificationStatus = await ExposureNotification.GetStatusAsync();
loggerService.EndMethod();
return(await GetStatusMessageAsync());
}
public async Task <bool> IsEnabled()
{
try
{
return(await ExposureNotification.IsEnabledAsync());
}
catch (Exception e)
{
if (!e.HandleExposureNotificationException(nameof(InfectionStatusViewModel), nameof(IsEnabled)))
{
throw e;
}
return(false);
}
}
async Task <Result> DoAsyncWork()
{
try
{
if (await ExposureNotification.IsEnabledAsync())
{
await ExposureNotification.UpdateKeysFromServer();
}
return(Result.InvokeSuccess());
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
return(Result.InvokeRetry());
}
}
protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
base.OnActivityResult(requestCode, resultCode, data);
try
{
if (resultCode == Result.Ok)
{
ExposureNotification.OnActivityResult(requestCode, resultCode, data);
}
}
finally
{
_permissionUtils.OnActivityResult(requestCode, resultCode, data);
UpdateUI();
}
}
public async Task <bool> IsRunning()
{
if (IsAppRestricted)
{
return(false);
}
try
{
return(await ExposureNotification.GetStatusAsync() == Status.Active);
}
catch (Exception e)
{
if (!e.HandleExposureNotificationException(nameof(InfectionStatusViewModel), nameof(IsRunning)))
{
throw e;
}
return(false);
}
}
private async void OnUserDataChanged(object sender, UserDataModel userData)
{
Console.WriteLine("User Data has Changed!!!");
this.userData = userDataService.Get();
Console.WriteLine(Utils.SerializeToJson(userData));
if (userData.IsExposureNotificationEnabled)
{
await StartExposureNotification();
}
else
{
await StopExposureNotification();
}
Status status = await ExposureNotification.GetStatusAsync();
GetStatusMessage(status);
}
public async void CheckIfAppIsRestricted(Action action = null)
{
try
{
if (await IsEnabled())
{
if (await IsRunning())
{
await ExposureNotification.StartAsync();
}
}
IsAppRestricted = false;
}
catch (Exception)
{
IsAppRestricted = true;
}
action?.Invoke();
}
public async Task <bool> StopENService()
{
if (IsAppRestricted)
{
return(false);
}
try
{
await ExposureNotification.StopAsync();
}
catch (Exception e)
{
if (!e.HandleExposureNotificationException(nameof(InfectionStatusViewModel), nameof(StopENService)))
{
throw e;
}
}
return(await IsRunning());
}
protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
base.OnActivityResult(requestCode, resultCode, data);
try
{
if (resultCode == Result.Ok)
{
ExposureNotification.OnActivityResult(requestCode, resultCode, data);
}
}
catch (Exception e)
{
_ = e.HandleExposureNotificationException(nameof(InfectionStatusActivity), nameof(OnActivityResult));
}
finally
{
_permissionUtils.OnActivityResult(requestCode, resultCode, data);
UpdateUI();
}
}
/*
* public async Task TestDownloadBatch()
* {
* long sinceEpochSeconds = new DateTimeOffset(DateTime.UtcNow.AddDays(-14)).ToUnixTimeSeconds();
* TemporaryExposureKeysResult tekResult = await httpDataService.GetTemporaryExposureKeys(sinceEpochSeconds);
* Console.WriteLine("Fetch Exposure Key");
*
* foreach (var keys in tekResult.Keys)
* {
* Console.WriteLine(keys.Url);
* }
*
* }
*
* public bool GetOptInStatus()
* {
* return userData.IsOptined;
* }
*/
/*
* public async Task SetOptinStatusAsync(bool flg)
* {
* userData.IsOptined = flg;
* await userDataService.SetAsync(userData);
* }
* public bool GetOptInStatus()
* {
* return userData.IsOptined;
* }
*
*
* public async Task SetExposureNotificationStatusAsync(bool flg)
* {
* userData.IsExposureNotificationEnabled = flg;
* await userDataService.SetAsync(userData);
* }
* public bool GetExposureNotificationStatus()
* {
* return userData.IsExposureNotificationEnabled;
* }
*
* public async Task SetNotificationStatusAsync(bool flg)
* {
* userData.IsNotificationEnabled = flg;
* await userDataService.SetAsync(userData);
* }
* public bool GetNotificationStatus()
* {
* return userData.IsNotificationEnabled;
* }
*/
public async Task <bool> StartExposureNotification()
{
if (!userData.IsOptined)
{
await UserDialogs.Instance.AlertAsync("利用規約に同意する必要があります。同意ページへ遷移します。");
await navigationService.NavigateAsync(nameof(PrivacyPolicyPage));
}
Status status = await ExposureNotification.GetStatusAsync();
if (status == Status.BluetoothOff
// || status == Status.Restricted
|| status == Status.NotAuthorized)
{
await UserDialogs.Instance.AlertAsync(GetStatusMessage(status));
userData.IsExposureNotificationEnabled = false;
await userDataService.SetAsync(userData);
return(false);
}
// bool IsEnabled = await ExposureNotification.IsEnabledAsync();
if (userData.IsOptined && userData.IsExposureNotificationEnabled && (status == Status.Unknown || status == Status.Active || status == Status.Disabled))
{
try
{
await ExposureNotification.StartAsync();
}
catch (Exception)
{
userData.IsExposureNotificationEnabled = false;
await userDataService.SetAsync(userData);
return(false);
}
}
return(true);
}
public async Task UploadSelfExposureKeysToServerAsync(IEnumerable <TemporaryExposureKey> tempKeys)
{
// Convert to ExposureKeyModel list as it is extended with DaysSinceOnsetOfSymptoms value
IEnumerable <ExposureKeyModel> temporaryExposureKeys = tempKeys?.Select(key => new ExposureKeyModel(key)) ?? new List <ExposureKeyModel>();
// There is a better behaviour of uploading keys when scanning is Stoped/Started (UIAlert for permission is always shown then),
// The IF-check just toggles the scanning status on/off or off/on to keep the scanning status
// the same as it was before method is called
try
{
if (ServiceLocator.Current.GetInstance <IDeviceInfo>().Platform == DevicePlatform.iOS)
{
if (await ExposureNotification.IsEnabledAsync())
{
await ExposureNotification.StopAsync();
await ExposureNotification.StartAsync();
}
else
{
await ExposureNotification.StartAsync();
await ExposureNotification.StopAsync();
}
}
}
catch (Exception e)
{
if (!e.HandleExposureNotificationException(nameof(ExposureNotificationHandler), nameof(UploadSelfExposureKeysToServerAsync)))
{
throw e;
}
}
if (FakeGatewayUtils.IsFakeGatewayTest)
{
FakeGatewayUtils.LastPulledExposureKeys = temporaryExposureKeys;
return;
}
if (AuthenticationState.PersonalData?.Access_token == null)
{
throw new AccessTokenMissingFromIDPortenException("The token from ID Porten is not set");
}
if (AuthenticationState.PersonalData?.VisitedCountries == null)
{
throw new VisitedCountriesMissingException(
"The visited countries list is missing. Possibly garbage collection removed it.");
}
if (!MiBaDate.HasValue)
{
throw new MiBaDateMissingException("The symptom onset date is not set from the calling view model");
}
DateTime MiBaDateAsUniversalTime = MiBaDate.Value.ToUniversalTime();
List <ExposureKeyModel> validKeys = UploadDiagnosisKeysHelper.CreateAValidListOfTemporaryExposureKeys(temporaryExposureKeys);
// Here all keys are extended with DaysSinceOnsetOfSymptoms value
validKeys = UploadDiagnosisKeysHelper.SetTransmissionRiskLevel(validKeys, MiBaDateAsUniversalTime);
bool success = await exposureNotificationWebService.PostSelfExposureKeys(validKeys);
if (!success)
{
throw new FailedToPushToServerException("Failed to push keys to the server");
}
}
public async Task <bool> StopExposureNotification()
{
await ExposureNotification.StopAsync();
return(true);
}
public static void InitExposureNotification()
{
UseMockExposureNotificationImplementationIfNeeded();
ExposureNotification.Init();
}
public async Task <bool> StartExposureNotification()
{
/*
* if (!userData.IsOptined)
* {
* await UserDialogs.Instance.AlertAsync("利用規約に同意する必要があります。同意ページへ遷移します。");
* await navigationService.NavigateAsync(nameof(PrivacyPolicyPage));
* }
*/
try
{
await ExposureNotification.StartAsync();
var count = 0;
while (true)
{
Thread.Sleep(1000);
await ExposureNotification.StartAsync();
Status status = await ExposureNotification.GetStatusAsync();
if (status == Status.Active)
{
return(true);
}
else if (status == Status.BluetoothOff)
{
await UserDialogs.Instance.AlertAsync(GetStatusMessage());
return(true);
}
else
{
if (count > 2)
{
throw new Exception();
}
count++;
}
}
}
catch (Exception)
{
userData.IsExposureNotificationEnabled = false;
await userDataService.SetAsync(userData);
return(false);
}
/*
* ExposureNotificationStatus = await ExposureNotification.GetStatusAsync();
* if (ExposureNotificationStatus == Status.BluetoothOff
* // || ExposureNotificationStatus == Status.Restricted
|| ExposureNotificationStatus == Status.NotAuthorized)
||{
|| await UserDialogs.Instance.AlertAsync(GetStatusMessage());
|| userData.IsExposureNotificationEnabled = false;
|| await userDataService.SetAsync(userData);
|| return false;
||}
||
||if (userData.IsOptined && userData.IsExposureNotificationEnabled && (ExposureNotificationStatus == Status.Unknown || ExposureNotificationStatus == Status.Active || ExposureNotificationStatus == Status.Disabled))
||{
|| try
|| {
|| await ExposureNotification.StartAsync();
||
|| }
|| catch (Exception)
|| {
|| userData.IsExposureNotificationEnabled = false;
|| await userDataService.SetAsync(userData);
|| return false;
|| }
||}
||return true;
*/
}
public async Task <bool> PermissionUnknown()
{
return(await ExposureNotification.GetStatusAsync() == Status.Unknown);
}
/// <summary>
/// Returns true if Status.Active || status == Status.Disabled || status == Status.Restricted.
/// Meaning that everything is ready for either starting or stopping the scanner.
/// </summary>
/// <returns></returns>
public async Task <bool> PoweredOn()
{
Status status = await ExposureNotification.GetStatusAsync();
return(status == Status.Active || status == Status.Disabled);
}
public async Task <bool> PoweredOff()
{
return(await ExposureNotification.GetStatusAsync() == Status.BluetoothOff);
}
public async Task <string> UpdateStatusMessageAsync()
{
this.ExposureNotificationStatus = await ExposureNotification.GetStatusAsync();
return(await GetStatusMessageAsync());
}
