@ledvance/ui-biz-bundle 1.1.55 → 1.1.57

package/src/newModules/mood/MoodParse.ts

@@ -0,0 +1,442 @@
+import { hex2Int, spliceByStep } from '@ledvance/base/src/utils/common';
+import { Utils } from '@tuya/tuya-panel-lamp-sdk';
+import { MoodInfo, MoodNodeInfo } from './Interface';
+import { getDefaultMood } from './MoodInfo';
+const { nToHS, toFixed, sToN } = Utils;
+
+// light source
+export function dp2Obj(dp: string, isFan: boolean = false, isUVCFan?: boolean): MoodInfo {
+  if (!dp) return getDefaultMood();
+  let dpCopy = dp;
+  let fanEnable: undefined | boolean = undefined;
+  let fanSpeed: undefined | number = undefined;
+  let mode = 0;
+  let speed = 75;
+  const id = hex2Int(dpCopy.slice(0, 2));
+  dpCopy = dpCopy.slice(2);
+  if (isFan) {
+    fanEnable = hex2Int(dpCopy.slice(0, 2)) === 1;
+    dpCopy = dpCopy.slice(2);
+    fanSpeed = hex2Int(dpCopy.slice(0, 2));
+    dpCopy = dpCopy.slice(2);
+  }
+  const nodes: MoodNodeInfo[] = spliceByStep(dpCopy, 26).map(nodeHex => {
+    let hex = nodeHex;
+    speed = isUVCFan ? 101 - hex2Int(hex.slice(0, 2)) : hex2Int(hex.slice(0, 2));
+    hex = hex.slice(2);
+    speed = isUVCFan ? 101 - hex2Int(hex.slice(0, 2)) : hex2Int(hex.slice(0, 2));
+    hex = hex.slice(2);
+    mode = hex2Int(hex.slice(0, 2));
+    hex = hex.slice(2);
+    const h = hex2Int(hex.slice(0, 4));
+    hex = hex.slice(4);
+    const s = Math.round(hex2Int(hex.slice(0, 4)) / 10);
+    hex = hex.slice(4);
+    const v = Math.round(hex2Int(hex.slice(0, 4)) / 10);
+    hex = hex.slice(4);
+    const brightness = Math.round(hex2Int(hex.slice(0, 4)) / 10);
+    hex = hex.slice(4);
+    const colorTemp = Math.round(hex2Int(hex.slice(0, 4)) / 10);
+    const isColorNode = h !== 0 || s !== 0 || v !== 0;
+    return {
+      h,
+      s,
+      v,
+      brightness,
+      colorTemp,
+      isColorNode,
+    };
+  });
+  return {
+    id,
+    version: 0,
+    mainLamp: {
+      mode,
+      speed,
+      fanEnable,
+      fanSpeed,
+      nodes,
+      enable: true,
+    },
+    secondaryLamp: {
+      mode: 0,
+      speed: 100,
+      nodes: [],
+      enable: true,
+    },
+  };
+}
+
+export function obj2Dp(mood: MoodInfo, isFan: boolean = false, isUVCFan?: boolean): string {
+  const { mainLamp } = mood;
+  let fanEnableHex = '';
+  let fanSpeedHex = '';
+  const idHex = mood.id.toString(16).padStart(2, '0');
+  if (isFan) {
+    fanEnableHex = (mainLamp.fanEnable ? 1 : 0).toString(16).padStart(2, '0');
+    fanSpeedHex = (mainLamp.fanSpeed || 1).toString(16).padStart(2, '0');
+  }
+  const hex =
+    idHex +
+    fanEnableHex +
+    fanSpeedHex +
+    mainLamp.nodes
+      ?.map(node => {
+        const switchingIntervalHex = (isUVCFan ? 101 - mainLamp.speed : mainLamp.speed)
+          .toString(16)
+          .padStart(2, '0');
+        const transitionTimeHex = (isUVCFan ? 101 - mainLamp.speed : mainLamp.speed)
+          .toString(16)
+          .padStart(2, '0');
+        const transitionModeHex = mainLamp.mode.toString(16).padStart(2, '0');
+        const hHex = node.h.toString(16).padStart(4, '0');
+        const sHex = (node.s * 10).toString(16).padStart(4, '0');
+        const vHex = (node.v * 10).toString(16).padStart(4, '0');
+        const brightnessHex = (node.brightness * 10).toString(16).padStart(4, '0');
+        const colorTempHex = (node.colorTemp * 10).toString(16).padStart(4, '0');
+        return (
+          switchingIntervalHex +
+          transitionTimeHex +
+          transitionModeHex +
+          hHex +
+          sHex +
+          vHex +
+          brightnessHex +
+          colorTempHex
+        );
+      })
+      .join('');
+  return hex;
+}
+
+// strip,string light
+export function stripDp2Obj(dp: string, isStringLight: boolean = false): MoodInfo {
+  if (!dp) return getDefaultMood();
+  const version = hex2Int(dp.slice(0, 2));
+  const id = hex2Int(dp.slice(2, 4));
+  const mode = hex2Int(dp.slice(4, 6));
+  const intervalTime = hex2Int(dp.slice(6, 8));
+  const changeTime = hex2Int(dp.slice(8, 10));
+  const speed = intervalTime || changeTime;
+  const optionA = hex2Int(dp.slice(10, 12)).toString(2).padStart(8, '0');
+  const segmented = sToN(optionA.slice(0, 1), 2);
+  const loop = sToN(optionA.slice(1, 2), 2);
+  const excessive = sToN(optionA.slice(2, 3), 2);
+  const direction = sToN(optionA.slice(3, 4), 2);
+  const expand = sToN(optionA.slice(4, 6), 2);
+  const reserved1 = sToN(optionA.slice(6, 7), 2);
+  const reserved2 = sToN(optionA.slice(7, 8), 2);
+  // 这两个目前灯具用不上
+  // const optionB = toN(dp.slice(12, 14))
+  // const optionC = toN(dp.slice(14, 16))
+  let nodes = [] as MoodNodeInfo[];
+  if (isStringLight) {
+    nodes = spliceByStep(dp.slice(16, dp.length), 16).map(nodeHex => {
+      const v = hex2Int(nodeHex.slice(0, 2));
+      const h = hex2Int(nodeHex.slice(2, 6));
+      const s = hex2Int(nodeHex.slice(6, 8));
+      const brightness = hex2Int(nodeHex.slice(8, 12)) / 10;
+      const colorTemp = hex2Int(nodeHex.slice(12, 16)) / 10;
+      const isColorNode = v > 0 && brightness === 0;
+      return { h, s, v, brightness, colorTemp, isColorNode };
+    });
+  } else {
+    const bright = hex2Int(dp.slice(16, 18));
+    nodes = spliceByStep(dp.slice(18, dp.length), 6).map(nodeHex => {
+      const h = hex2Int(nodeHex.slice(0, 4));
+      const s = hex2Int(nodeHex.slice(4, 6));
+      const v = bright;
+      const brightness = 0;
+      const colorTemp = 0;
+      const isColorNode = true;
+      return { h, s, v, brightness, colorTemp, isColorNode };
+    });
+  }
+
+  return {
+    version,
+    id,
+    mainLamp: {
+      mode,
+      speed,
+      direction,
+      segmented,
+      loop,
+      excessive,
+      expand,
+      reserved1,
+      reserved2,
+      nodes,
+      enable: true,
+    },
+    secondaryLamp: {
+      mode,
+      speed,
+      nodes: [],
+      enable: true,
+    },
+  };
+}
+
+export function stripObj2Dp(mood: MoodInfo, isStringLight: boolean = false) {
+  const {
+    expand = 0,
+    reserved1 = 0,
+    reserved2 = 0,
+    // mixedIds = [],
+    segmented = 0,
+    loop = 0,
+    excessive = 0,
+    direction = 0,
+    mode,
+    speed,
+    nodes,
+  } = mood.mainLamp;
+  const versionHex = nToHS(mood.version);
+  const idHex = nToHS(mood.id);
+  const modeHex = nToHS(mode);
+  const intervalTimeHex = nToHS(speed);
+  const changeTimeHex = nToHS(speed);
+  const optionAHex = nToHS(
+    parseInt(
+      `${segmented}${loop}${excessive}${direction}${toFixed(
+        expand.toString(2),
+        2
+      )}${reserved1}${reserved2}`,
+      2
+    )
+  );
+  const optionBHex = nToHS(0);
+  const optionCHex = nToHS(0);
+  let nodeHex = '';
+  if (isStringLight) {
+    nodeHex = nodes
+      .map(node => {
+        return `${nToHS(node.v)}${nToHS(node.h, 4)}${nToHS(node.s)}${nToHS(
+          node.brightness * 10,
+          4
+        )}${nToHS(node.colorTemp * 10, 4)}`;
+      })
+      .join('');
+  } else {
+    const brightHex = nToHS(nodes[0].v);
+    nodeHex =
+      brightHex +
+      nodes
+        .map(node => {
+          return `${nToHS(node.h, 4)}${nToHS(node.s)}`;
+        })
+        .join('');
+  }
+
+  return (
+    versionHex +
+    idHex +
+    modeHex +
+    intervalTimeHex +
+    changeTimeHex +
+    optionAHex +
+    optionBHex +
+    optionCHex +
+    nodeHex
+  );
+}
+
+// mix light
+export function MixObj2Dp(mood: MoodInfo) {
+  const { mainLamp, secondaryLamp } = mood;
+  const versionHex = nToHS(mood.version);
+  const idHex = nToHS(mood.id);
+  const lamps = [mainLamp, secondaryLamp];
+  const lampsHex = lamps
+    .map(lamp => {
+      let lampHex = lamp.enable ? '01' : '00';
+      const nodes = lamp.nodes || [];
+      lampHex += nToHS(nodes.length || 0);
+      if (nodes.length === 0 || !lamp.enable) {
+        return lampHex;
+      }
+      lampHex += nToHS(lamp.type);
+      lampHex += nodes
+        .map(node => {
+          let nodeHex = '';
+          nodeHex += nToHS(lamp.speed);
+          nodeHex += nToHS(lamp.speed);
+          nodeHex += nToHS(lamp.mode);
+          switch (
+            lamp.type // 1:W 只有亮度，2:CW 亮度+色温，3:RGB HSV，4:RGBC HSV+色温，5:RGBCW HSV+色温+亮度
+          ) {
+            case 1:
+              nodeHex += nToHS(node.brightness * 10, 4);
+              break;
+            case 2:
+              nodeHex += nToHS(node.brightness * 10, 4);
+              nodeHex += nToHS(node.colorTemp * 10, 4);
+              break;
+            case 3:
+              nodeHex += nToHS(node.h, 4);
+              nodeHex += nToHS(node.s * 10, 4);
+              nodeHex += nToHS(node.v * 10, 4);
+              break;
+            case 4:
+              nodeHex += nToHS(node.h, 4);
+              nodeHex += nToHS(node.s * 10, 4);
+              nodeHex += nToHS(node.v * 10, 4);
+              nodeHex += nToHS(node.colorTemp * 10, 4);
+              break;
+            case 5:
+              nodeHex += nToHS(node.h, 4);
+              nodeHex += nToHS(node.s * 10, 4);
+              nodeHex += nToHS(node.v * 10, 4);
+              nodeHex += nToHS(node.brightness * 10, 4);
+              nodeHex += nToHS(node.colorTemp * 10, 4);
+              break;
+          }
+          return nodeHex;
+        })
+        .join('');
+      return lampHex;
+    })
+    .join('');
+  return versionHex + idHex + lampsHex;
+}
+
+export function MixDp2Obj(dp: string): MoodInfo {
+  if (!dp) return getDefaultMood();
+  const result = { mainLamp: {}, secondaryLamp: {} } as MoodInfo;
+  result.version = sToN(dp.slice(0, 2));
+  result.id = sToN(dp.slice(2, 4));
+  const mainEnable = sToN(dp.slice(4, 6)) === 1;
+  const mainNum = sToN(dp.slice(6, 8));
+  let sliceDp = dp.slice(8);
+  result.mainLamp.enable = mainEnable;
+  result.mainLamp.nodes = [];
+  if (mainEnable && mainNum) {
+    result.mainLamp.type = sToN(sliceDp.slice(0, 2));
+    sliceDp = sliceDp.slice(2);
+    for (let i = 0; i < mainNum; i++) {
+      result.mainLamp.speed = sToN(sliceDp.slice(0, 2));
+      result.mainLamp.mode = sToN(sliceDp.slice(4, 6));
+      sliceDp = sliceDp.slice(6);
+      const node = {} as MoodNodeInfo;
+      switch (result.mainLamp.type) {
+        case 1:
+          node.brightness = sToN(sliceDp.slice(0, 4)) / 10;
+          node.isColorNode = false;
+          sliceDp = sliceDp.slice(4);
+          break;
+        case 2:
+          node.brightness = sToN(sliceDp.slice(0, 4)) / 10;
+          node.colorTemp = sToN(sliceDp.slice(4, 8)) / 10;
+          node.isColorNode = false;
+          sliceDp = sliceDp.slice(8);
+          break;
+        case 3:
+          node.h = sToN(sliceDp.slice(0, 4));
+          node.s = sToN(sliceDp.slice(4, 8)) / 10;
+          node.v = sToN(sliceDp.slice(8, 12)) / 10;
+          node.isColorNode = true;
+          sliceDp = sliceDp.slice(12);
+          break;
+        case 4:
+          node.h = sToN(sliceDp.slice(0, 4));
+          node.s = sToN(sliceDp.slice(4, 8)) / 10;
+          node.v = sToN(sliceDp.slice(8, 12)) / 10;
+          node.colorTemp = sToN(sliceDp.slice(12, 16)) / 10;
+          node.isColorNode = true;
+          sliceDp = sliceDp.slice(16);
+          break;
+        case 5:
+          node.h = sToN(sliceDp.slice(0, 4));
+          node.s = sToN(sliceDp.slice(4, 8)) / 10;
+          node.v = sToN(sliceDp.slice(8, 12)) / 10;
+          node.brightness = sToN(sliceDp.slice(12, 16)) / 10;
+          node.colorTemp = sToN(sliceDp.slice(16, 20)) / 10;
+          node.isColorNode = true;
+          sliceDp = sliceDp.slice(20);
+          break;
+      }
+      result.mainLamp.nodes.push(node);
+    }
+  }
+  const secondaryEnable = sToN(sliceDp.slice(0, 2)) === 1;
+  const secondaryNum = sToN(sliceDp.slice(2, 4));
+  result.secondaryLamp.enable = secondaryEnable;
+  result.secondaryLamp.nodes = [];
+  sliceDp = sliceDp.slice(4);
+  if (secondaryEnable && secondaryNum) {
+    result.secondaryLamp.type = sToN(sliceDp.slice(0, 2));
+    sliceDp = sliceDp.slice(2);
+    for (let i = 0; i < secondaryNum; i++) {
+      result.secondaryLamp.speed = sToN(sliceDp.slice(0, 2));
+      result.secondaryLamp.mode = sToN(sliceDp.slice(4, 6));
+      sliceDp = sliceDp.slice(6);
+      const node = {} as MoodNodeInfo;
+      switch (result.secondaryLamp.type) {
+        case 1:
+          node.brightness = sToN(sliceDp.slice(0, 4)) / 10;
+          node.isColorNode = true;
+          sliceDp = sliceDp.slice(4);
+          break;
+        case 2:
+          node.brightness = sToN(sliceDp.slice(0, 4)) / 10;
+          node.colorTemp = sToN(sliceDp.slice(4, 8)) / 10;
+          node.isColorNode = false;
+          sliceDp = sliceDp.slice(8);
+          break;
+        case 3:
+          node.h = sToN(sliceDp.slice(0, 4));
+          node.s = sToN(sliceDp.slice(4, 8)) / 10;
+          node.v = sToN(sliceDp.slice(8, 12)) / 10;
+          node.isColorNode = true;
+          sliceDp = sliceDp.slice(12);
+          break;
+        case 4:
+          node.h = sToN(sliceDp.slice(0, 4));
+          node.s = sToN(sliceDp.slice(4, 8)) / 10;
+          node.v = sToN(sliceDp.slice(8, 12)) / 10;
+          node.colorTemp = sToN(sliceDp.slice(12, 16)) / 10;
+          node.isColorNode = true;
+          sliceDp = sliceDp.slice(16);
+          break;
+        case 5:
+          node.h = sToN(sliceDp.slice(0, 4));
+          node.s = sToN(sliceDp.slice(4, 8)) / 10;
+          node.v = sToN(sliceDp.slice(8, 12)) / 10;
+          node.brightness = sToN(sliceDp.slice(12, 16)) / 10;
+          node.colorTemp = sToN(sliceDp.slice(16, 20)) / 10;
+          node.isColorNode = true;
+          sliceDp = sliceDp.slice(20);
+          break;
+      }
+      result.secondaryLamp.nodes.push(node);
+    }
+  }
+
+  return result;
+}
+
+export function MixCeilingDpObj(mainDp: string, secondaryDp: string): MoodInfo {
+  const mainLamp = dp2Obj(mainDp);
+  const secondaryLamp = secondaryDp ? stripDp2Obj(secondaryDp) : '';
+  return {
+    id: 0,
+    version: 0,
+    mainLamp: {
+      id: mainLamp.id,
+      version: mainLamp.version,
+      ...mainLamp.mainLamp,
+    },
+    secondaryLamp: secondaryLamp
+      ? {
+          id: secondaryLamp.id,
+          version: secondaryLamp.version,
+          ...secondaryLamp.secondaryLamp,
+        }
+      : {
+          mode: 0,
+          speed: 75,
+          nodes: [],
+        },
+  };
+}

package/src/newModules/mood/RecommendMoodItem.tsx

@@ -0,0 +1,68 @@
+import React from 'react';
+import { Utils } from 'tuya-panel-kit';
+import Card from '@ledvance/base/src/components/Card';
+import { CellContent } from '@ledvance/base/src/components/Cell';
+import { StyleSheet, View } from 'react-native';
+import Spacer from '@ledvance/base/src/components/Spacer';
+import { MoodUIInfo } from './Interface';
+import { MixMoodColorsLine } from './MoodItem';
+
+const cx = Utils.RatioUtils.convertX;
+
+interface RecommendMixMoodItemProps {
+  title: string;
+  isMix: boolean;
+  mood: MoodUIInfo;
+  onPress: () => void;
+}
+
+const RecommendMixMoodItem = (props: RecommendMixMoodItemProps) => {
+  const { mood, isMix } = props;
+
+  return (
+    <Card style={styles.root} onPress={props.onPress}>
+      <CellContent
+        title={props.title}
+        value={''}
+        style={styles.content}
+        titleStyle={styles.title}
+        iconStyle={{
+          color: '#000',
+          size: cx(16),
+        }}
+      />
+      {!!(mood.mainLamp) && (
+        <>
+          <View style={styles.lineStyle}>
+            <MixMoodColorsLine mixSubLight={mood?.mainLamp} isMix={isMix} />
+            <Spacer height={cx(7)} />
+            {isMix && <MixMoodColorsLine mixSubLight={mood.secondaryLamp} isMix={isMix} />}
+          </View>
+          <Spacer height={cx(24)} />
+        </>
+      )}
+    </Card>
+  );
+};
+
+const styles = StyleSheet.create({
+  root: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    marginHorizontal: cx(24),
+  },
+  content: {
+    height: cx(56),
+    marginHorizontal: cx(16),
+  },
+  title: {
+    color: '#000',
+    fontSize: cx(16),
+    fontFamily: 'helvetica_neue_lt_std_bd',
+  },
+  lineStyle: {
+    alignItems: 'center',
+  },
+});
+
+export default RecommendMixMoodItem;

package/src/newModules/mood/Router.ts

@@ -0,0 +1,53 @@
+import {NavigationRoute, TransitionPresets} from "tuya-panel-kit";
+import DynamicMoodEditorPage from "../../modules/mood/DynamicMoodEditorPage";
+import StaticMoodEditorPage from "../../modules/mood/StaticMoodEditorPage";
+import AddMoodPage from "../../modules/mood/AddMoodPage";
+import MoodPage from "../../modules/mood/MoodPage";
+import SelectPage from "../../modules/select/SelectPage";
+import {ui_biz_routerKey} from "../../navigation/Routers";
+
+const MoodPageRouters: NavigationRoute[] = [
+  {
+    name: ui_biz_routerKey.ui_biz_dynamic_mood_edit,
+    component: DynamicMoodEditorPage,
+    options: {
+      hideTopbar: true,
+      showOfflineView: false,
+    },
+  },
+  {
+    name: ui_biz_routerKey.ui_biz_static_mood_edit,
+    component: StaticMoodEditorPage,
+    options: {
+      hideTopbar: true,
+      showOfflineView: false,
+    },
+  },
+  {
+    name: ui_biz_routerKey.ui_biz_mood_add,
+    component: AddMoodPage,
+    options: {
+      hideTopbar: true,
+      showOfflineView: false,
+    },
+  },
+  {
+    name: ui_biz_routerKey.ui_biz_mood,
+    component: MoodPage,
+    options: {
+      hideTopbar: true,
+      showOfflineView: false,
+    },
+  },
+  {
+    name: ui_biz_routerKey.ui_biz_select_page,
+    component: SelectPage,
+    options: {
+      gesture: true,
+      hideTopbar: true,
+      ...TransitionPresets.ModalPresentationIOS,
+    },
+  },
+]
+
+export default MoodPageRouters