public override void OnWrite (PageRange[] pages, ParcelFileDescriptor destination, CancellationSignal cancellationSignal, Android.Print.PrintDocumentAdapter.WriteResultCallback callback)
{
InputStream input = null;
OutputStream output = null;
try {
input = new FileInputStream (PathToDoc);
output = new FileOutputStream (destination.FileDescriptor);
byte[] buf = new byte[1024];
int bytesRead;
while ((bytesRead = input.Read (buf)) > 0) {
output.Write (buf, 0, bytesRead);
}
callback.OnWriteFinished (new PageRange[]{ PageRange.AllPages });
} catch (System.IO.FileNotFoundException ee) {
Insights.Report (ee);
} catch (Exception e) {
Insights.Report (e);
} finally {
try {
input.Close ();
output.Close ();
} catch (Java.IO.IOException e) {
e.PrintStackTrace ();
}
}
}
void WritePrintedPdfDoc(ParcelFileDescriptor destination)
{
var javaStream = new Java.IO.FileOutputStream(destination.FileDescriptor);
var osi = new OutputStreamInvoker(javaStream);
using (var mem = new MemoryStream())
{
document.WriteTo(mem);
var bytes = mem.ToArray();
osi.Write(bytes, 0, bytes.Length);
}
}
public void CommitWrite()
{
ParcelFileDescriptor fileDescriptor = _ctx.ContentResolver.OpenFileDescriptor(Android.Net.Uri.Parse(_path), "rwt");
using (var outputStream = new FileOutputStream(fileDescriptor.FileDescriptor))
{
byte[] data = _memoryStream.ToArray();
outputStream.Write(data);
outputStream.Close();
}
fileDescriptor.Close();
}
private int OnTunBuilderEstablishImpl()
{
ParcelFileDescriptor fileDescriptor = ActiveContext.Establish();
if (fileDescriptor == null)
{
throw new Exception("VpnService.Builder.Establish failed");
}
Service.HandleThreadStarted();
return(fileDescriptor.DetachFd());
}
public override ParcelFileDescriptor OpenFile(Android.Net.Uri uri, string mode)
{
switch ((UriMatches)UriMatcher.Match(uri))
{
case UriMatches.GetIcon:
var iconId = (PwIcon)Enum.Parse(typeof(PwIcon), uri.GetQueryParameter(IconIdParameter));
var customIconUuid = new PwUuid(MemUtil.HexStringToByteArray(uri.GetQueryParameter(CustomIconUuidParameter)));
int databaseIndex = int.Parse(uri.GetQueryParameter(DatabaseIndexParameter));
List <Database> databases = App.Kp2a.OpenDatabases.ToList();
Database database = databases[databaseIndex];
var iconDrawable = database.DrawableFactory.GetIconDrawable(App.Context, database.KpDatabase, iconId, customIconUuid, false) as BitmapDrawable;
if (iconDrawable?.Bitmap != null)
{
var pipe = ParcelFileDescriptor.CreatePipe();
var outStream = new OutputStreamInvoker(new ParcelFileDescriptor.AutoCloseOutputStream(pipe[1]));
ThreadPool.QueueUserWorkItem(state =>
{
var original = iconDrawable.Bitmap;
Bitmap copy = Bitmap.CreateBitmap(original.Width, original.Height, original.GetConfig() ?? Bitmap.Config.Argb8888);
Canvas copiedCanvas = new Canvas(copy);
copiedCanvas.DrawBitmap(original, 0f, 0f, null);
var bitmap = copy;
float maxSize = convertDpToPixel(60, App.Context);
float scale = Math.Min(maxSize / bitmap.Width, maxSize / bitmap.Height);
var scaleWidth = (int)(bitmap.Width * scale);
var scaleHeight = (int)(bitmap.Height * scale);
var scaledBitmap = Bitmap.CreateScaledBitmap(bitmap, scaleWidth, scaleHeight, true);
Bitmap newRectBitmap = Bitmap.CreateBitmap((int)maxSize, (int)maxSize, Bitmap.Config.Argb8888);
Canvas c = new Canvas(newRectBitmap);
c.DrawBitmap(scaledBitmap, (maxSize - scaledBitmap.Width) / 2.0f, (maxSize - scaledBitmap.Height) / 2.0f, null);
bitmap = newRectBitmap;
bitmap.Compress(Bitmap.CompressFormat.Png, 100, outStream);
outStream.Close();
});
return(pipe[0]);
}
// Couldn't get an icon for some reason.
return(null);
default:
throw new ArgumentException("Unknown Uri: " + uri, "uri");
}
}
private async void CreatePDF2(Android.Webkit.WebView webview)
{
try
{
// 计算webview打印需要的页数
int numberOfPages = await GetPDFPageCount(webview);
File pdfFile = new File(fileNameWithPath);
if (pdfFile.Exists())
{
pdfFile.Delete();
}
pdfFile.CreateNewFile();
descriptor = ParcelFileDescriptor.Open(pdfFile, ParcelFileMode.ReadWrite);
// 设置打印参数
var dm = webview.Context.Resources.DisplayMetrics;
var d = dm.Density;
var dpi = dm.DensityDpi;
var height = dm.HeightPixels;
var width = dm.WidthPixels;
var xdpi = dm.Xdpi;
var ydpi = dm.Ydpi;
PrintAttributes attributes = new PrintAttributes.Builder()
.SetMediaSize(MediaSize)
.SetResolution(new PrintAttributes.Resolution("id", Context.PrintService, Convert.ToInt16(xdpi), Convert.ToInt16(ydpi)))
.SetColorMode(PrintColorMode.Color)
.SetMinMargins(PrintAttributes.Margins.NoMargins)
.Build();
ranges = new PageRange[] { new PageRange(0, numberOfPages - 1) };
// 创建pdf文件缓存目录
// 获取需要打印的webview适配器
printAdapter = webview.CreatePrintDocumentAdapter("CreatePDF");
// 开始打印
printAdapter.OnStart();
printAdapter.OnLayout(attributes, attributes, new CancellationSignal(), GetLayoutResultCallback(this), new Bundle());
}
catch (Java.IO.FileNotFoundException e)
{
System.Console.WriteLine(e.Message);
}
catch (Java.IO.IOException e)
{
System.Console.WriteLine(e.Message);
}
catch (Java.Lang.Exception e)
{
System.Console.WriteLine(e.Message);
}
}
public override void OnWrite(PageRange[] pages, ParcelFileDescriptor destination,
CancellationSignal cancellationSignal, WriteResultCallback callback)
{
// If we are already cancelled, don't do any work.
if (cancellationSignal.IsCanceled)
{
callback.OnWriteCancelled();
return;
}
var onWriteAsyncTask = new MyOnWriteAsyncTask(this, pages, destination, cancellationSignal, callback);
onWriteAsyncTask.ExecuteOnExecutor(AsyncTask.ThreadPoolExecutor, (Java.Lang.Void[])null);
}
public bool StartAecDump(string file, int fileSizeLimitBytes)
{
try
{
ParcelFileDescriptor aecDumpFileDescriptor = ParcelFileDescriptor.Open(new File(file),
ParcelFileMode.Create | ParcelFileMode.Truncate | ParcelFileMode.ReadWrite);
return(_factory.StartAecDump(aecDumpFileDescriptor.DetachFd(), fileSizeLimitBytes));
}
catch (IOException ex)
{
return(false);
}
}
public bool StartRtcEventLog(string file, int fileSizeLimitBytes)
{
try
{
ParcelFileDescriptor rtcEventLog = ParcelFileDescriptor.Open(new File(file),
ParcelFileMode.Create | ParcelFileMode.Truncate | ParcelFileMode.ReadWrite);
return(_peerConnection.StartRtcEventLog(rtcEventLog.DetachFd(), fileSizeLimitBytes));
}
catch (IOException ex)
{
return(false);
}
}
protected override void Dispose(bool disposing)
{
if (!disposing || _isDisposed)
{
return;
}
_isDisposed = true;
(_stream as Java.IO.ICloseable)?.Close();
_stream?.Dispose();
ParcelFileDescriptor?.Close();
ParcelFileDescriptor?.Dispose();
}
public override void OnWrite(PageRange[] pages, ParcelFileDescriptor destination, CancellationSignal cancellationSignal, WriteResultCallback callback)
{
InputStream input = null;
OutputStream output = null;
try
{
File file = new File(path);
input = new FileInputStream(file);
output = new FileOutputStream(destination.FileDescriptor);
byte[] buf = new byte[8 * 1024];
int ligne;
while ((ligne = input.Read(buf)) >= 0 && !cancellationSignal.IsCanceled)
{
output.Write(buf, 0, ligne);
}
if (cancellationSignal.IsCanceled)
{
callback.OnWriteCancelled();
}
else
{
callback.OnWriteFinished(new PageRange[] { PageRange.AllPages });
}
}
catch (Exception ex)
{
callback.OnWriteFailed(ex.Message);
}
finally
{
try
{
input.Close();
output.Close();
}
catch (IOException ex)
{
Log.Error("e", "", ex.Message);
}
}
}
public void RenderPDFPagesIntoImages(Java.IO.File file)
{
pages = new List <Bitmap>();
// create a new renderer
try
{
renderer = new PdfRenderer(ParcelFileDescriptor.Open(file, ParcelFileMode.ReadOnly));
numPages = renderer.PageCount;
}
catch (Exception)
{
// handle any exceptions
}
}
public bool StartAecDumpWithFilePath(string filePath, long maxSizeInBytes)
{
try
{
ParcelFileDescriptor aecDumpFileDescriptor = ParcelFileDescriptor.Open(new File(filePath),
ParcelFileMode.Create | ParcelFileMode.Truncate | ParcelFileMode.ReadWrite);
return(_peerConnectionfactory.StartAecDump(aecDumpFileDescriptor.DetachFd(), (int)maxSizeInBytes));
}
catch (Exception exception)
{
Log.Error(TAG, $"An Exception has occured : {exception.Message}");
return(false);
}
}
public void onRestore(BackupDataInput data, int appVersionCode,
ParcelFileDescriptor newState)
{
while (data.ReadNextHeader()) {
String key = data.GetKey();
int dataSize = data.GetDataSize();
if (key.Equals(MY_BACKUP_KEY_ONE)) {
byte[] buffer = new byte[dataSize];
data.ReadEntityData(buffer, 0, dataSize);
} else if (key.Equals(MY_BACKUP_KEY_TO_IGNORE)) {
data.SkipEntityData();
}
}
}
public bool StartRtcEventLogWithFilePath(string filePath, long maxSizeInBytes)
{
try
{
ParcelFileDescriptor rtcEventLog = ParcelFileDescriptor.Open(new File(filePath),
ParcelFileMode.Create | ParcelFileMode.Truncate | ParcelFileMode.ReadWrite);
return(_peerConnection.StartRtcEventLog(rtcEventLog.DetachFd(), (int)maxSizeInBytes));
}
catch (System.Exception exception)
{
Log.Error("PlatformPeerConnection", $"Could not Start RTCEvent logging {exception.Message}");
return(false);
}
}
public override void OnLayoutFinished(PrintDocumentInfo info, bool changed)
{
try
{
var file = new Java.IO.File(PDFToHtml.FilePath);
var fileDescriptor = ParcelFileDescriptor.Open(file, ParcelFileMode.ReadWrite);
var writeResultCallback = new PdfWriteResultCallback(PDFToHtml);
Adapter.OnWrite(new PageRange[] { PageRange.AllPages }, fileDescriptor, new CancellationSignal(), writeResultCallback);
}
catch
{
PDFToHtml.Status = PDFEnum.Failed;
}
base.OnLayoutFinished(info, changed);
}
private void CloseFD()
{
if (m_vpnFD != null)
{
try
{
Log.Debug(TAG, "close fd");
m_vpnFD.Close();
}
catch (Exception ex)
{
Log.Error(TAG, ex.Message + "\n" + ex.StackTrace);
}
m_vpnFD = null;
}
}
public override void OnLayoutFinished(PrintDocumentInfo info, bool changed)
{
//using (var _dir = Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryDocuments))
//using (var _dir = Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryDownloads))
//using (var _dir = Forms9Patch.Droid.Settings.Context.FilesDir)
using (var _dir = Forms9Patch.Droid.Settings.Context.CacheDir)
{
if (!_dir.Exists())
{
_dir.Mkdir();
}
// var path = _dir.Path + "/" + FileName + ".pdf";
//var path = System.IO.Path.Combine(_dir.AbsolutePath, Android.OS.Environment.DirectoryDownloads, FileName + ".pdf");
//var file = new Java.IO.File(path);
/*
* var file = new Java.IO.File(_dir, FileName + ".pdf");
* int iter = 0;
* while (file.Exists())
* {
* file.Dispose();
* iter++;
* //path = _dir.Path + "/" + FileName + "_" + iter.ToString("D3") + ".pdf";
* //path = System.IO.Path.Combine(_dir.AbsolutePath, Android.OS.Environment.DirectoryDownloads, FileName + "_" + iter.ToString("D4") + ".pdf");
* //file = new Java.IO.File(path);
* file = new Java.IO.File(_dir, FileName + "_" + iter.ToString("D3") + ".pdf");
* }
*
*
* //file.CreateNewFile();
*/
var file = Java.IO.File.CreateTempFile(FileName + ".", ".pdf", _dir);
var fileDescriptor = ParcelFileDescriptor.Open(file, ParcelFileMode.ReadWrite);
var writeResultCallback = new PdfWriteResultCallback(TaskCompletionSource, file.AbsolutePath);
Adapter.OnWrite(new Android.Print.PageRange[] { PageRange.AllPages }, fileDescriptor, new CancellationSignal(), writeResultCallback);
file.Dispose();
//Android.Media.MediaScannerConnection.ScanFile(Forms9Patch.Droid.Settings.Context, new string[] { file.AbsolutePath }, new string[] { "application/pdf" }, null);
//Android.Media.MediaScannerConnection.ScanFile(file.AbsolutePath, "application/pdf");
}
base.OnLayoutFinished(info, changed);
}
public override void OnWrite(PageRange[] pages, ParcelFileDescriptor destination, CancellationSignal cancellationSignal, WriteResultCallback callback)
{
InputStream input = null;
OutputStream output = null;
try
{
//Create FileInputStream object from the given file
input = new FileInputStream(FileToPrint);
//Create FileOutputStream object from the destination FileDescriptor instance
output = new FileOutputStream(destination.FileDescriptor);
byte[] buf = new byte[1024];
int bytesRead;
while ((bytesRead = input.Read(buf)) > 0)
{
//Write the contents of the given file to the print destination
output.Write(buf, 0, bytesRead);
}
callback.OnWriteFinished(new PageRange[] { PageRange.AllPages });
}
catch (FileNotFoundException ex)
{
//Catch exception
System.Diagnostics.Debug.WriteLine(ex);
}
catch (Exception e)
{
//Catch exception
System.Diagnostics.Debug.WriteLine(e);
}
finally
{
try
{
input.Close();
output.Close();
}
catch (IOException e)
{
e.PrintStackTrace();
System.Diagnostics.Debug.WriteLine(e);
}
}
}
public override void OnWrite(PageRange[] pages, ParcelFileDescriptor destination, CancellationSignal cancellationSignal, WriteResultCallback callback)
{
InputStream input = null;
OutputStream output = null;
try
{
File file = new File(_filePath);
input = new FileInputStream(file);
output = new FileOutputStream(destination.FileDescriptor);
byte[] buf = new byte[16384];
int size;
while ((size = input.Read(buf)) >= 0 && !cancellationSignal.IsCanceled)
{
output.Write(buf, 0, size);
}
if (cancellationSignal.IsCanceled)
{
callback.OnWriteCancelled();
}
else
{
callback.OnWriteFinished(new PageRange[] { PageRange.AllPages });
}
}
catch (Exception e)
{
callback.OnWriteFailed(e.Message);
System.Diagnostics.Debug.WriteLine(e.Message);
}
finally
{
try
{
input?.Close();
output?.Close();
}
catch (IOException e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
}
}
}
async Task <BitmapFactory.Options> GetBitmapOptionsOfImageAsync(Uri uri)
{
BitmapFactory.Options options = new BitmapFactory.Options
{
InJustDecodeBounds = true
};
// The result will be null because InJustDecodeBounds == true.
ParcelFileDescriptor parcelFileDescriptor = null;
try
{
parcelFileDescriptor = this.ContentResolver.OpenFileDescriptor(uri, "r");
var fileDescriptor = parcelFileDescriptor.FileDescriptor;
Bitmap result = await BitmapFactory.DecodeFileDescriptorAsync(fileDescriptor, null, options).ConfigureAwait(false);
parcelFileDescriptor.Close();
}
catch (Java.Lang.Exception e)
{
// Log.Error(TAG, "Failed to load image.", e);
e.PrintStackTrace();
return(null);
}
finally
{
try
{
if (parcelFileDescriptor != null)
{
parcelFileDescriptor.Close();
}
}
catch (IOException e)
{
e.PrintStackTrace();
// Log.Error(TAG, "Error closing ParcelFile Descriptor");
}
}
int imageHeight = options.OutHeight;
int imageWidth = options.OutWidth;
return(options);
}
public override ParcelFileDescriptor OpenFile(Uri uri, string mode)
{
string path = uri.GetPath();
if (mode.Equals("r") &&
(path.Equals("/foo.txt") || path.Equals("/bar.txt")))
{
try {
return(ParcelFileDescriptor.Open(
new Java.Io.File(GetContext().GetFilesDir() + path),
ParcelFileDescriptor.MODE_READ_ONLY));
} catch (FileNotFoundException) {
Log.E(TAG, "Bad file " + uri);
}
}
return(null);
}
protected override Android.Graphics.Bitmap RunInBackground(params string[] @params)
{
if (IsCancelled)
{
RecycleBitmap(_pdfPageBitmap);
return(null);
}
string url = (string)@params[0];
int position = int.Parse(@params[1]);
double zoom = double.Parse(@params[2]);
_pdfPageBitmap = null;
if (File.Exists(url))
{
var file = new Java.IO.File(url);
var mFileDescriptor = ParcelFileDescriptor.Open(file, ParcelFileMode.ReadOnly);
// This is the PdfRenderer we use to render the PDF.
if (mFileDescriptor != null)
{
// create a new renderer
using (PdfRenderer renderer = new PdfRenderer(mFileDescriptor))
{
using (PdfRenderer.Page page = renderer.OpenPage(position))
{
try
{
_pdfPageBitmap = Android.Graphics.Bitmap.CreateBitmap((int)(page.Width.Px() * zoom), (int)(page.Height.Px() * zoom), Android.Graphics.Bitmap.Config.Argb4444);
page.Render(_pdfPageBitmap, null, null, PdfRenderMode.ForDisplay);
}
catch (Exception e)
{
_listener.RenderingErrorCaught(string.Format("PdfPageGenerationTask failed for index {0} :{1}", TaskIndex.ToString(), e.Message));
Console.WriteLine(e);
}
page.Close();
}
renderer.Close();
}
}
}
return(_pdfPageBitmap);
}
public ChannelStream(ParcelFileDescriptor parcelFileDescriptor, string mode)
{
_mode = mode;
ParcelFileDescriptor = parcelFileDescriptor;
if (mode.Contains("w"))
{
var outStream = new Java.IO.FileOutputStream(parcelFileDescriptor.FileDescriptor);
Channel = outStream.Channel;
_stream = outStream;
}
else
{
var inStream = new Java.IO.FileInputStream(parcelFileDescriptor.FileDescriptor);
Channel = inStream.Channel;
_stream = inStream;
}
}
public ParcelFileDescriptor Establish()
{
EnsureRoutes();
EnsureDNS();
if (m_builder == null)
{
throw new Exception("internal error (m_builder is null)");
}
if (m_fileDescriptor != null)
{
throw new Exception("internal error (m_fileDescriptor already initialized)");
}
m_fileDescriptor = m_builder.Establish();
return(m_fileDescriptor);
}
void SetSource(string url)
{
if (File.Exists(_url))
{
var file = new Java.IO.File(_url);
var mFileDescriptor = ParcelFileDescriptor.Open(file, ParcelFileMode.ReadOnly);
// This is the PdfRenderer we use to render the PDF.
if (mFileDescriptor != null)
{
// create a new renderer
using (PdfRenderer renderer = new PdfRenderer(mFileDescriptor))
{
_count = renderer.PageCount;
}
}
}
}
public bool Email(string mailTo, string subject, List <string> filePaths)
{
try
{
Context context = Android.App.Application.Context;
var email = new Intent(Intent.ActionSendMultiple);
email.SetType("message/rfc822");
email.PutExtra(Intent.ExtraEmail, new string[] { mailTo });
email.PutExtra(Intent.ExtraSubject, subject);
List <IParcelable> uris = new List <IParcelable>();
filePaths.ForEach(file =>
{
var fileIn = new File(file);
if (!fileIn.Exists() || !fileIn.CanRead())
{
Toast.MakeText(context, "Attachment Error", ToastLength.Short);
return;
}
fileIn.SetReadable(true, false);
ParcelFileDescriptor.Open(fileIn, ParcelFileMode.ReadOnly);
var uri = FileProvider.GetUriForFile(Forms.Context.ApplicationContext, "triotech.hubo.droid.fileprovider", fileIn);
uris.Add(uri);
});
email.PutParcelableArrayListExtra(Intent.ExtraStream, uris);
email.AddFlags(ActivityFlags.NewTask);
email.AddFlags(ActivityFlags.GrantReadUriPermission);
email.AddFlags(ActivityFlags.GrantWriteUriPermission);
email.SetFlags(ActivityFlags.GrantReadUriPermission);
email.SetFlags(ActivityFlags.GrantWriteUriPermission);
context.StartActivity(Intent.CreateChooser(email, "Send Email...").AddFlags(ActivityFlags.NewTask));
return(true);
}
catch
{
return(false);
}
}
public async Task Open(string filePath)
{
var client = new HttpClient();
var rawPdf = await client.GetByteArrayAsync(filePath);
var f = new Java.IO.File(MainActivity.CurrentActivity.CacheDir, "sample.pdf");
FileOutputStream output = new FileOutputStream(f);
await output.WriteAsync(rawPdf);
output.Close();
var pdfFileDescriptor = ParcelFileDescriptor.Open(f, ParcelFileMode.ReadOnly);
var renderer = new PdfRenderer(pdfFileDescriptor);
PdfActivity.PdfRenderer = renderer;
PdfActivity.File = filePath;
MainActivity.CurrentActivity.StartActivity(new Intent(MainActivity.CurrentActivity, typeof(PdfActivity)));
}
public override void OnWrite(PageRange[] pages, ParcelFileDescriptor destination,
CancellationSignal cancellationSignal, WriteResultCallback callback)
{
PrintedPdfDocument.Page page = document.StartPage(0);
page.Canvas.Scale(scale, scale);
page.Canvas.DrawText(text, page.Canvas.ClipBounds.Right / 2, page.Canvas.ClipBounds.Bottom / 2, new Android.Graphics.Paint());
document.FinishPage(page);
WritePrintedPdfDoc(destination);
document.Close();
document.Dispose();
callback.OnWriteFinished(pages);
}
public override void OnWrite(PageRange[] pages, ParcelFileDescriptor destination,
CancellationSignal cancellationSignal, WriteResultCallback callback)
{
PrintedPdfDocument.Page page = document.StartPage(0);
page.Canvas.Scale(scale, scale);
view.Draw(page.Canvas);
document.FinishPage(page);
WritePrintedPdfDoc(destination);
document.Close();
document.Dispose();
callback.OnWriteFinished(pages);
}
public override void OnWrite(PageRange[] pages, ParcelFileDescriptor destination,
CancellationSignal cancellationSignal, WriteResultCallback callback)
{
PrintedPdfDocument.Page page = document.StartPage(0);
page.Canvas.Scale(scale, scale);
page.Canvas.DrawText(text, page.Canvas.ClipBounds.Right / 2, page.Canvas.ClipBounds.Bottom / 2, new Android.Graphics.Paint());
document.FinishPage(page);
WritePrintedPdfDoc(destination);
document.Close();
document.Dispose();
callback.OnWriteFinished(pages);
}
public override void OnWrite(PageRange[] pages, ParcelFileDescriptor destination, CancellationSignal cancellationSignal, WriteResultCallback callback)
{
int totalPages = 1;
for (int i = 0; i < totalPages; i++)
{
if (pageInRange(pages, i))
{
PdfDocument.Page[] writtenPagesArray;
PdfDocument.Page page = mPdfDocument.StartPage(i);
if (cancellationSignal.IsCanceled)
{
callback.OnWriteCancelled();
mPdfDocument.Close();
mPdfDocument = null;
return;
}
drawPage(page);
mPdfDocument.FinishPage(page);
}
}
try
{
FileOutputStream fileOutputStream = new FileOutputStream(destination.FileDescriptor);
MemoryStream stream = new MemoryStream();
mPdfDocument.WriteTo(stream);
byte[] bytes = stream.ToArray();
stream.Close();
fileOutputStream.Write(bytes);
}
catch (Java.IO.IOException e)
{
callback.OnWriteFailed(e.ToString());
return;
}
finally
{
mPdfDocument.Close();
mPdfDocument = null;
}
callback.OnWriteFinished(pages);
}
public ParcelFileDescriptor Establish()
{
EnsureRoutes();
EnsureDNS();
if (vpnServiceBuilder == null)
{
throw new Exception("Internal error (vpnServiceBuilder is null)");
}
if (fileDescriptor != null)
{
throw new Exception("Internal error (fileDescriptor already initialized)");
}
fileDescriptor = vpnServiceBuilder.Establish();
return(fileDescriptor);
}
/// <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);
}
public override void OnWrite (PageRange[] pages, ParcelFileDescriptor destination,
CancellationSignal cancellationSignal, WriteResultCallback callback)
{
mWrappedInstance.OnWrite (pages, destination, cancellationSignal, callback);
}
