@simplysm/capacitor-plugin-intent 12.16.41

package/README.md

@@ -0,0 +1,188 @@
+# @simplysm/capacitor-plugin-intent
+
+Capacitor Intent Plugin -- Android intent send/receive for industrial devices (barcode scanners, PDA, etc.). Provides subscription-based intent receiving, intent sending with extras, launch intent retrieval, and startActivityForResult support.
+
+## Installation
+
+```bash
+npm install @simplysm/capacitor-plugin-intent
+```
+
+## API Overview
+
+| API | Type | Description |
+|-----|------|-------------|
+| `Intent` | Abstract class | Static methods for subscribing to, sending, and managing Android intents |
+| `IIntentResult` | Interface | Intent result containing action and extras |
+| `IStartActivityForResultOptions` | Interface | Options for starting an activity for result |
+| `IActivityResult` | Interface | Activity result containing resultCode, data, and extras |
+| `IIntentPlugin` | Interface | Low-level Capacitor plugin interface for intent operations |
+
+## API Reference
+
+### `IIntentResult`
+
+Result object received from an intent or launch intent.
+
+```typescript
+export interface IIntentResult {
+  action?: string;
+  extras?: Record<string, unknown>;
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `action` | `string \| undefined` | The intent action string |
+| `extras` | `Record<string, unknown> \| undefined` | Extra data attached to the intent |
+
+### `IStartActivityForResultOptions`
+
+Options for starting an activity and receiving its result.
+
+```typescript
+export interface IStartActivityForResultOptions {
+  action: string;
+  uri?: string;
+  extras?: Record<string, unknown>;
+  package?: string;
+  component?: string;
+  type?: string;
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `action` | `string` | Intent action (required) |
+| `uri` | `string \| undefined` | Data URI |
+| `extras` | `Record<string, unknown> \| undefined` | Extra data to include in the intent |
+| `package` | `string \| undefined` | Target package name |
+| `component` | `string \| undefined` | Target component class name (requires `package`) |
+| `type` | `string \| undefined` | MIME type |
+
+### `IActivityResult`
+
+Result returned from a started activity.
+
+```typescript
+export interface IActivityResult {
+  resultCode: number;
+  data?: string;
+  extras?: Record<string, unknown>;
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `resultCode` | `number` | Activity result code (`RESULT_OK = -1`, `RESULT_CANCELED = 0`) |
+| `data` | `string \| undefined` | Result data URI |
+| `extras` | `Record<string, unknown> \| undefined` | Result extras |
+
+### `IIntentPlugin`
+
+Low-level Capacitor plugin interface. Use `Intent` instead for a simplified API.
+
+```typescript
+export interface IIntentPlugin {
+  subscribe(
+    options: { filters: string[] },
+    callback: (result: IIntentResult) => void,
+  ): Promise<{ id: string }>;
+  unsubscribe(options: { id: string }): Promise<void>;
+  unsubscribeAll(): Promise<void>;
+  send(options: { action: string; extras?: Record<string, unknown> }): Promise<void>;
+  getLaunchIntent(): Promise<IIntentResult>;
+  startActivityForResult(options: IStartActivityForResultOptions): Promise<IActivityResult>;
+}
+```
+
+| Method | Parameters | Returns | Description |
+|--------|------------|---------|-------------|
+| `subscribe` | `options: { filters: string[] }, callback` | `Promise<{ id: string }>` | Register an intent receiver with action filters |
+| `unsubscribe` | `options: { id: string }` | `Promise<void>` | Remove a specific intent receiver by ID |
+| `unsubscribeAll` | -- | `Promise<void>` | Remove all intent receivers |
+| `send` | `options: { action, extras? }` | `Promise<void>` | Send an intent with action and optional extras |
+| `getLaunchIntent` | -- | `Promise<IIntentResult>` | Get the intent that launched the app |
+| `startActivityForResult` | `options: IStartActivityForResultOptions` | `Promise<IActivityResult>` | Start an activity and receive its result |
+
+### `Intent`
+
+Abstract class with static methods for Android intent send/receive. Designed for industrial device integration (barcode scanners, PDA, etc.).
+
+```typescript
+export abstract class Intent {
+  static async subscribe(
+    filters: string[],
+    callback: (result: IIntentResult) => void,
+  ): Promise<() => Promise<void>>;
+
+  static async unsubscribeAll(): Promise<void>;
+
+  static async send(options: {
+    action: string;
+    extras?: Record<string, unknown>;
+  }): Promise<void>;
+
+  static async getLaunchIntent(): Promise<IIntentResult>;
+
+  static async startActivityForResult(
+    options: IStartActivityForResultOptions,
+  ): Promise<IActivityResult>;
+}
+```
+
+| Method | Parameters | Returns | Description |
+|--------|------------|---------|-------------|
+| `subscribe` | `filters: string[], callback: (result: IIntentResult) => void` | `Promise<() => Promise<void>>` | Register an intent receiver; returns an unsubscribe function |
+| `unsubscribeAll` | -- | `Promise<void>` | Remove all registered intent receivers |
+| `send` | `options: { action: string; extras?: Record<string, unknown> }` | `Promise<void>` | Send an intent with action and optional extras |
+| `getLaunchIntent` | -- | `Promise<IIntentResult>` | Retrieve the intent that launched the application |
+| `startActivityForResult` | `options: IStartActivityForResultOptions` | `Promise<IActivityResult>` | Start an activity and receive its result |
+
+## Usage Examples
+
+### Subscribe to intents from a barcode scanner
+
+```typescript
+import { Intent } from "@simplysm/capacitor-plugin-intent";
+
+const unsubscribe = await Intent.subscribe(
+  ["com.symbol.datawedge.api.RESULT_ACTION"],
+  (result) => {
+    console.log("Action:", result.action);
+    console.log("Extras:", result.extras);
+  },
+);
+
+// Later, unsubscribe
+await unsubscribe();
+```
+
+### Send an intent to trigger a scan
+
+```typescript
+import { Intent } from "@simplysm/capacitor-plugin-intent";
+
+await Intent.send({
+  action: "com.symbol.datawedge.api.ACTION",
+  extras: {
+    "com.symbol.datawedge.api.SOFT_SCAN_TRIGGER": "TOGGLE_SCANNING",
+  },
+});
+```
+
+### Start an activity for result
+
+```typescript
+import { Intent } from "@simplysm/capacitor-plugin-intent";
+
+const result = await Intent.startActivityForResult({
+  action: "android.intent.action.GET_CONTENT",
+  type: "image/*",
+});
+
+if (result.resultCode === -1) {
+  // RESULT_OK
+  console.log("Selected:", result.data);
+}
+```

package/android/build.gradle

@@ -0,0 +1,14 @@
+apply plugin: 'com.android.library'
+
+android {
+    namespace "kr.co.simplysm.capacitor.intent"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdk project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+    }
+}
+
+dependencies {
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/kr/co/simplysm/capacitor/intent/IntentPlugin.java

@@ -0,0 +1,376 @@
+package kr.co.simplysm.capacitor.intent;
+
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.util.Log;
+
+import androidx.activity.result.ActivityResult;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.ActivityCallback;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+@CapacitorPlugin(name = "Intent")
+public class IntentPlugin extends Plugin {
+
+    private static final String TAG = "IntentPlugin";
+    private final Map<String, BroadcastReceiver> receivers = new HashMap<>();
+
+    @Override
+    protected void handleOnNewIntent(Intent intent) {
+        super.handleOnNewIntent(intent);
+        notifyListeners("onNewIntent", intentToJson(intent));
+    }
+
+    @PluginMethod(returnType = PluginMethod.RETURN_CALLBACK)
+    public void subscribe(PluginCall call) {
+        try {
+            JSArray filters = call.getArray("filters");
+
+            if (filters == null || filters.length() == 0) {
+                call.reject("filters is required");
+                return;
+            }
+
+            call.setKeepAlive(true);
+
+            String receiverId = UUID.randomUUID().toString();
+
+            IntentFilter intentFilter = new IntentFilter();
+            for (int i = 0; i < filters.length(); i++) {
+                intentFilter.addAction(filters.getString(i));
+            }
+
+            BroadcastReceiver receiver = new BroadcastReceiver() {
+                @Override
+                public void onReceive(Context context, Intent intent) {
+                    JSObject result = intentToJson(intent);
+                    result.put("id", receiverId);
+                    call.resolve(result);
+                }
+            };
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                getContext().registerReceiver(receiver, intentFilter, Context.RECEIVER_EXPORTED);
+            } else {
+                getContext().registerReceiver(receiver, intentFilter);
+            }
+
+            receivers.put(receiverId, receiver);
+
+            JSObject ret = new JSObject();
+            ret.put("id", receiverId);
+            call.resolve(ret);
+        } catch (Exception e) {
+            Log.e(TAG, "subscribe failed", e);
+            call.reject("subscribe failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void unsubscribe(PluginCall call) {
+        try {
+            String id = call.getString("id");
+            if (id == null) {
+                call.reject("id is required");
+                return;
+            }
+
+            BroadcastReceiver receiver = receivers.remove(id);
+            if (receiver != null) {
+                getContext().unregisterReceiver(receiver);
+            }
+
+            call.resolve();
+        } catch (Exception e) {
+            Log.e(TAG, "unsubscribe failed", e);
+            call.reject("unsubscribe failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void unsubscribeAll(PluginCall call) {
+        try {
+            for (BroadcastReceiver receiver : receivers.values()) {
+                try {
+                    getContext().unregisterReceiver(receiver);
+                } catch (Exception ignored) {
+                }
+            }
+            receivers.clear();
+            call.resolve();
+        } catch (Exception e) {
+            Log.e(TAG, "unsubscribeAll failed", e);
+            call.reject("unsubscribeAll failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void send(PluginCall call) {
+        try {
+            String action = call.getString("action");
+            if (action == null) {
+                call.reject("action is required");
+                return;
+            }
+
+            Intent intent = new Intent(action);
+
+            JSObject extras = call.getObject("extras");
+            if (extras != null) {
+                populateExtras(intent, extras);
+            }
+
+            getContext().sendBroadcast(intent);
+            call.resolve();
+        } catch (Exception e) {
+            Log.e(TAG, "send failed", e);
+            call.reject("send failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void getLaunchIntent(PluginCall call) {
+        try {
+            Intent intent = getActivity().getIntent();
+            call.resolve(intentToJson(intent));
+        } catch (Exception e) {
+            Log.e(TAG, "getLaunchIntent failed", e);
+            call.reject("getLaunchIntent failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void startActivityForResult(PluginCall call) {
+        try {
+            String action = call.getString("action");
+            if (action == null) {
+                call.reject("action is required");
+                return;
+            }
+
+            Intent intent = new Intent(action);
+
+            String uri = call.getString("uri");
+            String type = call.getString("type");
+            if (uri != null && type != null) {
+                intent.setDataAndType(Uri.parse(uri), type);
+            } else if (uri != null) {
+                intent.setData(Uri.parse(uri));
+            } else if (type != null) {
+                intent.setType(type);
+            }
+
+            String pkg = call.getString("package");
+            String component = call.getString("component");
+            if (component != null && pkg == null) {
+                call.reject("component requires package");
+                return;
+            }
+            if (pkg != null && component != null) {
+                intent.setComponent(new ComponentName(pkg, component));
+            } else if (pkg != null) {
+                intent.setPackage(pkg);
+            }
+
+            JSObject extras = call.getObject("extras");
+            if (extras != null) {
+                populateExtras(intent, extras);
+            }
+
+            startActivityForResult(call, intent, "onActivityResult");
+        } catch (Exception e) {
+            Log.e(TAG, "startActivityForResult failed", e);
+            call.reject("startActivityForResult failed: " + e.getMessage());
+        }
+    }
+
+    @ActivityCallback
+    private void onActivityResult(PluginCall call, ActivityResult result) {
+        if (call == null) {
+            return;
+        }
+
+        JSObject ret = new JSObject();
+        ret.put("resultCode", result.getResultCode());
+
+        Intent data = result.getData();
+        if (data != null) {
+            String dataString = data.getDataString();
+            if (dataString != null) {
+                ret.put("data", dataString);
+            }
+
+            Bundle extras = data.getExtras();
+            if (extras != null && !extras.isEmpty()) {
+                ret.put("extras", bundleToJson(extras));
+            }
+        }
+
+        call.resolve(ret);
+    }
+
+    private void populateExtras(Intent intent, JSObject extras) throws JSONException {
+        Iterator<String> keys = extras.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            Object value = extras.get(key);
+
+            if (value instanceof String) {
+                intent.putExtra(key, (String) value);
+            } else if (value instanceof Integer) {
+                intent.putExtra(key, (Integer) value);
+            } else if (value instanceof Long) {
+                intent.putExtra(key, (Long) value);
+            } else if (value instanceof Double) {
+                intent.putExtra(key, (Double) value);
+            } else if (value instanceof Boolean) {
+                intent.putExtra(key, (Boolean) value);
+            } else if (value instanceof JSONArray) {
+                JSONArray arr = (JSONArray) value;
+                String[] strArr = new String[arr.length()];
+                for (int i = 0; i < arr.length(); i++) {
+                    strArr[i] = arr.getString(i);
+                }
+                intent.putExtra(key, strArr);
+            } else if (value instanceof JSONObject) {
+                Bundle bundle = jsonToBundle((JSONObject) value);
+                intent.putExtra(key, bundle);
+            }
+        }
+    }
+
+    private Bundle jsonToBundle(JSONObject json) throws JSONException {
+        Bundle bundle = new Bundle();
+        Iterator<String> keys = json.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            Object value = json.get(key);
+
+            if (value instanceof String) {
+                bundle.putString(key, (String) value);
+            } else if (value instanceof Integer) {
+                bundle.putInt(key, (Integer) value);
+            } else if (value instanceof Long) {
+                bundle.putLong(key, (Long) value);
+            } else if (value instanceof Double) {
+                bundle.putDouble(key, (Double) value);
+            } else if (value instanceof Boolean) {
+                bundle.putBoolean(key, (Boolean) value);
+            }
+        }
+        return bundle;
+    }
+
+    private JSObject intentToJson(Intent intent) {
+        JSObject json = new JSObject();
+
+        if (intent == null) {
+            return json;
+        }
+
+        try {
+            json.put("action", intent.getAction());
+
+            Bundle extras = intent.getExtras();
+            if (extras != null) {
+                json.put("extras", bundleToJson(extras));
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "intentToJson failed", e);
+        }
+
+        return json;
+    }
+
+    private JSObject bundleToJson(Bundle bundle) {
+        JSObject json = new JSObject();
+
+        if (bundle == null) {
+            return json;
+        }
+
+        for (String key : bundle.keySet()) {
+            try {
+                Object value = bundle.get(key);
+
+                if (value == null) {
+                    json.put(key, JSONObject.NULL);
+                } else if (value instanceof String) {
+                    json.put(key, value);
+                } else if (value instanceof Integer) {
+                    json.put(key, value);
+                } else if (value instanceof Long) {
+                    json.put(key, value);
+                } else if (value instanceof Double) {
+                    json.put(key, value);
+                } else if (value instanceof Float) {
+                    json.put(key, ((Float) value).doubleValue());
+                } else if (value instanceof Boolean) {
+                    json.put(key, value);
+                } else if (value instanceof Bundle) {
+                    json.put(key, bundleToJson((Bundle) value));
+                } else if (value instanceof String[]) {
+                    JSArray arr = new JSArray();
+                    for (String s : (String[]) value) {
+                        arr.put(s);
+                    }
+                    json.put(key, arr);
+                } else if (value instanceof int[]) {
+                    JSArray arr = new JSArray();
+                    for (int i : (int[]) value) {
+                        arr.put(i);
+                    }
+                    json.put(key, arr);
+                } else if (value instanceof Parcelable) {
+                    json.put(key, value.toString());
+                } else if (value instanceof Parcelable[]) {
+                    JSArray arr = new JSArray();
+                    for (Parcelable p : (Parcelable[]) value) {
+                        arr.put(p.toString());
+                    }
+                    json.put(key, arr);
+                } else {
+                    json.put(key, value.toString());
+                }
+            } catch (Exception e) {
+                Log.w(TAG, "bundleToJson key failed: " + key, e);
+            }
+        }
+
+        return json;
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        for (BroadcastReceiver receiver : receivers.values()) {
+            try {
+                getContext().unregisterReceiver(receiver);
+            } catch (Exception ignored) {
+            }
+        }
+        receivers.clear();
+        super.handleOnDestroy();
+    }
+}

package/dist/src/IIntentPlugin.d.ts

@@ -0,0 +1,63 @@
+export interface IIntentResult {
+    /** Intent action */
+    action?: string;
+    /** Extra data */
+    extras?: Record<string, unknown>;
+}
+export interface IStartActivityForResultOptions {
+    /** Intent action */
+    action: string;
+    /** Data URI */
+    uri?: string;
+    /** Extra data */
+    extras?: Record<string, unknown>;
+    /** Target package name */
+    package?: string;
+    /** Target component class name */
+    component?: string;
+    /** MIME type */
+    type?: string;
+}
+export interface IActivityResult {
+    /** Activity result code (RESULT_OK = -1, RESULT_CANCELED = 0) */
+    resultCode: number;
+    /** Result data URI */
+    data?: string;
+    /** Result extras */
+    extras?: Record<string, unknown>;
+}
+export interface IIntentPlugin {
+    /**
+     * Intent 수신기 등록
+     */
+    subscribe(options: {
+        filters: string[];
+    }, callback: (result: IIntentResult) => void): Promise<{
+        id: string;
+    }>;
+    /**
+     * 특정 Intent 수신기 해제
+     */
+    unsubscribe(options: {
+        id: string;
+    }): Promise<void>;
+    /**
+     * 모든 Intent 수신기 해제
+     */
+    unsubscribeAll(): Promise<void>;
+    /**
+     * Intent 전송
+     */
+    send(options: {
+        action: string;
+        extras?: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * 앱 시작 Intent 가져오기
+     */
+    getLaunchIntent(): Promise<IIntentResult>;
+    /**
+     * Activity 시작 후 결과 수신
+     */
+    startActivityForResult(options: IStartActivityForResultOptions): Promise<IActivityResult>;
+}

package/dist/src/IIntentPlugin.js

@@ -0,0 +1 @@
+export {};