@getquip/expo-nordic-dfu 0.1.0

package/example/App.tsx

@@ -0,0 +1,372 @@
+import ExpoNordicDfu from 'expo-nordic-dfu';
+import { useEffect, useState } from 'react';
+import { Alert, KeyboardAvoidingView, PermissionsAndroid, Platform, SafeAreaView, ScrollView, TouchableOpacity, View, ViewStyle } from 'react-native';
+import BleManager, { Peripheral } from 'react-native-ble-manager'
+import { Text, Button } from 'react-native-paper'
+import * as DocumentPicker from 'expo-document-picker';
+import * as FileSystem from 'expo-file-system';
+
+const SERVICE_UUIDS = process.env.EXPO_PUBLIC_BLUETOOTH_SERVICE_UUIDS.split(',').map((uuid: string) => uuid.trim())
+const ANDROID_BONDING_ENABLED = process.env.EXPO_PUBLIC_ANDROID_BONDING_ENABLED === 'true'
+const SELECTION_COLORS = {
+  none: '#ffffff',
+  disabled: '#e0e0e0',
+  connected: '#8ec781',
+  connecting: '#ede598',
+  error: '#ff0000',
+}
+
+let bleInitialized = false
+const bleManagerInitialize = async () => {
+  if (bleInitialized) {
+    return true
+  }
+
+  const initializing = (async () => {
+    try {
+      await BleManager.start({ showAlert: true })
+      bleInitialized = true
+      console.info('BleManager started')
+      return true
+    } catch (error) {
+      console.error('Unexpected error starting BleManager', error)
+      return false
+    }
+  })()
+
+  return await initializing
+}
+
+function sleep(ms: number) {
+  return new Promise<void>((resolve) => setTimeout(resolve, ms))
+}
+
+type FirmwareFileType = {
+  uri: string
+  name: string
+}
+
+type ProgressType = {
+  state?: string
+  avgSpeed?: number
+  currentPart?: number,
+  partsTotal?: number,
+  percent?: number,
+  speed?: number,
+}
+
+export default function App() {
+  const [peripherals, setPeripherals] = useState<Peripheral[]>([])
+  const [peripheral, setPeripheral] = useState<Peripheral>()
+  const [firmwareFile, setFirmwareFile] = useState<FirmwareFileType | false>()
+  const [selectedColor, setSelectedColor] = useState<string>(SELECTION_COLORS.none)
+  const [firmwareProgress, setFirmwareProgress] = useState<ProgressType | undefined>(undefined)
+  const [isScanning, setIsScanning] = useState<boolean | undefined>(undefined)
+
+  const processScanning = (peripheral: Peripheral) => {
+    setPeripherals((peripherals) => {
+      return !peripherals.find((p) => p.id === peripheral.id) ? [...peripherals, peripheral] : peripherals
+    })
+  }
+
+  useEffect(() => {
+    void bleManagerInitialize()
+    const discoverListener = BleManager.onDiscoverPeripheral(processScanning)
+    const onStopScanListener = BleManager.onStopScan(() => setIsScanning(false))
+
+    return () => {
+      discoverListener.remove();
+      onStopScanListener.remove();
+    };
+  }, [])
+
+  useEffect(() => {
+    if(peripheral && selectedColor === SELECTION_COLORS.connecting) {
+      void connect()
+    }
+  }, [selectedColor, peripheral])
+
+  if (Platform.OS === 'android') {
+    PermissionsAndroid.requestMultiple([
+      PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
+      PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
+      PermissionsAndroid.PERMISSIONS.BLUETOOTH_ADVERTISE,
+    ]).then((result) => {
+      if (result) {
+        console.debug('User accepts Bluetooth permissions')
+      } else {
+        console.error('User refuses Bluetooth permissions')
+        Alert.alert(
+          'Accept Permissions',
+          'You have to accept Bluetooth permissions to use this app',
+        );
+      }
+    })
+  }
+
+  const firmwareDisableButtons = firmwareProgress !== undefined && firmwareProgress.state !== 'DEVICE_DISCONNECTED' && firmwareProgress.state !== 'DFU_FAILED' && firmwareProgress.state !== 'DFU_COMPLETED' && firmwareProgress.state !== 'DFU_ABORTED'
+
+  const backgroundColor = (selected: Peripheral) => {
+    const isSelected = selected.id === peripheral?.id
+    const isConnecting = selectedColor === SELECTION_COLORS.connecting
+    if (isConnecting && !isSelected) {
+      return SELECTION_COLORS.disabled
+    } else if (isSelected) {
+      return selectedColor
+    } else {
+      return SELECTION_COLORS.none
+    }
+  }
+
+  const reset = async (peripheral: Peripheral | undefined) => {
+    if (peripheral) {
+      await BleManager.disconnect(peripheral.id)
+    }
+    setPeripherals([])
+    setPeripheral(undefined)
+    setFirmwareProgress(undefined)
+    setFirmwareFile(undefined)
+    setIsScanning(undefined)
+  }
+
+  const scan = async () => {
+    await reset(peripheral)
+    try {
+      await BleManager.scan(SERVICE_UUIDS, 5, false)
+      setIsScanning(true)
+    } catch (error) {
+      await BleManager.stopScan()
+      throw error
+    }
+  }
+
+  const handleConnect = (peripheral: Peripheral) => {
+    setSelectedColor(SELECTION_COLORS.connecting)
+    setPeripheral(peripheral)
+  }
+
+  const connect = async () => {
+    if (!peripheral) {
+      console.error('No peripheral selected')
+      return
+    }
+    try {
+      await BleManager.connect(peripheral.id)
+
+      if (Platform.OS === 'android' && ANDROID_BONDING_ENABLED) {
+        console.debug(`${peripheral.id}] createBond`)
+        try {
+          await BleManager.createBond(peripheral.id)
+          console.debug(`${peripheral.id}] createBond success or there is already an existing one`)
+        } catch (e) {
+          console.warn(`${peripheral.id}] createBond failed:`, e)
+        }
+      }
+      // before retrieving services, it is often a good idea to let bonding & connection finish properly
+      // See https://github.com/innoveit/react-native-ble-manager/blob/d7613a48ff201914f4a91d7167f35d615ce0d24a/example/components/ScanDevicesScreen.tsx#L276 for context
+      await sleep(900)
+
+      await BleManager.retrieveServices(peripheral.id)
+      setPeripheral(peripheral)
+      setSelectedColor(SELECTION_COLORS.connected)
+      console.debug(`${peripheral.id}] Connected to ${peripheral.name}`)
+    } catch (error) {
+      console.error('Connection error', error)
+      setSelectedColor(SELECTION_COLORS.error)
+      setPeripheral(undefined)
+      throw error
+    }
+  }
+
+  const handleFileSelect = async (): Promise<void> => {
+    try {
+      const result = await DocumentPicker.getDocumentAsync({
+        type: [
+          'binary/octet-stream',
+          'application/octet-stream',
+          'application/zip',
+          'application/x-zip-compressed',
+        ],
+        copyToCacheDirectory: true,
+      });
+
+      if (!result.canceled && result.assets && result.assets.length > 0) {
+        const file = result.assets[0];
+
+        if (!file.name.toLowerCase().endsWith('.zip')) {
+          Alert.alert(
+            'Invalid File',
+            'Please select a valid firmware (.zip) file',
+          );
+          return;
+        }
+
+        const fileInfo = await FileSystem.getInfoAsync(file.uri);
+        if (!fileInfo.exists) {
+          throw new Error('File does not exist');
+        }
+
+        console.debug('File selected:', file);
+        setFirmwareFile({
+          uri: file.uri,
+          name: file.name,
+        });
+      }
+    } catch (err) {
+      console.error('File select error', err);
+      Alert.alert('Error', 'Check your file and try again');
+    }
+  };
+
+  const startDFU = async (peripheral: Peripheral, firmwareFile: FirmwareFileType) => {
+    try {
+      ExpoNordicDfu.module.addListener('DFUProgress', (progress) => {
+        console.info('DFUProgress:', progress)
+        setFirmwareProgress({ ...progress, state: 'Updating...' })
+      })
+      ExpoNordicDfu.module.addListener('DFUStateChanged', ({ state }) => {
+        console.info('DFUStateChanged:', state)
+        setFirmwareProgress({ state, ...firmwareProgress })
+      })
+      await ExpoNordicDfu.startDfu({
+        deviceAddress: peripheral.id,
+        fileUri: firmwareFile.uri,
+        // These optional values are set to useful values for quip.
+        // Change them to your needs.
+        packetReceiptNotificationParameter: 2,
+        android: {
+          deviceName: peripheral.name,
+        },
+      })
+    } catch (error) {
+      console.error(error)
+    } finally {
+      ExpoNordicDfu.module.removeAllListeners('DFUProgress')
+      ExpoNordicDfu.module.removeAllListeners('DFUStateChanged')
+    }
+  }
+
+  const abortDFU = async () => {
+    try {
+      await ExpoNordicDfu.abortDfu()
+      setFirmwareProgress({ state: 'DFU_ABORTED' })
+    } catch (error) {
+      console.error(error)
+    } finally {
+      ExpoNordicDfu.module.removeAllListeners('DFUProgress')
+      ExpoNordicDfu.module.removeAllListeners('DFUStateChanged')
+    }
+  }
+
+  return (
+    <SafeAreaView style={styles.container} >
+      <KeyboardAvoidingView style={styles.container} behavior={Platform.OS === 'ios' ? 'padding' : 'height'}>
+        <ScrollView contentContainerStyle={{ minHeight: '100%', width: '100%' }}>
+          <View style={styles.view}>
+            <Text variant="headlineLarge">Nordic DFU Example App</Text>
+            <Button disabled={firmwareDisableButtons || isScanning} mode="contained" onPress={scan}>
+              Scan for Devices
+            </Button>
+            {isScanning === false && peripherals.length === 0 && <Text>No devices found</Text>}
+            {peripherals.length > 0 && <Text>Click one of the following devices to connect and pair:</Text>}
+            {[...peripherals].map((peripheral) => (
+              <TouchableOpacity
+                disabled={selectedColor === SELECTION_COLORS.connecting || firmwareDisableButtons}
+                style={{ ...styles.touchable, backgroundColor: backgroundColor(peripheral) }}
+                key={peripheral.id}
+                onPress={() => handleConnect(peripheral)}
+              >
+                <Text>ID: {peripheral.id}</Text>
+                {peripheral.name &&  (<Text>Name: {peripheral.name}</Text>)}
+                <Text>RSSI: {peripheral.rssi}</Text>
+                <Text>Advertising Data: {JSON.stringify({
+                      isConnectable: peripheral.advertising.isConnectable,
+                      localName: peripheral.advertising.localName,
+                      serviceData: peripheral.advertising.serviceData,
+                      serviceUUIDs: peripheral.advertising.serviceUUIDs,
+                      txPowerLevel: peripheral.advertising.txPowerLevel,
+                })}</Text>
+                <Text>Manufacturing Data: {JSON.stringify(peripheral.advertising.manufacturerData)}</Text>
+              </TouchableOpacity>
+            ))}
+            {peripheral && selectedColor === SELECTION_COLORS.connected && (
+              <Button disabled={firmwareDisableButtons} mode="contained" onPress={handleFileSelect}>
+                Select Firmware File
+              </Button>
+            )}
+            {firmwareProgress && (
+              <View>
+                <Text>DFU State: {firmwareProgress.state}</Text>
+                <Text>DFU Percent Done: {firmwareProgress.percent}</Text>
+                <Text>DFU Current Part: {firmwareProgress.currentPart}</Text>
+                <Text>DFU Total Parts: {firmwareProgress.partsTotal}</Text>
+                <Text>DFU Current Speed: {firmwareProgress.speed}</Text>
+                <Text>DFU Average Speed: {firmwareProgress.avgSpeed}</Text>
+              </View>)}
+            {peripheral && selectedColor === SELECTION_COLORS.connected && firmwareFile && !firmwareDisableButtons && (
+              <Button
+                mode="contained"
+                onPress={() => {
+                  startDFU(peripheral, firmwareFile)
+                }}
+              >
+                Start DFU
+              </Button>
+            )}
+            {firmwareDisableButtons && (
+              <Button
+                mode="contained-tonal"
+                onPress={() => {
+                  abortDFU()
+                }}
+              >
+                Abort DFU
+              </Button>
+          )}
+            {peripheral && selectedColor === SELECTION_COLORS.connected && (
+              <Button
+                disabled={firmwareDisableButtons}
+                mode="contained-tonal"
+                onPress={() => {
+                  reset(peripheral)
+                }}
+              >
+                Disconnect
+              </Button>
+            )}
+          </View>
+        </ScrollView>
+      </KeyboardAvoidingView>
+    </SafeAreaView>
+  );
+}
+
+const styles: { [key: string]: ViewStyle } = {
+  container: {
+    backgroundColor: '#eee',
+    flex: 1,
+    height: '100%',
+    width: '100%',
+  },
+  touchable: {
+    borderColor: '#000',
+    borderRadius: 5,
+    borderWidth: 1,
+    flex: 1,
+    flexDirection: 'column',
+    flexGrow: 0,
+    gap: 2,
+    justifyContent: 'center',
+    padding: 10,
+  },
+  view: {
+    flex: 1,
+    flexDirection: 'column',
+    gap: 20,
+    height: '100%',
+    justifyContent: 'center',
+    marginBottom: 200,
+    padding: 20,
+    width: '100%',
+  },
+};

package/example/android/app/build.gradle

@@ -0,0 +1,176 @@
+apply plugin: "com.android.application"
+apply plugin: "org.jetbrains.kotlin.android"
+apply plugin: "com.facebook.react"
+
+def projectRoot = rootDir.getAbsoluteFile().getParentFile().getAbsolutePath()
+
+/**
+ * This is the configuration block to customize your React Native Android app.
+ * By default you don't need to apply any configuration, just uncomment the lines you need.
+ */
+react {
+    entryFile = file(["node", "-e", "require('expo/scripts/resolveAppEntry')", projectRoot, "android", "absolute"].execute(null, rootDir).text.trim())
+    reactNativeDir = new File(["node", "--print", "require.resolve('react-native/package.json')"].execute(null, rootDir).text.trim()).getParentFile().getAbsoluteFile()
+    hermesCommand = new File(["node", "--print", "require.resolve('react-native/package.json')"].execute(null, rootDir).text.trim()).getParentFile().getAbsolutePath() + "/sdks/hermesc/%OS-BIN%/hermesc"
+    codegenDir = new File(["node", "--print", "require.resolve('@react-native/codegen/package.json', { paths: [require.resolve('react-native/package.json')] })"].execute(null, rootDir).text.trim()).getParentFile().getAbsoluteFile()
+
+    // Use Expo CLI to bundle the app, this ensures the Metro config
+    // works correctly with Expo projects.
+    cliFile = new File(["node", "--print", "require.resolve('@expo/cli', { paths: [require.resolve('expo/package.json')] })"].execute(null, rootDir).text.trim())
+    bundleCommand = "export:embed"
+
+    /* Folders */
+     //   The root of your project, i.e. where "package.json" lives. Default is '../..'
+    // root = file("../../")
+    //   The folder where the react-native NPM package is. Default is ../../node_modules/react-native
+    // reactNativeDir = file("../../node_modules/react-native")
+    //   The folder where the react-native Codegen package is. Default is ../../node_modules/@react-native/codegen
+    // codegenDir = file("../../node_modules/@react-native/codegen")
+
+    /* Variants */
+    //   The list of variants to that are debuggable. For those we're going to
+    //   skip the bundling of the JS bundle and the assets. By default is just 'debug'.
+    //   If you add flavors like lite, prod, etc. you'll have to list your debuggableVariants.
+    // debuggableVariants = ["liteDebug", "prodDebug"]
+
+    /* Bundling */
+    //   A list containing the node command and its flags. Default is just 'node'.
+    // nodeExecutableAndArgs = ["node"]
+
+    //
+    //   The path to the CLI configuration file. Default is empty.
+    // bundleConfig = file(../rn-cli.config.js)
+    //
+    //   The name of the generated asset file containing your JS bundle
+    // bundleAssetName = "MyApplication.android.bundle"
+    //
+    //   The entry file for bundle generation. Default is 'index.android.js' or 'index.js'
+    // entryFile = file("../js/MyApplication.android.js")
+    //
+    //   A list of extra flags to pass to the 'bundle' commands.
+    //   See https://github.com/react-native-community/cli/blob/main/docs/commands.md#bundle
+    // extraPackagerArgs = []
+
+    /* Hermes Commands */
+    //   The hermes compiler command to run. By default it is 'hermesc'
+    // hermesCommand = "$rootDir/my-custom-hermesc/bin/hermesc"
+    //
+    //   The list of flags to pass to the Hermes compiler. By default is "-O", "-output-source-map"
+    // hermesFlags = ["-O", "-output-source-map"]
+
+    /* Autolinking */
+    autolinkLibrariesWithApp()
+}
+
+/**
+ * Set this to true to Run Proguard on Release builds to minify the Java bytecode.
+ */
+def enableProguardInReleaseBuilds = (findProperty('android.enableProguardInReleaseBuilds') ?: false).toBoolean()
+
+/**
+ * The preferred build flavor of JavaScriptCore (JSC)
+ *
+ * For example, to use the international variant, you can use:
+ * `def jscFlavor = 'org.webkit:android-jsc-intl:+'`
+ *
+ * The international variant includes ICU i18n library and necessary data
+ * allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that
+ * give correct results when using with locales other than en-US. Note that
+ * this variant is about 6MiB larger per architecture than default.
+ */
+def jscFlavor = 'org.webkit:android-jsc:+'
+
+android {
+    ndkVersion rootProject.ext.ndkVersion
+
+    buildToolsVersion rootProject.ext.buildToolsVersion
+    compileSdk rootProject.ext.compileSdkVersion
+
+    namespace 'expo.modules.nordicdfu.example'
+    defaultConfig {
+        applicationId 'expo.modules.nordicdfu.example'
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode 1
+        versionName "1.0.0"
+    }
+    signingConfigs {
+        debug {
+            storeFile file('debug.keystore')
+            storePassword 'android'
+            keyAlias 'androiddebugkey'
+            keyPassword 'android'
+        }
+    }
+    buildTypes {
+        debug {
+            signingConfig signingConfigs.debug
+        }
+        release {
+            // Caution! In production, you need to generate your own keystore file.
+            // see https://reactnative.dev/docs/signed-apk-android.
+            signingConfig signingConfigs.debug
+            shrinkResources (findProperty('android.enableShrinkResourcesInReleaseBuilds')?.toBoolean() ?: false)
+            minifyEnabled enableProguardInReleaseBuilds
+            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+            crunchPngs (findProperty('android.enablePngCrunchInReleaseBuilds')?.toBoolean() ?: true)
+        }
+    }
+    packagingOptions {
+        jniLibs {
+            useLegacyPackaging (findProperty('expo.useLegacyPackaging')?.toBoolean() ?: false)
+        }
+    }
+    androidResources {
+        ignoreAssetsPattern '!.svn:!.git:!.ds_store:!*.scc:!CVS:!thumbs.db:!picasa.ini:!*~'
+    }
+}
+
+// Apply static values from `gradle.properties` to the `android.packagingOptions`
+// Accepts values in comma delimited lists, example:
+// android.packagingOptions.pickFirsts=/LICENSE,**/picasa.ini
+["pickFirsts", "excludes", "merges", "doNotStrip"].each { prop ->
+    // Split option: 'foo,bar' -> ['foo', 'bar']
+    def options = (findProperty("android.packagingOptions.$prop") ?: "").split(",");
+    // Trim all elements in place.
+    for (i in 0..<options.size()) options[i] = options[i].trim();
+    // `[] - ""` is essentially `[""].filter(Boolean)` removing all empty strings.
+    options -= ""
+
+    if (options.length > 0) {
+        println "android.packagingOptions.$prop += $options ($options.length)"
+        // Ex: android.packagingOptions.pickFirsts += '**/SCCS/**'
+        options.each {
+            android.packagingOptions[prop] += it
+        }
+    }
+}
+
+dependencies {
+    // The version of react-native is set by the React Native Gradle Plugin
+    implementation("com.facebook.react:react-android")
+
+    def isGifEnabled = (findProperty('expo.gif.enabled') ?: "") == "true";
+    def isWebpEnabled = (findProperty('expo.webp.enabled') ?: "") == "true";
+    def isWebpAnimatedEnabled = (findProperty('expo.webp.animated') ?: "") == "true";
+
+    if (isGifEnabled) {
+        // For animated gif support
+        implementation("com.facebook.fresco:animated-gif:${reactAndroidLibs.versions.fresco.get()}")
+    }
+
+    if (isWebpEnabled) {
+        // For webp support
+        implementation("com.facebook.fresco:webpsupport:${reactAndroidLibs.versions.fresco.get()}")
+        if (isWebpAnimatedEnabled) {
+            // Animated webp support
+            implementation("com.facebook.fresco:animated-webp:${reactAndroidLibs.versions.fresco.get()}")
+        }
+    }
+
+    if (hermesEnabled.toBoolean()) {
+        implementation("com.facebook.react:hermes-android")
+    } else {
+        implementation jscFlavor
+    }
+}

package/example/android/app/proguard-rules.pro

@@ -0,0 +1,14 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# react-native-reanimated
+-keep class com.swmansion.reanimated.** { *; }
+-keep class com.facebook.react.turbomodule.** { *; }
+
+# Add any project specific keep options here:

package/example/android/app/src/debug/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
+
+    <application android:usesCleartextTraffic="true" tools:targetApi="28" tools:ignore="GoogleAppIndexingWarning" tools:replace="android:usesCleartextTraffic" />
+</manifest>

package/example/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,40 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools">
+  <uses-permission-sdk-23 android:name="android.permission.ACCESS_COARSE_LOCATION" android:maxSdkVersion="30"/>
+  <uses-permission-sdk-23 android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="30"/>
+  <uses-permission android:name="android.permission.BLUETOOTH"/>
+  <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
+  <uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/>
+  <uses-permission android:name="android.permission.BLUETOOTH_SCAN" android:usesPermissionFlags="neverForLocation" tools:targetApi="31"/>
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE"/>
+  <uses-permission android:name="android.permission.INTERNET"/>
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+  <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
+  <uses-permission android:name="android.permission.VIBRATE"/>
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+  <uses-feature android:name="android.hardware.bluetooth_le" android:required="true"/>
+  <queries>
+    <intent>
+      <action android:name="android.intent.action.VIEW"/>
+      <category android:name="android.intent.category.BROWSABLE"/>
+      <data android:scheme="https"/>
+    </intent>
+  </queries>
+  <application android:name=".MainApplication" android:label="@string/app_name" android:icon="@mipmap/ic_launcher" android:roundIcon="@mipmap/ic_launcher_round" android:allowBackup="true" android:theme="@style/AppTheme" android:supportsRtl="true">
+    <meta-data android:name="expo.modules.updates.ENABLED" android:value="false"/>
+    <meta-data android:name="expo.modules.updates.EXPO_UPDATES_CHECK_ON_LAUNCH" android:value="ALWAYS"/>
+    <meta-data android:name="expo.modules.updates.EXPO_UPDATES_LAUNCH_WAIT_MS" android:value="0"/>
+    <activity android:name=".MainActivity" android:configChanges="keyboard|keyboardHidden|orientation|screenSize|screenLayout|uiMode" android:launchMode="singleTask" android:windowSoftInputMode="adjustResize" android:theme="@style/Theme.App.SplashScreen" android:exported="true" android:screenOrientation="portrait">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN"/>
+        <category android:name="android.intent.category.LAUNCHER"/>
+      </intent-filter>
+      <intent-filter>
+        <action android:name="android.intent.action.VIEW"/>
+        <category android:name="android.intent.category.DEFAULT"/>
+        <category android:name="android.intent.category.BROWSABLE"/>
+        <data android:scheme="expo.modules.nordicdfu.example"/>
+      </intent-filter>
+    </activity>
+  </application>
+</manifest>

package/example/android/app/src/main/java/expo/modules/nordicdfu/example/MainActivity.kt

@@ -0,0 +1,61 @@
+package expo.modules.nordicdfu.example
+
+import android.os.Build
+import android.os.Bundle
+
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
+import com.facebook.react.defaults.DefaultReactActivityDelegate
+
+import expo.modules.ReactActivityDelegateWrapper
+
+class MainActivity : ReactActivity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    // Set the theme to AppTheme BEFORE onCreate to support
+    // coloring the background, status bar, and navigation bar.
+    // This is required for expo-splash-screen.
+    setTheme(R.style.AppTheme);
+    super.onCreate(null)
+  }
+
+  /**
+   * Returns the name of the main component registered from JavaScript. This is used to schedule
+   * rendering of the component.
+   */
+  override fun getMainComponentName(): String = "main"
+
+  /**
+   * Returns the instance of the [ReactActivityDelegate]. We use [DefaultReactActivityDelegate]
+   * which allows you to enable New Architecture with a single boolean flags [fabricEnabled]
+   */
+  override fun createReactActivityDelegate(): ReactActivityDelegate {
+    return ReactActivityDelegateWrapper(
+          this,
+          BuildConfig.IS_NEW_ARCHITECTURE_ENABLED,
+          object : DefaultReactActivityDelegate(
+              this,
+              mainComponentName,
+              fabricEnabled
+          ){})
+  }
+
+  /**
+    * Align the back button behavior with Android S
+    * where moving root activities to background instead of finishing activities.
+    * @see <a href="https://developer.android.com/reference/android/app/Activity#onBackPressed()">onBackPressed</a>
+    */
+  override fun invokeDefaultOnBackPressed() {
+      if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
+          if (!moveTaskToBack(false)) {
+              // For non-root activities, use the default implementation to finish them.
+              super.invokeDefaultOnBackPressed()
+          }
+          return
+      }
+
+      // Use the default back button implementation on Android S
+      // because it's doing more than [Activity.moveTaskToBack] in fact.
+      super.invokeDefaultOnBackPressed()
+  }
+}