@eohjsc/react-native-smart-city 0.7.3-rc24 → 0.7.3-rc25

package/src/screens/Device/__test__/BluetoothDevice.test.js

@@ -0,0 +1,300 @@
+import React from 'react';
+import { Alert } from 'react-native';
+import { act } from 'react-test-renderer';
+import MockAdapter from 'axios-mock-adapter';
+import { NavigationContext } from '@react-navigation/native';
+
+import DeviceDetail from '../detail';
+import { API } from '../../../configs';
+import { AccessibilityLabel } from '../../../configs/Constants';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import api from '../../../utils/Apis/axios';
+import { useWatchConfigs } from '../../../hooks/IoT';
+import { render } from '../../../../jest/render';
+import { BleManager } from 'react-native-ble-plx';
+import { v4 as uuidv4 } from 'uuid';
+import base64 from 'react-native-base64';
+
+const mock = new MockAdapter(api.axiosInstance);
+
+jest.mock('../../../hooks/IoT', () => {
+  return {
+    ...jest.requireActual('../../../hooks/IoT'),
+    useWatchConfigs: jest.fn(),
+  };
+});
+
+jest.mock('../../../hooks/Common', () => {
+  return {
+    ...jest.requireActual('../../../hooks/Common'),
+    useHomeAssistantDeviceConnected: () => ({ isConnected: true }),
+  };
+});
+
+let store = mockSCStore({});
+
+const navContextValue = {
+  isFocused: () => false,
+  addListener: jest.fn(() => jest.fn()),
+};
+
+const wrapComponent = (state, account, route) => (
+  <SCProvider initState={state}>
+    <NavigationContext.Provider
+      value={{
+        ...navContextValue,
+        isFocused: () => true,
+      }}
+    >
+      <DeviceDetail account={account} route={route} />
+    </NavigationContext.Provider>
+  </SCProvider>
+);
+
+const mockAlertShow = jest.fn();
+Alert.alert = mockAlertShow;
+
+describe('test DeviceDetail', () => {
+  let route;
+  let account;
+  const address = uuidv4();
+  const password = uuidv4();
+  const device = {
+    connect: jest.fn(() => Promise.resolve(device)),
+    discoverAllServicesAndCharacteristics: jest.fn(() =>
+      Promise.resolve(device)
+    ),
+    writeCharacteristicWithoutResponseForService: jest.fn(),
+    writeCharacteristicWithResponseForService: jest.fn(),
+    cancelConnection: jest.fn(),
+    readCharacteristicForService: jest.fn((service, characteristic) => ({
+      value: base64.encode('confirmed'),
+    })),
+  };
+  const bleManager = new BleManager();
+  bleManager.startDeviceScan.mockImplementation((uuids, options, handler) =>
+    handler(null, device)
+  );
+
+  beforeEach(() => {
+    device.connect.mockClear();
+    device.cancelConnection.mockClear();
+    device.discoverAllServicesAndCharacteristics.mockClear();
+    device.writeCharacteristicWithoutResponseForService.mockClear();
+    device.writeCharacteristicWithResponseForService.mockClear();
+    device.readCharacteristicForService.mockClear();
+
+    mock.onGet(API.DEVICE.DEVICE_DETAIL(1)).reply(200, {
+      id: 1,
+      is_enable_bluetooth: true,
+      remote_control_options: {
+        bluetooth: {
+          address,
+          password,
+        },
+      },
+    });
+
+    mock.onGet(API.DEVICE.DISPLAY(1)).reply(200, {
+      items: [
+        {
+          configuration: {
+            action1: '2b949045-8e03-4c07-a855-7794ade2e69c',
+            action1_data: {
+              color: '#00979D',
+              command_prefer_over_bluetooth: true,
+              command_prefer_over_googlehome: false,
+              command_prefer_over_internet: false,
+              googlehome_actions: [],
+              icon: 'caretup',
+              id: 9,
+              key: '2b949045-8e03-4c07-a855-7794ade2e69c',
+              arduino_action: {
+                value: 1,
+                pin: {
+                  pin_number: 2,
+                },
+              },
+            },
+            action2: '38347d5e-4418-4ab0-978c-c82f4c034897',
+            action2_data: {
+              color: '#00979D',
+              command_prefer_over_bluetooth: false,
+              command_prefer_over_googlehome: false,
+              command_prefer_over_internet: true,
+              googlehome_actions: [],
+              icon: 'stop',
+              id: 11,
+              key: '38347d5e-4418-4ab0-978c-c82f4c034897',
+            },
+            action3: 'a492e08c-8cb1-44ee-8ea0-46aaca4e5141',
+            action3_data: {
+              color: '#00979D',
+              command_prefer_over_bluetooth: false,
+              command_prefer_over_googlehome: false,
+              command_prefer_over_internet: true,
+              googlehome_actions: [],
+              icon: 'caretdown',
+              id: 10,
+              key: 'a492e08c-8cb1-44ee-8ea0-46aaca4e5141',
+            },
+            icon1: 'caretup',
+            icon2: 'stop',
+            icon3: 'caretdown',
+            text1: 'UP',
+            text2: 'STOP/UNLOCK',
+            text3: 'DOWN',
+          },
+          id: 19,
+          order: 2,
+          template: 'three_button_action_template',
+          type: 'action',
+        },
+      ],
+      side_menu_items: [{ id: 1, order: 1, name: 'Setup generate passcode' }],
+    });
+    route = {
+      params: {
+        unitData: {
+          id: 1,
+          name: 'Unit name',
+          address: '298 Dien Bien Phu',
+          remote_control_options: {
+            googlehome: [
+              {
+                config_maps: [],
+                auth: {},
+                chip_id: 1,
+              },
+            ],
+          },
+        },
+        station: {
+          id: 2,
+          name: 'Station name',
+        },
+        sensorData: {
+          id: 1,
+          is_managed_by_backend: true,
+          station: { id: 2, name: 'Station name' },
+          name: 'Sensor name',
+          chip_id: 1,
+        },
+        title: 'Button',
+      },
+    };
+    account = {
+      token: 'abc',
+    };
+    jest.useFakeTimers();
+
+    const setState = jest.fn();
+    const useLayoutEffectSpy = jest.spyOn(React, 'useLayoutEffect');
+    useLayoutEffectSpy.mockImplementation(() => setState);
+    useWatchConfigs.mockReset();
+  });
+
+  it('scan bluetooth if available', async () => {
+    await render(wrapComponent(store, account, route));
+    jest.runAllTimers();
+    expect(bleManager.stopDeviceScan).toHaveBeenCalledTimes(2);
+    expect(bleManager.startDeviceScan).toHaveBeenCalledTimes(1);
+    expect(bleManager.startDeviceScan.mock.calls[0][0]).toEqual([address]);
+  });
+
+  it('connect to first device', async () => {
+    await render(wrapComponent(store, account, route));
+    jest.runAllTimers();
+    expect(bleManager.stopDeviceScan).toHaveBeenCalledTimes(2);
+    expect(device.connect).toHaveBeenCalledTimes(1);
+    expect(device.discoverAllServicesAndCharacteristics).toHaveBeenCalledTimes(
+      1
+    );
+    expect(
+      device.writeCharacteristicWithoutResponseForService
+    ).toHaveBeenCalledTimes(1);
+    expect(
+      device.writeCharacteristicWithResponseForService
+    ).toHaveBeenCalledTimes(1);
+    expect(
+      base64.decode(
+        device.writeCharacteristicWithoutResponseForService.mock.calls[0][2]
+      )
+    ).toEqual('start');
+    const confirmMessage =
+      device.writeCharacteristicWithResponseForService.mock.calls[0][2];
+    expect(base64.decode(confirmMessage).substring(0, 7)).toEqual('confirm');
+  });
+
+  it('disconnect when leave screen', async () => {
+    const { unmount } = await render(wrapComponent(store, account, route));
+    jest.runAllTimers();
+    await act(async () => {
+      unmount();
+    });
+    expect(device.cancelConnection).toHaveBeenCalledTimes(1);
+  });
+
+  it('fail scan', async () => {
+    bleManager.startDeviceScan.mockImplementationOnce(
+      (uuids, options, handler) => handler('error', device)
+    );
+    await render(wrapComponent(store, account, route));
+    jest.runAllTimers();
+    expect(bleManager.stopDeviceScan).toHaveBeenCalledTimes(1);
+    expect(device.connect).toHaveBeenCalledTimes(0);
+  });
+
+  it('control arduino pin device', async () => {
+    const { root } = await render(wrapComponent(store, account, route));
+    jest.runAllTimers();
+    const button = root.findByProps({
+      accessibilityLabel: AccessibilityLabel.BUTTON_TEMPLATE_1,
+    });
+    device.writeCharacteristicWithResponseForService.mockClear();
+    device.writeCharacteristicWithoutResponseForService.mockClear();
+    await act(async () => {
+      await button.props.onPress();
+    });
+    expect(
+      device.writeCharacteristicWithResponseForService
+    ).toHaveBeenCalledTimes(1);
+  });
+
+  it('control arduino pin fail', async () => {
+    device.readCharacteristicForService.mockReturnValue({ value: 'wrong' });
+    const { root } = await render(wrapComponent(store, account, route));
+    jest.runAllTimers();
+    const button = root.findByProps({
+      accessibilityLabel: AccessibilityLabel.BUTTON_TEMPLATE_1,
+    });
+    device.writeCharacteristicWithResponseForService.mockClear();
+    device.writeCharacteristicWithoutResponseForService.mockClear();
+    await act(async () => {
+      await button.props.onPress();
+    });
+    expect(
+      device.writeCharacteristicWithResponseForService
+    ).toHaveBeenCalledTimes(0);
+  });
+
+  it('control after fail scan', async () => {
+    bleManager.startDeviceScan.mockImplementationOnce(
+      (uuids, options, handler) => handler('error', device)
+    );
+    const { root } = await render(wrapComponent(store, account, route));
+    jest.runAllTimers();
+    const button = root.findByProps({
+      accessibilityLabel: AccessibilityLabel.BUTTON_TEMPLATE_1,
+    });
+    device.writeCharacteristicWithResponseForService.mockClear();
+    device.writeCharacteristicWithoutResponseForService.mockClear();
+    await act(async () => {
+      await button.props.onPress();
+    });
+    expect(
+      device.writeCharacteristicWithResponseForService
+    ).toHaveBeenCalledTimes(0);
+  });
+});

package/src/screens/Device/components/BluetoothDevice.js

@@ -0,0 +1,135 @@
+/* eslint-disable no-console */
+// console log is required for debug, this feature has a lot of debugging
+import { useCallback, useEffect, useRef, useState } from 'react';
+import base64 from 'react-native-base64';
+import { ScanMode } from 'react-native-ble-plx';
+import md5 from 'md5';
+import { bleManager } from '../../../utils/bluetooth';
+
+const CHARACTERISTIC_CONFIRM_CODE_UUID = '6ee26cfb-b42f-43ae-9ecf-f70d84bbd64f';
+const CHARACTERISTIC_CONTROL_UUID = 'f0e7aa38-e466-42af-b4c7-5e6ec5c9a614';
+
+export const useBluetoothDevice = (device) => {
+  const serviceUuid = device?.remote_control_options?.bluetooth?.address;
+  const password = device?.remote_control_options?.bluetooth?.password;
+  const deviceRef = useRef(null);
+  const [isConnected, setIsConnected] = useState(false);
+
+  useEffect(() => {
+    // on unmount, disconnect bluetooth, so it can be reused again
+    return () => {
+      if (isConnected) {
+        deviceRef.current.cancelConnection();
+      }
+    };
+  }, [isConnected]);
+
+  const control = useCallback(
+    (action, data) => {
+      if (!isConnected) {
+        return;
+      }
+
+      const value =
+        data?.value === undefined ? action.arduino_action.value : data?.value;
+      const message = `${action.arduino_action.pin.pin_number};${value}`;
+
+      console.log('control', message);
+
+      deviceRef.current.writeCharacteristicWithResponseForService(
+        serviceUuid,
+        CHARACTERISTIC_CONTROL_UUID,
+        base64.encode(message)
+      );
+    },
+    [isConnected, serviceUuid]
+  );
+
+  const sendConfirmCode = useCallback(
+    async (instanceCode) => {
+      console.log(`sendConfirmCode ${instanceCode}`);
+      const confirmCode = md5(`${password}${instanceCode}`);
+
+      await deviceRef.current.writeCharacteristicWithResponseForService(
+        serviceUuid,
+        CHARACTERISTIC_CONFIRM_CODE_UUID,
+        base64.encode('confirm' + confirmCode)
+      );
+      const result = await deviceRef.current.readCharacteristicForService(
+        serviceUuid,
+        CHARACTERISTIC_CONFIRM_CODE_UUID
+      );
+      const resultText = base64.decode(result.value);
+      console.log(resultText);
+      if (resultText.includes('confirmed')) {
+        setIsConnected(true);
+        return true;
+      }
+      return false;
+    },
+    [password, serviceUuid]
+  );
+
+  const askInstanceCode = useCallback(async () => {
+    console.log('askInstanceCode');
+
+    await deviceRef.current.writeCharacteristicWithoutResponseForService(
+      serviceUuid,
+      CHARACTERISTIC_CONFIRM_CODE_UUID,
+      base64.encode('start')
+    );
+    const response = await deviceRef.current.readCharacteristicForService(
+      serviceUuid,
+      CHARACTERISTIC_CONFIRM_CODE_UUID
+    );
+    return base64.decode(response.value);
+  }, [serviceUuid]);
+
+  const realConnect = useCallback(async () => {
+    // return await new Promise((resolve) => {
+    if (!serviceUuid || !password) {
+      console.log('Bluetooth is not enabled for this device');
+      return false;
+    }
+    console.log('start real connect');
+    try {
+      bleManager.stopDeviceScan();
+    } catch (e) {
+      /* istanbul ignore next */
+      console.log('Failed to stop scan');
+    }
+    bleManager.startDeviceScan(
+      [serviceUuid],
+      { scanMode: ScanMode?.LowLatency },
+      // eslint-disable-next-line promise/prefer-await-to-callbacks
+      async (error, bleDevice) => {
+        if (error) {
+          console.log(error);
+          return false;
+        }
+        console.log(bleDevice?.name, bleDevice?.localName);
+
+        console.log('bleManager.stopDeviceScan');
+        bleManager.stopDeviceScan();
+        console.log('device.connect');
+        const connectedDevice = await bleDevice.connect({ timeout: 5000 });
+
+        console.log('device.discoverAllServicesAndCharacteristics');
+        const fullInfoDevice =
+          await connectedDevice.discoverAllServicesAndCharacteristics();
+        console.log('device.publicCodeCharacteristic');
+        deviceRef.current = fullInfoDevice;
+
+        const instanceCode = await askInstanceCode();
+        return await sendConfirmCode(instanceCode);
+      }
+    );
+    // });
+  }, [askInstanceCode, password, sendConfirmCode, serviceUuid]);
+
+  useEffect(() => {
+    realConnect();
+  }, [realConnect]);
+
+  return { control, isConnected };
+};

package/src/screens/Device/components/SensorDisplayItem.js

@@ -33,6 +33,7 @@ const { standardizeWidth, standardizeHeight } = standardizeCameraScreenSize(
 export const SensorDisplayItem = ({
   item = {},
   sensor,
+  bluetoothDevice,
   emergency,
   offsetTitle,
   setOffsetTitle,
@@ -46,7 +47,7 @@ export const SensorDisplayItem = ({
   const { type, template, uri, id, name, title, value_evaluation } =
     configuration;
 
-  const sendRemoteCommand = useRemoteControl();
+  const sendRemoteCommand = useRemoteControl(bluetoothDevice);
   const [processing, setProcessing] = useState(false);
   // eslint-disable-next-line no-unused-vars
   const [configValues, setConfigValues] = useConfigGlobalState('configValues');
@@ -114,12 +115,12 @@ export const SensorDisplayItem = ({
   }, [configValues, evaluate, evaluateValue, configuration, value_evaluation]);
 
   const doAction = useCallback(
-    async (action, data, interrupted = false) => {
+    async (action, data, interrupted = false, silent = false) => {
       if (processing && !interrupted) {
         return;
       }
       setProcessing(true);
-      await sendRemoteCommand(sensor, action, data, userId);
+      await sendRemoteCommand(sensor, action, data, userId, silent);
       setProcessing(false);
     },
     [processing, sendRemoteCommand, sensor, userId]