Share, clipboard and print

Example

The standard Clipboard API, answered by the phone's real clipboard inside the app.

Returns: writeText(text) → a Promise that resolves when copied and rejects with a NotAllowedError otherwise. readText() → a Promise with the clipboard text ("" when empty). write([item]) / read() → Promises, as in the standard. Needs: nothing. Installed at document start, so a check made while your page parses already sees it.

Copy:

Copyasync function copyLink(link) {
  if (!(navigator.clipboard && navigator.clipboard.writeText)) { alert('Copy is not available'); return; }
  try {
    await navigator.clipboard.writeText(link);
    showMessage('Link copied');
  } catch (e) {
    showMessage('Could not copy');
  }
}

Paste - from a tap:

Copydocument.getElementById('paste').onclick = async function () {
  try {
    var text = await navigator.clipboard.readText();
    document.getElementById('input').value = text;
  } catch (e) {
    showMessage('Could not read the clipboard');
  }
};

Copy an image (for example a QR code drawn on a canvas) with ClipboardItem:

Copyasync function copyCanvas(canvas) {
  if (!(navigator.clipboard && navigator.clipboard.write && window.ClipboardItem)) {
    alert('Copying images is not available here');
    return;
  }
  var blob = await new Promise(function (r) { canvas.toBlob(r, 'image/png'); });
  try {
    await navigator.clipboard.write([new ClipboardItem({ 'image/png': blob })]);
    showMessage('Image copied');
  } catch (e) {
    showMessage('Could not copy the image');
  }
}

Notes: In the app, writeText/readText call WebToApk.copyToClipboard and WebToApk.readClipboard. write() takes the first ClipboardItem only and supports text/plain, text/html and one image (up to 16 MB; an image wins over text in the same item). read() resolves to [item] with the clipboard's text, HTML or image ([] when it is empty). Only the app's own pages can read it: a foreign website opened inside the app is refused (NotAllowedError). Read it on a user tap - Android 12+ shows a "pasted from clipboard" notice. In a browser the same code works with the browser's own permission rules.

Example

The standard Web Share API, made to work inside the app: text and links open the Android share sheet, and files are shared as real files (WhatsApp, Gmail, Drive…).

Returns: navigator.share → a Promise that resolves when the sheet opens (it does not tell you which app was picked). navigator.canShare → true/false. Needs: nothing. Installed at document start, so a check made while your page parses already sees it.

Text and a link:

Copyasync function shareItem(item) {
  if (!navigator.share) { alert('Sharing is not available here'); return; }
  try {
    await navigator.share({ title: item.name, text: 'Look at this', url: item.link });
  } catch (e) { /* in a browser: AbortError when the user closes the sheet */ }
}

Files - check with canShare first:

Copyasync function sharePdf(blob) {
  var file = new File([blob], 'invoice.pdf', { type: 'application/pdf' });
  var data = { files: [file], title: 'Invoice', text: 'Invoice for March' };
  if (!(navigator.canShare && navigator.canShare(data))) {
    alert('File sharing is not available here');
    return;
  }
  try {
    await navigator.share(data);
  } catch (e) { console.log('Share failed', e); }
}

Notes: In the app title becomes the subject, and text + url are sent as one text. With files, each file is read in the page and sent as base64 (WebToApk.shareFiles), so keep files to a few MB. If the share sheet cannot open, the files are saved as downloads instead and the promise still resolves. canShare returns true for any text share. AI-built apps can use share from @/lib/appmintNative.

Example

The standard print call, made to work inside the app: it opens Android's print screen, where the user prints on paper or saves a PDF.

Returns: nothing. Needs: nothing.

Copydocument.getElementById('print-receipt').onclick = function () {
  window.print();
};

Hide the app's controls on paper with a print stylesheet:

Copy<style>
  @media print {
    nav, .toolbar, button { display: none !important; }
    body { background: #fff; color: #000; }
  }
</style>

Notes: window.print() prints the main page as it is drawn now. A same-origin <iframe> - the hidden iframe a print library fills with a receipt and calls iframe.contentWindow.print() on, or an iframe page calling its own window.print() - prints THAT iframe's document (see __printHtml). A cross-origin iframe cannot be printed from the page. The replacement exists before the page's first script. beforeprint cannot be cancelled (in any browser).

Example

Internal transport behind navigator.clipboard.read(). Pages use the standard API; never call this directly - the __ methods may change without notice.

Returns: {parts:[{type, text|base64}]} - the same reach as readClipboard() in this app. Needs: nothing to switch on.

Use the public API:

Copycanvas.toBlob(async (png) => {
  await navigator.clipboard.write([new ClipboardItem({ 'image/png': png })]);
});
const [item] = await navigator.clipboard.read();
if (item && item.types.includes('image/png')) preview(await item.getType('image/png'));

Notes: Android 12+ shows its own "pasted from your clipboard" message when an app reads the clipboard.

Example

Internal transport behind navigator.clipboard.write([ClipboardItem]). Pages use the standard API; never call this directly - the __ methods may change without notice.

Returns: true when the clip was placed. Needs: nothing to switch on.

Use the public API:

Copycanvas.toBlob(async (png) => {
  await navigator.clipboard.write([new ClipboardItem({ 'image/png': png })]);
});
const [item] = await navigator.clipboard.read();
if (item && item.types.includes('image/png')) preview(await item.getType('image/png'));

Notes: Text, HTML and one image per item. The image is copied as a content URI through the app's FileProvider, so it pastes into WhatsApp, Gmail or Keep.

Example

Internal transport behind printing an iframe: iframe.contentWindow.print() (and an iframe page's own window.print()) sends that iframe's document here, and the app prints it through Android's print screen. Pages use the standard calls; never call this directly.

Returns: nothing. Needs: nothing.

The receipt pattern this makes work - a hidden iframe filled with just the receipt:

Copyfunction printReceipt(order) {
  var frame = document.createElement('iframe');
  frame.style.display = 'none';
  document.body.appendChild(frame);
  var doc = frame.contentWindow.document;
  doc.open();
  doc.write('<html><head><title>Receipt ' + order.id + '</title>' +
            '<style>body{font:14px sans-serif} td{padding:2px 8px}</style></head><body>' +
            '<h2>Receipt ' + order.id + '</h2><table>' +
            order.lines.map(function (l) { return '<tr><td>' + l.name + '</td><td>' + l.price + '</td></tr>'; }).join('') +
            '</table></body></html>');
  doc.close();
  frame.contentWindow.print();   // prints the RECEIPT, not the page behind it
  setTimeout(function () { frame.remove(); }, 1000);
}

Notes: Arguments are (html, baseUrl, title): the iframe's serialised document, the address its relative links resolve against (the page's own address for an about:blank iframe), and the print job name (the iframe's <title>, else the page's). The snapshot is taken when print() is called - scripts inside it do not run again - and beforeprint / afterprint fire on the iframe's window around it. A cross-origin iframe cannot be printed from the page.

Example

Forgets the text or link that was shared into the app, once your page has used it.

Returns: nothing. Needs: nothing (the share itself needs Receive Shares From Other Apps with Text and links ticked).

Read the kept share, use it, then clear it so it is not handled again after a reload:

Copyif (window.WebToApk && typeof window.WebToApk.getSharedText === 'function') {
  var raw = window.WebToApk.getSharedText();
  if (raw) {
    var shared = JSON.parse(raw);          // { text, subject, url, receivedAt }
    saveNote(shared.subject, shared.text);
    window.WebToApk.clearSharedText();     // getSharedText() now returns ""
  }
}

window.addEventListener('appmint:shared', function (e) {
  saveNote(e.detail.subject, e.detail.text);
  if (window.WebToApk && window.WebToApk.clearSharedText) window.WebToApk.clearSharedText();
});

Notes: Clearing only affects getSharedText(). A new share replaces the kept one and fires appmint:shared again. Files shared into the app are released separately with AppMint.releaseOpenedFile().

Example

Copies plain text to the phone's clipboard. Pages normally use the standard navigator.clipboard.writeText(text), which the shell routes here.

Returns: true on success, false on failure (synchronously). Needs: nothing.

The standard API first:

Copydocument.getElementById('copy-btn').onclick = async function () {
  try {
    await navigator.clipboard.writeText('PROMO-2026');
    showMessage('Copied');
  } catch (e) {
    showMessage('Could not copy');
  }
};

The raw call:

Copyif (window.WebToApk && typeof window.WebToApk.copyToClipboard === 'function') {
  var ok = window.WebToApk.copyToClipboard('PROMO-2026');
  showMessage(ok ? 'Copied' : 'Could not copy');
}

Notes: Plain text only (no images or HTML). Android 13+ shows its own small "Copied" preview, so you may not need your own message there.

Example

Text or a link that another app shared INTO your app ("Share → your app"), as a JSON string, or "" when nothing was shared.

Returns: a JSON string {text, subject, url, receivedAt} or "" (synchronously). url is the first http(s):// link found in text (or ""); receivedAt is a time in milliseconds. Needs: Receive Shares From Other Apps switched on when you build, with Text and links ticked - that puts your app in other apps' Share menu.

The share is kept until you clear it, so read it on start, and listen for shares that arrive while the app runs:

Copyfunction handleShare(s) {
  addBookmark(s.url || s.text, s.subject);
  if (window.WebToApk && window.WebToApk.clearSharedText) window.WebToApk.clearSharedText();
}

// 1. On start (the app may have been opened by the share).
if (window.WebToApk && typeof window.WebToApk.getSharedText === 'function') {
  var raw = window.WebToApk.getSharedText();
  if (raw) handleShare(JSON.parse(raw));
}

// 2. While running: detail has the same keys { text, subject, url, receivedAt }.
window.addEventListener('appmint:shared', function (e) {
  handleShare(e.detail);
});

A global hook receives the same object, if you prefer one:

Copywindow.onAppMintShared = function (s) { handleShare(s); };

Notes: A YouTube video shared from the YouTube app arrives as its link. A photo or video shared WITH a caption delivers the file through AppMint.getOpenedFile() and the caption here. Clear the share after you use it, or you will see it again on the next start. AI-built apps can use sharedText() / onShared() from @/lib/appmintNative.

Example

Opens Android's print screen for the page as it looks now - print on paper or "Save as PDF". Pages normally use the standard window.print(), which the shell routes here.

Returns: nothing. Needs: nothing.

The standard API first:

Copydocument.getElementById('print-btn').onclick = function () {
  window.print();   // in the app: the Android print screen
};

The raw call does the same:

Copyif (window.WebToApk && typeof window.WebToApk.print === 'function') {
  window.WebToApk.print();
}

Notes: It prints the whole WebView - the main page. A same-origin iframe's own print() prints just that iframe (see window.print). Use a @media print stylesheet to hide buttons and menus. The job is named "<App name> Document". Errors are only logged.

Example

Reads the text that is on the phone's clipboard now. Pages normally use the standard navigator.clipboard.readText(), which the shell routes here.

Returns: the text, or "" when the clipboard is empty or cannot be read (synchronously). Needs: nothing.

The standard API first - for example a "Paste code" button:

Copydocument.getElementById('paste-btn').onclick = async function () {
  try {
    var text = await navigator.clipboard.readText();
    if (text) document.getElementById('code').value = text.trim();
    else showMessage('The clipboard is empty');
  } catch (e) {
    showMessage('Could not read the clipboard');
  }
};

The raw call:

Copyif (window.WebToApk && typeof window.WebToApk.readClipboard === 'function') {
  var text = window.WebToApk.readClipboard();
  if (text) document.getElementById('code').value = text;
}

Notes: Only your own app's pages can read it: a foreign website opened inside the app gets "". Android only lets the app read the clipboard while it is on screen, and Android 12+ shows a "pasted from clipboard" notice - read it on a user tap, not on page load.

Example

Shares one or more real files (an image, a PDF…) through the Android share sheet. Pages normally use the standard navigator.share({ files: [...] }), which the shell routes here.

Returns: true if the share sheet opened, false otherwise (synchronously). Needs: nothing.

The standard API first:

Copyasync function shareCanvas(canvas) {
  var blob = await new Promise(function (r) { canvas.toBlob(r, 'image/png'); });
  var file = new File([blob], 'drawing.png', { type: 'image/png' });
  if (!(navigator.canShare && navigator.canShare({ files: [file] }))) {
    alert('File sharing is not available here');
    return;
  }
  try {
    await navigator.share({ files: [file], title: 'My drawing', text: 'Made in my app' });
  } catch (e) { /* in a browser: the user closed the sheet */ }
}

The raw call takes a JSON string of [{name, mimeType, base64}] (base64 without the data: prefix), then title and text:

Copyfunction shareBase64Png(base64) {
  if (!(window.WebToApk && typeof window.WebToApk.shareFiles === 'function')) return false;
  var files = [{ name: 'receipt.png', mimeType: 'image/png', base64: base64 }];
  return window.WebToApk.shareFiles(JSON.stringify(files), 'Receipt', 'Your receipt');
}

Notes: Files are written to the app's cache and shared through its FileProvider. Unsafe characters in name become _. Several files of one type share with that type; mixed types share as */*. The whole file travels as base64 over the bridge, so keep it to a few MB. When navigator.share({files}) cannot open the sheet, the shell saves the files as downloads instead and the promise still resolves.

Example

Opens the Android share sheet with a title, text and link. Pages normally use the standard navigator.share({title, text, url}), which the shell routes here.

Returns: nothing (it cannot tell you which app the user picked). Needs: nothing.

The standard API first - it also works in a mobile browser:

Copydocument.getElementById('share-btn').onclick = async function () {
  if (!navigator.share) { alert('Sharing is not available here'); return; }
  try {
    await navigator.share({ title: 'My app', text: 'Look at this', url: 'https://mysite.com/item/42' });
  } catch (e) {
    // in a browser: AbortError when the user closes the sheet
  }
};

The raw call, all three arguments are strings (use '' to leave one out):

Copyif (window.WebToApk && typeof window.WebToApk.shareNative === 'function') {
  window.WebToApk.shareNative('My app', 'Look at this', 'https://mysite.com/item/42');
}

Notes: The shared text is text + a new line + url (or just one of them). title becomes the email subject and the share sheet's heading. Text and links only - to share a file, use navigator.share({files}) (see shareFiles).