feat(mobile): add NFC plugin (#830)

* feat: scaffold NFC plugin, initial iOS code

* adjust script paths (api example)

* update entitlements & plist

* update class name

* update api

* sketch api, remove desktop

* update response data

* add write fn

* remove commands

* fixes for write mode

* check nfc state before using the APIs

* fix(example): downgrade internal-ip to v7

* feat: typed iOS arguments

* update swift requirement

* android updates

* update tauri

* fix icon

* update example

* fix build

* fix notification example

* fix clipboard

* fix ios notification build

* fix info.plist

* update tauri

* add change file

* fmt

* update to new args class syntax :( [skip ci]

* add lang code handling in RTD_TEXT helper (written payload is broken without it)

* update nfc to latest tauri. use tauri from git

* update lockfile

* android: add initial nfc writer implementation

* check sdk version for pendingintent flag

* quicksaving basic ndef reading that doesn't crash

* add basic ndef reading (android)

* small cleanup

* change pending action type

* validate available state

* gradle 8.0.0

* use session class

* implement keep session alive

* fix notification crash??

* remove dox feature, fix breaking changes

* update dependencies

* fix shell tests [skip ci]

* fmt [skip ci]

* type safe args

* scan kind options

* commit .idea files

* update api

* update example

* fix app check

* alertmessage options for iOS

* default to tag on example

* fix(ios): always close session on write, remove keepsessionalive option

* add kind input to write options

* empty records if message not found

* fill tag metadata for ndef read

* add contributors

* update vite

* covector setup

* tauri/dox removed

* docs and examples

* fmt [skip ci]

---------

Co-authored-by: FabianLars-crabnebula <fabianlars@crabnebula.dev>
Co-authored-by: Lucas Nogueira <lucas@tauri.app>
Co-authored-by: Lucas Nogueira <lucas@tauri.studio>

plugins/nfc/src/api-iife.js

@@ -0,0 +1 @@
+if("__TAURI__"in window){var __TAURI_PLUGIN_NFC__=function(n){"use strict";async function e(n,e={},t){return window.__TAURI_INTERNALS__.invoke(n,e,t)}"function"==typeof SuppressedError&&SuppressedError;const t=[84],r=[85];var o,c;function i(n,e,t,r){return{format:n,kind:"string"==typeof e?Array.from((new TextEncoder).encode(e)):e,id:"string"==typeof t?Array.from((new TextEncoder).encode(t)):t,payload:"string"==typeof r?Array.from((new TextEncoder).encode(r)):r}}n.TechKind=void 0,(o=n.TechKind||(n.TechKind={}))[o.IsoDep=0]="IsoDep",o[o.MifareClassic=1]="MifareClassic",o[o.MifareUltralight=2]="MifareUltralight",o[o.Ndef=3]="Ndef",o[o.NdefFormatable=4]="NdefFormatable",o[o.NfcA=5]="NfcA",o[o.NfcB=6]="NfcB",o[o.NfcBarcode=7]="NfcBarcode",o[o.NfcF=8]="NfcF",o[o.NfcV=9]="NfcV",n.NFCTypeNameFormat=void 0,(c=n.NFCTypeNameFormat||(n.NFCTypeNameFormat={}))[c.Empty=0]="Empty",c[c.NfcWellKnown=1]="NfcWellKnown",c[c.Media=2]="Media",c[c.AbsoluteURI=3]="AbsoluteURI",c[c.NfcExternal=4]="NfcExternal",c[c.Unknown=5]="Unknown",c[c.Unchanged=6]="Unchanged";const a=["","http://www.","https://www.","http://","https://","tel:","mailto:","ftp://anonymous:anonymous@","ftp://ftp.","ftps://","sftp://","smb://","nfs://","ftp://","dav://","news:","telnet://","imap:","rtsp://","urn:","pop:","sip:","sips:","tftp:","btspp://","btl2cap://","btgoep://","tcpobex://","irdaobex://","file://","urn:epc:id:","urn:epc:tag:","urn:epc:pat:","urn:epc:raw:","urn:epc:","urn:nfc:"];function f(n){const{type:e,...t}=n;return{[e]:t}}return n.RTD_TEXT=t,n.RTD_URI=r,n.isAvailable=async function(){return await e("plugin:nfc|isAvailable")},n.record=i,n.scan=async function(n,t){return await e("plugin:nfc|scan",{kind:f(n),...t})},n.textRecord=function(e,r,o="en"){const c=Array.from((new TextEncoder).encode(o+e));return c.unshift(o.length),i(n.NFCTypeNameFormat.NfcWellKnown,t,r||[],c)},n.uriRecord=function(e,t){return i(n.NFCTypeNameFormat.NfcWellKnown,r,t||[],function(n){let e="";a.slice(1).forEach((function(t){e&&"urn:"!==e||0!==n.indexOf(t)||(e=t)})),e||(e="");const t=Array.from((new TextEncoder).encode(n.slice(e.length))),r=a.indexOf(e);return t.unshift(r),t}(e))},n.write=async function(n,t){const{kind:r,...o}=t||{};return r&&(o.kind=f(r)),await e("plugin:nfc|write",{records:n,...o})},n}({});Object.defineProperty(window.__TAURI__,"nfc",{value:__TAURI_PLUGIN_NFC__})}

plugins/nfc/src/error.rs

@@ -0,0 +1,25 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use serde::{ser::Serializer, Serialize};
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[cfg(mobile)]
+    #[error(transparent)]
+    PluginInvoke(#[from] tauri::plugin::mobile::PluginInvokeError),
+}
+
+impl Serialize for Error {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.to_string().as_ref())
+    }
+}

plugins/nfc/src/lib.rs

@@ -0,0 +1,84 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+#![cfg(mobile)]
+
+use serde::{Deserialize, Serialize};
+use tauri::{
+    plugin::{Builder, PluginHandle, TauriPlugin},
+    Manager, Runtime,
+};
+
+pub use models::*;
+
+mod error;
+mod models;
+
+pub use error::{Error, Result};
+
+#[cfg(target_os = "android")]
+const PLUGIN_IDENTIFIER: &str = "app.tauri.nfc";
+
+#[cfg(target_os = "ios")]
+tauri::ios_plugin_binding!(init_plugin_nfc);
+
+/// Access to the nfc APIs.
+pub struct Nfc<R: Runtime>(PluginHandle<R>);
+
+#[derive(Deserialize)]
+struct IsAvailableResponse {
+    available: bool,
+}
+
+#[derive(Serialize)]
+struct WriteRequest {
+    records: Vec<NfcRecord>,
+}
+
+impl<R: Runtime> Nfc<R> {
+    pub fn is_available(&self) -> crate::Result<bool> {
+        self.0
+            .run_mobile_plugin::<IsAvailableResponse>("isAvailable", ())
+            .map(|r| r.available)
+            .map_err(Into::into)
+    }
+
+    pub fn scan(&self, payload: ScanRequest) -> crate::Result<ScanResponse> {
+        self.0
+            .run_mobile_plugin("scan", payload)
+            .map_err(Into::into)
+    }
+
+    pub fn write(&self, records: Vec<NfcRecord>) -> crate::Result<()> {
+        self.0
+            .run_mobile_plugin("write", WriteRequest { records })
+            .map_err(Into::into)
+    }
+}
+
+/// Extensions to [`tauri::App`], [`tauri::AppHandle`] and [`tauri::Window`] to access the nfc APIs.
+pub trait NfcExt<R: Runtime> {
+    fn nfc(&self) -> &Nfc<R>;
+}
+
+impl<R: Runtime, T: Manager<R>> crate::NfcExt<R> for T {
+    fn nfc(&self) -> &Nfc<R> {
+        self.state::<Nfc<R>>().inner()
+    }
+}
+
+/// Initializes the plugin.
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
+    Builder::new("nfc")
+        .js_init_script(include_str!("api-iife.js").to_string())
+        .setup(|app, api| {
+            #[cfg(target_os = "android")]
+            let handle = api.register_android_plugin(PLUGIN_IDENTIFIER, "NfcPlugin")?;
+            #[cfg(target_os = "ios")]
+            let handle = api.register_ios_plugin(init_plugin_nfc)?;
+            app.manage(Nfc(handle));
+            Ok(())
+        })
+        .build()
+}

plugins/nfc/src/mobile.rs

@@ -0,0 +1,11 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use serde::de::DeserializeOwned;
+use tauri::{
+    plugin::{PluginApi, PluginHandle},
+    AppHandle, Runtime,
+};
+
+use crate::models::*;

plugins/nfc/src/models.rs

@@ -0,0 +1,119 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use serde::{Deserialize, Serialize, Serializer};
+use std::fmt::Display;
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScanRequest {
+    pub kind: ScanKind,
+    pub keep_session_alive: bool,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NfcRecord {
+    pub format: NFCTypeNameFormat,
+    pub kind: Vec<u8>,
+    pub id: Vec<u8>,
+    pub payload: Vec<u8>,
+}
+
+#[derive(serde_repr::Deserialize_repr, serde_repr::Serialize_repr)]
+#[repr(u8)]
+pub enum NFCTypeNameFormat {
+    Empty = 0,
+    NfcWellKnown = 1,
+    Media = 2,
+    AbsoluteURI = 3,
+    NfcExternal = 4,
+    Unknown = 5,
+    Unchanged = 6,
+}
+
+#[derive(Deserialize)]
+pub struct NfcTagRecord {
+    pub tnf: NFCTypeNameFormat,
+    pub kind: Vec<u8>,
+    pub id: Vec<u8>,
+    pub payload: Vec<u8>,
+}
+
+#[derive(Deserialize)]
+pub struct NfcTag {
+    pub id: String,
+    pub kind: String,
+    pub records: Vec<NfcTagRecord>,
+}
+
+#[derive(Deserialize)]
+pub struct ScanResponse {
+    pub tag: NfcTag,
+}
+
+#[derive(Debug, Default, Serialize)]
+pub struct UriFilter {
+    scheme: Option<String>,
+    host: Option<String>,
+    path_prefix: Option<String>,
+}
+
+#[derive(Debug)]
+pub enum TechKind {
+    IsoDep,
+    MifareClassic,
+    MifareUltralight,
+    Ndef,
+    NdefFormatable,
+    NfcA,
+    NfcB,
+    NfcBarcode,
+    NfcF,
+    NfcV,
+}
+
+impl Display for TechKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::IsoDep => "IsoDep",
+                Self::MifareClassic => "MifareClassic",
+                Self::MifareUltralight => "MifareUltralight",
+                Self::Ndef => "Ndef",
+                Self::NdefFormatable => "NdefFormatable",
+                Self::NfcA => "NfcA",
+                Self::NfcB => "NfcB",
+                Self::NfcBarcode => "NfcBarcode",
+                Self::NfcF => "NfcF",
+                Self::NfcV => "NfcV",
+            }
+        )
+    }
+}
+
+impl Serialize for TechKind {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum ScanKind {
+    Ndef {
+        mime_type: Option<String>,
+        uri: Option<UriFilter>,
+        tech_list: Option<Vec<Vec<TechKind>>>,
+    },
+    Tag {
+        mime_type: Option<String>,
+        uri: Option<UriFilter>,
+    },
+}