@nordicsemiconductor/pc-nrfconnect-shared 120.0.0 → 122.0.0

package/src/Device/deviceLister.ts

@@ -4,11 +4,7 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import {
-    DeviceTraits,
-    NrfutilDevice,
-    NrfutilDeviceWithSerialnumber,
-} from '../../nrfutil/device/common';
+import { DeviceTraits, NrfutilDevice } from '../../nrfutil/device/common';
 import NrfutilDeviceLib from '../../nrfutil/device/device';
 import logger from '../logging';
 import type { AppThunk, RootState } from '../store';
@@ -23,7 +19,14 @@ import {
     WaitForDevice,
 } from './deviceAutoSelectSlice';
 import { closeDeviceSetupDialog } from './deviceSetupSlice';
-import { addDevice, Device, removeDevice } from './deviceSlice';
+import {
+    addDevice,
+    Device,
+    getDevice,
+    removeDevice,
+    selectDevice,
+    setSelectedDeviceInfo,
+} from './deviceSlice';
 import { isDeviceInDFUBootloader } from './sdfuOperations';
 
 let stopNrfutilDevice: (callback?: () => void) => void;
@@ -52,6 +55,11 @@ const shouldAutoReselect = (
     // device is still connected
     if (disconnectionTime === undefined) return false;
 
+    // device does not have sn
+    if (!addedDevice.serialNumber) {
+        return false;
+    }
+
     // The device that was selected when disconnection occurred is not yet connected
     if (addedDevice.serialNumber !== autoReselectDevice.serialNumber) {
         return false;
@@ -100,28 +108,6 @@ const initAutoReconnectTimeout =
         );
     };
 
-/**
- * Wrap the device form nrfutil-device to make the Device type consistent
- *
- * @param {NrfutilDevice} device The input device from nrfutil-device
- * @returns {NrfutilDevice} The updated device
- */
-export const wrapDeviceFromNrfdl = (device: NrfutilDevice): Device => ({
-    ...device,
-    boardVersion: device.jlink?.boardVersion ?? undefined,
-    serialport: device.serialPorts?.[0] ?? undefined,
-    serialNumber: device.serialNumber ?? `fallback-serialnumber-${device.id}`,
-});
-
-/**
- * Wrap the device form nrfutil-device to make the Device type consistent
- *
- * @param {NrfutilDevice[]} devices The input devices from nrfutil-device
- * @returns {NrfutilDevice[]} The updated devices
- */
-export const wrapDevicesFromNrfdl = (devices: NrfutilDevice[]): Device[] =>
-    devices.map(wrapDeviceFromNrfdl);
-
 export const hasValidDeviceTraits = (
     deviceTraits: DeviceTraits,
     requiredTraits: DeviceTraits
@@ -143,17 +129,17 @@ const removeDeviceFromList =
     ): AppThunk =>
     (dispatch, getState) => {
         if (
-            removedDevice.serialNumber ===
-            getState().device.selectedSerialNumber
+            removedDevice.serialNumber !==
+            getState().device.selectedDevice?.serialNumber
         ) {
-            onDeviceDeselected();
+            dispatch(removeDevice(removedDevice));
+            onDeviceDisconnected(removedDevice);
+            return;
         }
 
-        if (
-            removedDevice.serialNumber ===
-                getState().device.selectedSerialNumber &&
-            !getState().deviceAutoSelect.waitForDevice
-        ) {
+        onDeviceDeselected();
+
+        if (!getState().deviceAutoSelect.waitForDevice) {
             dispatch(closeDeviceSetupDialog());
         }
 
@@ -176,22 +162,21 @@ export const startWatchingDevices =
         doSelectDevice: (device: Device, autoReselected: boolean) => void
     ): AppThunk<RootState, void> =>
     (dispatch, getState) => {
-        const onDeviceArrived = (device: NrfutilDeviceWithSerialnumber) => {
+        const onDeviceArrived = async (device: NrfutilDevice) => {
             if (hasValidDeviceTraits(device.traits, deviceListing)) {
-                device = wrapDeviceFromNrfdl(device);
                 if (
                     device.serialNumber &&
-                    !getState().device.devices.has(device.serialNumber)
+                    !getState().device.devices.find(
+                        d => d.serialNumber === device.serialNumber
+                    )
                 ) {
                     onDeviceConnected(device);
                 }
 
-                const sn = getState().device.selectedSerialNumber;
                 const disconnectionTime =
                     getState().deviceAutoSelect.disconnectionTime;
                 const autoSelectDevice = getState().deviceAutoSelect.device;
-                const selectedDevice =
-                    sn !== null ? getState().device.devices.get(sn) : undefined;
+                const selectedDevice = getState().device.selectedDevice;
 
                 const result = shouldAutoReselect(
                     device,
@@ -202,17 +187,32 @@ export const startWatchingDevices =
                 );
 
                 dispatch(addDevice(device));
-                const deviceWithPersistedData = getState().device.devices.get(
-                    device.serialNumber
+                const deviceWithPersistedData = getState().device.devices.find(
+                    d => d.serialNumber === device.serialNumber
                 );
 
                 if (!deviceWithPersistedData) return;
 
-                if (result) {
+                // We might get multiple events with the same info so no to trigger auto reconnect multiple times we
+                // only do it once per device id
+                if (
+                    result &&
+                    getState().deviceAutoSelect.lastArrivedDeviceId !==
+                        deviceWithPersistedData.id
+                ) {
+                    dispatch(
+                        setLastArrivedDeviceId(deviceWithPersistedData.id)
+                    );
+
+                    const deviceInfo = await NrfutilDeviceLib.deviceInfo(
+                        device
+                    );
+
                     logger.info(
                         `Auto Reconnecting Device SN: ${deviceWithPersistedData.serialNumber}`
                     );
                     doSelectDevice(deviceWithPersistedData, true);
+                    dispatch(setSelectedDeviceInfo(deviceInfo));
                 } else if (
                     deviceWithPersistedData.serialNumber ===
                     getState().deviceAutoSelect.device?.serialNumber
@@ -220,6 +220,10 @@ export const startWatchingDevices =
                     const waitForDevice =
                         getState().deviceAutoSelect.waitForDevice;
 
+                    const deviceInfo = await NrfutilDeviceLib.deviceInfo(
+                        device
+                    );
+
                     // Device lib might fail to advertise that a device has left before it rejoins (Mainly OSx)
                     // but we still need to trigger the onSuccess if a device 'reappeared' with a different 'id'
                     // and there is an outstanding waitForDevice Request. In this case the disconnectionTime was
@@ -245,8 +249,7 @@ export const startWatchingDevices =
                                     deviceWithPersistedData
                                 )) ||
                             (waitForDevice.when === 'applicationMode' &&
-                                deviceWithPersistedData.dfuTriggerInfo !==
-                                    null) ||
+                                deviceInfo?.dfuTriggerVersion) ||
                             (selectedDevice &&
                                 waitForDevice.when === 'sameTraits' &&
                                 hasSameDeviceTraits(
@@ -269,6 +272,9 @@ export const startWatchingDevices =
                                 clearWaitForDeviceTimeout(waitForDevice.once)
                             );
 
+                            dispatch(selectDevice(deviceWithPersistedData));
+                            dispatch(setSelectedDeviceInfo(deviceInfo));
+
                             if (waitForDevice.onSuccess)
                                 waitForDevice.onSuccess(
                                     deviceWithPersistedData
@@ -288,8 +294,9 @@ export const startWatchingDevices =
                     const waitForDevice =
                         getState().deviceAutoSelect.waitForDevice;
                     if (
+                        device.serialNumber &&
                         device.serialNumber ===
-                        getState().deviceAutoSelect.device?.serialNumber
+                            getState().deviceAutoSelect.device?.serialNumber
                     ) {
                         if (waitForDevice) {
                             dispatch(setArrivedButWrongWhen(undefined));
@@ -351,8 +358,10 @@ export const startWatchingDevices =
                 const autoSelectSN = getAutoSelectDeviceCLISerial();
 
                 if (autoSelectSN !== undefined) {
-                    const autoSelectDevice =
-                        getState().device.devices.get(autoSelectSN);
+                    const autoSelectDevice = getDevice(
+                        getState(),
+                        autoSelectSN
+                    );
 
                     if (autoSelectDevice)
                         doSelectDevice(autoSelectDevice, true);

package/src/Device/deviceSetup.ts

@@ -3,6 +3,7 @@
  *
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
+import { DeviceInfo } from '../../nrfutil/device/deviceInfo';
 import logger from '../logging';
 import describeError from '../logging/describeError';
 import { AppThunk, RootState } from '../store';
@@ -33,15 +34,24 @@ export interface JprogEntry {
 }
 
 export interface DeviceSetup {
-    supportsProgrammingMode: (device: Device) => boolean; // Return true if this device can be programed using this interface e.g. MCU Boot or DFU
-    getFirmwareOptions: (device: Device) => {
+    supportsProgrammingMode: (
+        device: Device,
+        deviceInfo?: DeviceInfo
+    ) => boolean; // Return true if this device can be programed using this interface e.g. MCU Boot or DFU
+    getFirmwareOptions: (
+        device: Device,
+        deviceInfo?: DeviceInfo
+    ) => {
         key: string;
         description?: string;
         programDevice: (
             onProgress: (progress: number, message?: string) => void
         ) => AppThunk<RootState, Promise<Device>>;
     }[]; // The list of all firmware that can be applied for this device with the program function for that fw item
-    isExpectedFirmware: (device: Device) => AppThunk<
+    isExpectedFirmware: (
+        device: Device,
+        deviceInfo?: DeviceInfo
+    ) => AppThunk<
         RootState,
         Promise<{
             device: Device;
@@ -66,6 +76,7 @@ export const prepareDevice =
         deviceSetupConfig: DeviceSetupConfig,
         onSuccess: (device: Device) => void,
         onFail: (reason?: unknown) => void,
+        deviceInfo: DeviceInfo | undefined,
         checkCurrentFirmwareVersion = true,
         requireUserConfirmation = true
     ): AppThunk<RootState, Promise<void>> =>
@@ -74,18 +85,22 @@ export const prepareDevice =
             onSuccess(d);
             dispatch(closeDeviceSetupDialog());
         };
+
         const validDeviceSetups = deviceSetupConfig.deviceSetups.filter(
-            deviceSetup => deviceSetup.supportsProgrammingMode(device)
+            deviceSetup =>
+                deviceSetup.supportsProgrammingMode(device, deviceInfo)
         );
 
         const possibleFirmware = validDeviceSetups
-            .map(deviceSetup => deviceSetup.getFirmwareOptions(device))
+            .map(deviceSetup =>
+                deviceSetup.getFirmwareOptions(device, deviceInfo)
+            )
             .flat();
 
         if (possibleFirmware.length === 0) {
             logger.info(
                 `Connected to device with serial number: ${device.serialNumber} ` +
-                    `and family: ${device.jlink?.deviceFamily || 'Unknown'} `
+                    `and family: ${device.devkit?.deviceFamily || 'Unknown'} `
             );
             if (deviceSetupConfig.allowCustomDevice) {
                 logger.info(
@@ -110,7 +125,7 @@ export const prepareDevice =
                 try {
                     // eslint-disable-next-line no-await-in-loop
                     const result = await dispatch(
-                        deviceSetup.isExpectedFirmware(device)
+                        deviceSetup.isExpectedFirmware(device, deviceInfo)
                     );
                     device = result.device;
                     if (result.validFirmware) {
@@ -153,6 +168,7 @@ export const prepareDevice =
         };
 
         const cancelAction = async () => {
+            dispatch(closeDeviceSetupDialog());
             let i = 0;
             do {
                 const deviceSetup = validDeviceSetups[i];
@@ -226,7 +242,8 @@ export const setupDevice =
         device: Device,
         deviceSetupConfig: DeviceSetupConfig,
         onDeviceIsReady: (device: Device) => void,
-        doDeselectDevice: () => void
+        doDeselectDevice: () => void,
+        deviceInfo: DeviceInfo | undefined
     ): AppThunk<RootState> =>
     (dispatch, getState) =>
         dispatch(
@@ -241,7 +258,7 @@ export const setupDevice =
                     // while that is still in progress select some other device
                     // if both were to call onDeviceIsReady the app might have unexpected side effects
                     if (
-                        getState().device.selectedSerialNumber ===
+                        getState().device.selectedDevice?.serialNumber ===
                         d.serialNumber
                     ) {
                         onDeviceIsReady(d);
@@ -254,6 +271,7 @@ export const setupDevice =
                     );
                     logger.error(describeError(error));
                     doDeselectDevice();
-                }
+                },
+                deviceInfo
             )
         );

package/src/Device/deviceSlice.ts

@@ -8,7 +8,8 @@ import { createSlice, PayloadAction } from '@reduxjs/toolkit';
 import type { AutoDetectTypes } from '@serialport/bindings-cpp';
 import { SerialPortOpenOptions } from 'serialport';
 
-import { NrfutilDevice, SerialPort } from '../../nrfutil/device/common';
+import { DeviceInfo } from '../../nrfutil';
+import { NrfutilDevice } from '../../nrfutil/device/common';
 import type { RootState } from '../store';
 import {
     getPersistedIsFavorite,
@@ -20,65 +21,74 @@ import {
 } from '../utils/persistentStore';
 
 export interface Device extends NrfutilDevice {
-    serialNumber: string;
-    boardVersion?: string;
     nickname?: string;
-    serialport?: SerialPort;
     favorite?: boolean;
-    id: number;
     persistedSerialPortOptions?: SerialPortOpenOptions<AutoDetectTypes>;
 }
 
+const findDeviceItem = (
+    devices: Device[],
+    id: number,
+    serialNumber?: string
+) => {
+    const index = devices.findIndex(
+        d => d.id === id || d.serialNumber === serialNumber
+    );
+
+    return { index, device: devices[index] };
+};
+
 const updateDevice = (
     state: DeviceState,
-    serialNumber: string,
-    updateToMergeIn: Partial<Device>
+    updateToMergeIn: Partial<Device>,
+    id: number,
+    serialNumber?: string
 ) => {
-    const device = state.devices.get(serialNumber);
+    const device = findDeviceItem(state.devices, id, serialNumber).device;
     if (device) {
         Object.assign(device, updateToMergeIn);
     }
 };
 
 export interface DeviceState {
-    devices: Map<string, Device>;
-    deviceInfo: Device | null;
-    selectedSerialNumber: string | null;
+    devices: Device[];
     readbackProtection: 'unknown' | 'protected' | 'unprotected';
+    selectedDevice?: Device;
+    selectedDeviceInfo?: DeviceInfo;
 }
 
 const initialState: DeviceState = {
-    devices: new Map(),
-    selectedSerialNumber: null,
-    deviceInfo: null,
+    devices: [],
     readbackProtection: 'unknown',
 };
 
 const setPersistedData = (device: Device) => {
-    const newDevice = {
-        ...device,
-        favorite: getPersistedIsFavorite(device.serialNumber),
-        nickname: getPersistedNickname(device.serialNumber),
-    };
-
-    const persistedSerialPortSettings = getPersistedSerialPortSettings(
-        newDevice.serialNumber
-    );
-
-    if (persistedSerialPortSettings) {
-        const path =
-            newDevice.serialPorts?.[persistedSerialPortSettings.vComIndex]
-                ?.comName;
-
-        if (path) {
-            newDevice.persistedSerialPortOptions = {
-                ...persistedSerialPortSettings.serialPortOptions,
-                path,
-            };
+    if (device.serialNumber) {
+        const newDevice = { ...device };
+        newDevice.favorite = getPersistedIsFavorite(device.serialNumber);
+        newDevice.nickname = getPersistedNickname(device.serialNumber);
+
+        const persistedSerialPortSettings = getPersistedSerialPortSettings(
+            device.serialNumber
+        );
+
+        if (persistedSerialPortSettings) {
+            const path =
+                newDevice.serialPorts?.[persistedSerialPortSettings.vComIndex]
+                    ?.comName;
+
+            if (path) {
+                newDevice.persistedSerialPortOptions = {
+                    ...persistedSerialPortSettings.serialPortOptions,
+                    path,
+                };
+            }
         }
+
+        return newDevice;
     }
 
-    return newDevice;
+    return device;
 };
 
 const slice = createSlice({
@@ -89,104 +99,158 @@ const slice = createSlice({
          * Indicates that a device has been selected.
          */
         selectDevice: (state, action: PayloadAction<Device>) => {
-            state.selectedSerialNumber = action.payload.serialNumber;
+            state.selectedDevice = action.payload;
+        },
+
+        setSelectedDeviceInfo: (
+            state,
+            action: PayloadAction<DeviceInfo | undefined>
+        ) => {
+            state.selectedDeviceInfo = action.payload;
         },
 
         /*
          * Indicates that the currently selected device has been deselected.
          */
         deselectDevice: state => {
-            state.selectedSerialNumber = null;
-            state.deviceInfo = null;
+            state.selectedDevice = undefined;
+            state.selectedDeviceInfo = undefined;
             state.readbackProtection = 'unknown';
         },
 
         addDevice: (state, action: PayloadAction<Device>) => {
-            state.devices.set(
-                action.payload.serialNumber,
-                setPersistedData(action.payload)
+            const index = state.devices.findIndex(
+                item =>
+                    item.serialNumber === action.payload.serialNumber ||
+                    item.id === action.payload.id
             );
+
+            const device = setPersistedData(action.payload);
+            if (index !== -1) {
+                state.devices[index] = device;
+            } else {
+                state.devices.push(device);
+            }
         },
 
         persistSerialPortOptions: (
             state,
             action: PayloadAction<SerialPortOpenOptions<AutoDetectTypes>>
         ) => {
-            if (state.selectedSerialNumber === null) return;
+            if (!state.selectedDevice) return;
 
-            const selectedDevice = state.devices.get(
-                state.selectedSerialNumber
-            );
+            const selectedDevice = state.selectedDevice;
 
             if (selectedDevice) {
                 const vComIndex = selectedDevice.serialPorts?.findIndex(
                     e => e.comName === action.payload.path
                 );
 
-                if (vComIndex !== undefined && vComIndex !== -1) {
+                if (
+                    selectedDevice.serialNumber &&
+                    vComIndex !== undefined &&
+                    vComIndex !== -1
+                ) {
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars -- used to filter out the path property
                     const { path: _, ...serialPortOptions } = action.payload;
 
                     persistSerialPortSettingsToStore(
-                        state.selectedSerialNumber,
+                        selectedDevice.serialNumber,
                         {
                             serialPortOptions,
                             vComIndex,
                         }
                     );
 
-                    state.devices.set(state.selectedSerialNumber, {
-                        ...selectedDevice,
-                        persistedSerialPortOptions: action.payload,
-                    });
+                    updateDevice(
+                        state,
+                        {
+                            ...selectedDevice,
+                            persistedSerialPortOptions: action.payload,
+                        },
+                        selectedDevice.id,
+                        selectedDevice.serialNumber
+                    );
                 }
             }
         },
 
         removeDevice: (state, action: PayloadAction<Device>) => {
-            state.devices.delete(action.payload.serialNumber);
-
-            if (state.selectedSerialNumber === action.payload.serialNumber) {
-                state.selectedSerialNumber = null;
-                state.deviceInfo = null;
+            const index = findDeviceItem(
+                state.devices,
+                action.payload.id,
+                action.payload.serialNumber
+            ).index;
+            state.devices.splice(index, 1);
+
+            if (action.payload.id === state.selectedDevice?.id) {
+                state.selectedDevice = undefined;
+                state.selectedDeviceInfo = undefined;
             }
         },
 
-        toggleDeviceFavorited: (state, action: PayloadAction<string>) => {
-            const newFavoriteState = !state.devices.get(action.payload)
-                ?.favorite;
-            persistIsFavorite(action.payload, newFavoriteState);
-            updateDevice(state, action.payload, {
-                favorite: newFavoriteState,
-            });
+        toggleDeviceFavorited: (state, action: PayloadAction<Device>) => {
+            const device = findDeviceItem(
+                state.devices,
+                action.payload.id,
+                action.payload.serialNumber
+            ).device;
+
+            if (!device.serialNumber) return;
+
+            const newFavoriteState = !device.favorite;
+
+            persistIsFavorite(device.serialNumber, newFavoriteState);
+            updateDevice(
+                state,
+                {
+                    favorite: newFavoriteState,
+                },
+                action.payload.id,
+                action.payload.serialNumber
+            );
         },
 
         setDeviceNickname: {
-            prepare: (serialNumber: string, nickname: string) => ({
-                payload: { serialNumber, nickname },
+            prepare: (device: Device, nickname: string) => ({
+                payload: { device, nickname },
             }),
             reducer: (
                 state,
                 action: PayloadAction<{
-                    serialNumber: string;
+                    device: Device;
                     nickname: string;
                 }>
             ) => {
+                if (!action.payload.device.serialNumber) return;
+
                 persistNickname(
-                    action.payload.serialNumber,
+                    action.payload.device.serialNumber,
                     action.payload.nickname
                 );
-                updateDevice(state, action.payload.serialNumber, {
-                    nickname: action.payload.nickname,
-                });
+                updateDevice(
+                    state,
+                    {
+                        nickname: action.payload.nickname,
+                    },
+                    action.payload.device.id,
+                    action.payload.device.serialNumber
+                );
             },
         },
 
-        resetDeviceNickname: (state, action: PayloadAction<string>) => {
-            persistNickname(action.payload, '');
-            updateDevice(state, action.payload, {
-                nickname: '',
-            });
+        resetDeviceNickname: (state, action: PayloadAction<Device>) => {
+            if (!action.payload.serialNumber) return;
+
+            persistNickname(action.payload.serialNumber, '');
+            updateDevice(
+                state,
+                {
+                    nickname: '',
+                },
+                action.payload.id,
+                action.payload.serialNumber
+            );
         },
 
         setReadbackProtected: (
@@ -204,6 +268,7 @@ export const {
         deselectDevice,
         resetDeviceNickname,
         selectDevice,
+        setSelectedDeviceInfo,
         addDevice,
         removeDevice,
         setDeviceNickname,
@@ -213,22 +278,21 @@ export const {
     },
 } = slice;
 
-export const getDevice = (serialNumber: string) => (state: RootState) =>
-    state.device.devices.get(serialNumber);
+export const getDevice = (state: RootState, serialNumber: string) =>
+    state.device.devices.find(d => d.serialNumber === serialNumber);
 
 export const getDevices = (state: RootState) => state.device.devices;
 
 export const deviceIsSelected = (state: RootState) =>
-    state.device.selectedSerialNumber != null;
+    !!state.device.selectedDevice;
+
+export const selectedDevice = (state: RootState) => state.device.selectedDevice;
 
-export const selectedDevice = (state: RootState) =>
-    state.device.selectedSerialNumber !== null
-        ? state.device.devices.get(state.device.selectedSerialNumber)
-        : undefined;
+export const selectedDeviceInfo = (state: RootState) =>
+    state.device.selectedDevice ? state.device.selectedDeviceInfo : undefined;
 
-export const deviceInfo = (state: RootState) => state.device.deviceInfo;
 export const selectedSerialNumber = (state: RootState) =>
-    state.device.selectedSerialNumber;
+    state.device.selectedDevice?.serialNumber;
 
 export const getReadbackProtection = (state: RootState) =>
     state.device.readbackProtection;