prs/prs.mobile.new/PRS.Mobile/CustomControls/PDFViewer/PDFViewer.xaml.cs

using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using Syncfusion.SfPdfViewer.XForms;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using InABox.Mobile;
using Xamarin.Essentials;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;
using XF.Material.Forms.UI.Dialogs;
using LogType = InABox.Core.LogType;
using PRSSecurity = InABox.Core.Security;

namespace PRS.Mobile
{
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class PDFViewer
    {
        Document doc = new Document();
        bool externalOpened = false;
        
        public bool AllowPrintShare { get; set; }
        
        public PDFViewer(Guid id)
        {
            InitializeComponent();
            if (Device.RuntimePlatform.Equals(Device.Android))
            {
                pdfViewerControl.CustomPdfRenderer = DependencyService.Get<ICustomPdfRendererService>().AlternatePdfRenderer;
                pdfViewerControl.MaximumZoomPercentage = 600;
            }
            else
                pdfViewerControl.MaximumZoomPercentage = 50000;
            LoadPDF(id);
        }

        public PDFViewer(MemoryStream stream)
        {
            InitializeComponent();
            pdfViewerControl.LoadDocument(stream);
        }

        private void SetupPrintShare()
        {
            _share.IsVisible = AllowPrintShare;
            _print.IsVisible = AllowPrintShare;
        }

        void Exit_Clicked(object sedner, EventArgs e)
        {
            Navigation.PopAsync();
        }

        protected override void OnAppearing()
        {
            base.OnAppearing();
            if (externalOpened)
                Navigation.PopAsync();
        }

        #region Load PDF
        public async void LoadPDF(Guid docid)
        {
            try
            {
                using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
                {
                    CoreTable table = QueryDocument(docid);
                    while (table == null)
                        table = QueryDocument(docid);

                    if (table.Rows.Any())
                    {
                        doc.FileName = table.Rows.First().Values[0].ToString();
                        if (doc.FileName.EndsWith("pdf") || doc.FileName.EndsWith("pdf") || doc.FileName.EndsWith("pdf"))
                        {
                            byte[] data = table.Rows.First().Get<Document, byte[]>(x => x.Data);
                            //if (Device.RuntimePlatform.Equals(Device.Android) && PRSSecurity.IsAllowed<CanOpenMobileNativePDFViewer>())
                            //    OpenNativeViewer(doc.FileName, data);
                            //else
                                ShowPDF(data);
                        }
                        else
                        {
                            Device.BeginInvokeOnMainThread(() =>
                            {
                                DisplayAlert("Error", "File type is not PDF", "OK");
                                Navigation.PopAsync();
                            });
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MobileLogging.Log(ex);

            }
        }

        private CoreTable QueryDocument(Guid docid)
        {
            try
            {
                return new Client<Document>().Query
                                (
                                    new Filter<Document>(x => x.ID).IsEqualTo(docid),
                                    new Columns<Document>(ColumnTypeFlags.None).Add(x => x.FileName, x => x.Data)
                                    );
            }
            catch (Exception ex)
            {
                MobileLogging.Log(ex);
                return null;
            }
        }
        private async void OpenNativeViewer(string filename, byte[] data)
        {
            var filePath = Path.Combine(FileSystem.AppDataDirectory, filename);

            File.WriteAllBytes(filePath, data);

            await Launcher.OpenAsync(new OpenFileRequest
            {
                File = new ReadOnlyFile(filePath)
            });
        }


        void ShowPDF(byte[] data)
        {
            MemoryStream memoryStream = new MemoryStream(data);

            Device.BeginInvokeOnMainThread(() =>
            {
                pdfViewerControl.LoadDocument(memoryStream);
            });

        }

        public void LoadPDF(List<Guid> docids)
        {
            Task.Run(async () =>
            {
                using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
                {
                    try
                    {
                        List<byte> bytes = new List<byte>();
                        foreach (var docid in docids)
                        {
                            CoreTable table2 = new Client<Document>().Query
                                    (
                                        new Filter<Document>(x => x.ID).IsEqualTo(docid)
                                        );
                            if (table2.Rows.Any())
                            {
                                Document doc = table2.Rows.First().ToObject<Document>();
                                byte[] data = table2.Rows.First().Get<Document, byte[]>(x => x.Data);
                                List<Byte> bytes1 = data.ToList();
                                bytes.AddRange(bytes1);
                            }
                        }
                        byte[] allData = bytes.ToArray();
                        MemoryStream memoryStream = new MemoryStream(allData);
                        Device.BeginInvokeOnMainThread(() =>
                        {
                            try
                            {
                                pdfViewerControl.LoadDocument(memoryStream);
                            }
                            catch { }
                        });
                    }
                    catch (Exception ex)
                    {
                        MobileLogging.Log(ex);
                    }
                }
            });
        }
        #endregion

        async void PrintBtn_Clicked(object sender, EventArgs e)
        {
            using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
            {
                pdfViewerControl.Print(doc.FileName);
            }
        }

        async void ShareBtn_Clicked(object sender, EventArgs e)
        {
            using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
            {
                var folder = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
                string path = Path.Combine(folder, doc.FileName);
                File.WriteAllBytes(path, doc.Data);
                ShareFile file = new ShareFile(path);
                await Share.RequestAsync(new ShareFileRequest
                {
                    Title = "Share PDF",
                    File = file
                });
            }
        }
    }
}