protected override void OnActivityResult(int requestCode, Result resultCode,
Intent resultData)
{
if (resultCode == Result.Ok)
{
// The document selected by the user won't be returned in the intent.
// Instead, a URI to that document will be contained in the return intent
// provided to this method as a parameter.
// Pull that URI using resultData.getData().
Uri uri = null;
if (resultData != null)
{
uri = resultData.Data;
ParcelFileDescriptor parcelFileDescriptor =
ContentResolver.OpenFileDescriptor(uri, "r");
FileDescriptor fileDescriptor = parcelFileDescriptor.FileDescriptor;
Bitmap image = BitmapFactory.DecodeFileDescriptor(fileDescriptor);
parcelFileDescriptor.Close();
var store = IsolatedStorageFile.GetUserStoreForApplication();
if (store.FileExists(Path))
{
store.DeleteFile(Path);
}
var fs = store.CreateFile(Path);
MemoryStream buffer = new MemoryStream();
image.Compress(Bitmap.CompressFormat.Png, 100, buffer);
buffer.Seek(0, SeekOrigin.Begin);
byte[] bytes = new byte[(int)buffer.Length];
buffer.Read(bytes, 0, (int)buffer.Length);
fs.Write(bytes, 0, bytes.Length);
fs.Close();
Texture2D text = null;
var file2 = store.OpenFile(Path, FileMode.Open);
text = Texture2D.FromStream(Game1.self.GraphicsDevice, file2);
file2.Close();
file2.Dispose();
Game1.self.config.listOfCards.Single(p => p.Name == Path).SkinPath = Path;
Game1.self.ShipsSkins.Single(p => p.ship == Path).skin = Game1.self.loadTexture2D(Path);
var file = store.OpenFile("Config_Cards", FileMode.Open);
TextWriter writer = new StreamWriter(file);
XmlSerializer xml = new XmlSerializer(typeof(Cards));
xml.Serialize(writer, Game1.self.config);
writer.Close();
file.Close();
store.Close();
}
}
}
public static void GetMetadataFromContentURI(this Android.Net.Uri uri, ContentResolver contentResolver, out long size, out string fileName)
{
using (var fd = contentResolver.OpenFileDescriptor(uri, "r"))
size = fd.StatSize;
using (var cursor = contentResolver.Query(uri, new string[] {
Android.Provider.OpenableColumns.DisplayName
}, null, null, null))
{
cursor.MoveToFirst();
fileName = GetFixedFileName(cursor.GetString(0), contentResolver.GetType(uri));
}
}
/// <summary>
/// Return file path for specified uri using CacheDir
/// </summary>
/// <param name="context">Current context</param>
/// <param name="uri">Specified uri</param>
/// <returns>Drive File absolute path</returns>
private static string GetDriveFileAbsolutePath(Context context, global::Android.Net.Uri uri)
{
ICursor cursor = null;
FileInputStream input = null;
FileOutputStream output = null;
try
{
cursor = context.ContentResolver.Query(uri, new string[] { OpenableColumns.DisplayName }, null, null, null);
if (cursor != null && cursor.MoveToFirst())
{
int column_index = cursor.GetColumnIndexOrThrow(OpenableColumns.DisplayName);
var fileName = cursor.GetString(column_index);
if (uri == null)
{
return(null);
}
ContentResolver resolver = context.ContentResolver;
string outputFilePath = new Java.IO.File(context.CacheDir, fileName).AbsolutePath;
ParcelFileDescriptor pfd = resolver.OpenFileDescriptor(uri, "r");
FileDescriptor fd = pfd.FileDescriptor;
input = new FileInputStream(fd);
output = new FileOutputStream(outputFilePath);
int read = 0;
byte[] bytes = new byte[4096];
while ((read = input.Read(bytes)) != -1)
{
output.Write(bytes, 0, read);
}
return(new Java.IO.File(outputFilePath).AbsolutePath);
}
}
catch (Java.IO.IOException ignored)
{
// nothing we can do
}
finally
{
if (cursor != null)
{
cursor.Close();
}
input.Close();
output.Close();
}
return(string.Empty);
}
private async Task CreateCopy(Uri sourceUri, Uri destinationUri)
{
using (var source = new FileInputStream(ContentResolver.OpenFileDescriptor(sourceUri, "r").FileDescriptor))
{
using (var destination = new FileOutputStream(ContentResolver.OpenFileDescriptor(destinationUri, "w").FileDescriptor))
{
byte[] content = new byte[source.Available()];
await source.ReadAsync(content);
await destination.WriteAsync(content);
destination.Close();
}
}
}
private Payload CreatePayload(Uri uri)
{
try
{
using (var fd = ContentResolver.OpenFileDescriptor(uri, "r"))
this.max = fd.StatSize;
var inputStream = ContentResolver.OpenInputStream(uri);
return(Payload.FromStream(inputStream));
}
catch (System.Exception e)
{
Log("Cannot read file: " + e.Message);
return(null);
}
}
private string Compress(string path)
{
var photoUri = Android.Net.Uri.Parse(path);
FileDescriptor fileDescriptor = null;
Bitmap btmp = null;
System.IO.FileStream stream = null;
try
{
fileDescriptor = ContentResolver.OpenFileDescriptor(photoUri, "r").FileDescriptor;
btmp = BitmapUtils.DecodeSampledBitmapFromDescriptor(fileDescriptor, 1600, 1600);
btmp = BitmapUtils.RotateImageIfRequired(btmp, fileDescriptor, path);
var directoryPictures = Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryPictures);
var directory = new Java.IO.File(directoryPictures, Constants.Steepshot);
if (!directory.Exists())
{
directory.Mkdirs();
}
path = $"{directory}/{Guid.NewGuid()}.jpeg";
stream = new System.IO.FileStream(path, System.IO.FileMode.Create);
btmp.Compress(Bitmap.CompressFormat.Jpeg, 100, stream);
return(path);
}
catch (Exception ex)
{
_postButton.Enabled = false;
this.ShowAlert(Localization.Errors.UnknownCriticalError);
AppSettings.Reporter.SendCrash(ex);
}
finally
{
fileDescriptor?.Dispose();
btmp?.Recycle();
btmp?.Dispose();
stream?.Dispose();
}
return(path);
}
/// <summary>
/// Loads a <see cref="Bitmap"/> from the provided <see cref="Android.Net.Uri"/> using the provided <see cref="ContentResolver"/>.
/// </summary>
/// <param name="contentResolver">A <see cref="ContentResolver"/> to use to load the image.</param>
/// <param name="uri">A <see cref="Android.Net.Uri"/> that identifies the image.</param>
/// <param name="reqWidth">The requested width for the loaded <see cref="Bitmap"/>. The actual width after the bitmap is loaded may be larger, but will not be smaller.</param>
/// <param name="reqHeight">The requested height for the loaded <see cref="Bitmap"/>. The actual height after the bitmap is loaded may be larger, but will not be smaller.</param>
/// <returns></returns>
public static Bitmap GetBitmapFromUri(ContentResolver contentResolver, AndroidUri uri, int reqWidth, int reqHeight)
{
ParcelFileDescriptor parcelFileDescriptor = contentResolver.OpenFileDescriptor(uri, "r");
FileDescriptor fileDescriptor = parcelFileDescriptor.FileDescriptor;
// Load just the dimensions of the image (doesn't actually allocate memory for the bitmap)
BitmapFactory.Options options = new BitmapFactory.Options();
options.InJustDecodeBounds = true;
BitmapFactory.DecodeFileDescriptor(fileDescriptor, null, options);
// Calculate inSampleSize so we can subsample the image appropriately.
options.InSampleSize = CalculateInSampleSize(options.OutWidth, options.OutHeight, reqWidth, reqHeight);
// Load the image into a Bitmap at the determined subsampling
options.InJustDecodeBounds = false;
Bitmap image = BitmapFactory.DecodeFileDescriptor(fileDescriptor, null, options);
parcelFileDescriptor.Close();
return(image);
}
protected async override void OnActivityResult(int requestCode, [GeneratedEnum] Result resultCode, Intent data)
{
base.OnActivityResult(requestCode, resultCode, data);
if (resultCode == Result.Canceled && requestCode == 43)
{
// Notify user file picking was cancelled.
OnDirectoryPickCancelled();
Finish();
}
else
{
System.Diagnostics.Debug.Write(data.Data);
try {
// read the file out of the cache dir
var file = new Java.IO.File(filePath);
var fileLength = (int)file.Length();
byte[] fileBytes = new byte[fileLength];
using (var inputStream = new FileInputStream(filePath))
{
await inputStream.ReadAsync(fileBytes, 0, fileLength);
}
// write the file to the path chosen by the user
using (var pFD = ContentResolver.OpenFileDescriptor(data.Data, "w"))
using (var outputSteam = new FileOutputStream(pFD.FileDescriptor))
{
outputSteam.Write(fileBytes);
}
OnDirectoryPicked(new SavePickerEventArgs(data.Data));
} catch (Exception readEx) {
// Notify user file picking failed.
OnDirectoryPickError(readEx.Message);
System.Diagnostics.Debug.Write(readEx);
} finally {
Finish();
}
}
}
private Bitmap GetBitmapFromUri(AndroidUri uri)
{
using (var parcelFileDescriptor = ContentResolver.OpenFileDescriptor(uri, "r")) {
return(BitmapFactory.DecodeFileDescriptor(parcelFileDescriptor.FileDescriptor));
}
}
/// <summary>
/// Decode image from imageUri, and resize according to the expectedMaxImageSideLength
/// If expectedMaxImageSideLength is
/// (1) less than or equal to 0,
/// (2) more than the actual max size length of the bitmap
/// then return the original bitmap
/// Else, return the scaled bitmap
/// </summary>
/// <returns>The size limited bitmap from URI.</returns>
/// <param name="contentResolver">Content resolver.</param>
/// <param name="imageUri">Image URI.</param>
/// <param name="maxImageSideLength">The maximum side length of the image to detect, to keep the size of image less than 4MB. Resize the image if its side length is larger than the maximum.</param>
public static Bitmap LoadSizeLimitedBitmapFromUri(this ContentResolver contentResolver, global::Android.Net.Uri imageUri, int maxImageSideLength = 1280)
{
try
{
var outPadding = new Rect();
int maxSideLength = 0;
// For saving memory, only decode the image meta and get the side length.
var options = new BitmapFactory.Options
{
InJustDecodeBounds = true
};
using (var fileDescriptor = contentResolver.OpenFileDescriptor(imageUri, "r"))
{
using (BitmapFactory.DecodeFileDescriptor(fileDescriptor.FileDescriptor, outPadding, options))
{
// Calculate shrink rate when loading the image into memory.
maxSideLength = options.OutWidth > options.OutHeight ? options.OutWidth : options.OutHeight;
options.InSampleSize = 1;
options.InSampleSize = calculateSampleSize(maxSideLength, maxImageSideLength);
options.InJustDecodeBounds = false;
}
// Load the bitmap and resize it to the expected size length
var bitmap = BitmapFactory.DecodeFileDescriptor(fileDescriptor.FileDescriptor, outPadding, options);
maxSideLength = bitmap.Width > bitmap.Height ? bitmap.Width : bitmap.Height;
double ratio = maxImageSideLength / (double)maxSideLength;
if (ratio < 1)
{
var rotatedBitmap = Bitmap.CreateScaledBitmap(
bitmap,
(int)(bitmap.Width * ratio),
(int)(bitmap.Height * ratio),
false);
if (rotatedBitmap != bitmap)
{
bitmap.Dispose();
bitmap = rotatedBitmap;
}
}
var returnBitmap = RotateBitmap(bitmap, GetImageRotationAngle(imageUri, contentResolver));
//kill this bitmap if rotate created a new one
if (returnBitmap != bitmap)
{
bitmap.Dispose();
}
return(returnBitmap);
}
}
catch (Exception ex)
{
Log.Error(ex);
return(null);
}
}
