//метод записи файла
private void WriteFile(DriveId folderBackUpId, string filename, IDriveApiDriveContentsResult content)
{
try
{
byte[] bytes = System.IO.File.ReadAllBytes(pathToDb);
string file = Convert.ToBase64String(bytes);
using (var writer = new OutputStreamWriter(content.DriveContents.OutputStream))
{
writer.Write(file);
writer.Close();
}
MetadataChangeSet changeSet = new MetadataChangeSet.Builder()
.SetTitle(filename)
.SetMimeType("application/octet-stream")
.Build();
IDriveFolder driveFolder = null;
//получаем папку по ID
driveFolder = driveFolder ?? folderBackUpId.AsDriveFolder();
//если папка не ноль то создаем файл
if (driveFolder != null)
{
var s = driveFolder.CreateFile(_googleApiClient, changeSet, content.DriveContents);
CreateAlertDialog("", successMessage);
}
}
catch (Exception er)
{
CreateAlertDialog("", errorMessage + er.Message);
}
}
private MetadataChangeSet GetChangeSet()
{
var fileName = GetFileName();
var changeSet = new MetadataChangeSet.Builder()
.SetTitle(fileName)
.Build();
return(changeSet);
}
private void WriteDriveFile(Stream stream, IDriveApiDriveContentsResult result)
{
//------ THIS IS AN EXAMPLE FOR PICTURE ------
//ByteArrayOutputStream bitmapStream = new ByteArrayOutputStream();
//image.compress(Bitmap.CompressFormat.PNG, 100, bitmapStream);
//try {
// outputStream.write(bitmapStream.toByteArray());
//} catch (IOException e1) {
// Log.i(TAG, "Unable to write file contents.");
//}
//// Create the initial metadata - MIME type and title.
//// Note that the user will be able to change the title later.
//MetadataChangeSet metadataChangeSet = new MetadataChangeSet.Builder()
// .setMimeType("image/jpeg").setTitle("Android Photo.png").build();
//------ THIS IS AN EXAMPLE FOR FILE --------
var path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
var filename = Path.Combine(path, Constants.BackupFileName);
using (var streamWriter = new StreamWriter(filename, true))
{
var json = JsonConvert.SerializeObject(DebtsManager.CurrentDebts);
streamWriter.WriteLine(json);
}
var message = String.Format(Utils.GetStringFromResource(Resource.String.upload), Utils.GetStringFromResource(Resource.String.app_name));
Utils.ShowToast(message);
var theFile = new Java.IO.File(filename); //>>>>>> WHAT FILE ?
try
{
var fileInputStream = new FileInputStream(theFile);
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fileInputStream.Read(buffer)) != -1)
{
stream.Write(buffer, 0, bytesRead);
}
}
catch (Java.IO.IOException e1)
{
Debug.WriteLine("U AR A MORON! Unable to write file contents.", e1);
}
MetadataChangeSet changeSet = new MetadataChangeSet.Builder().SetTitle(theFile.Name).SetMimeType("text/plain").SetStarred(false).Build();
var folder = _driveId.AsDriveFolder();
folder.CreateFile(_googleApiClient, changeSet, result.DriveContents)
.SetResultCallback(this);
ClearDirectory(path);
}
//создаем папку в Google
private void CreateFolder(string folderName)
{
try
{
MetadataChangeSet changeSet = new MetadataChangeSet.Builder()
.SetTitle(folderName)
.SetMimeType(DriveFolder.MimeType)
.SetStarred(true)
.Build();
var result = DriveClass.DriveApi.GetRootFolder(_googleApiClient).CreateFolder(_googleApiClient, changeSet);
}
catch (Exception er)
{
Log.Logger.Error(er.Message, er.StackTrace);
}
}
public void Upload(string currentWorkingName, MemoryStream currentWorkingStream)
{
Task.Run(delegate
{
var result = DriveClass.DriveApi.NewDriveContents(client).Await().JavaCast <IDriveApiDriveContentsResult>();
var metaBuilder = new MetadataChangeSet.Builder();
metaBuilder.SetMimeType(Type_Zip);
metaBuilder.SetTitle(currentWorkingName);
byte[] bytes = currentWorkingStream.ToByteArray();
result.DriveContents.OutputStream.Write(bytes, 0, bytes.Length);
DriveClass.DriveApi.GetRootFolder(client).CreateFile(client, metaBuilder.Build(), result.DriveContents);
if (UploadComplete != null)
{
UploadComplete(currentWorkingName, EventArgs.Empty);
}
});
}
private async Task <bool> CreateFileAsync()
{
this.logger.Debug("Creating file.");
var result = await DriveClass
.DriveApi
.NewDriveContentsAsync(this.client);
if (!result.Status.IsSuccess)
{
this.logger.Error("Failed to create drive contents. Status code: {0}. Status message: {1}.", result.Status.StatusCode, result.Status.StatusMessage);
return(false);
}
using (var streamWriter = new StreamWriter(result.DriveContents.OutputStream))
{
await streamWriter.WriteAsync(GetDefaultExerciseDocument());
}
var changeSet = new MetadataChangeSet.Builder()
.SetTitle(documentFilename)
.SetMimeType("text/plain")
.Build();
var createResult = await DriveClass
.DriveApi
.GetRootFolder(this.client)
.CreateFile(this.client, changeSet, result.DriveContents);
if (!createResult.Status.IsSuccess)
{
this.logger.Error("Failed to create file. Status code: {0}. Status message: {1}.", result.Status.StatusCode, result.Status.StatusMessage);
return(false);
}
return(true);
}
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();
}
void CheckIDriveApiMetadataBufferResult(Java.Lang.Object result)
{
try
{
var res = result.JavaCast <IDriveApiMetadataBufferResult>();
if (res != null)
{
if (!res.Status.IsSuccess)
{
Debug.WriteLine("Cannot create folder in the root.");
}
else
{
bool isFound = false;
bool readFileExists = false;
foreach (var m in res.MetadataBuffer)
{
if (m.Title.Equals(FolderName) && _driveAction == DriveAction.Write)
{
Debug.WriteLine("Folder exists");
var driveId = m.DriveId;
if (res.MetadataBuffer.Count > 0)
{
var folder = driveId.AsDriveFolder();
folder.Delete(_googleApiClient);
}
else
{
isFound = true;
CreateFileInFolder(driveId);
}
break;
}
if (m.Title.Equals(Constants.BackupFileName) && !m.IsTrashed)
{
Debug.WriteLine("file exists");
readFileExists = true;
var file = m.DriveId.AsDriveFile();
file.Open(_googleApiClient, DriveFile.ModeReadOnly, null).SetResultCallback(this);
}
}
if (_driveAction == DriveAction.Read && !readFileExists)
{
Utils.ShowNothigToRead(Relogin);
return;
}
if (_driveAction == DriveAction.Write && !isFound)
{
Debug.WriteLine("Folder not found; creating it.");
MetadataChangeSet changeSet = new MetadataChangeSet.Builder().SetTitle(FolderName).Build();
DriveClass.DriveApi.GetRootFolder(_googleApiClient)
.CreateFolder(_googleApiClient, changeSet)
.SetResultCallback(this);
}
}
}
}
catch (Exception e)
{
Debug.WriteLine("miscast 2", e);
}
}
private async Task<bool> CreateFileAsync()
{
this.logger.Debug("Creating file.");
var result = await DriveClass
.DriveApi
.NewDriveContentsAsync(this.client);
if (!result.Status.IsSuccess)
{
this.logger.Error("Failed to create drive contents. Status code: {0}. Status message: {1}.", result.Status.StatusCode, result.Status.StatusMessage);
return false;
}
using (var streamWriter = new StreamWriter(result.DriveContents.OutputStream))
{
await streamWriter.WriteAsync(GetDefaultExerciseDocument());
}
var changeSet = new MetadataChangeSet.Builder()
.SetTitle(documentFilename)
.SetMimeType("text/plain")
.Build();
var createResult = await DriveClass
.DriveApi
.GetRootFolder(this.client)
.CreateFile(this.client, changeSet, result.DriveContents);
if (!createResult.Status.IsSuccess)
{
this.logger.Error("Failed to create file. Status code: {0}. Status message: {1}.", result.Status.StatusCode, result.Status.StatusMessage);
return false;
}
return true;
}
public override async Task<bool> SaveFileToDriveAppFolderAsync(string title, string contentType, Stream contentStream)
{
IDriveApiDriveContentsResult driveContentsResult = await DriveClass.DriveApi
.NewDriveContentsAsync(_googleClientApi).ConfigureAwait(false);
if(!driveContentsResult.Status.IsSuccess) {
Logger.Error($"{_activity.GetType()} Failed to get drive contents for new appfolder file: {driveContentsResult.Status.StatusMessage}");
return false;
}
IDriveContents driveContents = driveContentsResult.DriveContents;
await contentStream.CopyToAsync(driveContents.OutputStream);
MetadataChangeSet changeSet = new MetadataChangeSet.Builder()
.SetTitle(title)
.SetMimeType(contentType)
.Build();
IDriveFolderDriveFileResult driveFileResult = await DriveClass.DriveApi
.GetAppFolder(_googleClientApi)
.CreateFileAsync(_googleClientApi, changeSet, driveContents).ConfigureAwait(false);
if(!driveFileResult.Status.IsSuccess) {
Logger.Error($"{_activity.GetType()} Failed to create new appfolder file: {driveFileResult.Status.StatusMessage}");
return false;
}
return true;
}
