Issue: Deinitialize taking too long causing sys kill

[TheDude70]

Your Socket Mobile Developer ID

35dafa26-3207-ea11-a812-000d3a378457

Environment

OS version: iOS 18.3
SDK version: latest
Device: iPad

Description

After using App then when closing the app (swipe up) the app gets sys killed for exceeding 5 seconds to gracefully close. From the crash log it indicates that the issue lies with:

+[NSThread sleepForTimeInterval:]
-[SKTBleManager deinitialize]
CSktBleDeviceManagerObject::NotifyRemoval()
SktCaptureProtocol::ResetBleDeviceManager()

Failed to terminate gracefully after 5.0s
code:0x8BADF00D

We do not call close or deinitialize ourselves directly.

Steps to Reproduce

Have BLE device attached to iPad
Initialize CaptureRN
use device (which works perfectly)
Close app which triggers the Capture SDK deinitialize which in turn cause sys kill

Expected Behavior

Deinitialize does not cause crash, but gracefully terminates

Actual Behavior

App gets sys killed for taking to long to deinitialize

Additional Context

crash-log.json

[cyrille-socket]

Hello @TheDude70,

thank you for submitting this issues and all the details.

Can you tell me which device you're using and provide some code snippets of how you use our CaptureSDK please?

Thank you,
Cyrille

[TheDude70]

@cyrille-socket

The scanners we use: Socket 700 series Bluetooth Scanner (S720 and S730)
Tested on iPad13 iOS 18.3

The code is pretty much a copy-paste of the sample app, with small updates to accommodate our use. I have the code in it's own component.

import React, { useState, useRef, useEffect } from 'react'
import { CaptureRn, SocketCamTypes, SktErrors, CaptureEventIds, CaptureProperty, CapturePropertyIds, CapturePropertyTypes } from 'react-native-capture';
import { SOCKET_APP_KEY, SOCKET_BUNDLE_ID, SOCKET_DEVELOPER_ID } from '../Config/Settings';

const initialState = {
    devices: [],
    deviceCapture: null,
    bleDeviceManagerCapture: null,
    socketcamDevice: null,
    deviceGuidMap: {},
    isContinuousTrigger: false,
    isAndroid: false,
}

const arrayToString = (dataArray) => {
    return String.fromCharCode.apply(null, dataArray)
}

const resToString = (res) => {
    return JSON.stringify(res, null, 4);
}

let lastDecodedData = {
    name: '',
    length: '',
    data: '',
    id: -1,
}

const appInfo = {
    appIdIos: SOCKET_BUNDLE_ID,
    developerId: SOCKET_DEVELOPER_ID,
    appKeyIos: SOCKET_APP_KEY,
}

const SocketMobileScan = ({ processBarcodeScan }) => {
    const [capture, setCapture] = useState(new CaptureRn());
    const [useSocketCam, setUseSocketCam] = useState(0);
    const [devices, setDevices] = useState([]);
    const [deviceGuidMap, setDeviceGuidMap] = useState({});
    const [status, setStatus] = useState('Opening Capture...');
    const [decodedData, setDecodedData] = useState({
        data: '',
        length: 0,
        name: '',
    });
    const [deviceCapture, setDeviceCapture] = useState(null);
    const [bleDeviceManagerCapture, setBleDeviceManagerCapture] = useState(null);
    const [socketcamDevice, setSocketCamDevice] = useState(null);
    const [isContinuousTrigger, setIsContinuousTrigger] = useState(false);

    const stateRef = useRef(initialState);

    stateRef.current = {
        devices,
        deviceCapture,
        bleDeviceManagerCapture,
        socketcamDevice,
        deviceGuidMap,
        isContinuousTrigger,
        isAndroid: false,
    }

    const handleIsContinuous = (v) => {
        setIsContinuousTrigger(v);
    };

    const genDevice = (
        dev,
        guid,
        name,
        type,
    ) => {
        return {
            guid,
            name,
            type,
            handle: dev.clientOrDeviceHandle,
            devCapture: dev,
        };
    };

    const openDeviceHelper = (
        dev,
        e,
        isManager,
    ) => {
        let { name, guid, type } = e.value;
        dev
            .openDevice(guid, capture)
            .then((result) => {
                setStatus(`result of opening ${name} : ${result}`);
                let myMap = { ...stateRef.current.deviceGuidMap };
                if (!myMap[guid] && !isManager) {
                    let device = genDevice(dev, guid, name, type);
                    let devs = [...stateRef.current.devices, device];
                    setDevices(devs);
                    myMap[guid] = '1';
                    setDeviceGuidMap(myMap);
                }
                if (!isManager) {
                    // check for SocketCam device type
                    if (SocketCamTypes.indexOf(e.value.type) > -1) {
                        let device = genDevice(dev, guid, name, type);
                        setSocketCamDevice(device);
                    } else {
                        setDeviceCapture(dev);
                    }
                } else {
                    setBleDeviceManagerCapture(dev);
                    getFavorite(dev);
                }
            })
            .catch((res) => {
                let { error } = res;
                const { code, message } = error;
                setStatus(`error opening a device: ${code} \n ${message}}`);
            });
    };

    const openCapture = () => {
        capture
            .open(appInfo, onCaptureEvent)
            .then(() => {
                setStatus('CaptureSDK open with success');
            })
            .catch((err) => {
                const { error } = err;
                const { code, message } = error;
                setStatus(`Failed to open CaptureSDK: ${code} \n ${message}`);
                // this is for Android which requires Socket Mobile Companion
                if (code === SktErrors.ESKT_UNABLEOPENDEVICE) {
                    setStatus('Is Socket Mobile Companion app installed?');
                }
            });
    };

    const getFavorite = async (dev) => {
        let property = new CaptureProperty(
            CapturePropertyIds.Favorite,
            CapturePropertyTypes.None,
            {},
        );

        try {
            let favorite = await dev.getProperty(property);

            setStatus('retrieving BLE Device Manager favorite... ');
            if (favorite.value.length === 0) {
                setFavorite(dev);
            } else {
                setStatus('Favorite found! Try using an NFC reader!');
            }
        } catch (err) {
            setStatus(`failed to get favorite: ${err.code} : ${err.message}`);
        }
    };

    const setFavorite = async (bleDevice) => {
        let property = new CaptureProperty(
            CapturePropertyIds.Favorite,
            CapturePropertyTypes.String,
            '*',
        );

        try {
            let data = await bleDevice.setProperty(property);
            setStatus(`successfully set favorite for BLE Device Manager!`);
        } catch (res) {
            let { code, message } = res.error;
            setStatus(`failed to set favorite: ${code} : ${message}`);
        }
    };

    const onCaptureEvent = (e, handle) => {
        if (!e) {
            return;
        }

        let devs = [...stateRef.current.devices];
        switch (e.id) {
            // **********************************
            // Device Arrival Event
            //   a device needs to be opened in
            //   to receive the decoded data
            //  e = {
            //    id: CaptureEventIds.DeviceArrival,
            //    type: CaptureEventTypes.DeviceInfo,
            //    value: {
            //      guid: "b876d9a8-85b6-1bb5-f1f6-1bb5d78a2c6e",
            //      name: "Socket S740 [E2ABB4]",
            //      type: CaptureDeviceType.ScannerS740
            //    }
            //  }
            // **********************************
            case CaptureEventIds.DeviceArrival:
                const newDevice = new CaptureRn();
                openDeviceHelper(newDevice, e, false);
                break;
            // **********************************
            // Device Removal Event
            //   it is better to close the device
            //  e = {
            //    id: CaptureEventIds.DeviceRemoval,
            //    type: CaptureEventTypes.DeviceInfo,
            //    value: {
            //      guid: "b876d9a8-85b6-1bb5-f1f6-1bb5d78a2c6e",
            //      name: "Socket S740 [E2ABB4]",
            //      type: CaptureDeviceType.ScannerS740
            //    }
            //  }
            // **********************************
            case CaptureEventIds.DeviceRemoval:
                let index = devs.findIndex((d) => {
                    return d.guid === e.value.guid;
                });
                if (index < 0) {
                    return;
                } else {
                    let removeDevice = devs[index];

                    if (!removeDevice) return;

                    removeDevice.devCapture
                        .close()
                        .then((result) => {
                            setStatus(`result of closing ${removeDevice?.name}: ${result}`);
                            devs.splice(index, 1);
                            setDevices(devs);
                            let myMap = { ...stateRef.current.deviceGuidMap };
                            delete myMap[e.value.guid];
                            setDeviceGuidMap(myMap);
                            let bleDeviceManagerCaptureDev =
                                bleDeviceManagerCapture;
                            if (
                                bleDeviceManagerCaptureDev &&
                                e.value.guid === bleDeviceManagerCaptureDev.guid
                            ) {
                                setBleDeviceManagerCapture(null);
                            } else {
                                setDeviceCapture(null);
                            }
                        })
                        .catch((res) => {
                            let { error } = res;
                            let { message, code } = error;
                            // The error code -38 is related to SocketCam extension closing the SocketCam device when you DISABLE SocketCam on android.
                            // When you disable SocketCam, it closes the device via the extension so there is no need to close it in the React Native side.
                            // It will not show up with other devices and therefore can be ignored.
                            // Other error codes must be handled accordingly.
                            if (code !== -38) {
                                setStatus(`error closing a device: ${code}: ${message}`);
                            }
                        });
                }
                break;
            // **********************************
            // Decoded Data
            //   receive the decoded data from
            //   a specific device
            //  e = {
            //    id: CaptureEventIds.DecodedData,
            //    type: CaptureEventTypes.DecodedData,
            //    value: {
            //      data: [55, 97, 100, 57, 53, 100, 97, 98, 48, 102, 102, 99, 52, 53, 57, 48, 97, 52, 57, 54, 49, 97, 51, 49, 57, 50, 99, 49, 102, 51, 53, 55],
            //      id: CaptureDataSourceID.SymbologyQRCode,
            //      name: "QR Code"
            //    }
            //  }
            // **********************************
            case CaptureEventIds.DecodedData:
                let devWithInfo = stateRef.current.devices.find(
                    (d) => {
                        return d.handle === handle;
                    },
                );

                lastDecodedData = {
                    data: arrayToString(e.value.data),
                    length: e.value.data.length,
                    name: e.value.name,
                    id: -1, //number placeholder
                };
                setDecodedData(lastDecodedData);
                break;
            case CaptureEventIds.DeviceManagerArrival:
                const newBleDeviceManager = new CaptureRn();
                openDeviceHelper(newBleDeviceManager, e, true);
                break;
            case CaptureEventIds.DeviceManagerRemoval:
                setBleDeviceManagerCapture(null);
                break;
            case CaptureEventIds.BatteryLevel:
                setStatus(`Battery has changed to ${e.value}%`);
                break;
            default:
                break;
        }
    }

    useEffect(() => {
        setUseSocketCam(false);
        openCapture();
    }, []);

    useEffect(() => {
        if (decodedData.data) {
            processBarcodeScan(decodedData.data);
        }
    }, [decodedData]);

    return (<></>);
}

export default SocketMobileScan;

[cyrille-socket]

Hi @TheDude70,

I'll look into it and get back to you.

Best,
Cyrille

[cyrille-socket]

Hi @TheDude70,

which version of iOS CaptureSDK are you using? It is embedded into the RN CaptureSDK. Check your Podfile.lock for the exact version please.

Thanks
Cyrille

[TheDude70]

@cyrille-socket CaptureSDK v1.9.113

[cyrille-socket]

Hello @TheDude70,

do you have some logs before this graceful termination please?

[TheDude70]

Sorry, I just have the crash report that Apple gives us on iPad, included in this issue.

Only thing I can think of that could be a possible issue is that I'm not using the CaptureSDK at the top level of the app, but in a component. This component may be initialized and destroyed several times during app usage. Could it be that we are creating several Capture instances that remain in the background? Maybe we end up with several on app close which causes issues with clean up?

[cyrille-socket]

Hello @TheDude70,

indeed that could be an issue. A SDK in general should be initialized at the top level of the app. We strongly encourage this approach.

Also, you don't need to "close" the CaptureSDK. It handles its own lifecycle and will be destroyed with your app's lifecycle as well.

Best,
Cyrille

[cyrille-socket]

Hello @TheDude70

we have released a new version 1.5.134 that supports the new architecture but also updated our iOS SDK to 1.9.166 that solves some BLE manager issues that we have.

Please do read the changeling because for this version, on iOS you do need our Socket Mobile Companion app if you want to use BLE devices.

Please let us know if that works for you

Best,
Cyrille