react-native-fpay 0.1.1

package/src/engine/BLEReceiverService.ts

@@ -0,0 +1,244 @@
+// FPay SDK — BLEReceiverService (Peripheral)
+// Ported directly from your BLEReceiverService.ts.
+// Same UUIDs, same event ordering, same write handler, same response flow.
+// Only changes: removed useBoundStore dependency, appName is 'FountainPay'.
+
+import { PermissionsAndroid, Platform } from 'react-native';
+import Peripheral, { Permission, Property } from 'react-native-multi-ble-peripheral';
+import { Buffer } from 'buffer';
+
+// ── UUIDs — shared with BLESenderService ─────────────────────
+export const FP_SERVICE_UUID       = 'E8E66D12-C217-425A-AB36-DDBA22F22A5D';
+export const FP_REQUEST_CHAR_UUID  = 'E1CC0349-343A-4E12-A4EF-CF69A681EE86';
+export const FP_RESPONSE_CHAR_UUID = 'DA9318CA-C740-4951-9C7C-5747FE002EF9';
+export const FP_USERINFO_CHAR_UUID = '933CA5AE-4D53-4CF4-864A-2FF51AFA05E9';
+
+// ── Types ─────────────────────────────────────────────────────
+
+export interface BLEPaymentRequest {
+  amount: number;
+  currency: string;
+  senderId: string;
+  senderName: string;
+  timestamp: number;
+}
+
+export interface BLEPaymentResponse {
+  accepted: boolean;
+  transactionId?: string;
+  timestamp: number;
+  // Receiver's account details — sent back to the sender so they can
+  // process the bank transfer on their end
+  accountDetails?: {
+    accountName: string;
+    accountNumber: string;
+    bankName: string;
+    bankCode: string;
+  };
+  // Echo of the original request timestamp — used by sender's polling
+  // to confirm this response belongs to their specific request
+  requestTimestamp?: number;
+}
+
+export type PaymentRequestCallback = (request: BLEPaymentRequest, deviceId: string) => void;
+
+// ── Class ─────────────────────────────────────────────────────
+
+class BLEReceiverService {
+  private peripheral: any = null;
+  private isAdvertising = false;
+  private onRequestCallback: PaymentRequestCallback | null = null;
+  private userInfo = { appName: 'FountainPay', userName: '', userId: '' };
+
+  // ── Init ───────────────────────────────────────────────────
+
+  async initializeWithUserInfo(userId: string, userName: string, appName = 'FountainPay'): Promise<void> {
+    this.userInfo = { userId, userName, appName };
+    await this._requestPermissions();
+  }
+
+  private async _requestPermissions(): Promise<boolean> {
+    if (Platform.OS !== 'android') return true;
+    if (Platform.Version >= 31) {
+      const results = await PermissionsAndroid.requestMultiple([
+        PermissionsAndroid.PERMISSIONS.BLUETOOTH_ADVERTISE,
+        PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+      ]);
+      return Object.values(results).every(r => r === PermissionsAndroid.RESULTS.GRANTED);
+    }
+    const granted = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION);
+    return granted === PermissionsAndroid.RESULTS.GRANTED;
+  }
+
+  // ── Advertising ────────────────────────────────────────────
+
+  async startAdvertising(): Promise<void> {
+    if (this.isAdvertising) {
+      console.log('[FPay BLE Receiver] Already advertising');
+      return;
+    }
+
+    this.peripheral = new Peripheral();
+
+    // CRITICAL: Register event listeners BEFORE the 'ready' event fires.
+    // This mirrors your original code exactly — if you set up listeners
+    // inside the 'ready' callback, write events that fire immediately after
+    // setup can be missed.
+    this._setupEventListeners();
+
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(new Error('[FPay BLE Receiver] Setup timeout (10s)')),
+        10000
+      );
+
+      this.peripheral.on('ready', async () => {
+        try {
+          clearTimeout(timeout);
+          console.log('[FPay BLE Receiver] Peripheral ready');
+
+          await Peripheral.setDeviceName(this.userInfo.userName);
+          console.log('[FPay BLE Receiver] Device name set:', this.userInfo.userName);
+
+          await this.peripheral.addService(FP_SERVICE_UUID, true);
+
+          // User info characteristic — READ only.
+          // Sender reads this to get display name and userId.
+          const userInfoPayload = JSON.stringify({
+            appName:  this.userInfo.appName,
+            userName: this.userInfo.userName,
+            userId:   this.userInfo.userId,
+          });
+          await this.peripheral.addCharacteristic(
+            FP_SERVICE_UUID, FP_USERINFO_CHAR_UUID,
+            Property.READ, Permission.READABLE
+          );
+          await this.peripheral.updateValue(
+            FP_SERVICE_UUID, FP_USERINFO_CHAR_UUID,
+            Buffer.from(userInfoPayload)
+          );
+
+          // Payment request characteristic — WRITE / WRITE_NO_RESPONSE.
+          // Sender writes the payment request JSON here.
+          await this.peripheral.addCharacteristic(
+            FP_SERVICE_UUID, FP_REQUEST_CHAR_UUID,
+            Property.WRITE | Property.WRITE_NO_RESPONSE,
+            Permission.WRITEABLE
+          );
+
+          // Payment response characteristic — READ + NOTIFY.
+          // Receiver writes accept/decline here; sender polls or subscribes.
+          await this.peripheral.addCharacteristic(
+            FP_SERVICE_UUID, FP_RESPONSE_CHAR_UUID,
+            Property.READ | Property.NOTIFY,
+            Permission.READABLE
+          );
+          // Seed a default value so the characteristic is always readable
+          // (prevents "characteristic not found" errors on first poll)
+          await this.peripheral.updateValue(
+            FP_SERVICE_UUID, FP_RESPONSE_CHAR_UUID,
+            Buffer.from(JSON.stringify({ accepted: false, timestamp: 0 }))
+          );
+
+          await this.peripheral.startAdvertising({
+            serviceUuids: [FP_SERVICE_UUID],
+            includeDeviceName: true,
+          });
+
+          this.isAdvertising = true;
+          console.log('[FPay BLE Receiver] Advertising as "' + this.userInfo.userName + '"');
+          resolve();
+        } catch (err) {
+          clearTimeout(timeout);
+          console.error('[FPay BLE Receiver] Setup error:', err);
+          reject(err);
+        }
+      });
+    });
+  }
+
+  // ── Event handling ─────────────────────────────────────────
+
+  private _setupEventListeners(): void {
+    if (!this.peripheral) return;
+
+    this.peripheral.on('write', (data: any) => {
+      console.log('[FPay BLE Receiver] Write event received');
+      if (data?.value) {
+        this._handlePaymentRequest(data);
+      } else {
+        console.warn('[FPay BLE Receiver] Write event had no value');
+      }
+    });
+
+    this.peripheral.on('read',        () => console.log('[FPay BLE Receiver] Read event'));
+    this.peripheral.on('subscribe',   () => console.log('[FPay BLE Receiver] Central subscribed'));
+    this.peripheral.on('unsubscribe', () => console.log('[FPay BLE Receiver] Central unsubscribed'));
+  }
+
+  private _handlePaymentRequest(data: { value: any }): void {
+    try {
+      let decoded: string;
+
+      // Handle all value formats the peripheral library may return
+      if (typeof data.value === 'string') {
+        decoded = Buffer.from(data.value, 'base64').toString('utf8');
+      } else if (Buffer.isBuffer(data.value)) {
+        decoded = data.value.toString('utf8');
+      } else if (Array.isArray(data.value)) {
+        decoded = Buffer.from(data.value).toString('utf8');
+      } else {
+        console.warn('[FPay BLE Receiver] Unknown value format:', typeof data.value);
+        return;
+      }
+
+      const request: BLEPaymentRequest = JSON.parse(decoded);
+      const deviceId = request.senderId?.toString() ?? 'unknown';
+
+      console.log('[FPay BLE Receiver] Payment request parsed:', request.senderName, request.currency + request.amount);
+
+      if (this.onRequestCallback) {
+        this.onRequestCallback(request, deviceId);
+      } else {
+        console.warn('[FPay BLE Receiver] No callback registered — request dropped');
+      }
+    } catch (err) {
+      console.error('[FPay BLE Receiver] Failed to parse payment request:', err);
+    }
+  }
+
+  // ── Public API ─────────────────────────────────────────────
+
+  listenForPaymentRequests(callback: PaymentRequestCallback): void {
+    this.onRequestCallback = callback;
+    console.log('[FPay BLE Receiver] Payment request listener registered');
+  }
+
+  async sendPaymentResponse(response: BLEPaymentResponse): Promise<void> {
+    if (!this.peripheral || !this.isAdvertising) {
+      throw new Error('[FPay BLE Receiver] Cannot send response — not advertising');
+    }
+    const buffer = Buffer.from(JSON.stringify(response));
+    await this.peripheral.updateValue(FP_SERVICE_UUID, FP_RESPONSE_CHAR_UUID, buffer);
+    console.log('[FPay BLE Receiver] Response sent:', response.accepted ? 'ACCEPTED' : 'DECLINED');
+  }
+
+  async stopAdvertising(): Promise<void> {
+    if (this.peripheral && this.isAdvertising) {
+      await this.peripheral.stopAdvertising();
+      this.isAdvertising = false;
+      console.log('[FPay BLE Receiver] Stopped advertising');
+    }
+  }
+
+  getIsAdvertising(): boolean { return this.isAdvertising; }
+
+  destroy(): void {
+    this.stopAdvertising();
+    this.peripheral = null;
+    this.onRequestCallback = null;
+  }
+}
+
+export default new BLEReceiverService();

package/src/engine/BLESenderService.ts

@@ -0,0 +1,314 @@
+// FPay SDK — BLESenderService (Central)
+// Ported directly from your BLESenderService.ts.
+// Same UUIDs (imported from BLEReceiverService), same polling strategy,
+// same write fallback (writeWithoutResponse → writeWithResponse).
+// Only changes: renamed types to match SDK conventions, removed Alert imports.
+
+import { BleManager, Device, State as BluetoothState, ScanMode } from 'react-native-ble-plx';
+import { PermissionsAndroid, Platform } from 'react-native';
+import { Buffer } from 'buffer';
+import {
+  FP_SERVICE_UUID,
+  FP_REQUEST_CHAR_UUID,
+  FP_RESPONSE_CHAR_UUID,
+  FP_USERINFO_CHAR_UUID,
+} from './BLEReceiverService';
+import type { FintechDevice } from '../core/types';
+
+// ── Types ─────────────────────────────────────────────────────
+
+// A discovered FountainPay-capable BLE device (shown in BluetoothSubScreen list)
+
+
+// The payment request written to the receiver's characteristic
+export interface BLESendPaymentRequest {
+  amount: number;
+  currency: string;
+  senderId: string;
+  senderName: string;
+  timestamp: number;
+}
+
+// The response polled from the receiver's characteristic
+export interface BLESendPaymentResponse {
+  accepted: boolean;
+  transactionId?: string;
+  timestamp: number;
+  // Receiver's bank account — used to process the actual money transfer
+  accountDetails?: {
+    accountName: string;
+    accountNumber: string;
+    bankName: string;
+    bankCode: string;
+  };
+  // Echo of the original request.timestamp — used to verify this response
+  // belongs to THIS request and not a stale previous one
+  requestTimestamp?: number;
+}
+
+// ── Class ─────────────────────────────────────────────────────
+
+class BLESenderService {
+  private bleManager: BleManager;
+  private connectedDevices = new Map<string, Device>();
+  private monitorSubscription: any = null;
+
+  constructor() {
+    this.bleManager = new BleManager();
+  }
+
+  // ── Init ───────────────────────────────────────────────────
+
+  async initialize(): Promise<void> {
+    await this._requestPermissions();
+    await this._initializeBLE();
+  }
+
+  private async _requestPermissions(): Promise<boolean> {
+    if (Platform.OS !== 'android') return true;
+    if (Platform.Version >= 31) {
+      const results = await PermissionsAndroid.requestMultiple([
+        PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
+        PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+      ]);
+      return Object.values(results).every(r => r === PermissionsAndroid.RESULTS.GRANTED);
+    }
+    const granted = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION);
+    return granted === PermissionsAndroid.RESULTS.GRANTED;
+  }
+
+  private _initializeBLE(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const sub = this.bleManager.onStateChange(state => {
+        switch (state) {
+          case BluetoothState.Unsupported:
+            reject(new Error('[FPay BLE Sender] Bluetooth not supported on this device'));
+            sub.remove();
+            break;
+          case BluetoothState.PoweredOff:
+            // Attempt to enable — works on Android; iOS will prompt the user
+            this.bleManager.enable().catch(reject);
+            break;
+          case BluetoothState.Unauthorized:
+            reject(new Error('[FPay BLE Sender] Bluetooth permission denied'));
+            sub.remove();
+            break;
+          case BluetoothState.PoweredOn:
+            console.log('[FPay BLE Sender] Bluetooth ready');
+            resolve();
+            sub.remove();
+            break;
+        }
+      }, true);
+    });
+  }
+
+  // ── Scanning ───────────────────────────────────────────────
+
+  // Scans for nearby FountainPay BLE peripherals.
+  // Connects briefly to each to read the USER_INFO characteristic,
+  // then disconnects. Same approach as your BLESenderService.readDeviceInfo().
+  async scanForDevices(
+    onDeviceFound: (device: FintechDevice) => void,
+    durationMs = 5000
+  ): Promise<void> {
+    const seen = new Set<string>();
+
+    return new Promise((resolve, reject) => {
+      console.log('[FPay BLE Sender] Starting scan...');
+
+      this.bleManager.startDeviceScan(
+        [FP_SERVICE_UUID],
+        { allowDuplicates: false, scanMode: ScanMode.LowPower },
+        async (error, device) => {
+          if (error) {
+            console.error('[FPay BLE Sender] Scan error:', error);
+            this.bleManager.stopDeviceScan();
+            reject(error);
+            return;
+          }
+
+          if (device && !seen.has(device.id)) {
+            seen.add(device.id);
+            console.log('[FPay BLE Sender] Found device:', device.name ?? device.id);
+            try {
+              const fp = await this._readDeviceInfo(device);
+              if (fp) onDeviceFound(fp);
+            } catch (err) {
+              console.warn('[FPay BLE Sender] Could not read device info:', err);
+            }
+          }
+        }
+      );
+
+      setTimeout(() => {
+        this.bleManager.stopDeviceScan();
+        console.log('[FPay BLE Sender] Scan complete. Found:', seen.size, 'FPay device(s)');
+        resolve();
+      }, durationMs);
+    });
+  }
+
+  private async _readDeviceInfo(device: Device): Promise<FintechDevice | null> {
+    try {
+      const connected = await this.bleManager.connectToDevice(device.id);
+      await connected.discoverAllServicesAndCharacteristics();
+      const char = await connected.readCharacteristicForService(FP_SERVICE_UUID, FP_USERINFO_CHAR_UUID);
+      await this.bleManager.cancelDeviceConnection(device.id);
+
+      if (!char.value) return null;
+      const info = JSON.parse(Buffer.from(char.value, 'base64').toString('utf8'));
+      return {
+        id:        device.id,
+        name:      device.name ?? 'Unknown Device',
+        appName:   info.appName  ?? 'FountainPay',
+        userName:  info.userName ?? '',
+        rssi:      device.rssi   ?? -100,
+        rawDevice: device,
+      };
+    } catch (err) {
+      try { await this.bleManager.cancelDeviceConnection(device.id); } catch {}
+      return null;
+    }
+  }
+
+  // ── Connection ─────────────────────────────────────────────
+
+  async connectToDevice(deviceId: string): Promise<Device> {
+    console.log('[FPay BLE Sender] Connecting to', deviceId);
+    const device = await this.bleManager.connectToDevice(deviceId, { timeout: 15000 });
+    await device.discoverAllServicesAndCharacteristics();
+    this.connectedDevices.set(deviceId, device);
+    console.log('[FPay BLE Sender] Connected and services discovered');
+    return device;
+  }
+
+  // ── Send Payment Request ───────────────────────────────────
+  //
+  // Flow:
+  //  1. Connect to receiver device
+  //  2. Start polling the RESPONSE characteristic in the background
+  //  3. Write the payment request JSON to the REQUEST characteristic
+  //     (tries writeWithoutResponse first, falls back to writeWithResponse)
+  //  4. Wait up to 60s for the receiver to accept/decline
+  //     The response is matched by requestTimestamp === request.timestamp
+  //  5. Return the response (contains accountDetails if accepted)
+  //
+  // This is your exact polling mechanism, unchanged.
+  async sendPaymentRequest(
+    deviceId: string,
+    request: BLESendPaymentRequest
+  ): Promise<BLESendPaymentResponse> {
+    let responseReceived = false;
+
+    try {
+      let device = this.connectedDevices.get(deviceId);
+      if (!device) device = await this.connectToDevice(deviceId);
+
+      // Start polling BEFORE writing the request, so we don't miss a fast response
+      const responsePromise = new Promise<BLESendPaymentResponse>(async (resolve, reject) => {
+        const startTime = Date.now();
+
+        const poll = async () => {
+          while (!responseReceived) {
+            if (Date.now() - startTime > 60000) {
+              reject(new Error('[FPay BLE Sender] Response timeout — receiver did not respond in 60s'));
+              break;
+            }
+
+            try {
+              await new Promise(r => setTimeout(r, 1000));
+              if (responseReceived) break;
+
+              console.log('[FPay BLE Sender] Polling response characteristic...');
+              const char = await device!.readCharacteristicForService(
+                FP_SERVICE_UUID, FP_RESPONSE_CHAR_UUID
+              );
+
+              if (char.value && char.value.length > 0) {
+                const decoded = Buffer.from(char.value, 'base64').toString('utf8');
+                const resp: BLESendPaymentResponse = JSON.parse(decoded);
+
+                // Verify this response matches OUR request via the echoed timestamp
+                if (
+                  resp.timestamp &&
+                  resp.requestTimestamp &&
+                  resp.requestTimestamp === request.timestamp
+                ) {
+                  console.log('[FPay BLE Sender] Response received — accepted:', resp.accepted);
+                  responseReceived = true;
+                  resolve(resp);
+                  break;
+                } else {
+                  console.log('[FPay BLE Sender] Old/unrelated response, still polling...');
+                }
+              }
+            } catch (pollErr: any) {
+              // errorCode 205 = device disconnected — abort immediately
+              if (pollErr.errorCode === 205) {
+                reject(new Error('[FPay BLE Sender] Device disconnected'));
+                break;
+              }
+              // All other errors: log and keep polling
+              console.warn('[FPay BLE Sender] Poll error (non-fatal):', pollErr.message);
+            }
+          }
+        };
+
+        poll().catch(reject);
+      });
+
+      // Write the payment request
+      const base64 = Buffer.from(JSON.stringify(request)).toString('base64');
+      console.log('[FPay BLE Sender] Writing payment request...');
+
+      try {
+        await device.writeCharacteristicWithoutResponseForService(
+          FP_SERVICE_UUID, FP_REQUEST_CHAR_UUID, base64
+        );
+        console.log('[FPay BLE Sender] Written without response (preferred)');
+      } catch {
+        console.log('[FPay BLE Sender] Retrying with response...');
+        await device.writeCharacteristicWithResponseForService(
+          FP_SERVICE_UUID, FP_REQUEST_CHAR_UUID, base64
+        );
+        console.log('[FPay BLE Sender] Written with response');
+      }
+
+      console.log('[FPay BLE Sender] Request sent. Waiting for accept/decline...');
+
+      const response = await responsePromise;
+      await this.disconnectDevice(deviceId);
+      return response;
+    } catch (err) {
+      await this.disconnectDevice(deviceId);
+      throw err;
+    }
+  }
+
+  // ── Disconnect ─────────────────────────────────────────────
+
+  async disconnectDevice(deviceId: string): Promise<void> {
+    if (this.monitorSubscription) {
+      try { this.monitorSubscription.remove(); } catch {}
+      this.monitorSubscription = null;
+    }
+    if (this.connectedDevices.has(deviceId)) {
+      try { await this.bleManager.cancelDeviceConnection(deviceId); } catch {}
+      this.connectedDevices.delete(deviceId);
+      console.log('[FPay BLE Sender] Disconnected from', deviceId);
+    }
+  }
+
+  // ── Cleanup ────────────────────────────────────────────────
+
+  destroy(): void {
+    this.bleManager.stopDeviceScan();
+    this.connectedDevices.clear();
+    if (this.monitorSubscription) { try { this.monitorSubscription.remove(); } catch {} }
+    this.bleManager.destroy();
+  }
+}
+
+export default new BLESenderService();