@nordicsemiconductor/pc-nrfconnect-shared 121.0.0 → 123.0.0

package/src/Device/DeviceSelector/DeviceSelector.tsx

@@ -4,10 +4,14 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import React, { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 
+import { NrfutilDeviceLib } from '../../../nrfutil';
 import { DeviceTraits } from '../../../nrfutil/device/common';
+import logger from '../../logging';
+import usageData from '../../utils/usageData';
+import { simplifyDeviceForLogging } from '../../utils/usageDataCommon';
 import useHotKey from '../../utils/useHotKey';
 import {
     clearWaitForDevice,
@@ -21,8 +25,10 @@ import {
     deselectDevice,
     Device,
     deviceIsSelected as deviceIsSelectedSelector,
+    isDeviceWithSerialNumber,
     selectDevice,
-    selectedSerialNumber,
+    selectedDevice,
+    setSelectedDeviceInfo,
 } from '../deviceSlice';
 import DeviceList from './DeviceList/DeviceList';
 import SelectDevice from './SelectDevice';
@@ -54,36 +60,73 @@ export default ({
     const [deviceListVisible, setDeviceListVisible] = useState(false);
 
     const deviceIsSelected = useSelector(deviceIsSelectedSelector);
-    const selectedSN = useSelector(selectedSerialNumber);
+    const currentDevice = useSelector(selectedDevice);
     const waitingToAutoReconnect = useSelector(getWaitingToAutoReselect);
     const showSelectedDevice = deviceIsSelected || waitingToAutoReconnect;
 
-    const doDeselectDevice = useCallback(() => {
-        dispatch(clearWaitForDevice());
-        dispatch(setAutoSelectDevice(undefined));
-        onDeviceDeselected();
-        dispatch(deselectDevice());
-    }, [dispatch, onDeviceDeselected]);
+    const doDeselectDevice = useCallback(
+        (device?: Device) => {
+            if (device) {
+                usageData.sendUsageData(
+                    'device deselected ',
+                    simplifyDeviceForLogging(device)
+                );
+            }
+
+            dispatch(clearWaitForDevice());
+            dispatch(setAutoSelectDevice(undefined));
+            onDeviceDeselected();
+            dispatch(deselectDevice());
+        },
+        [dispatch, onDeviceDeselected]
+    );
+
+    const abortController = useRef<AbortController>();
 
     // Ensure that useCallback is
     // not updated frequently as this
     // will have a side effect to stop and start the hotplug events
     const doSelectDevice = useCallback(
-        (device: Device, autoReselected: boolean) => {
+        async (device: Device, autoReselected: boolean) => {
             dispatch(clearWaitForDevice());
             setDeviceListVisible(false);
             dispatch(selectDevice(device));
             dispatch(setAutoSelectDevice(device));
             onDeviceSelected(device, autoReselected);
+
+            abortController.current?.abort();
+            abortController.current = new AbortController();
+            const deviceInfo = await NrfutilDeviceLib.deviceInfo(
+                device,
+                undefined,
+                undefined,
+                abortController.current
+            );
+            abortController.current = undefined;
+            setSelectedDeviceInfo(deviceInfo);
+
+            usageData.sendUsageData('device selected', {
+                device: simplifyDeviceForLogging(device),
+                deviceInfo,
+            });
+
             if (deviceSetupConfig) {
-                dispatch(
-                    setupDevice(
-                        device,
-                        deviceSetupConfig,
-                        onDeviceIsReady,
-                        doDeselectDevice
-                    )
-                );
+                if (isDeviceWithSerialNumber(device)) {
+                    dispatch(
+                        setupDevice(
+                            device,
+                            deviceSetupConfig,
+                            onDeviceIsReady,
+                            doDeselectDevice,
+                            deviceInfo
+                        )
+                    );
+                } else {
+                    logger.warn(
+                        `Selected device has no serial number. Device setup is not supported`
+                    );
+                    onDeviceIsReady(device);
+                }
             }
         },
         [
@@ -133,7 +176,7 @@ export default ({
         <div className="core19-device-selector">
             {showSelectedDevice ? (
                 <SelectedDevice
-                    doDeselectDevice={doDeselectDevice}
+                    doDeselectDevice={() => doDeselectDevice(currentDevice)}
                     toggleDeviceListVisible={toggleDeviceListVisible}
                 />
             ) : (
@@ -145,13 +188,13 @@ export default ({
             <DeviceList
                 isVisible={deviceListVisible}
                 doSelectDevice={(device, autoReselected) => {
-                    if (device.serialNumber === selectedSN) {
+                    if (device.id === currentDevice?.id) {
                         setDeviceListVisible(false);
                         return;
                     }
 
                     if (deviceIsSelected) {
-                        doDeselectDevice();
+                        doDeselectDevice(currentDevice);
                     }
 
                     doSelectDevice(device, autoReselected);

package/src/Device/DeviceSelector/Favorite.tsx

@@ -8,19 +8,18 @@ import React, { FC } from 'react';
 import { useDispatch } from 'react-redux';
 
 import PseudoButton from '../../PseudoButton/PseudoButton';
+import classNames from '../../utils/classNames';
 import { Device, toggleDeviceFavorited } from '../deviceSlice';
 
-import './favorite.scss';
-
 export const MakeDeviceFavorite: FC<{ device: Device }> = ({ device }) => {
     const dispatch = useDispatch();
 
     const toggleFavorite = () => {
-        dispatch(toggleDeviceFavorited(device.serialNumber));
+        dispatch(toggleDeviceFavorited(device));
     };
 
     return (
-        <PseudoButton className="make-favorite" onClick={toggleFavorite}>
+        <PseudoButton className="tw-mr-[1ex]" onClick={toggleFavorite}>
             <span
                 className={`mdi star ${
                     device.favorite ? 'mdi-star-off' : 'mdi-star'
@@ -35,15 +34,16 @@ export const FavoriteIndicator: FC<{ device: Device }> = ({ device }) => {
     const dispatch = useDispatch();
 
     const toggleFavorite = () => {
-        dispatch(toggleDeviceFavorited(device.serialNumber));
+        dispatch(toggleDeviceFavorited(device));
     };
 
-    return (
+    return device.serialNumber ? (
         <PseudoButton
-            className={`mdi ${
-                device.favorite ? 'mdi-star' : 'mdi-star-outline'
-            }`}
+            className={classNames(
+                !device.favorite && 'tw-invisible group-hover:tw-visible',
+                `mdi ${device.favorite ? 'mdi-star' : 'mdi-star-outline'}`
+            )}
             onClick={toggleFavorite}
         />
-    );
+    ) : null;
 };

package/src/Device/DeviceSelector/basic-device-info.scss

@@ -16,9 +16,6 @@
         .details {
             width: inherit;
 
-            display: flex;
-            flex-direction: column;
-
             line-height: 1;
 
             .name {
@@ -49,14 +46,5 @@
                 text-overflow: ellipsis;
             }
         }
-
-        .toggles {
-            display: flex;
-            flex-direction: column;
-            align-items: center;
-
-            width: 44px;
-            margin-right: 10px;
-        }
     }
 }

package/src/Device/deviceInfo/deviceInfo.ts

@@ -199,7 +199,7 @@ const devicesByPca: { [P in KnownDevicePCA]: DeviceInfo } = {
 
 const deviceByPca = (device: Device) =>
     devicesByPca[
-        String(device.jlink?.boardVersion).toUpperCase() as KnownDevicePCA
+        String(device.devkit?.boardVersion).toUpperCase() as KnownDevicePCA
     ];
 
 const NORDIC_VENDOR_ID = '1915';
@@ -252,7 +252,7 @@ export const displayedDeviceName = (
         return device.nickname;
     }
 
-    return deviceInfo(device).name || device.jlink?.boardVersion || 'Unknown';
+    return deviceInfo(device).name || device.devkit?.boardVersion || 'Unknown';
 };
 
 export const productPageUrl = (device: Device) =>

package/src/Device/deviceLister.ts

@@ -4,14 +4,12 @@
  * 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';
+import usageData from '../utils/usageData';
+import { simplifyDeviceForLogging } from '../utils/usageDataCommon';
 import {
     clearWaitForDevice,
     clearWaitForDeviceTimeout,
@@ -23,7 +21,13 @@ import {
     WaitForDevice,
 } from './deviceAutoSelectSlice';
 import { closeDeviceSetupDialog } from './deviceSetupSlice';
-import { addDevice, Device, removeDevice } from './deviceSlice';
+import {
+    addDevice,
+    Device,
+    removeDevice,
+    selectDevice,
+    setSelectedDeviceInfo,
+} from './deviceSlice';
 import { isDeviceInDFUBootloader } from './sdfuOperations';
 
 let stopNrfutilDevice: (callback?: () => void) => void;
@@ -52,6 +56,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 +109,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
@@ -144,7 +131,7 @@ const removeDeviceFromList =
     (dispatch, getState) => {
         if (
             removedDevice.serialNumber !==
-            getState().device.selectedSerialNumber
+            getState().device.selectedDevice?.serialNumber
         ) {
             dispatch(removeDevice(removedDevice));
             onDeviceDisconnected(removedDevice);
@@ -176,22 +163,27 @@ 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);
+                usageData.sendUsageData(
+                    'device connected',
+                    simplifyDeviceForLogging(device)
+                );
                 if (
-                    device.serialNumber &&
-                    !getState().device.devices.has(device.serialNumber)
+                    !getState().device.devices.find(
+                        d =>
+                            d.id === device.id ||
+                            (device.serialNumber && // we want to disregard comparing devices with no sn
+                                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 +194,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 +227,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 +256,7 @@ export const startWatchingDevices =
                                     deviceWithPersistedData
                                 )) ||
                             (waitForDevice.when === 'applicationMode' &&
-                                deviceWithPersistedData.dfuTriggerInfo !==
-                                    null) ||
+                                deviceInfo?.dfuTriggerVersion) ||
                             (selectedDevice &&
                                 waitForDevice.when === 'sameTraits' &&
                                 hasSameDeviceTraits(
@@ -269,6 +279,9 @@ export const startWatchingDevices =
                                 clearWaitForDeviceTimeout(waitForDevice.once)
                             );
 
+                            dispatch(selectDevice(deviceWithPersistedData));
+                            dispatch(setSelectedDeviceInfo(deviceInfo));
+
                             if (waitForDevice.onSuccess)
                                 waitForDevice.onSuccess(
                                     deviceWithPersistedData
@@ -288,8 +301,9 @@ export const startWatchingDevices =
                     const waitForDevice =
                         getState().deviceAutoSelect.waitForDevice;
                     if (
+                        device.serialNumber && // we want to disregard comparing devices with no sn
                         device.serialNumber ===
-                        getState().deviceAutoSelect.device?.serialNumber
+                            getState().deviceAutoSelect.device?.serialNumber
                     ) {
                         if (waitForDevice) {
                             dispatch(setArrivedButWrongWhen(undefined));
@@ -334,7 +348,10 @@ export const startWatchingDevices =
         stopWatchingDevices(async () => {
             const operation = await NrfutilDeviceLib.list(
                 deviceListing,
-                d => d.forEach(onDeviceArrived),
+                d => {
+                    d.forEach(onDeviceArrived);
+                    dispatch(autoSelectDeviceCLI(doSelectDevice));
+                },
                 error => {
                     logger.error(error);
                 },
@@ -346,28 +363,63 @@ export const startWatchingDevices =
                     callback?.();
                 });
             };
-
-            if (!autoSelectDeviceCLISerialUsed) {
-                const autoSelectSN = getAutoSelectDeviceCLISerial();
-
-                if (autoSelectSN !== undefined) {
-                    const autoSelectDevice =
-                        getState().device.devices.get(autoSelectSN);
-
-                    if (autoSelectDevice)
-                        doSelectDevice(autoSelectDevice, true);
-                }
-                autoSelectDeviceCLISerialUsed = true;
-            }
         });
     };
 
-const getAutoSelectDeviceCLISerial = () => {
+const getAutoSelectDeviceCLIProperty = (
+    property: string,
+    findDevice: (value: string) => Device | undefined
+) => {
     const { argv } = process;
-    const serialIndex = argv.findIndex(arg => arg === '--deviceSerial');
-    return serialIndex > -1 ? argv[serialIndex + 1] : undefined;
+    const index = argv.findIndex(arg => arg === property);
+    return index > -1
+        ? { index, device: findDevice(argv[index + 1]) }
+        : undefined;
 };
 
+const getAutoSelectDevice = (devices: Device[]) => {
+    const serialNumber = getAutoSelectDeviceCLIProperty('--deviceSerial', sn =>
+        devices.find(device => device.serialNumber === sn)
+    );
+    const serialPort = getAutoSelectDeviceCLIProperty('--comPort', portPath =>
+        devices.find(device =>
+            device.serialPorts?.find(port => port.comName === portPath)
+        )
+    );
+
+    if (serialNumber && serialPort) {
+        if (serialNumber.index > serialPort.index) {
+            return serialPort.device;
+        }
+
+        return serialNumber.device;
+    }
+
+    if (serialNumber) {
+        return serialNumber.device;
+    }
+
+    if (serialPort) {
+        return serialPort.device;
+    }
+};
+
+const autoSelectDeviceCLI =
+    (
+        doSelectDevice: (device: Device, autoReselected: boolean) => void
+    ): AppThunk<RootState> =>
+    (_, getState) => {
+        if (!autoSelectDeviceCLISerialUsed) {
+            const autoSelectDevice = getAutoSelectDevice(
+                getState().device.devices
+            );
+
+            if (autoSelectDevice) doSelectDevice(autoSelectDevice, true);
+
+            autoSelectDeviceCLISerialUsed = true;
+        }
+    };
+
 export const stopWatchingDevices = (callback?: () => void) => {
     if (stopNrfutilDevice) stopNrfutilDevice(callback);
     else callback?.();

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';
@@ -12,7 +13,7 @@ import {
     setDeviceSetupProgress,
     setDeviceSetupProgressMessage,
 } from './deviceSetupSlice';
-import { Device } from './deviceSlice';
+import { Device, DeviceWithSerialNumber } from './deviceSlice';
 import { InitPacket } from './initPacket';
 
 export interface DfuEntry {
@@ -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) {
@@ -224,10 +239,11 @@ export const prepareDevice =
 
 export const setupDevice =
     (
-        device: Device,
+        device: DeviceWithSerialNumber,
         deviceSetupConfig: DeviceSetupConfig,
         onDeviceIsReady: (device: Device) => void,
-        doDeselectDevice: () => void
+        doDeselectDevice: (device?: Device) => void,
+        deviceInfo: DeviceInfo | undefined
     ): AppThunk<RootState> =>
     (dispatch, getState) =>
         dispatch(
@@ -242,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,7 +270,8 @@ export const setupDevice =
                         `Error while setting up device ${device.serialNumber}`
                     );
                     logger.error(describeError(error));
-                    doDeselectDevice();
-                }
+                    doDeselectDevice(getState().device.selectedDevice);
+                },
+                deviceInfo
             )
         );