@iftek/react-native-print 0.12.0

package/scripts/examples_postinstall.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/*
+ * Using libraries within examples and linking them within packages.json like:
+ * "react-native-library-name": "file:../"
+ * will cause problems with the metro bundler if the example will run via
+ * `react-native run-[ios|android]`. This will result in an error as the metro
+ * bundler will find multiple versions for the same module while resolving it.
+ * The reason for that is that if the library is installed it also copies in the
+ * example folder itself as well as the node_modules folder of the library
+ * although their are defined in .npmignore and should be ignored in theory.
+ *
+ * This postinstall script removes the node_modules folder as well as all
+ * entries from the libraries .npmignore file within the examples node_modules
+ * folder after the library was installed. This should resolve the metro
+ * bundler issue mentioned above.
+ *
+ * It is expected this scripts lives in the libraries root folder within a
+ * scripts folder. As first parameter the relative path to the libraries
+ * folder within the example's node_modules folder may be provided.
+ * This script will determine the path from this project's package.json file
+ * if no such relative path is provided.
+ * An example's package.json entry could look like:
+ * "postinstall": "node ../scripts/examples_postinstall.js node_modules/react-native-library-name/"
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/// Delete all files and directories for the given path
+const removeFileDirectoryRecursively = fileDirPath => {
+  // Remove file
+  if (!fs.lstatSync(fileDirPath).isDirectory()) {
+    fs.unlinkSync(fileDirPath);
+    return;
+  }
+
+  // Go down the directory an remove each file / directory recursively
+  fs.readdirSync(fileDirPath).forEach(entry => {
+    const entryPath = path.join(fileDirPath, entry);
+    removeFileDirectoryRecursively(entryPath);
+  });
+  fs.rmdirSync(fileDirPath);
+};
+
+const removeFileDir = fileDirPath => {
+  try {
+    removeFileDirectoryRecursively(fileDirPath);
+    console.log(`Deleted: ${fileDirPath}`);
+  } catch (err) {
+    console.log(`Error deleting ${fileDirPath}: ${err.message}`);
+  }
+};
+
+/// Remove example/node_modules/react-native-library-name/node_modules directory
+const removeLibraryNodeModulesPath = nodeModulesPath => {
+  if (!fs.existsSync(nodeModulesPath)) {
+    console.log(
+      `No node_modules found at ${nodeModulesPath}. Skipping delete.`,
+    );
+    return;
+  }
+
+  removeFileDir(nodeModulesPath);
+};
+
+/// Remove all entries from the .npmignore within example/node_modules/react-native-library-name/
+const removeLibraryNpmIgnorePaths = (npmIgnorePath, libraryNodeModulesPath) => {
+  if (!fs.existsSync(npmIgnorePath)) {
+    console.log(
+      `No .npmignore found at ${npmIgnorePath}. Skipping deleting content.`,
+    );
+    return;
+  }
+
+  fs.readFileSync(npmIgnorePath, 'utf8')
+    .split(/\r?\n/)
+    .forEach(entry => {
+      if (entry.length === 0) {
+        return;
+      }
+
+      const npmIgnoreLibraryNodeModulesEntryPath = path.resolve(
+        libraryNodeModulesPath,
+        entry,
+      );
+      if (!fs.existsSync(npmIgnoreLibraryNodeModulesEntryPath)) {
+        return;
+      }
+
+      removeFileDir(npmIgnoreLibraryNodeModulesEntryPath);
+    });
+};
+
+// Main start sweeping process
+(() => {
+  // Read out dir of example project
+  const cwd = process.cwd();
+
+  console.log(`Starting postinstall cleanup for ${cwd}`);
+
+  // Resolve the React Native library's path within the example's node_modules directory
+  const libraryNodeModulesPath =
+    process.argv.length > 2
+      ? path.resolve(cwd, process.argv[2])
+      : path.resolve(cwd, 'node_modules', require('../package.json').name);
+
+  removeLibraryNodeModulesPath(
+    path.resolve(libraryNodeModulesPath, 'node_modules'),
+  );
+  removeLibraryNpmIgnorePaths(
+    path.resolve(__dirname, '../.npmignore'),
+    libraryNodeModulesPath,
+  );
+})();

package/types/index.d.ts

@@ -0,0 +1,19 @@
+type PrintOptionsType = {
+	printerURL?: string;
+	isLandscape?: boolean;
+	jobName?: string;
+} & ({ html: string } | { filePath: string });
+
+type SelectPrinterOptionsType = {
+	x: number;
+	y: number;
+};
+
+type SelectPrinterReturnType = {
+	name: string;
+	url: string;
+}
+
+export function print(options: PrintOptionsType): Promise<any>;
+
+export function selectPrinter(options: SelectPrinterOptionsType): Promise<SelectPrinterReturnType>;

package/windows/README.md

@@ -0,0 +1,57 @@
+# react-native-print Windows Implementation
+
+## Module Installation
+You can either use autolinking on react-native-windows 0.63 and later or manually link the module on earlier realeases.
+
+## Automatic install with autolinking on RNW >= 0.63
+react-native-print supports autolinking. Just call: `npm i react-native-print --save`
+
+## Manual installation on RNW >= 0.62
+1. `npm install react-native-print --save`
+2. Open your solution in Visual Studio 2019 (eg. `windows\yourapp.sln`)
+3. Right-click Solution icon in Solution Explorer > Add > Existing Project...
+4. Add `node_modules\react-native-print\windows\RNPrint\RNPrint.vcxproj`
+5. Right-click main application project > Add > Reference...
+6. Select `RNPrint` in Solution Projects
+7. In app `pch.h` add `#include "winrt/RNPrint.h"`
+8. In `App.cpp` add `PackageProviders().Append(winrt::RNPrint::ReactPackageProvider());` before `InitializeComponent();`
+
+## Windows print canvas
+
+On Windows, `react-native-print` needs an element in the visual tree to add the printable pages to.
+It will look for a XAML `Canvas` named `RNPrintCanvas` and use it.
+This needs to be added to the XAML tree of the screens where `react-native-print` is used.
+
+As an example, in `windows/myapp/MainPage.xaml` from the `react-native-windows` app template this can be done by adding a XAML `Grid` with an invisible `Canvas` alongside the `ReactRootView`. Change `windows/myapp/MainPage.xaml` from:
+```xaml
+<Page
+  ...
+  >
+  <react:ReactRootView
+    x:Name="ReactRootView"
+    ...
+  />
+</Page>
+```
+to
+```xaml
+<Page
+  ...
+  >
+  <Grid>
+    <Canvas x:Name="RNPrintCanvas" Opacity="0" />
+    <react:ReactRootView
+      x:Name="ReactRootView"
+      ...
+    />
+  </Grid>
+</Page>
+```
+
+## Module development
+
+If you want to contribute to this module Windows implementation, first you must install the [Windows Development Dependencies](https://aka.ms/rnw-deps).
+
+You must temporarily install the `react-native-windows` package. Versions of `react-native-windows` and `react-native` must match, e.g. if the module uses `react-native@0.62`, install `npm i react-native-windows@^0.62 --dev`.
+
+Now, you will be able to open corresponding `RNPrint...sln` file, e.g. `RNPrint62.sln` for `react-native-windows@0.62`.

package/windows/RNPrint/PropertySheet.props

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <!--
+    To customize common C++/WinRT project properties: 
+    * right-click the project node
+    * expand the Common Properties item
+    * select the C++/WinRT property page
+
+    For more advanced scenarios, and complete documentation, please see:
+    https://github.com/Microsoft/xlang/tree/master/src/package/cppwinrt/nuget 
+    -->
+  <PropertyGroup />
+  <ItemDefinitionGroup />
+</Project>

package/windows/RNPrint/RNPrint.cpp

@@ -0,0 +1,375 @@
+#include "pch.h"
+#include "RNPrint.h"
+
+namespace winrt::RNPrint
+{
+  // Searches for the RNPrintCanvas element in the visual tree.
+  Canvas RNPrint::searchForPrintCanvas(xaml::DependencyObject startNode)
+  {
+    const int count = winrt::Windows::UI::Xaml::Media::VisualTreeHelper::GetChildrenCount(startNode);
+    Canvas result = nullptr;
+    for (int i = 0; i < count; i++)
+    {
+      xaml::DependencyObject current = winrt::Windows::UI::Xaml::Media::VisualTreeHelper::GetChild(startNode, i);
+      Canvas temp = current.try_as<Canvas>();
+      if (temp)
+      {
+        std::string tempName = winrt::to_string(temp.Name());
+        if (tempName == RNPrintCanvasName)
+        {
+          return temp;
+        }
+      } else
+      {
+        result = searchForPrintCanvas(current);
+        if (result)
+        {
+          break;
+        }
+      }
+    }
+    return result;
+  }
+
+  // cleans up local variables and XAML elements.
+  void RNPrint::cleanUp()
+  {
+    reactContext.UIDispatcher().Post([=]()
+      {
+        auto printMan = PrintManager::GetForCurrentView();
+        {
+          std::lock_guard<std::mutex> guard(printSync);
+          servingPrintRequest = false;
+          if (printToken)
+          {
+            printMan.PrintTaskRequested(printToken);
+          }
+          printToken = {};
+          pageCollection.clear();
+          if (printCanvas)
+          {
+            printCanvas.Children().Clear();
+          }
+        }
+      }
+    );
+  }
+
+  // Generates a XAML page asynchronously.
+  concurrency::task<std::optional<xaml::UIElement>> RNPrint::GeneratePageAsync(
+    PdfDocument pdfDocument,
+    int pageNumber,
+    PrintPageDescription pageDescription)
+  {
+    Image pageImage;
+    PdfPage pdfPage = pdfDocument.GetPage(pageNumber - 1);
+    BitmapImage pageSource;
+    pageImage.Source(pageSource);
+    InMemoryRandomAccessStream pageStream;
+    Canvas page;
+    page.Width(pageDescription.PageSize.Width);
+    page.Height(pageDescription.PageSize.Height);
+
+    const float leftMargin = pageDescription.ImageableRect.X;
+    const float topMargin = pageDescription.ImageableRect.Y;
+    const float printableWidth = pageDescription.ImageableRect.Width;
+    const float printableHeight = pageDescription.ImageableRect.Height;
+
+    Canvas printableAreaCanvas;
+    printableAreaCanvas.Width(printableWidth);
+    printableAreaCanvas.Height(printableWidth);
+
+    auto pdfContentDimensions = pdfPage.Dimensions().MediaBox();
+    float pdfContentWidth = pdfContentDimensions.Width;
+    float pdfContentHeight = pdfContentDimensions.Height;
+
+    //Scale to Fit logic
+    const float scale = min(printableHeight / pdfContentHeight, printableWidth / pdfContentWidth);
+    pdfContentWidth *= scale;
+    pdfContentHeight *= scale;
+    Canvas::SetLeft(printableAreaCanvas, (double)leftMargin + (printableWidth - pdfContentWidth) / 2);
+    Canvas::SetTop(printableAreaCanvas, (double)topMargin + (printableHeight - pdfContentHeight) / 2);
+
+    auto renderOptions = PdfPageRenderOptions();
+    renderOptions.SourceRect(pdfContentDimensions);
+    renderOptions.DestinationWidth(pdfContentWidth);
+    renderOptions.DestinationHeight(pdfContentHeight);
+
+    printableAreaCanvas.Children().Append(pageImage);
+    page.Children().Append(printableAreaCanvas);
+
+    // Can't block or co_await on this Delegate.
+    auto renderToStreamTask = pdfPage.RenderToStreamAsync(pageStream, renderOptions);
+    return concurrency::create_task([=]
+      {
+        renderToStreamTask.get();
+        reactContext.UIDispatcher().Post([=]()
+          {
+            // Needs to be run on UI thread.
+            pageSource.SetSource(pageStream);
+          });
+      }).then([=]() -> std::optional<xaml::UIElement>
+        {
+          return page;
+        });
+  }
+
+  // Asynchronously loads the PDF document, registers print callbacks and fires the print UI.
+  IAsyncAction RNPrint::PrintAsyncHelper(
+    RNPrintOptions options,
+    ReactPromise<JSValue> promise) noexcept
+  {
+    auto capturedPromise = promise;
+    auto capturedOptions = options;
+
+
+    if ((!capturedOptions.html && !capturedOptions.filePath) || (capturedOptions.html && capturedOptions.filePath))
+    {
+      cleanUp();
+      capturedPromise.Reject("Must provide either 'html' or 'filePath'. Both are either missing or passed together.");
+      co_return;
+    }
+
+    if (capturedOptions.html)
+    {
+      cleanUp();
+      capturedPromise.Reject("Printing HTML not supported");
+      co_return;
+    } else
+    {
+      // Pdf print instructions.
+      winrt::Windows::Foundation::Uri uri(winrt::to_hstring(*capturedOptions.filePath));
+
+      bool isValidURL = !uri.Host().empty() && (winrt::to_string(uri.SchemeName()) == "http" || winrt::to_string(uri.SchemeName()) == "https");
+      PdfDocument pdfDocument = nullptr;
+
+      if (isValidURL)
+      {
+        // Should be a valid URL.
+        auto httpClient = HttpClient();
+        auto httpResponseMessage = co_await httpClient.GetAsync(uri);
+        auto memoryStream = InMemoryRandomAccessStream();
+        co_await httpResponseMessage.Content().WriteToStreamAsync(memoryStream.GetOutputStreamAt(0));
+        pdfDocument = co_await PdfDocument::LoadFromStreamAsync(memoryStream);
+      } else
+      {
+        // Not a valid URL, try to open as a file.
+        StorageFile pdfFile = nullptr;
+        pdfFile = co_await StorageFile::GetFileFromPathAsync(winrt::to_hstring(*capturedOptions.filePath));
+        pdfDocument = co_await PdfDocument::LoadFromFileAsync(pdfFile);
+      }
+      if (pdfDocument == nullptr)
+      {
+        cleanUp();
+        capturedPromise.Reject("Couldn't open the PDF file.");
+        co_return;
+      } else
+      {
+        auto printMan = PrintManager::GetForCurrentView();
+        printDoc = PrintDocument();
+        printDocSource = printDoc.DocumentSource();
+
+        printDoc.Paginate(
+          [=](auto const& sender, PaginateEventArgs const& args)
+          {
+            {
+              // Clears the XAML pages.
+              std::lock_guard<std::mutex> guard(printSync);
+              pageCollection.clear();
+              printCanvas.Children().Clear();
+            }
+            auto printTaskOptions = args.PrintTaskOptions();
+            printPageDescr = printTaskOptions.GetPageDescription(0);
+            numberOfPages = pdfDocument.PageCount();
+            sender.as<PrintDocument>().SetPreviewPageCount(numberOfPages, PreviewPageCountType::Final);
+          }
+        );
+
+        printDoc.GetPreviewPage(
+          [=](auto const& sender, GetPreviewPageEventArgs const& args) -> void
+          {
+            auto printDocArg = sender.as<PrintDocument>();
+            const int pageNumber = args.PageNumber();
+            GeneratePageAsync(pdfDocument, pageNumber, printPageDescr).then([=](std::optional<xaml::UIElement> generatedPage)
+              {
+                reactContext.UIDispatcher().Post([=]()
+                  {
+                    {
+                      std::lock_guard<std::mutex> guard(printSync);
+                      printCanvas.Children().Append(*generatedPage);
+                      printCanvas.InvalidateMeasure();
+                      printCanvas.UpdateLayout();
+                    }
+                    printDocArg.SetPreviewPage(pageNumber, *generatedPage);
+                  });
+              }
+            );
+          }
+        );
+
+        printDoc.AddPages(
+          [=](auto const& sender, AddPagesEventArgs const& args)
+          {
+            PrintDocument printDoc = sender.as<PrintDocument>();
+            std::vector<concurrency::task<void>> createPageTasks;
+
+            // Generate tasks for each page that needs to be sent to the printer.
+            for (int i = 0; i < numberOfPages; i++)
+            {
+              createPageTasks.push_back(GeneratePageAsync(pdfDocument, i + 1, printPageDescr).then([=](std::optional<xaml::UIElement> generatedPage)
+                {
+                  pageCollection[i] = *generatedPage;
+                }
+              ));
+            }
+
+            // After all pages have been generated, submit them for printing.
+            concurrency::when_all(createPageTasks.begin(), createPageTasks.end()).then(
+              [=]()
+              {
+                reactContext.UIDispatcher().Post([=]()
+                  {
+                    std::for_each(pageCollection.begin(), pageCollection.end(),
+                      [=](auto keyValue)
+                      {
+
+                        printDoc.AddPage(*(keyValue.second));
+                      }
+                    );
+                    printDoc.AddPagesComplete();
+                  }
+                );
+              }
+            );
+
+          });
+
+        printToken = printMan.PrintTaskRequested(
+          [=](PrintManager const& sender, PrintTaskRequestedEventArgs const& args)
+          {
+            auto printTask = args.Request().CreatePrintTask(winrt::to_hstring(capturedOptions.jobName),
+              [=](PrintTaskSourceRequestedArgs const& args)
+              {
+                args.SetSource(printDocSource);
+              }
+            );
+            if (options.isLandscape)
+            {
+              printTask.Options().Orientation(PrintOrientation::Landscape);
+            } else
+            {
+              printTask.Options().Orientation(PrintOrientation::Portrait);
+            }
+
+            printTask.Completed([=](PrintTask const& sender, PrintTaskCompletedEventArgs const& args)
+              {
+                cleanUp();
+                switch (args.Completion())
+                {
+                case PrintTaskCompletion::Failed:
+                  capturedPromise.Reject("Failed to print.");
+                  break;
+                case PrintTaskCompletion::Abandoned:
+                  capturedPromise.Reject("Printing Abandoned");
+                  break;
+                default:
+                  capturedPromise.Resolve(options.jobName);
+                  break;
+                }
+              }
+            );
+          }
+        );
+
+        co_await PrintManager::ShowPrintUIAsync();
+      }
+    }
+  }
+
+  void RNPrint::Print(JSValueObject&& options, ReactPromise<JSValue> promise) noexcept
+  {
+    bool ok_to_go_ahead = true;
+    {
+      // Only support one print request at a time.
+      std::lock_guard<std::mutex> guard(printSync);
+      if (servingPrintRequest)
+      {
+        ok_to_go_ahead = false;
+      } else
+      {
+        servingPrintRequest = true;
+      }
+    }
+    if (!ok_to_go_ahead)
+    {
+      promise.Reject("Another print request is already being served.");
+      return;
+    }
+
+    RNPrintOptions printOptions;
+
+    if (options.find("html") != options.end())
+    {
+      printOptions.html = options["html"].AsString();
+    }
+
+    std::optional<std::string> filePath = std::nullopt;
+    if (options.find("filePath") != options.end())
+    {
+      printOptions.filePath = options["filePath"].AsString();
+    }
+
+    printOptions.isLandscape = (options.find("isLandscape") != options.end() ? options["isLandscape"].AsBoolean() : false);
+    printOptions.jobName = (options.find("jobName") != options.end() ? options["jobName"].AsString() : defaultJobName);
+    reactContext.UIDispatcher().Post([=]()
+      {
+        xaml::FrameworkElement root{ nullptr };
+
+        auto window = xaml::Window::Current();
+
+        if (window != nullptr)
+        {
+          root = window.Content().try_as<xaml::FrameworkElement>();
+        } else
+        {
+          if (auto xamlRoot = React::XamlUIService::GetXamlRoot(reactContext.Properties().Handle()))
+          {
+            root = xamlRoot.Content().try_as<xaml::FrameworkElement>();
+          }
+        }
+
+        if (!root)
+        {
+          cleanUp();
+          promise.Reject("A valid XAML root was not found.");
+          return;
+        }
+
+        printCanvas = searchForPrintCanvas(root);
+
+        if (!printCanvas)
+        {
+          cleanUp();
+          promise.Reject("The XAML Canvas named \"RNPrintCanvas\" was not found.");
+          return;
+        }
+
+        auto asyncOp = PrintAsyncHelper(printOptions, promise);
+        asyncOp.Completed([=](auto action, auto status)
+          {
+            // Here we handle any unhandled exceptions thrown during the
+            // asynchronous call by rejecting the promise with the error code
+            if (status == winrt::Windows::Foundation::AsyncStatus::Error)
+            {
+              cleanUp();
+              std::stringstream errorCode;
+              errorCode << "0x" << std::hex << action.ErrorCode() << std::dec << std::endl;
+
+              auto error = winrt::Microsoft::ReactNative::ReactError();
+              error.Message = "HRESULT " + errorCode.str() + ": " + std::system_category().message(action.ErrorCode());
+              promise.Reject(error);
+            }
+          });
+      });
+  }
+}

package/windows/RNPrint/RNPrint.def

@@ -0,0 +1,3 @@
+EXPORTS
+DllCanUnloadNow = WINRT_CanUnloadNow                    PRIVATE
+DllGetActivationFactory = WINRT_GetActivationFactory    PRIVATE

package/windows/RNPrint/RNPrint.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include "pch.h"
+#include "NativeModules.h"
+
+#include <functional>
+#include <sstream>
+#include <mutex>
+#include <string_view>
+
+#include "JSValue.h"
+
+using namespace winrt::Microsoft::ReactNative;
+using namespace winrt::Windows::Data::Pdf;
+using namespace winrt::Windows::Foundation;
+using namespace winrt::Windows::Storage;
+using namespace winrt::Windows::Storage::Streams;
+using namespace winrt::Windows::Web::Http;
+using namespace winrt::Windows::Graphics::Printing;
+using namespace winrt::Windows::Graphics::Printing::OptionDetails;
+using namespace winrt::Windows::UI::Xaml::Printing;
+using namespace winrt::Windows::UI::Xaml::Controls;
+using namespace winrt::Windows::UI::Xaml::Media::Imaging;
+using namespace winrt::Windows::UI::Xaml::Media;
+
+namespace winrt::RNPrint
+{
+  // Represent the options object passed to print()
+  struct RNPrintOptions
+  {
+    std::optional<std::string> html = std::nullopt;
+    std::optional<std::string> filePath = std::nullopt;
+    bool isLandscape = false;
+    std::string jobName;
+  };
+
+  REACT_MODULE(RNPrint);
+  struct RNPrint
+  {
+    inline static constexpr std::string_view Name = "RNPrint";
+
+    // Default name for the print job.
+    inline static constexpr std::string_view defaultJobName = "Document";
+
+    // Name for the XAML Canvas to add preview folders to.
+    inline static constexpr std::string_view RNPrintCanvasName = "RNPrintCanvas";
+
+    // These are needed between print PDF callbacks, so we place them in the struct.
+    ReactContext reactContext = nullptr;
+    Canvas printCanvas = nullptr; // holds reference to RNPrintCanvas in visual tree
+    PrintPageDescription printPageDescr;
+    PrintDocument printDoc = nullptr;
+    IPrintDocumentSource printDocSource;
+    int numberOfPages = 0;
+    std::map<int, std::optional<xaml::UIElement>> pageCollection; // references to the xaml pages
+    std::mutex printSync; // prevent race conditions when manipulating pageCollection or checking a print request is being processed
+    bool servingPrintRequest = false;
+
+    // Event token for print registratio.
+    winrt::event_token printToken;
+
+    REACT_INIT(RNPrint_Init);
+    void RNPrint_Init(ReactContext const& context) noexcept
+    {
+      reactContext = context;
+    }
+
+    // Searches for the RNPrintCanvas element in the visual tree.
+    Canvas searchForPrintCanvas(xaml::DependencyObject startNode);
+
+    // cleans up local variables and XAML elements.
+    void cleanUp();
+
+    // Generates a XAML page asynchronously.
+    concurrency::task<std::optional<xaml::UIElement>> GeneratePageAsync(
+      PdfDocument pdfDocument,
+      int pageNumber,
+      PrintPageDescription pageDescription);
+
+    // Asynchronously loads the PDF document, registers print callbacks and fires the print UI.
+    IAsyncAction PrintAsyncHelper(
+      RNPrintOptions options,
+      ReactPromise<JSValue> promise) noexcept;
+
+    REACT_METHOD(Print, L"print");
+    void Print(JSValueObject&& options, ReactPromise<JSValue> promise) noexcept;
+
+  };
+}