public void RestricsAccessForApiDeprecatedException()
{
ErrorHandlingService.TryHandleDeprecationError(exception);
AccessRestrictionStorage.Received().SetApiOutdated();
}
public void RestrictsAccessForNoWorkspaceException()
{
ErrorHandlingService.TryHandleNoDefaultWorkspaceError(new NoDefaultWorkspaceException());
AccessRestrictionStorage.Received().SetNoDefaultWorkspaceStateReached(true);
}
public void ReturnsTrueForApiDeprecatedException()
{
var result = ErrorHandlingService.TryHandleDeprecationError(exception);
result.Should().BeTrue();
}
public void DoesNotNavigateForDifferentExceptions()
{
ErrorHandlingService.TryHandleUnauthorizedError(exception);
NavigationService.DidNotReceive().Navigate <TokenResetViewModel>();
}
public void ReturnsTrueForNoWorkspaceException()
{
var result = ErrorHandlingService.TryHandleNoDefaultWorkspaceError(new NoDefaultWorkspaceException());
result.Should().BeTrue();
}
public void NavigatesToOutdatedAppViewModelForClientDeprecatedException()
{
ErrorHandlingService.TryHandleUnauthorizedError(exception);
NavigationService.Received().Navigate <TokenResetViewModel>();
}
public void DoesNotRestrictAccessForDifferentExceptions()
{
ErrorHandlingService.TryHandleUnauthorizedError(exception);
AccessRestrictionStorage.DidNotReceive().SetUnauthorizedAccess(Arg.Any <string>());
}
public void RestricsAccessForClientDeprecatedException()
{
ErrorHandlingService.TryHandleUnauthorizedError(exception);
AccessRestrictionStorage.Received().SetUnauthorizedAccess(Arg.Is(User.ApiToken));
}
public void ReturnsTrueForClientDeprecatedException()
{
var result = ErrorHandlingService.TryHandleUnauthorizedError(exception);
result.Should().BeTrue();
}
public void DoesNotNavigateForDifferentExceptions()
{
ErrorHandlingService.TryHandleDeprecationError(exception);
NavigationService.DidNotReceive().Navigate <OutdatedAppViewModel>();
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
_deferral = taskInstance.GetDeferral();
// Set the API to use depending on the settings
SdkService.MegaSdk.changeApiUrl(SettingsService.LoadSetting(
ResourceService.SettingsResources.GetString("SR_UseStagingServer"), false) ?
"https://staging.api.mega.co.nz/" : "https://g.api.mega.co.nz/");
// Load the connection upload settings
CameraUploadsConnectionType cameraUploadsConnectionType = CameraUploadsConnectionType.EthernetWifiOnly;
try
{
cameraUploadsConnectionType = (CameraUploadsConnectionType)await SettingsService.LoadSettingFromFileAsync <int>("CameraUploadsSettingsHowKey");
}
catch (Exception e)
{
LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "Could not load settings", e);
}
if (!CheckNetWork(cameraUploadsConnectionType))
{
_deferral.Complete();
return;
}
SdkService.InitializeSdkParams();
var loggedIn = await LoginAsync();
if (loggedIn)
{
var fetched = await FetchNodesAsync();
if (fetched)
{
// Enable the transfers resumption for the Camera Uploads service
SdkService.MegaSdk.enableTransferResumption();
var megaGlobalListener = new MegaGlobalListener();
SdkService.MegaSdk.addGlobalListener(megaGlobalListener);
await megaGlobalListener.ExecuteAsync(() => SdkService.MegaSdk.enableTransferResumption());
var cameraUploadRootNode = await SdkService.GetCameraUploadRootNodeAsync();
if (cameraUploadRootNode == null)
{
// No camera upload node found or created
// Just finish this run and try again next time
LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "No Camera Uploads folder detected/created");
_deferral.Complete();
return;
}
// Load the file upload settings
CameraUploadsFileType cameraUploadsFileType = CameraUploadsFileType.PhotoAndVideo;
try
{
cameraUploadsFileType = (CameraUploadsFileType)await SettingsService.LoadSettingFromFileAsync <int>("CameraUploadsSettingsFileKey");
}
catch (Exception e)
{
LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "Could not load settings", e);
}
var uploadFolders = new List <StorageFolder>();
switch (cameraUploadsFileType)
{
case CameraUploadsFileType.PhotoAndVideo:
uploadFolders.Add(KnownFolders.PicturesLibrary);
uploadFolders.Add(KnownFolders.VideosLibrary);
break;
case CameraUploadsFileType.PhotoOnly:
uploadFolders.Add(KnownFolders.PicturesLibrary);
break;
case CameraUploadsFileType.VideoOnly:
uploadFolders.Add(KnownFolders.VideosLibrary);
break;
}
// Get the IMAGE and/or VIDEO files to upload to MEGA
var fileToUpload = await TaskService.GetAvailableUploadAsync(
TaskService.ImageDateSetting, uploadFolders.ToArray());
foreach (var storageFile in fileToUpload)
{
// Skip the current file if it has failed more than the max error count
if (await ErrorHandlingService.SkipFileAsync(
storageFile.Name,
ErrorHandlingService.ImageErrorFileSetting,
ErrorHandlingService.ImageErrorCountSetting))
{
continue;
}
if (!CheckNetWork(cameraUploadsConnectionType))
{
break;
}
// Calculate time for fingerprint check and upload
ulong mtime = TaskService.CalculateMtime(storageFile.DateCreated.DateTime);
try
{
using (var fs = await storageFile.OpenStreamForReadAsync())
{
var isUploaded = SdkService.IsAlreadyUploaded(storageFile, fs, cameraUploadRootNode, mtime);
if (isUploaded)
{
await TaskService.SaveLastUploadDateAsync(storageFile, TaskService.ImageDateSetting);
continue;
}
await SdkService.UploadAsync(storageFile, fs, cameraUploadRootNode, mtime);
// No error, clear error storage
await ErrorHandlingService.ClearAsync(ErrorHandlingService.ImageErrorFileSetting,
ErrorHandlingService.ImageErrorCountSetting);
}
}
catch (OutOfMemoryException e)
{
// Something went wrong (could be memory limit)
// Just finish this run and try again next time
LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "Out of memory while uploading", e);
break;
}
catch (Exception e)
{
LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "Error uploading item", e);
await ErrorHandlingService.SetFileErrorAsync(storageFile.Name,
ErrorHandlingService.ImageErrorFileSetting, ErrorHandlingService.ImageErrorCountSetting);
}
}
}
else
{
LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "Failed to fetch nodes");
}
}
else
{
LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "Failed to login");
}
_deferral.Complete();
}
protected override void InitializeApp(IMvxPluginManager pluginManager, IMvxApplication app)
{
const string clientName = "Giskard";
var packageInfo = ApplicationContext.PackageManager.GetPackageInfo(ApplicationContext.PackageName, 0);
var version = packageInfo.VersionName;
var sharedPreferences = ApplicationContext.GetSharedPreferences(clientName, FileCreationMode.Private);
var database = new Database();
var scheduler = Scheduler.Default;
var timeService = new TimeService(scheduler);
var backgroundService = new BackgroundService(timeService, analyticsService);
var suggestionProviderContainer = new SuggestionProviderContainer(
new MostUsedTimeEntrySuggestionProvider(database, timeService, maxNumberOfSuggestions)
);
var appVersion = Version.Parse(version);
var userAgent = new UserAgent(clientName, version);
var dialogService = new DialogServiceAndroid();
var platformInfo = new PlatformInfoAndroid();
var keyValueStorage = new SharedPreferencesStorageAndroid(sharedPreferences);
var settingsStorage = new SettingsStorage(appVersion, keyValueStorage);
var schedulerProvider = new AndroidSchedulerProvider();
var permissionsService = new PermissionsServiceAndroid();
var calendarService = new CalendarServiceAndroid(permissionsService);
var automaticSyncingService = new AutomaticSyncingService(backgroundService, timeService, analyticsService);
var errorHandlingService = new ErrorHandlingService(navigationService, settingsStorage);
ApplicationContext.RegisterReceiver(new TimezoneChangedBroadcastReceiver(timeService),
new IntentFilter(Intent.ActionTimezoneChanged));
var foundation =
TogglFoundation
.ForClient(userAgent, appVersion)
.WithDatabase(database)
.WithScheduler(scheduler)
.WithTimeService(timeService)
.WithApiEnvironment(environment)
.WithGoogleService <GoogleServiceAndroid>()
.WithRatingService(new RatingServiceAndroid(ApplicationContext))
.WithLicenseProvider <LicenseProviderAndroid>()
.WithAnalyticsService(analyticsService)
.WithSchedulerProvider(schedulerProvider)
.WithPlatformInfo(platformInfo)
.WithNotificationService <NotificationServiceAndroid>()
.WithRemoteConfigService <RemoteConfigServiceAndroid>()
.WithApiFactory(new ApiFactory(environment, userAgent))
.WithBackgroundService(backgroundService)
.WithAutomaticSyncingService(automaticSyncingService)
.WithSuggestionProviderContainer(suggestionProviderContainer)
.WithApplicationShortcutCreator(new ApplicationShortcutCreator(ApplicationContext))
.WithStopwatchProvider <FirebaseStopwatchProviderAndroid>()
.WithIntentDonationService(new NoopIntentDonationServiceAndroid())
.WithPrivateSharedStorageService(new NoopPrivateSharedStorageServiceAndroid())
.WithBackgroundSyncService <BackgroundSyncServiceAndroid>()
.StartRegisteringPlatformServices()
.WithDialogService(dialogService)
.WithLastTimeUsageStorage(settingsStorage)
.WithBrowserService <BrowserServiceAndroid>()
.WithCalendarService(calendarService)
.WithKeyValueStorage(keyValueStorage)
.WithUserPreferences(settingsStorage)
.WithOnboardingStorage(settingsStorage)
.WithNavigationService(navigationService)
.WithPermissionsService(permissionsService)
.WithAccessRestrictionStorage(settingsStorage)
.WithErrorHandlingService(errorHandlingService)
.WithSyncErrorHandlingService(new SyncErrorHandlingService(errorHandlingService))
.WithRxActionFactory(new RxActionFactory(schedulerProvider))
.Build();
foundation.RevokeNewUserIfNeeded().Initialize();
ensureDataSourceInitializationIfLoggedIn();
createApplicationLifecycleObserver(backgroundService);
base.InitializeApp(pluginManager, app);
}
