Esempio n. 1
0
        //поиск папки для backup
        private async Task <DriveId> FindItems(string folderName)
        {
            DriveId folderId = null;

            try
            {
                //установим запрос поиска
                IDriveFolder appFolder = DriveClass.DriveApi.GetRootFolder(_googleApiClient);
                var          query     = new QueryClass
                                         .Builder().AddFilter(Filters.And(
                                                                  Filters.Eq(SearchableField.Title, folderName),
                                                                  Filters.Eq(SearchableField.Trashed, false))).Build();
                var queryResult = await appFolder.QueryChildrenAsync(_googleApiClient, query);

                foreach (var driveItem in queryResult.MetadataBuffer)
                {
                    if (driveItem.IsFolder && driveItem.Title == folderName)
                    {
                        folderId = driveItem.DriveId;
                    }
                }
                return(folderId);
            }
            catch (Exception er)
            {
                Log.Logger.Error(er.Message, er.StackTrace);
                return(folderId);
            }
        }
Esempio n. 2
0
        private void ReadFileFromDrive()
        {
            var query = new QueryClass.Builder()
                        .AddFilter(Filters.Contains(SearchableField.Title, Constants.BackupFileName)).Build();

            DriveClass.DriveApi.Query(_googleApiClient, query)
            .SetResultCallback(this);
        }
Esempio n. 3
0
        private void CheckFolderExists()
        {
            var query =
                new QueryClass.Builder().AddFilter(Filters.And(Filters.Eq(SearchableField.Title, FolderName), Filters.Eq(SearchableField.Trashed, false)))
                .Build();

            DriveClass.DriveApi.Query(_googleApiClient, query).SetResultCallback(this);
        }
Esempio n. 4
0
        // https://stackoverflow.com/questions/45725225/how-to-query-an-idriveresource-in-google-drive-for-xamarin-android-using-the-dri
        private async Task <BackupMetadata> GetMetadataFromDrive(int retry = 6)
        {
            try
            {
                var fileName = GetFileName();
                var folder   = GetFolder();

                var query = new QueryClass.Builder()
                            .AddFilter(Filters.Contains(SearchableField.Title, fileName))
                            .Build();

                using (var queryResult = await folder.QueryChildrenAsync(_googleApiClient, query))
                {
                    if (queryResult?.MetadataBuffer == null)
                    {
                        Thread.Sleep(150);
                        return(retry > 0 ? await GetMetadataFromDrive(--retry) : new BackupMetadata());
                    }

                    if (queryResult.MetadataBuffer.Count > 1)
                    {
                        //LogEvent(nameof(GetMetadataFromDrive), new System.Exception($"Warning: {queryResult.MetadataBuffer.Count} backup files found."));
                    }

                    var result = queryResult
                                 .MetadataBuffer
                                 .Select(x => x as Metadata)
                                 .Where(x => x != null)
                                 .Select(x => new BackupMetadata(x))
                                 .Where(x => x != null)
                                 .Where(x => x.HasValue)
                                 .OrderByDescending(x => x.LastBackup)
                                 .FirstOrDefault();

                    if (result == null)
                    {
                        Thread.Sleep(150);
                        return(retry > 0 ? await GetMetadataFromDrive(--retry) : new BackupMetadata());
                    }

                    return(result);
                }
            }
            catch (System.Exception ex)
            {
                //LogEvent(nameof(GetMetadataFromDrive), ex);
            }

            return(null);
        }
        private async Task <IDriveFile> GetFileAsync()
        {
            var rootFolder = DriveClass
                             .DriveApi
                             .GetRootFolder(this.client);
            var query = new QueryClass.Builder()
                        .AddFilter(Filters.Eq(SearchableField.Title, documentFilename))
                        .Build();

            var result = await rootFolder.QueryChildrenAsync(this.client, query);

            if (!result.Status.IsSuccess || result.MetadataBuffer.Count == 0)
            {
                this.logger.Warn("Failed to find existing exercise document.");
                return(null);
            }

            var fileMetadata = result.MetadataBuffer.First();
            var file         = DriveClass
                               .DriveApi
                               .GetFile(this.client, fileMetadata.DriveId);

            return(file);
        }
        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);

            // Set our view from the "main" layout resource
            SetContentView(Resource.Layout.Main);

            buttonCreate     = FindViewById <Button> (Resource.Id.buttonCreate);
            buttonSearch     = FindViewById <Button> (Resource.Id.buttonSearch);
            editTextFilename = FindViewById <EditText> (Resource.Id.editTextFilename);
            listViewResults  = FindViewById <ListView> (Resource.Id.listViewResults);

            buttonCreate.Click += async delegate {
                // Create the new file info
                var metadataChangeSet = new MetadataChangeSet.Builder()
                                        .SetMimeType("text/plain")
                                        .SetTitle(editTextFilename.Text)
                                        .Build();

                // Get our root folder
                var rootFolder = DriveClass.DriveApi.GetRootFolder(googleApiClient);

                // Create a blank file
                await rootFolder.CreateFile(googleApiClient, metadataChangeSet, null).AsAsync <IDriveFolderDriveFileResult> ();
            };

            buttonSearch.Click += async delegate {
                buttonSearch.Enabled = false;

                // Build a query to search for files of
                // This will only return files that you created/opened through this app
                var query = new QueryClass.Builder()
                            .AddFilter(Filters.Contains(SearchableField.Title, editTextFilename.Text))
                            .Build();

                // Execute search asynchronously
                var results = await DriveClass.DriveApi.Query(googleApiClient, query).AsAsync <IDriveApiMetadataBufferResult> ();

                // Check for a successful result
                if (results.Status.IsSuccess)
                {
                    var files = new List <Metadata> ();

                    // Loop through the results
                    for (var i = 0; i < results.MetadataBuffer.Count; i++)
                    {
                        files.Add(results.MetadataBuffer.Get(i).JavaCast <Metadata> ());
                    }

                    listViewResults.Adapter = new ArrayAdapter <string> (
                        this,
                        Android.Resource.Layout.SimpleListItem1,
                        Android.Resource.Id.Text1,
                        (from f in files select f.Title).ToArray());

                    if (files.Count <= 0)
                    {
                        Toast.MakeText(this, "No results found!", ToastLength.Short).Show();
                    }
                }

                buttonSearch.Enabled = true;
            };

            buttonCreate.Enabled = false;
            buttonSearch.Enabled = false;

            googleApiClient = new GoogleApiClient.Builder(this)
                              .AddApi(DriveClass.API)
                              .AddScope(DriveClass.ScopeFile)
                              .AddScope(DriveClass.ScopeAppfolder)
                              .UseDefaultAccount()
                              .AddConnectionCallbacks(this)
                              .AddOnConnectionFailedListener(this)
                              .Build();
        }
        private async Task<IDriveFile> GetFileAsync()
        {
            var rootFolder = DriveClass
                .DriveApi
                .GetRootFolder(this.client);
            var query = new QueryClass.Builder()
                .AddFilter(Filters.Eq(SearchableField.Title, documentFilename))
                .Build();
                
            var result = await rootFolder.QueryChildrenAsync(this.client, query);

            if (!result.Status.IsSuccess || result.MetadataBuffer.Count == 0)
            {
                this.logger.Warn("Failed to find existing exercise document.");
                return null;
            }

            var fileMetadata = result.MetadataBuffer.First();
            var file = DriveClass
                .DriveApi
                .GetFile(this.client, fileMetadata.DriveId);

            return file;
        }
// https://www.youtube.com/watch?v=UiTHG_yl-jA
// https://github.com/athingunique/Drive-Database-Sync
// https://developers.google.com/drive/android/appfolder

        // https://developers.google.com/drive/android/queries
        private async Task<Metadata> QueryFileInDriveAppFolderAsync(string title)
        {
            QueryClass query = new QueryClass.Builder()
                .AddFilter(Filters.Eq(SearchableField.Title, title))
                .Build();

            IDriveApiMetadataBufferResult metadataBufferResult = await DriveClass.DriveApi
                .GetAppFolder(_googleClientApi)
                .QueryChildrenAsync(_googleClientApi, query).ConfigureAwait(false);
            if(!metadataBufferResult.Status.IsSuccess) {
                Logger.Error($"{_activity.GetType()} Failed to query drive file: {metadataBufferResult.Status.StatusMessage}");
                return null;
            }

            return metadataBufferResult.MetadataBuffer.Count < 1 ? null : metadataBufferResult.MetadataBuffer.ElementAt(0);
        }