Thiết kế website giá rẻ

Question

I would like to connect to insta 360 camera X3 using Insta 360 SDK android in react native. I should be able to capture images on my react native app. Sharing the below code here

This is my Insta360Module.kt

package com.Instamodule.reactnative

import android.app.Activity
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothManager
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Handler
import android.os.Looper
import android.util.Log
import android.util.SparseArray
import androidx.core.app.ActivityCompat
import com.arashivision.sdkcamera.camera.InstaCameraManager
import com.clj.fastble.data.BleDevice
import com.facebook.react.bridge.Arguments
import com.facebook.react.bridge.Promise
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.bridge.ReactContextBaseJavaModule
import com.facebook.react.bridge.ReactMethod
import com.facebook.react.modules.core.DeviceEventManagerModule

class Insta360Module(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
    private val mainHandler = Handler(Looper.getMainLooper())
    private val bluetoothAdapter: BluetoothAdapter? by lazy {
        val bluetoothManager = reactContext.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
        bluetoothManager.adapter
    }

    private val bleDeviceList = mutableListOf<BleDevice>()

    override fun getName(): String {
        return "Insta360Module"
    }

    @ReactMethod
    fun initializeSDK(promise: Promise) {
        try {
            promise.resolve("Insta360SDK initialized successfully")
        } catch (e: Exception) {
            promise.reject("INIT_ERROR", e.message)
        }
    }

    @ReactMethod
    fun captureImage(promise: Promise){
        try {
            InstaCameraManager.getInstance().startNormalCapture(false);
        } catch(e: Exception){
            promise.reject("image capture failed",e.message)
        }
    }

    @ReactMethod
    fun connectBle(deviceAddress: String, promise: Promise) {
        try {
            val bleDevice = getBleDeviceFromAddress(deviceAddress)
            if (bleDevice != null) {
                InstaCameraManager.getInstance().connectBle(bleDevice)
                promise.resolve("BLE Device connected")
            } else {
                promise.reject("BLE_CONNECT_ERROR", "Device not found")
            }
        } catch (e: Exception) {
            Log.e(TAG, "Error connecting to BLE device: ${e.message}", e)
            promise.reject("BLE_CONNECT_ERROR", e.message)
        }
    }

    private fun getBleDeviceFromAddress(address: String): BleDevice? {
        return bleDeviceList.find { it.mac == address }
    }

    @ReactMethod
    fun connectByWifi(promise: Promise) {
        mainHandler.post {
            try {
                InstaCameraManager.getInstance().openCamera(InstaCameraManager.CONNECT_TYPE_WIFI)
                promise.resolve("Connected to camera via WiFi successfully")
            } catch (e: Exception) {
                promise.reject("WIFI_CONNECTION_ERROR", e.message)
            }
        }
    }

    @ReactMethod
    fun scanForCameras(promise: Promise) {
        val hasPermissions = checkPermissions()
        if (!hasPermissions) {
            promise.reject("PERMISSION_ERROR", "Bluetooth and Location permissions are required")
            return
        }

        val devices = mutableListOf<BluetoothDevice>()
        val receiver = BluetoothAdapter.LeScanCallback { device, rssi, scanRecord ->
            devices.add(device)
            addBleDevice(device, rssi, scanRecord)
            sendDeviceEvent(device)
        }

        bluetoothAdapter?.startLeScan(receiver)

        mainHandler.postDelayed({
            bluetoothAdapter?.stopLeScan(receiver)
            promise.resolve("Scan completed")
        }, 10000) // Stop scan after 10 seconds
    }

    @ReactMethod
    fun ensureBluetoothEnabled(promise: Promise) {
        mainHandler.post {
            try {
                if (bluetoothAdapter == null) {
                    promise.reject("BLUETOOTH_ERROR", "Bluetooth not supported on this device")
                    return@post
                }

                if (bluetoothAdapter!!.isEnabled) {
                    promise.resolve("Bluetooth is already enabled")
                } else {
                    val enableBtIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
                    (reactContext.currentActivity as? Activity)?.startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT)
                    promise.resolve("Bluetooth enable request sent")
                }
            } catch (e: Exception) {
                promise.reject("BLUETOOTH_ERROR", e.message)
            }
        }
    }

    fun onActivityResult(requestCode: Int, resultCode: Int) {
        if (requestCode == REQUEST_ENABLE_BT) {
            if (resultCode == Activity.RESULT_OK) {
                // Handle Bluetooth enabled case
            } else {
                // Handle Bluetooth not enabled case
            }
        }
    }

    companion object {
        private const val REQUEST_ENABLE_BT = 1
        private const val TAG = "Insta360Module"
    }

    private fun checkPermissions(): Boolean {
        val requiredPermissions = arrayOf(
            android.Manifest.permission.BLUETOOTH_SCAN,
            android.Manifest.permission.BLUETOOTH_CONNECT,
            android.Manifest.permission.ACCESS_FINE_LOCATION
        )

        for (permission in requiredPermissions) {
            if (ActivityCompat.checkSelfPermission(reactContext, permission) != PackageManager.PERMISSION_GRANTED) {
                return false
            }
        }
        return true
    }

    private fun addBleDevice(device: BluetoothDevice, rssi: Int, scanRecord: ByteArray) {
        val manufacturerData = parseManufacturerData(scanRecord)
        val bleDevice = BleDevice(
            device,
            device.name ?: "Unknown",
            rssi,
            scanRecord,
            System.currentTimeMillis(),
            manufacturerData
        )
        bleDeviceList.add(bleDevice)
    }

    private fun parseManufacturerData(scanRecord: ByteArray): SparseArray<ByteArray> {
        val manufacturerData = SparseArray<ByteArray>()
        var currentPos = 0
        while (currentPos < scanRecord.size) {
            val length = scanRecord[currentPos].toInt()
            if (length == 0) break
            val dataType = scanRecord[currentPos + 1].toInt()
            if (dataType == 0xFF) { // Manufacturer specific data
                val manufacturerBytes = scanRecord.copyOfRange(currentPos + 2, currentPos + length + 1)
                manufacturerData.put(manufacturerBytes[0].toInt(), manufacturerBytes)
            }
            currentPos += length + 1
        }
        return manufacturerData
    }

    private fun sendDeviceEvent(device: BluetoothDevice) {
        val params = Arguments.createMap().apply {
            putString("address", device.address)
            putString("name", device.name)
        }
        reactContext
            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
            .emit("onDeviceFound", params)
    }
}

this is my insta360package.kt

package com.Instamodule.reactnative

import com.facebook.react.ReactPackage
import com.facebook.react.bridge.NativeModule
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.uimanager.ViewManager

class Insta360Package : ReactPackage {

    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
        return listOf(Insta360Module(reactContext))
    }

    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
        return emptyList()
    }
}

And this is my App.jsx

import React, { useEffect, useState } from 'react';
import {
  SafeAreaView,
  StyleSheet,
  Text,
  View,
  NativeModules,
  Button,
  NativeEventEmitter,
  Alert,
  PermissionsAndroid,
  Platform,
  FlatList,
  TouchableOpacity,
} from 'react-native';

const { Insta360Module } = NativeModules;

function App() {
  const [devices, setDevices] = useState([]);
  const [message, setMessage] = useState('');
  const [isConnected, setIsConnected] = useState(false);

  useEffect(() => {
    const requestPermissions = async () => {
      if (Platform.OS === 'android') {
        try {
          const granted = await PermissionsAndroid.requestMultiple([
            PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
            PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
            PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
          ]);

          if (
            granted['android.permission.BLUETOOTH_SCAN'] === PermissionsAndroid.RESULTS.GRANTED &&
            granted['android.permission.BLUETOOTH_CONNECT'] === PermissionsAndroid.RESULTS.GRANTED &&
            granted['android.permission.ACCESS_FINE_LOCATION'] === PermissionsAndroid.RESULTS.GRANTED
          ) {
            console.log('All permissions granted');
            return true;
          } else {
            console.log('Some permissions denied');
            return false;
          }
        } catch (err) {
          console.warn(err);
          return false;
        }
      }
      return true;
    };

    requestPermissions();

    const eventEmitter = new NativeEventEmitter(Insta360Module);
    const subscription = eventEmitter.addListener('onDeviceFound', (device) => {
      setDevices((prevDevices) => {
        if (!prevDevices.some(d => d.address === device.address)) {
          return [...prevDevices, device];
        }
        return prevDevices;
      });
    });

    return () => {
      subscription.remove();
    };
  }, []);

  useEffect(() => {
    Insta360Module.initializeSDK()
      .then(() => {
        console.log('Insta360 CameraSDK initialized successfully');
      })
      .catch((error) => {
        console.error('SDK initialization failed:', error);
      });

    // checkCameraConnection();
  }, []);

  const scanForDevices = async () => {
    setDevices([]);
    setMessage('Scanning for devices...');

    Insta360Module.scanForCameras()
      .then((response) => {
        setMessage(response);
      })
      .catch((error) => {
        setMessage(`Error: ${error.message}`);
      });
  };

  const connectToDevice = (deviceAddress) => {
    Insta360Module.connectBle(deviceAddress)
      .then((response) => {
        Alert.alert('Success', response);
        console.log('Clicked to connect');
        // checkCameraConnection();
      })
      .catch((error) => {
        Alert.alert('Error', error.message);
      });
  };

  // const checkCameraConnection = () => {
  //   Insta360Module.isCameraConnected()
  //     .then((response) => {
  //       setIsConnected(response);
  //       console.log('Camera connection status:', response);
  //     })
  //     .catch((error) => {
  //       console.error('Error checking camera connection:', error);
  //     });
  // };

  const captureImage = () => {
    console.log('Captured');
    Insta360Module.captureImage()
      .then(() => {
        console.log('Image captured successfully');
      })
      .catch((error) => {
        console.error('Error capturing image:', error);
      });
  };

  const isScanning = () => {
    Insta360Module.isBleScanning().then(() => {
      console.log('scanning ble devices...')
    }).catch((error) => {
      console.log('Error scanning',error)
    })
  }
 
  const limitDevices = devices.slice(0, 13);
  console.log('devices', limitDevices);

  return (
    <SafeAreaView style={styles.container}>
      <Text style={styles.header}>Insta360 Camera SDK</Text>
      <Button title="Scan for Devices" onPress={scanForDevices} />
      <Button title='capture' onPress={captureImage}/>
      <FlatList
        data={limitDevices}
        keyExtractor={(item, index) => `${item.address}-${index}`}
        renderItem={({ item }) => (
          <TouchableOpacity onPress={() => connectToDevice(item.address)}>
            <View style={styles.deviceItem}>
              <Text style={{ color: 'red' }}>{item.name} ({item.address})</Text>
            </View>
          </TouchableOpacity>
        )}
        ListEmptyComponent={<Text>No devices found</Text>}
        initialNumToRender={12}
        maxToRenderPerBatch={12}
        windowSize={17}
        removeClippedSubviews={true}
      />
      {message ? <Text style={{ color: 'red' }}>{message}</Text> : null}
      <Text style={{ color: 'red' }}>Camera Connected: {isConnected ? 'Yes' : 'No'}</Text>
    </SafeAreaView>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#fff',
    padding: 20,
  },
  header: {
    fontSize: 24,
    fontWeight: 'bold',
    marginBottom: 20,
    color: 'red',
  },
  deviceItem: {
    padding: 10,
    borderBottomWidth: 1,
    borderBottomColor: '#ccc',
    backgroundColor: 'yellow',
  },
});

export default App;

I’m trying to connect Insta 360 camera X3 to my react native application

Thiết kế website giá rẻ

Danh mục

Want to connect to Insta 360 camera X3 via its SDK in react native and capture images