@nordicsemiconductor/pc-nrfconnect-shared 89.0.0 → 90.0.0

package/src/Device/deviceLister.ts

@@ -4,12 +4,12 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import nrfDeviceLib, {
-    Device as NrfdlDevice,
+import {
     DeviceTraits,
-    HotplugEvent,
-} from '@nordicsemiconductor/nrf-device-lib-js';
-
+    NrfutilDevice,
+    NrfutilDeviceWithSerialnumber,
+} from '../../nrfutil/device/common';
+import NrfutilDeviceLib from '../../nrfutil/device/device';
 import logger from '../logging';
 import type { AppThunk, RootState } from '../store';
 import {
@@ -21,11 +21,11 @@ import {
     setWaitForDeviceTimeout,
     WaitForDevice,
 } from './deviceAutoSelectSlice';
-import { getDeviceLibContext } from './deviceLibWrapper';
 import { closeDeviceSetupDialog } from './deviceSetupSlice';
-import { addDevice, Device, removeDevice, setDevices } from './deviceSlice';
+import { addDevice, Device, removeDevice } from './deviceSlice';
 import { isDeviceInDFUBootloader } from './sdfuOperations';
 
+let stopNrfutilDevice: (callback?: () => void) => void;
 let autoSelectDeviceCLISerialUsed = false;
 
 const hasSameDeviceTraits = (
@@ -99,15 +99,13 @@ const initAutoReconnectTimeout =
         );
     };
 
-let hotplugTaskId: bigint | null = null;
-
 /**
- * Wrap the device form nrf-device-lib to make the Device type consistent
+ * Wrap the device form nrfutil-device to make the Device type consistent
  *
- * @param {Device} device The input device from nrf-device-lib
- * @returns {Device} The updated device
+ * @param {NrfutilDevice} device The input device from nrfutil-device
+ * @returns {NrfutilDevice} The updated device
  */
-export const wrapDeviceFromNrfdl = (device: NrfdlDevice): Device => ({
+export const wrapDeviceFromNrfdl = (device: NrfutilDevice): Device => ({
     ...device,
     boardVersion: device.jlink?.boardVersion ?? undefined,
     serialport: device.serialPorts?.[0] ?? undefined,
@@ -115,12 +113,12 @@ export const wrapDeviceFromNrfdl = (device: NrfdlDevice): Device => ({
 });
 
 /**
- * Wrap the device form nrf-device-lib to make the Device type consistent
+ * Wrap the device form nrfutil-device to make the Device type consistent
  *
- * @param {Device[]} devices The input devices from nrf-device-lib
- * @returns {Device[]} The updated devices
+ * @param {NrfutilDevice[]} devices The input devices from nrfutil-device
+ * @returns {NrfutilDevice[]} The updated devices
  */
-export const wrapDevicesFromNrfdl = (devices: NrfdlDevice[]): Device[] =>
+export const wrapDevicesFromNrfdl = (devices: NrfutilDevice[]): Device[] =>
     devices.map(wrapDeviceFromNrfdl);
 
 export const hasValidDeviceTraits = (
@@ -164,7 +162,7 @@ const removeDeviceFromList =
         }
     };
 /*
- * Starts watching for devices with the given traits. See the nrf-device-lib
+ * Starts watching for devices with the given traits. See the nrfutil-device
  * library for available traits. Whenever devices are attached/detached, this
  * will dispatch AddDevice or removeDevice and trigger events.
  */
@@ -175,197 +173,176 @@ export const startWatchingDevices =
         onDeviceDisconnected: (device: Device) => void,
         onDeviceDeselected: () => void,
         doSelectDevice: (device: Device, autoReselected: boolean) => void
-    ): AppThunk<RootState, Promise<void>> =>
-    async (dispatch, getState) => {
-        const updateDeviceList = (event: HotplugEvent) => {
-            switch (event.event_type) {
-                case 'NRFDL_DEVICE_EVENT_ARRIVED':
-                    if (!event.device) {
-                        return;
-                    }
+    ): AppThunk<RootState, void> =>
+    (dispatch, getState) => {
+        const onDeviceArrived = (device: NrfutilDeviceWithSerialnumber) => {
+            if (hasValidDeviceTraits(device.traits, deviceListing)) {
+                device = wrapDeviceFromNrfdl(device);
+                if (
+                    device.serialNumber &&
+                    !getState().device.devices.has(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 result = shouldAutoReselect(
+                    device,
+                    getState().deviceAutoSelect.autoReselect,
+                    autoSelectDevice,
+                    disconnectionTime,
+                    selectedDevice
+                );
+
+                dispatch(addDevice(device));
+                const deviceWithPersistedData = getState().device.devices.get(
+                    device.serialNumber
+                );
+
+                if (!deviceWithPersistedData) return;
+
+                if (result) {
+                    logger.info(
+                        `Auto Reconnecting Device SN: ${deviceWithPersistedData.serialNumber}`
+                    );
+                    doSelectDevice(deviceWithPersistedData, true);
+                } else if (
+                    deviceWithPersistedData.serialNumber ===
+                    getState().deviceAutoSelect.device?.serialNumber
+                ) {
+                    const waitForDevice =
+                        getState().deviceAutoSelect.waitForDevice;
+
+                    // 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
+                    // never set (as NRFDL_DEVICE_EVENT_LEFT was never sent) This created an additional problem as device
+                    // lib may advertise the the same device with a single connect event. Hance we are keeping track of
+                    // the device ID which is guaranteed to be change if a is disconnected and reconnected (for the
+                    // same hotplug event listener) to ensure we only call the onSuccess once for every reconnect event.
+                    // This is mostly relevant when 'when' is always
+
+                    // Device is to be reconnected as timeout is provided
                     if (
-                        hasValidDeviceTraits(
-                            event.device?.traits,
-                            deviceListing
-                        )
+                        waitForDevice &&
+                        ((disconnectionTime === undefined &&
+                            getState().deviceAutoSelect.lastArrivedDeviceId !==
+                                deviceWithPersistedData.id) ||
+                            (disconnectionTime ?? 0) + waitForDevice.timeout >=
+                                Date.now())
                     ) {
-                        const device = wrapDeviceFromNrfdl(event.device);
                         if (
-                            !getState().device.devices.has(device.serialNumber)
+                            waitForDevice.when === 'always' ||
+                            (waitForDevice.when === 'dfuBootLoaderMode' &&
+                                isDeviceInDFUBootloader(
+                                    deviceWithPersistedData
+                                )) ||
+                            (waitForDevice.when === 'applicationMode' &&
+                                deviceWithPersistedData.dfuTriggerInfo !==
+                                    null) ||
+                            (selectedDevice &&
+                                waitForDevice.when === 'sameTraits' &&
+                                hasSameDeviceTraits(
+                                    device.traits,
+                                    selectedDevice.traits
+                                )) ||
+                            (typeof waitForDevice.when === 'function' &&
+                                waitForDevice.when(device))
                         ) {
-                            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 result = shouldAutoReselect(
-                            device,
-                            getState().deviceAutoSelect.autoReselect,
-                            autoSelectDevice,
-                            disconnectionTime,
-                            selectedDevice
-                        );
-
-                        dispatch(addDevice(device));
-                        const deviceWithPersistedData =
-                            getState().device.devices.get(device.serialNumber);
+                            dispatch(
+                                setLastArrivedDeviceId(
+                                    deviceWithPersistedData.id
+                                )
+                            );
+                            dispatch(setDisconnectedTime(undefined));
 
-                        if (!deviceWithPersistedData) return;
+                            logger.info('Wait For Device was successfully');
 
-                        if (result) {
-                            logger.info(
-                                `Auto Reconnecting Device SN: ${deviceWithPersistedData.serialNumber}`
+                            dispatch(
+                                clearWaitForDeviceTimeout(waitForDevice.once)
                             );
-                            doSelectDevice(deviceWithPersistedData, true);
-                        } else if (
-                            deviceWithPersistedData.serialNumber ===
-                            getState().deviceAutoSelect.device?.serialNumber
-                        ) {
-                            const waitForDevice =
-                                getState().deviceAutoSelect.waitForDevice;
-
-                            // 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
-                            // never set (as NRFDL_DEVICE_EVENT_LEFT was never sent) This created an additional problem as device
-                            // lib may advertise the the same device with a single connect event. Hance we are keeping track of
-                            // the device ID which is guaranteed to be change if a is disconnected and reconnected (for the
-                            // same hotplug event listener) to ensure we only call the onSuccess once for every reconnect event.
-                            // This is mostly relevant when 'when' is always
-
-                            // Device is to be reconnected as timeout is provided
-                            if (
-                                waitForDevice &&
-                                ((disconnectionTime === undefined &&
-                                    getState().deviceAutoSelect
-                                        .lastArrivedDeviceId !==
-                                        deviceWithPersistedData.id) ||
-                                    (disconnectionTime ?? 0) +
-                                        waitForDevice.timeout >=
-                                        Date.now())
-                            ) {
-                                if (
-                                    waitForDevice.when === 'always' ||
-                                    (waitForDevice.when ===
-                                        'dfuBootLoaderMode' &&
-                                        isDeviceInDFUBootloader(
-                                            deviceWithPersistedData
-                                        )) ||
-                                    (waitForDevice.when === 'applicationMode' &&
-                                        deviceWithPersistedData.dfuTriggerInfo !==
-                                            null) ||
-                                    (selectedDevice &&
-                                        waitForDevice.when === 'sameTraits' &&
-                                        hasSameDeviceTraits(
-                                            device.traits,
-                                            selectedDevice.traits
-                                        )) ||
-                                    (typeof waitForDevice.when === 'function' &&
-                                        waitForDevice.when(device))
-                                ) {
-                                    dispatch(
-                                        setLastArrivedDeviceId(
-                                            deviceWithPersistedData.id
-                                        )
-                                    );
-                                    dispatch(setDisconnectedTime(undefined));
-
-                                    logger.info(
-                                        'Wait For Device was successfully'
-                                    );
-
-                                    dispatch(
-                                        clearWaitForDeviceTimeout(
-                                            waitForDevice.once
-                                        )
-                                    );
-
-                                    if (waitForDevice.onSuccess)
-                                        waitForDevice.onSuccess(
-                                            deviceWithPersistedData
-                                        );
-                                } else {
-                                    dispatch(setArrivedButWrongWhen(true));
-                                }
-                            }
+
+                            if (waitForDevice.onSuccess)
+                                waitForDevice.onSuccess(
+                                    deviceWithPersistedData
+                                );
+                        } else {
+                            dispatch(setArrivedButWrongWhen(true));
                         }
                     }
-                    break;
-                case 'NRFDL_DEVICE_EVENT_LEFT':
-                    {
-                        const devices = getState().device.devices;
-
-                        devices.forEach(device => {
-                            if (device.id === event.device_id) {
-                                const waitForDevice =
-                                    getState().deviceAutoSelect.waitForDevice;
-                                if (
-                                    device.serialNumber ===
-                                    getState().deviceAutoSelect.device
-                                        ?.serialNumber
-                                ) {
-                                    if (waitForDevice) {
-                                        dispatch(
-                                            setArrivedButWrongWhen(undefined)
-                                        );
+                }
+            }
+        };
+        const onDeviceLeft = (id: number) => {
+            const devices = getState().device.devices;
 
-                                        dispatch(
-                                            initAutoReconnectTimeout(
-                                                () =>
-                                                    dispatch(
-                                                        removeDeviceFromList(
-                                                            device,
-                                                            onDeviceDeselected,
-                                                            onDeviceDisconnected
-                                                        )
-                                                    ),
-                                                waitForDevice
-                                            )
-                                        );
-                                    } else {
+            devices.forEach(device => {
+                if (device.id === id) {
+                    const waitForDevice =
+                        getState().deviceAutoSelect.waitForDevice;
+                    if (
+                        device.serialNumber ===
+                        getState().deviceAutoSelect.device?.serialNumber
+                    ) {
+                        if (waitForDevice) {
+                            dispatch(setArrivedButWrongWhen(undefined));
+
+                            dispatch(
+                                initAutoReconnectTimeout(
+                                    () =>
                                         dispatch(
                                             removeDeviceFromList(
                                                 device,
                                                 onDeviceDeselected,
                                                 onDeviceDisconnected
                                             )
-                                        );
-                                    }
-
-                                    dispatch(setDisconnectedTime(Date.now()));
-                                } else {
-                                    dispatch(
-                                        removeDeviceFromList(
-                                            device,
-                                            onDeviceDeselected,
-                                            onDeviceDisconnected
-                                        )
-                                    );
-                                }
-                            }
-                        });
+                                        ),
+                                    waitForDevice
+                                )
+                            );
+                        } else {
+                            dispatch(
+                                removeDeviceFromList(
+                                    device,
+                                    onDeviceDeselected,
+                                    onDeviceDisconnected
+                                )
+                            );
+                        }
+
+                        dispatch(setDisconnectedTime(Date.now()));
+                    } else {
+                        dispatch(
+                            removeDeviceFromList(
+                                device,
+                                onDeviceDeselected,
+                                onDeviceDisconnected
+                            )
+                        );
                     }
-                    break;
-            }
+                }
+            });
         };
 
-        try {
-            stopWatchingDevices();
-            const nrfdlDevices = await nrfDeviceLib.enumerate(
-                getDeviceLibContext(),
-                deviceListing
+        stopWatchingDevices(async () => {
+            const operation = await NrfutilDeviceLib.list(
+                deviceListing,
+                d => d.forEach(onDeviceArrived),
+                logger.error,
+                { onDeviceArrived, onDeviceLeft }
             );
 
-            const currentDevices = wrapDevicesFromNrfdl(nrfdlDevices);
-            dispatch(setDevices(currentDevices));
+            stopNrfutilDevice = (callback?: () => void) => {
+                operation.stop(() => {
+                    callback?.();
+                });
+            };
 
             if (!autoSelectDeviceCLISerialUsed) {
                 const autoSelectSN = getAutoSelectDeviceCLISerial();
@@ -379,18 +356,7 @@ export const startWatchingDevices =
                 }
                 autoSelectDeviceCLISerialUsed = true;
             }
-
-            hotplugTaskId = nrfDeviceLib.startHotplugEvents(
-                getDeviceLibContext(),
-                () => {},
-                updateDeviceList
-            );
-        } catch (error) {
-            logger.logError(
-                'Error while probing devices, more details in the debug log',
-                error
-            );
-        }
+        });
     };
 
 const getAutoSelectDeviceCLISerial = () => {
@@ -406,19 +372,7 @@ export const clearWaitForDevice = (): AppThunk => (dispatch, getState) => {
     dispatch(clearWaitForDeviceTimeout(true));
 };
 
-/**
- * Stops watching for devices.
- *
- * @returns {undefined}
- */
-export const stopWatchingDevices = () => {
-    // Not sure, if this guard clause is really needed
-    if (getDeviceLibContext() && hotplugTaskId !== null) {
-        try {
-            nrfDeviceLib.stopHotplugEvents(hotplugTaskId);
-            hotplugTaskId = null;
-        } catch (error) {
-            logger.logError('Error while stopping to watch devices', error);
-        }
-    }
+export const stopWatchingDevices = (callback?: () => void) => {
+    if (stopNrfutilDevice) stopNrfutilDevice(callback);
+    else callback?.();
 };

package/src/Device/deviceSlice.ts

@@ -4,14 +4,11 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import type {
-    Device as NrfdlDevice,
-    SerialPort,
-} from '@nordicsemiconductor/nrf-device-lib-js';
 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 type { RootState } from '../store';
 import {
     getPersistedIsFavorite,
@@ -22,7 +19,7 @@ import {
     persistSerialPortSettings as persistSerialPortSettingsToStore,
 } from '../utils/persistentStore';
 
-export interface Device extends NrfdlDevice {
+export interface Device extends NrfutilDevice {
     serialNumber: string;
     boardVersion?: string;
     nickname?: string;
@@ -104,16 +101,6 @@ const slice = createSlice({
             state.readbackProtection = 'unknown';
         },
 
-        setDevices: (state, action: PayloadAction<Device[]>) => {
-            state.devices.clear();
-            action.payload.forEach(device => {
-                state.devices.set(
-                    device.serialNumber,
-                    setPersistedData(device)
-                );
-            });
-        },
-
         addDevice: (state, action: PayloadAction<Device>) => {
             state.devices.set(
                 action.payload.serialNumber,
@@ -219,7 +206,6 @@ export const {
         selectDevice,
         addDevice,
         removeDevice,
-        setDevices,
         setDeviceNickname,
         toggleDeviceFavorited,
         setReadbackProtected,

package/src/Device/jprogOperations.ts

@@ -4,77 +4,23 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import nrfDeviceLib, {
-    deviceControlRecover,
-    deviceControlReset,
-    Error as nrfError,
-    firmwareProgram,
-    FirmwareStreamType,
-    readFwInfo,
-} from '@nordicsemiconductor/nrf-device-lib-js';
-
+import NrfutilDeviceLib from '../../nrfutil/device/device';
+import { FWInfo } from '../../nrfutil/device/getFwInfo';
 import logger from '../logging';
 import type { AppThunk, RootState } from '../store';
-import { getDeviceLibContext } from './deviceLibWrapper';
 import { DeviceSetup, JprogEntry } from './deviceSetup';
 import { Device, setReadbackProtected } from './deviceSlice';
 
-const program = (
-    deviceId: number,
-    firmware: string | Buffer,
-    onProgress: (progress: number, message?: string) => void
-) => {
-    let fwFormat: FirmwareStreamType;
-    if (firmware instanceof Buffer) {
-        fwFormat = 'NRFDL_FW_BUFFER';
-    } else {
-        fwFormat = 'NRFDL_FW_FILE';
-    }
-    return new Promise<void>((resolve, reject) => {
-        onProgress(0, 'Preparing to program');
-        firmwareProgram(
-            getDeviceLibContext(),
-            deviceId,
-            fwFormat,
-            'NRFDL_FW_INTEL_HEX',
-            firmware,
-            (error?: nrfError) => {
-                if (error) reject(error);
-                logger.info('Device programming completed.');
-                resolve();
-            },
-            progress => {
-                onProgress(
-                    progress.progressJson.progressPercentage,
-                    progress.progressJson.message ?? 'programming'
-                );
-            },
-            null,
-            'NRFDL_DEVICE_CORE_APPLICATION'
-        );
-    });
-};
-
-/**
- * Reset the device after programming
- *
- * @param {Number} deviceId The Id of the device.
- * @returns {Promise} Promise that resolves if successful or rejects with error.
- */
-const reset = async (deviceId: number) => {
-    await deviceControlReset(getDeviceLibContext(), deviceId);
-};
-
 const getDeviceReadProtection = async (
     device: Device
 ): Promise<{
-    fwInfo: nrfDeviceLib.FWInfo.ReadResult | null;
+    fwInfo: FWInfo | null;
     readbackProtection: 'unknown' | 'protected' | 'unprotected';
 }> => {
     try {
-        const fwInfo = await readFwInfo(getDeviceLibContext(), device.id);
+        const info = await NrfutilDeviceLib.getFwInfo(device);
         return {
-            fwInfo,
+            fwInfo: info,
             readbackProtection: 'unprotected',
         };
     } catch (error) {
@@ -106,20 +52,26 @@ const programDeviceWithFw =
             if (getState().device.readbackProtection === 'protected') {
                 logger.info('Recovering device');
                 onProgress(0, 'Recovering device');
-                await deviceControlRecover(
-                    getDeviceLibContext(),
-                    device.id,
-                    'NRFDL_DEVICE_CORE_APPLICATION'
-                );
+                await NrfutilDeviceLib.recover(device, 'Application');
             }
 
             logger.debug(
                 `Programming ${device.serialNumber} with ${selectedFw.fw}`
             );
-            await program(device.id, selectedFw.fw, onProgress);
+            await NrfutilDeviceLib.program(
+                device,
+                selectedFw.fw,
+                progress => {
+                    onProgress(
+                        progress.progressPercentage,
+                        progress.message ?? 'programming'
+                    );
+                },
+                'Application'
+            );
             logger.debug(`Resetting ${device.serialNumber}`);
             onProgress(100, 'Resetting device');
-            await reset(device.id);
+            await NrfutilDeviceLib.reset(device);
             const { readbackProtection } = await getDeviceReadProtection(
                 device
             );
@@ -178,11 +130,11 @@ export const jprogDeviceSetup = (
         }
 
         return getDeviceReadProtection(device).then(
-            ({ fwInfo, readbackProtection }) => {
+            ({ fwInfo: info, readbackProtection }) => {
                 dispatch(setReadbackProtected(readbackProtection));
-                if (fwInfo && fwInfo.imageInfoList.length > 0) {
+                if (info && info.imageInfoList.length > 0) {
                     const fw = fwVersions.find(version =>
-                        fwInfo.imageInfoList.find(
+                        info.imageInfoList.find(
                             imageInfo =>
                                 typeof imageInfo.version === 'string' &&
                                 imageInfo.version.includes(version.fwVersion)