@eohjsc/react-native-smart-city 0.7.27 → 0.7.31

package/src/commons/SubUnit/__test__/ShortDetail.test.js

@@ -1,13 +1,17 @@
 import React from 'react';
+import MockAdapter from 'axios-mock-adapter';
 import { Image, View } from 'react-native';
 import mock from 'react-native-permissions/mock';
 import { act, create } from 'react-test-renderer';
+import { API } from '../../../configs';
 import { AccessibilityLabel } from '../../../configs/Constants';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import { watchMultiConfigs } from '../../../iot/Monitor';
 import { keyPermission } from '../../../utils/Permission/common';
+import api from '../../../utils/Apis/axios';
 import Routes from '../../../utils/Route';
+import { gatewayDataFactory } from '../../../utils/FactoryGateway';
 import ItemHanetDevice from '../../Device/Hanet/ItemHanetDevice';
 import ItemAddNew from '../../Device/ItemAddNew';
 import ItemDevice from '../../Device/ItemDevice';
@@ -15,6 +19,8 @@ import Text from '../../Text';
 import { DeviceTemplate } from '../DeviceTemplate/DeviceTemplate';
 import ShortDetailSubUnit from '../ShortDetail';
 
+const mockAxios = new MockAdapter(api.axiosInstance);
+
 jest.mock('../../../iot/Monitor');
 
 const wrapComponent = (props) => (
@@ -32,7 +38,9 @@ jest.mock('../../../iot/states', () => ({
 }));
 
 describe('test ShortDetail Subunit', () => {
-  let tree, props;
+  let tree;
+  let props;
+
   beforeEach(() => {
     jest.useFakeTimers();
     props = {
@@ -69,6 +77,7 @@ describe('test ShortDetail Subunit', () => {
       isNetworkConnected: true,
       isGGHomeConnected: true,
     };
+    watchMultiConfigs.mockClear();
   });
 
   it('render ShortDetail', async () => {
@@ -182,6 +191,42 @@ describe('test ShortDetail Subunit', () => {
     expect(watchMultiConfigs).toHaveBeenCalledWith([1]);
   });
 
+  it('render using mqtt not call watch config', async () => {
+    mockAxios
+      .onGet(API.CHIP.JSON_CONFIGURATION)
+      .reply(200, [gatewayDataFactory]);
+    props.station.devices = [
+      {
+        action: {
+          color: '#00979D',
+          icon: 'caretup',
+          id: 1,
+          key: '',
+        },
+        action2: null,
+        chip_id: 7689,
+        description: null,
+        icon: '',
+        id: 1,
+        name: 'People Counting',
+        quick_action: { config_id: 128282 },
+        remote_control_options: {},
+        station: {},
+        status: null,
+        status2: null,
+        is_managed_by_backend: true,
+      },
+    ];
+
+    await act(async () => {
+      tree = await create(wrapComponent(props));
+    });
+    await act(async () => {
+      jest.runOnlyPendingTimers();
+    });
+    expect(watchMultiConfigs).not.toHaveBeenCalled();
+  });
+
   ['ConfigAndEvaluation', 'ConfigValue', 'EvaluationOverConfig'].forEach(
     (template) => {
       it(`render with device template ${template}`, async () => {

package/src/configs/API.js

@@ -2,8 +2,12 @@ import { SCConfig } from './SCConfig';
 
 const API = {
   AUTH: {
+    CREATE_PASSWORD: '/accounts/create_password/',
     PERMISSIONS: () => '/accounts/permissions/',
   },
+  ACCOUNTS: {
+    USABLE_PASSWORD: '/accounts/usable_password/',
+  },
   UNIT: {
     MY_UNITS: () => '/property_manager/units/mine/',
     SHARED_UNITS: () => '/property_manager/shared_units/',
@@ -65,6 +69,7 @@ const API = {
         `/iot/modules/zigbee/chips/${id}/device_permit_to_join/`,
     },
     JSON_CONFIGURATION: '/chip_manager/chips/json_configuration/',
+    SHARED_CONFIGURATION: '/chip_manager/chips/shared_configuration/',
   },
   DEVICE: {
     DEVICE_DETAIL: (id) => `/property_manager/devices/${id}/`,
@@ -144,6 +149,8 @@ const API = {
     CREATE_AUTOMATE_V2: () => '/property_manager/automate_v2/',
     UPDATE_AUTOMATE: (automateId) =>
       `/property_manager/automate/${automateId}/`,
+    ENABLE_NOTIFICATIONS: (automateId) =>
+      `/property_manager/automate/${automateId}/enable_notifications/`,
     ENABLE_SCRIPT: (automateId) =>
       `/property_manager/automate/${automateId}/enable_script/`,
     STAR_SCRIPT: (id) => `/property_manager/automate/${id}/star_script/`,
@@ -203,6 +210,7 @@ const API = {
   IOT: {
     CHIP_MANAGER: {
       WATCH_CONFIGS: () => '/chip_manager/watch_configs_v2/',
+      WATCH_DATA_CHIPS: () => '/chip_manager/watch_data_chips/',
       PUSHER_AUTH: () => '/chip_manager/pusher/auth_v2/',
     },
     LG: {

package/src/configs/AccessibilityLabel.js

@@ -164,6 +164,7 @@ export default {
   //Enter Password
   ENTER_PASSWORD_TEXT_INPUT_PASSWORD: 'ENTER_PASSWORD_TEXT_INPUT_PASSWORD',
   ENTER_PASSWORD_BUTTON_DONE: 'ENTER_PASSWORD_BUTTON_DONE',
+  CREATE_PASSWORD_BUTTON_DONE: 'CREATE_PASSWORD_BUTTON_DONE',
 
   // Map Dashboard
   PARKING_MARKER: 'PARKING_MARKER',
@@ -261,6 +262,8 @@ export default {
   AUTOMATE_SELECT_CONDITION: 'AUTOMATE_SELECT_CONDITION',
   AUTOMATE_DELETE_CONDITION: 'AUTOMATE_DELETE_CONDITION',
   AUTOMATE_NUMBER_CONDITION: 'AUTOMATE_NUMBER_CONDITION',
+  SWITCH_ENABLE_SCRIPT: 'SWITCH_ENABLE_SCRIPT',
+  SWITCH_ENABLE_NOTIFICATIONS_SCRIPT: 'SWITCH_ENABLE_NOTIFICATIONS_SCRIPT',
 
   // Parking input maunaly spot
   PARKING_SPOT_INFO_BUTTON: 'PARKING_SPOT_INFO_BUTTON',

package/src/configs/Constants.js

@@ -294,3 +294,10 @@ export const WIDGET_TYPE = {
   iframe: 'IFrame',
   iframeWithConfig: 'IFrameWithConfig',
 };
+
+export const WATCH_DATA_CHIP_TYPE = {
+  MODBUS: 'modbus',
+  ZIGBEE: 'zigbee',
+  THIRD_PARTY: 'third_party',
+  SELF: 'self',
+};

package/src/configs/SCConfig.js

@@ -99,6 +99,7 @@ const SCDefaultConfig = {
   pusherAppKey: '8557fcc63959f564f1aa',
   pusherAppCluster: 'ap1',
   intervalWatchConfigTime: 30000,
+  intervalWatchervalWatchDataChipTime: 30000,
   setCurrentSensorDisplay: () => {},
   appName: 'E-Ra',
   appLogo: Images.logo,
@@ -118,6 +119,8 @@ export class SCConfig {
   static pusherAppCluste = SCDefaultConfig.pusherAppCluster;
   static language = 'en';
   static intervalWatchConfigTime = SCDefaultConfig.intervalWatchConfigTime;
+  static intervalWatchervalWatchDataChipTime =
+    SCDefaultConfig.intervalWatchervalWatchDataChipTime;
   static setCurrentSensorDisplay = SCDefaultConfig.setCurrentSensorDisplay;
   static appName = SCDefaultConfig.appName;
   static appLogo = SCDefaultConfig.appLogo;
@@ -150,6 +153,9 @@ export const initSCConfig = (config) => {
     config.pusherAppCluster ?? SCDefaultConfig.pusherAppCluster;
   SCConfig.intervalWatchConfigTime =
     config.intervalWatchConfigTime ?? SCDefaultConfig.intervalWatchConfigTime;
+  SCConfig.intervalWatchervalWatchDataChipTime =
+    config.intervalWatchervalWatchDataChipTime ??
+    SCDefaultConfig.intervalWatchervalWatchDataChipTime;
   SCConfig.setCurrentSensorDisplay =
     config.setCurrentSensorDisplay ?? SCDefaultConfig.setCurrentSensorDisplay;
   SCConfig.appName = config.appName ?? SCDefaultConfig.appName;

package/src/context/SCContext.tsx

@@ -1,4 +1,4 @@
-import React, { useContext, useReducer } from 'react';
+import React, { useContext, useEffect, useRef, useReducer } from 'react';
 import { StyleSheet, View } from 'react-native';
 import Toast from 'react-native-toast-message';
 
@@ -10,6 +10,7 @@ import {
   StatusBar,
 } from './actionType';
 import { initialState, Action, ContextData, reducer } from './reducer';
+import { setSCStoreGetter } from './SCStore';
 import { setConfigGlobalState } from '../iot/states.js';
 import { setAxiosDefaultLanguage } from '../utils/Utils';
 import { Alert } from '../commons';
@@ -50,6 +51,16 @@ export const SCProvider = ({ children, initState = initialState }) => {
     initState
   );
 
+  const stateRef = useRef<ContextData>(stateData);
+  useEffect(() => {
+    stateRef.current = stateData;
+  }, [stateData]);
+
+  useEffect(() => {
+    setSCStoreGetter(() => stateRef.current);
+    return () => setSCStoreGetter(null);
+  }, []);
+
   const setAuth = (authData: AuthData) => {
     setAction('UPDATE_AUTH', authData);
   };

package/src/context/SCStore.ts

@@ -0,0 +1,14 @@
+import type { ContextData } from './reducer';
+
+let getStateFn: (() => ContextData) | null = null;
+
+export const setSCStoreGetter = (getter: () => ContextData) => {
+  getStateFn = getter;
+};
+
+export const getSCState = (): ContextData => {
+  if (!getStateFn) {
+    throw new Error('SC store is not ready');
+  }
+  return getStateFn();
+};

package/src/context/actionType.ts

@@ -29,6 +29,8 @@ export const Action = {
   SET_HOME_ASSISTANT_CONNECTIONS: 'SET_HOME_ASSISTANT_CONNECTIONS',
   CHANGE_HOME_ASSISTANT_CONN_STATE: 'CHANGE_HOME_ASSISTANT_CONN_STATE',
   SET_LG_THINQ_CONNECTED: 'SET_LG_THINQ_CONNECTED',
+  UPDATE_CONFIGS_BY_ID: 'UPDATE_CONFIGS_BY_ID',
+  UPDATE_SHARED_CHIPS_BY_ID: 'UPDATE_SHARED_CHIPS_BY_ID',
   UPDATE_VALUE_EVALUATIONS: 'UPDATE_VALUE_EVALUATIONS',
   INIT_VALUE_EVALUATIONS: 'INIT_VALUE_EVALUATIONS',
   NEED_UPDATE_VALUE_EVALUATIONS: 'NEED_UPDATE_VALUE_EVALUATIONS',
@@ -91,6 +93,14 @@ export type AutomateType = {
   isUpdateCondition: false;
 };
 
+export type ChipType = {
+  sharedChipsById: {};
+};
+
+export type ConfigType = {
+  configsById: {};
+};
+
 export type ActionType = keyof typeof Action;
 
 export type ActionDataMap = {

package/src/context/mockStore.ts

@@ -32,14 +32,27 @@ export const mockDataStore: ContextData = {
   },
   automate: {
     starredScriptIds: [],
+    isCreateCondition: false,
+    isUpdateCondition: false,
+  },
+  chip: {
+    sharedChipsById: {},
+  },
+  config: {
+    configsById: {},
   },
   app: {
     isFirstOpenCamera: true,
     isLavidaSource: false,
     isConnectWifiGateway: false,
-    isNetworkConnected: true,
+    isNetworkConnected: false,
     camera_opened: [],
+    notificationData: null,
+    popoverAnimating: false,
     isLockWhenPickColor: false,
+    isNeedUpdateCache: false,
+    isDeleteUnitSuccessFully: false,
+    appState: 'active',
   },
   iot: {
     bluetooth: {
@@ -114,11 +127,27 @@ export const mockSCStore = (data: ContextData): ContextData => {
       ],
     },
     automate: {
+      ...mockDataStore.automate,
+      ...data?.automate,
       starredScriptIds: [
         ...mockDataStore.automate.starredScriptIds,
         ...(data?.automate?.starredScriptIds || []),
       ],
     },
+    chip: {
+      ...mockDataStore.chip,
+      sharedChipsById: {
+        ...mockDataStore.chip.sharedChipsById,
+        ...data?.chip?.sharedChipsById,
+      },
+    },
+    config: {
+      ...mockDataStore.config,
+      configsById: {
+        ...mockDataStore.config.configsById,
+        ...data?.config?.configsById,
+      },
+    },
     iot: {
       ...mockDataStore.iot,
       homeassistant: {

package/src/context/reducer.ts

@@ -9,6 +9,8 @@ import {
   ListAction,
   UnitType,
   AutomateType,
+  ChipType,
+  ConfigType,
   AppType,
   IoTType,
   DevModeType,
@@ -25,6 +27,8 @@ export type ContextData = {
   statusBar: StatusBar;
   unit: UnitType;
   automate: AutomateType;
+  chip: ChipType;
+  config: ConfigType;
   app: AppType;
   iot: IoTType;
   valueEvaluations: {};
@@ -62,6 +66,12 @@ export const initialState = {
   automate: {
     starredScriptIds: [],
   },
+  chip: {
+    sharedChipsById: {},
+  },
+  config: {
+    configsById: {},
+  },
   app: {
     isFirstOpenCamera: true,
     isLavidaSource: false,
@@ -366,6 +376,31 @@ export const reducer = (currentState: ContextData, action: Action) => {
           isUpdateCondition: payload,
         },
       };
+
+    case Action.UPDATE_CONFIGS_BY_ID:
+      return {
+        ...currentState,
+        config: {
+          ...currentState.config,
+          configsById: {
+            ...currentState.config.configsById,
+            ...payload,
+          },
+        },
+      };
+
+    case Action.UPDATE_SHARED_CHIPS_BY_ID:
+      return {
+        ...currentState,
+        chip: {
+          ...currentState.chip,
+          sharedChipsById: {
+            ...currentState.chip.sharedChipsById,
+            ...payload,
+          },
+        },
+      };
+
     case Action.SET_BLUETOOTH_CONNECTED_DEVICE:
       return {
         ...currentState,

package/src/hooks/IoT/useRemoteControl.js

@@ -9,6 +9,7 @@ import {
 } from '../../iot/RemoteControl/Bluetooth';
 import { sendCommandOverHomeAssistant } from '../../iot/RemoteControl/HomeAssistant';
 import { sendCommandOverInternet } from '../../iot/RemoteControl/Internet';
+import useInAppReview from '../Review/useInAppReview';
 import { ToastBottomHelper } from '../../utils/Utils';
 
 const handleReconnectionDeviceBle = async (device, action, data, userId) => {
@@ -30,6 +31,7 @@ const useRemoteControl = (bluetoothDevice) => {
   const homeAssistantConnections = useSCContextSelector(
     (state) => state.iot.homeassistant.connections
   );
+  const { incrementReviewTrigger } = useInAppReview(false);
 
   const sendRemoteCommand = useCallback(
     async (device, action, data, userId, silent = false) => {
@@ -41,6 +43,7 @@ const useRemoteControl = (bluetoothDevice) => {
         );
         return result;
       }
+      incrementReviewTrigger();
       if (action.command_prefer_over_bluetooth) {
         // custom control for i/o pin over bluetooth
         if (bluetoothDevice?.isConnected && action.arduino_action) {
@@ -106,7 +109,7 @@ const useRemoteControl = (bluetoothDevice) => {
 
       return await sendCommandOverInternet(device, action, data, 'internet');
     },
-    [bluetoothDevice, homeAssistantConnections]
+    [bluetoothDevice, homeAssistantConnections, incrementReviewTrigger]
   );
 
   return sendRemoteCommand;

package/src/hooks/IoT/useWatchSharedChips.js

@@ -0,0 +1,130 @@
+import {
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+import { useIsFocused } from '@react-navigation/native';
+
+import { API } from '../../configs';
+import { Action } from '../../context/actionType';
+import { SCContext, useSCContextSelector } from '../../context';
+import { axiosGet } from '../../utils/Apis/axios';
+import { unwatchMultiDataChips, watchMultiDataChips } from '../../iot/Monitor';
+import { SCConfig } from '../../configs';
+
+const useWatchSharedChips = ({ dashboardId, filterChipIds, ready = true }) => {
+  const isFocused = useIsFocused();
+  const { setAction } = useContext(SCContext);
+  const [chipIds, setChipIds] = useState([]);
+
+  const chipIdsToWatchRef = useRef([]);
+  const intervalWatchRef = useRef(null);
+
+  const isNetworkConnected = useSCContextSelector(
+    (state) => state.app.isNetworkConnected
+  );
+
+  const handleUpdateConfigsById = useCallback(
+    (chips) => {
+      const configsById = chips.reduce((acc, chip) => {
+        chip.sensors.forEach((sensor) => {
+          sensor.configs.forEach((config) => {
+            acc[config.id] = config;
+          });
+        });
+        return acc;
+      }, {});
+      setAction(Action.UPDATE_CONFIGS_BY_ID, configsById);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+
+  const handleUpdateSharedChipsById = useCallback(
+    (chips) => {
+      const sharedChipsById = chips.reduce((acc, chip) => {
+        acc[chip.id] = chip;
+        return acc;
+      }, {});
+      setAction(Action.UPDATE_SHARED_CHIPS_BY_ID, sharedChipsById);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+
+  useEffect(() => {
+    if (!isNetworkConnected) {
+      return;
+    }
+    const getGateways = async () => {
+      const { success, data } = await axiosGet(API.CHIP.SHARED_CONFIGURATION, {
+        params: {
+          unit: dashboardId,
+        },
+      });
+      if (success) {
+        setChipIds(data.map((chip) => chip.id));
+        handleUpdateConfigsById(data);
+        handleUpdateSharedChipsById(data);
+      }
+    };
+    ready && getGateways();
+  }, [
+    dashboardId,
+    ready,
+    isNetworkConnected,
+    handleUpdateConfigsById,
+    handleUpdateSharedChipsById,
+  ]);
+
+  const chipIdsToWatch = useMemo(() => {
+    if (Array.isArray(filterChipIds)) {
+      return chipIds.filter((chip) => filterChipIds.includes(chip));
+    }
+    return chipIds;
+  }, [chipIds, filterChipIds]);
+
+  const cleanupWatch = useCallback(() => {
+    if (intervalWatchRef.current) {
+      clearInterval(intervalWatchRef.current);
+      intervalWatchRef.current = null;
+    }
+    if (chipIdsToWatchRef.current.length) {
+      unwatchMultiDataChips(chipIdsToWatchRef.current);
+      chipIdsToWatchRef.current = [];
+    }
+  }, []);
+
+  useEffect(() => {
+    if (!isFocused) {
+      cleanupWatch();
+      return;
+    }
+    if (!chipIdsToWatch.length) {
+      return;
+    }
+
+    if (!chipIdsToWatchRef.current.length) {
+      watchMultiDataChips(chipIdsToWatch);
+      chipIdsToWatchRef.current = chipIdsToWatch;
+    }
+
+    if (intervalWatchRef.current) {
+      clearInterval(intervalWatchRef.current);
+    }
+    intervalWatchRef.current = setInterval(() => {
+      watchMultiDataChips(chipIdsToWatch);
+    }, SCConfig.intervalWatchervalWatchDataChipTime);
+  }, [isFocused, chipIdsToWatch, cleanupWatch]);
+
+  useEffect(() => {
+    return () => {
+      cleanupWatch();
+    };
+  }, [cleanupWatch]);
+};
+
+export default useWatchSharedChips;

package/src/hooks/Review/__test__/useInAppReview.test.js

@@ -0,0 +1,99 @@
+import { act, renderHook } from '@testing-library/react-hooks';
+import InAppReview from 'react-native-in-app-review';
+import { getObject, storeObject } from '../../../utils/Storage';
+
+import useInAppReview from '../useInAppReview';
+
+jest.mock('../../../utils/Storage', () => {
+  return {
+    ...jest.requireActual('../../../utils/Storage'),
+    getObject: jest.fn(),
+    storeObject: jest.fn(),
+  };
+});
+
+describe('Test useInAppReview', () => {
+  const mockOnFailed = jest.fn();
+
+  beforeEach(() => {
+    Date.now = jest.fn(() => new Date('2025-09-09T10:00:00.00Z'));
+    getObject.mockImplementation(() => ({ allow: true }));
+    storeObject.mockClear();
+    mockOnFailed.mockClear();
+  });
+
+  it('test calls RequestInAppReview and updates cache when allowed', async () => {
+    await act(async () => {
+      renderHook(() => useInAppReview(true, mockOnFailed));
+    });
+    expect(storeObject).toHaveBeenCalledWith('in_app_review', {
+      allow: true,
+      count: 1,
+      last: new Date('2025-09-09T10:00:00.00Z'),
+    });
+    expect(InAppReview.RequestInAppReview).toHaveBeenCalled();
+    expect(mockOnFailed).not.toHaveBeenCalled();
+  });
+
+  it('test updates cache even when RequestInAppReview rejects', async () => {
+    InAppReview.RequestInAppReview.mockRejectedValueOnce(new Error('fail'));
+    await act(async () => {
+      renderHook(() => useInAppReview(true, mockOnFailed));
+    });
+    expect(storeObject).toHaveBeenCalledWith('in_app_review', {
+      allow: true,
+      count: 1,
+      last: new Date('2025-09-09T10:00:00.00Z'),
+    });
+    expect(InAppReview.RequestInAppReview).toHaveBeenCalled();
+    expect(mockOnFailed).toHaveBeenCalled();
+  });
+
+  it('test does nothing when InAppReview is not available', async () => {
+    InAppReview.isAvailable.mockReturnValueOnce(false);
+    await act(async () => {
+      renderHook(() => useInAppReview(true, mockOnFailed));
+    });
+    expect(storeObject).toHaveBeenCalledWith('in_app_review', {
+      allow: true,
+      count: 1,
+      last: new Date('2025-09-09T10:00:00.00Z'),
+    });
+    expect(InAppReview.RequestInAppReview).not.toHaveBeenCalled();
+    expect(mockOnFailed).toHaveBeenCalled();
+  });
+
+  it('test does nothing when max prompts reached', async () => {
+    getObject.mockImplementation(() => ({ allow: true, count: 3 }));
+    await act(async () => {
+      renderHook(() => useInAppReview(true, mockOnFailed));
+    });
+    expect(storeObject).not.toHaveBeenCalled();
+    expect(InAppReview.RequestInAppReview).not.toHaveBeenCalled();
+    expect(mockOnFailed).not.toHaveBeenCalled();
+  });
+
+  it('test does nothing when still in retry interval', async () => {
+    getObject.mockImplementation(() => ({
+      allow: true,
+      count: 0,
+      last: new Date('2025-09-06T10:00:01.00Z'),
+    }));
+    await act(async () => {
+      renderHook(() => useInAppReview(true, mockOnFailed));
+    });
+    expect(storeObject).not.toHaveBeenCalled();
+    expect(InAppReview.RequestInAppReview).not.toHaveBeenCalled();
+    expect(mockOnFailed).not.toHaveBeenCalled();
+  });
+
+  it('test does nothing when first time and allow = false', async () => {
+    getObject.mockImplementation(() => ({}));
+    await act(async () => {
+      renderHook(() => useInAppReview(true, mockOnFailed));
+    });
+    expect(storeObject).not.toHaveBeenCalled();
+    expect(InAppReview.RequestInAppReview).not.toHaveBeenCalled();
+    expect(mockOnFailed).not.toHaveBeenCalled();
+  });
+});