732 lines
26 KiB
TypeScript
732 lines
26 KiB
TypeScript
import { useCallback, useEffect, useRef, useState } from 'react'
|
||
import { Alert, PermissionsAndroid, Platform, Linking } from 'react-native'
|
||
import {
|
||
BindingResponse,
|
||
BLE_UUIDS,
|
||
BleClient,
|
||
BleDevice,
|
||
BleError,
|
||
BleProtocolService,
|
||
ConnectionState,
|
||
DeviceInfo,
|
||
COMMAND_TYPES,
|
||
EVENT_TYPES,
|
||
UnBindResponse,
|
||
} from '../index'
|
||
import { DeviceInfoService } from '../services/DeviceInfoService'
|
||
import { FileTransferService } from '../services/FileTransferService'
|
||
import { ScanMode } from 'react-native-ble-plx'
|
||
import * as ImagePicker from 'expo-image-picker'
|
||
import { File, Directory, Paths } from 'expo-file-system'
|
||
import * as ImageManipulator from 'expo-image-manipulator'
|
||
import * as Sentry from '@sentry/react-native'
|
||
|
||
interface BleState {
|
||
isScanning: boolean
|
||
isConnected: boolean
|
||
connectedDevice: BleDevice | null
|
||
deviceInfo: DeviceInfo | null
|
||
version: string
|
||
isActivated: boolean
|
||
transferProgress: number
|
||
discoveredDevices: BleDevice[]
|
||
loading: {
|
||
connecting: boolean
|
||
querying: boolean
|
||
converting: boolean
|
||
transferring: boolean
|
||
}
|
||
error: string | null
|
||
}
|
||
|
||
export const useBleExplorer = () => {
|
||
const bleClient = BleClient.getInstance()
|
||
const deviceInfoService = DeviceInfoService.getInstance()
|
||
const fileTransferService = FileTransferService.getInstance()
|
||
const protocolService = BleProtocolService.getInstance()
|
||
|
||
const [bleSeesionId, setBleSessionId] = useState(`ble-session-${Date.now().toString()}`)
|
||
|
||
const [state, setState2] = useState<BleState>({
|
||
isScanning: false,
|
||
isConnected: false,
|
||
connectedDevice: null,
|
||
deviceInfo: null,
|
||
version: '',
|
||
isActivated: false,
|
||
transferProgress: 0,
|
||
discoveredDevices: [],
|
||
loading: {
|
||
connecting: false,
|
||
querying: false,
|
||
converting: false,
|
||
transferring: false,
|
||
},
|
||
error: null,
|
||
})
|
||
|
||
const setState = useCallback(
|
||
(updater: (prev: BleState) => BleState) => {
|
||
try {
|
||
setState2(updater)
|
||
Sentry.captureException(new Error('ble'), {
|
||
tags: {
|
||
sessionId: bleSeesionId,
|
||
component: 'useBleExplorer',
|
||
operation: 'setState',
|
||
has_device: !!state.connectedDevice,
|
||
is_scanning: state.isScanning,
|
||
},
|
||
contexts: {
|
||
ble_state: {
|
||
connection: {
|
||
connected: state.isConnected,
|
||
device_id: state.connectedDevice?.id,
|
||
device_name: state.connectedDevice?.name,
|
||
},
|
||
device: {
|
||
activated: state.isActivated,
|
||
version: state.version,
|
||
free_space: state.deviceInfo?.freespace,
|
||
brand: state.deviceInfo?.brand,
|
||
},
|
||
transfer: {
|
||
progress: state.transferProgress,
|
||
converting: state.loading.converting,
|
||
transferring: state.loading.transferring,
|
||
},
|
||
discovery: {
|
||
scanning: state.isScanning,
|
||
devices_found: state.discoveredDevices.length,
|
||
},
|
||
},
|
||
},
|
||
extra: {
|
||
error_message: state.error,
|
||
loading_states: state.loading,
|
||
},
|
||
})
|
||
} catch (error) {
|
||
console.error('State update failed:', error)
|
||
}
|
||
},
|
||
[
|
||
state.connectedDevice,
|
||
state.isConnected,
|
||
state.isActivated,
|
||
state.version,
|
||
state.deviceInfo,
|
||
state.transferProgress,
|
||
state.loading,
|
||
state.isScanning,
|
||
state.discoveredDevices.length,
|
||
state.error,
|
||
],
|
||
)
|
||
|
||
const setError = useCallback((error: string | null) => {
|
||
setState((prev) => ({ ...prev, error }))
|
||
if (error) {
|
||
console.error(`ERROR: ${error}`)
|
||
}
|
||
}, [])
|
||
|
||
const requestBluetoothPermissions = useCallback(async (): Promise<boolean> => {
|
||
if (Platform.OS !== 'android') return true
|
||
try {
|
||
const sdk = Number(Platform.Version) || 0
|
||
const perms: Array<string> = []
|
||
if (sdk >= 31) {
|
||
perms.push(PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN)
|
||
perms.push(PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT)
|
||
} else {
|
||
perms.push(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION)
|
||
}
|
||
|
||
// 先预检，有些 ROM（如 MIUI）会在 check 阶段就返回 false
|
||
const preChecks = await Promise.all(perms.map((p) => PermissionsAndroid.check(p as any)))
|
||
const needRequest = perms.filter((_, i) => !preChecks[i])
|
||
if (needRequest.length === 0) return true
|
||
|
||
const results = await PermissionsAndroid.requestMultiple(needRequest as any)
|
||
console.log('results-----------', results)
|
||
|
||
const allGranted = Object.values(results).every((r) => r === PermissionsAndroid.RESULTS.GRANTED)
|
||
if (allGranted) return true
|
||
|
||
const neverAsk = Object.values(results).some((r) => r === PermissionsAndroid.RESULTS.NEVER_ASK_AGAIN)
|
||
if (neverAsk) {
|
||
Alert.alert(
|
||
'需要权限',
|
||
'检测到蓝牙权限已被禁止且选择了不再询问。请在系统设置中为应用手动开启蓝牙和位置权限。',
|
||
[
|
||
{ text: '取消', style: 'cancel' },
|
||
{
|
||
text: '打开设置',
|
||
onPress: () =>
|
||
Linking.openSettings().catch(() => {
|
||
setError('无法打开系统设置，请手动前往应用权限设置')
|
||
}),
|
||
},
|
||
],
|
||
{ cancelable: true },
|
||
)
|
||
}
|
||
|
||
const denied = Object.entries(results)
|
||
.filter(([_, r]) => r !== PermissionsAndroid.RESULTS.GRANTED)
|
||
.map(([p]) => p.split('.').pop())
|
||
setError(`Bluetooth permissions required: ${denied.join(', ')}`)
|
||
return false
|
||
} catch (err) {
|
||
setError(`Permission request failed: ${err}`)
|
||
return false
|
||
}
|
||
}, [setError])
|
||
|
||
useEffect(() => {
|
||
if (Platform.OS === 'web') {
|
||
console.log('BLE not supported on web platform')
|
||
return
|
||
}
|
||
|
||
const onConnectionStateChange = ({ deviceId, state: connState }: { deviceId: string; state: ConnectionState }) => {
|
||
const isConnected = connState === ConnectionState.CONNECTED
|
||
setState((prev) => {
|
||
const updatedDevices = prev.discoveredDevices.map((d) => {
|
||
if (d.id === deviceId) {
|
||
const newDevice = Object.assign(Object.create(Object.getPrototypeOf(d)), d) as BleDevice
|
||
newDevice.connected = isConnected
|
||
return newDevice
|
||
}
|
||
return d
|
||
})
|
||
|
||
return {
|
||
...prev,
|
||
isConnected,
|
||
connectedDevice: connState === ConnectionState.DISCONNECTED ? null : prev.connectedDevice,
|
||
discoveredDevices: updatedDevices,
|
||
}
|
||
})
|
||
console.log(`Connection state ${deviceId}: ${connState}`)
|
||
}
|
||
|
||
const onScanError = (error: BleError) => {
|
||
setError(`Scan error: ${error.message}`)
|
||
setState((prev) => ({ ...prev, isScanning: false }))
|
||
}
|
||
|
||
bleClient.addListener('connectionStateChange', onConnectionStateChange)
|
||
bleClient.addListener('scanError', onScanError)
|
||
|
||
const onDeviceInfo = (info: DeviceInfo) => {
|
||
setState((prev) => ({ ...prev, deviceInfo: info }))
|
||
}
|
||
|
||
const onVersionInfo = (version: string) => {
|
||
setState((prev) => ({ ...prev, version: version }))
|
||
}
|
||
|
||
const onBindStatus = (status: BindingResponse) => {
|
||
const activated = status.success === 1
|
||
setState((prev) => ({ ...prev, isActivated: activated }))
|
||
}
|
||
|
||
const onUnBindStatus = (status: UnBindResponse) => {
|
||
const activated = status.success === 1
|
||
setState((prev) => ({ ...prev, isActivated: activated }))
|
||
}
|
||
|
||
deviceInfoService.addListener(EVENT_TYPES.DEVICE_INFO.name, onDeviceInfo)
|
||
deviceInfoService.addListener(EVENT_TYPES.VERSION_INFO.name, onVersionInfo)
|
||
deviceInfoService.addListener(EVENT_TYPES.BIND_DEVICE.name, onBindStatus)
|
||
deviceInfoService.addListener(EVENT_TYPES.UNBIND_DEVICE.name, onUnBindStatus)
|
||
|
||
return () => {
|
||
bleClient.removeListener('connectionStateChange', onConnectionStateChange)
|
||
bleClient.removeListener('scanError', onScanError)
|
||
deviceInfoService.removeListener(EVENT_TYPES.DEVICE_INFO.name, onDeviceInfo)
|
||
deviceInfoService.removeListener(EVENT_TYPES.VERSION_INFO.name, onVersionInfo)
|
||
deviceInfoService.removeListener(EVENT_TYPES.BIND_DEVICE.name, onBindStatus)
|
||
deviceInfoService.removeListener(EVENT_TYPES.UNBIND_DEVICE.name, onUnBindStatus)
|
||
}
|
||
}, [bleClient, deviceInfoService, setError])
|
||
|
||
const startScan = useCallback(async () => {
|
||
if (Platform.OS === 'web') return
|
||
try {
|
||
setError(null)
|
||
console.log('Starting scan...')
|
||
const hasPerms = await requestBluetoothPermissions()
|
||
if (!hasPerms) return
|
||
|
||
setState((prev) => ({ ...prev, isScanning: true, discoveredDevices: [] }))
|
||
|
||
// Check for already connected devices
|
||
try {
|
||
const relevantDevices = await bleClient.getConnectedDevices([BLE_UUIDS.SERVICE])
|
||
|
||
if (relevantDevices.length > 0) {
|
||
console.log(`Found ${relevantDevices.length} system-connected devices`)
|
||
setState((prev) => {
|
||
// Avoid duplicates if any
|
||
const newDevices = relevantDevices.filter((nd) => !prev.discoveredDevices.some((ed) => ed.id === nd.id))
|
||
newDevices.forEach((d) => {
|
||
d.connected = false
|
||
}) // Treat as disconnected until explicit connect
|
||
return {
|
||
...prev,
|
||
discoveredDevices: [...prev.discoveredDevices, ...newDevices],
|
||
}
|
||
})
|
||
}
|
||
} catch (e) {
|
||
console.warn('Failed to check connected devices', e)
|
||
}
|
||
await bleClient.startScan(
|
||
// [BLE_UUIDS.SERVICE],
|
||
null,
|
||
{ scanMode: ScanMode.LowLatency, allowDuplicates: false },
|
||
(result) => {
|
||
setState((prev) => {
|
||
const device = result.device as BleDevice
|
||
|
||
// Filter only for service UUID
|
||
if (device.name?.startsWith('707')) {
|
||
// continue
|
||
} else if (!device.serviceUUIDs) {
|
||
return prev
|
||
}
|
||
|
||
if (prev.discoveredDevices.find((d) => d.id === device.id)) return prev
|
||
|
||
device.connected = false
|
||
|
||
console.debug(`Device found: ${device.name} (${device.id}), serviceUUIDs: ${device.serviceUUIDs}`)
|
||
return { ...prev, discoveredDevices: [...prev.discoveredDevices, device] }
|
||
})
|
||
},
|
||
)
|
||
} catch (e: any) {
|
||
setError(`Start scan failed: ${e.message}`)
|
||
console.log('scan error --------------', e)
|
||
// 解决安卓31以下爱无法检测到蓝牙是否开启的问题
|
||
setState((prev) => ({ ...prev, isScanning: false, discoveredDevices: [] }))
|
||
Alert.alert('手机蓝牙未开启', '检测到手机蓝牙未打开，请打开手机蓝牙再试。', [{ text: '确定', style: 'default' }], { cancelable: true })
|
||
}
|
||
}, [bleClient, requestBluetoothPermissions, setError])
|
||
|
||
const stopScan = useCallback(() => {
|
||
bleClient.stopScan()
|
||
setState((prev) => ({ ...prev, isScanning: false }))
|
||
console.log('Scan stopped')
|
||
}, [bleClient])
|
||
|
||
const connectToDevice = useCallback(
|
||
async (device: BleDevice) => {
|
||
try {
|
||
stopScan()
|
||
setState((prev) => ({ ...prev, loading: { ...prev.loading, connecting: true } }))
|
||
console.log(`Connecting to ${device.name}...${device.id}`)
|
||
if (!device?.id) return
|
||
const connectedDevice = (await bleClient.connect(device?.id)) as BleDevice
|
||
connectedDevice.connected = true
|
||
|
||
// Scan and log all services and characteristics
|
||
try {
|
||
const services = await connectedDevice.services()
|
||
for (const service of services) {
|
||
console.log(`[Service] ${service.uuid}`)
|
||
const characteristics = await service.characteristics()
|
||
for (const char of characteristics) {
|
||
const props = [
|
||
char.isReadable ? 'Read' : '',
|
||
char.isWritableWithResponse ? 'Write' : '',
|
||
char.isWritableWithoutResponse ? 'WriteNoResp' : '',
|
||
char.isNotifiable ? 'Notify' : '',
|
||
char.isIndicatable ? 'Indicate' : '',
|
||
]
|
||
.filter(Boolean)
|
||
.join(',')
|
||
console.log(` -> [Char] ${char.uuid} (${props})`)
|
||
}
|
||
}
|
||
} catch (scanError) {
|
||
console.error(`Error scanning services: ${scanError}`)
|
||
}
|
||
|
||
await protocolService.initialize(device.id)
|
||
|
||
setState((prev) => ({
|
||
...prev,
|
||
connectedDevice,
|
||
isConnected: true,
|
||
loading: { ...prev.loading, connecting: false },
|
||
}))
|
||
console.log('Connected and Protocol initialized')
|
||
} catch (e: any) {
|
||
setError(`Connection failed: ${e.message}`)
|
||
setState((prev) => ({ ...prev, loading: { ...prev.loading, connecting: false } }))
|
||
}
|
||
},
|
||
[bleClient, protocolService, stopScan, setError],
|
||
)
|
||
|
||
const disconnectDevice = useCallback(async () => {
|
||
try {
|
||
console.log('Disconnecting...')
|
||
await bleClient.disconnect()
|
||
protocolService.disconnect()
|
||
} catch (e: any) {
|
||
console.error(`Disconnect failed: ${e.message}`)
|
||
}
|
||
}, [bleClient, protocolService])
|
||
|
||
const getDeviceInfo = useCallback(async () => {
|
||
if (!state.connectedDevice) return
|
||
try {
|
||
console.log(`[${state.connectedDevice.id}] Requesting Device Info...`)
|
||
await deviceInfoService.getDeviceInfo(state.connectedDevice.id)
|
||
console.log(`[${state.connectedDevice.id}] Device Info query request sent.`)
|
||
return Promise.resolve()
|
||
} catch (e: any) {
|
||
setError(`Request failed: ${e.message}`)
|
||
return Promise.reject(e.message)
|
||
}
|
||
}, [deviceInfoService, state.connectedDevice, setError])
|
||
|
||
const getDeviceVersion = useCallback(async () => {
|
||
if (!state.connectedDevice) return
|
||
try {
|
||
console.log(`[${state.connectedDevice.id}] Requesting Device Version...`)
|
||
await deviceInfoService.getDeviceVersion(state.connectedDevice.id)
|
||
console.log(`[${state.connectedDevice.id}] Device Version query request sent`)
|
||
} catch (e: any) {
|
||
setError(`Request failed: ${e.message}`)
|
||
}
|
||
}, [state.connectedDevice, deviceInfoService, setError])
|
||
|
||
const bindDevice = useCallback(
|
||
async (userId: string) => {
|
||
if (!state.connectedDevice) return
|
||
try {
|
||
await deviceInfoService.bindDevice(state.connectedDevice.id, userId)
|
||
return Promise.resolve()
|
||
} catch (e: any) {
|
||
setError(`Request failed: ${e.message}`)
|
||
return Promise.reject(e.message)
|
||
}
|
||
},
|
||
[state.connectedDevice, deviceInfoService, setError],
|
||
)
|
||
|
||
const unBindDevice = useCallback(
|
||
async (userId: string) => {
|
||
if (!state.connectedDevice) return
|
||
try {
|
||
await deviceInfoService.unbindDevice(state.connectedDevice.id, userId)
|
||
return Promise.resolve()
|
||
} catch (e: any) {
|
||
setError(`Request failed: ${e.message}`)
|
||
return Promise.reject(e.message)
|
||
}
|
||
},
|
||
[state.connectedDevice, deviceInfoService, setError],
|
||
)
|
||
|
||
const pickImage = async () => {
|
||
// No permissions request is necessary for launching the image library.
|
||
// Manually request permissions for videos on iOS when `allowsEditing` is set to `false`
|
||
// and `videoExportPreset` is `'Passthrough'` (the default), ideally before launching the picker
|
||
// so the app users aren't surprised by a system dialog after picking a video.
|
||
// See "Invoke permissions for videos" sub section for more details.
|
||
const permissionResult = await ImagePicker.requestMediaLibraryPermissionsAsync()
|
||
|
||
if (!permissionResult.granted) {
|
||
Alert.alert('Permission required', 'Permission to access the media library is required.')
|
||
return []
|
||
}
|
||
|
||
let result = await ImagePicker.launchImageLibraryAsync({
|
||
mediaTypes: ['images', 'videos'],
|
||
allowsEditing: false,
|
||
aspect: [1, 1],
|
||
quality: 1.0,
|
||
})
|
||
if (!result.canceled) {
|
||
return result.assets
|
||
} else {
|
||
return []
|
||
}
|
||
}
|
||
|
||
const convertToANIAsFile = useCallback(async (tempDir: Directory, media: ImagePicker.ImagePickerAsset): Promise<File> => {
|
||
const tempFile = new File(tempDir, `${media.fileName?.split('.')[0]}.ani`)
|
||
const formData = new FormData()
|
||
formData.append('file', {
|
||
uri: media.uri,
|
||
name: media.fileName || 'video.mp4',
|
||
type: media.mimeType || 'video/mp4',
|
||
} as any)
|
||
const response = await fetch('https://bowongai-test--ani-video-converter-fastapi-app.modal.run/api/convert/ani', {
|
||
method: 'POST',
|
||
body: formData,
|
||
headers: { Accept: 'multipart/form-data' },
|
||
})
|
||
if (!response.ok) {
|
||
throw new Error(`Conversion failed with status ${response.status}`)
|
||
}
|
||
const content = await response.arrayBuffer()
|
||
tempFile.write(new Uint8Array(content))
|
||
const tempFileInfo = tempFile.info()
|
||
console.debug(`Converted video saved to ${tempFile.uri}, size : ${tempFileInfo.size} bytes`)
|
||
return tempFile
|
||
}, [])
|
||
|
||
const convertToANIAsBuffer = useCallback(async (tempDir: Directory, media: ImagePicker.ImagePickerAsset): Promise<ArrayBuffer> => {
|
||
const formData = new FormData()
|
||
formData.append('file', {
|
||
uri: media.uri,
|
||
name: media.fileName || 'video.mp4',
|
||
type: media.mimeType || 'video/mp4',
|
||
} as any)
|
||
const response = await fetch('https://bowongai-test--ani-video-converter-fastapi-app.modal.run/api/convert/ani', {
|
||
method: 'POST',
|
||
body: formData,
|
||
headers: { Accept: 'multipart/form-data' },
|
||
})
|
||
if (!response.ok) {
|
||
throw new Error(`Conversion failed with status ${response.status}`)
|
||
}
|
||
const content = await response.arrayBuffer()
|
||
console.debug(`Converted video size : ${content.byteLength} bytes`)
|
||
return content
|
||
}, [])
|
||
|
||
const transferMedia = useCallback(async () => {
|
||
if (!state.connectedDevice) {
|
||
setError('No device connected')
|
||
return
|
||
}
|
||
const tempDir = new Directory(Paths.cache, 'anis')
|
||
if (!tempDir.exists) tempDir.create()
|
||
const medias = await pickImage()
|
||
if (medias.length === 0) return
|
||
console.debug(`[${state.connectedDevice.id}] processing ${medias.length} files...`)
|
||
for (const media of medias) {
|
||
if (media.type === 'video') {
|
||
// let tempFile: File;
|
||
let tempBuffer: ArrayBuffer
|
||
console.debug(`Converting video: ${media.fileName || 'video'}...`)
|
||
setState((prev) => ({ ...prev, loading: { ...prev.loading, converting: true } }))
|
||
// tempFile = await convertToANIAsFile(tempDir, media)
|
||
tempBuffer = await convertToANIAsBuffer(tempDir, media)
|
||
setState((prev) => ({ ...prev, loading: { ...prev.loading, converting: false } }))
|
||
console.log(`Transferring converted file to device...`)
|
||
await fileTransferService.transferFile(state.connectedDevice.id, tempBuffer, COMMAND_TYPES.TRANSFER_ANI_VIDEO, (progress) => {
|
||
setState((prev) => ({ ...prev, transferProgress: progress * 100 }))
|
||
// Optional: throttle logs to avoid spam
|
||
if (Math.round(progress * 100) % 10 === 0) {
|
||
// addLog(`Transfer progress: ${Math.round(progress * 100)}%`);
|
||
}
|
||
})
|
||
// tempFile.delete();
|
||
console.log(`Transfer successful`)
|
||
} else if (media.type === 'image') {
|
||
try {
|
||
console.debug(`Processing image: ${media.fileName || 'image'}...`)
|
||
|
||
// Check if it is a GIF
|
||
const isGif = media.mimeType === 'image/gif' || media.uri.toLowerCase().endsWith('.gif')
|
||
|
||
if (isGif) {
|
||
console.debug(`Converting GIF to ANI: ${media.fileName || 'gif'}...`)
|
||
// const tempFile = await convertToANIAsFile(tempDir, media)
|
||
const tempBuffer = await convertToANIAsBuffer(tempDir, media)
|
||
console.log(`Transferring converted file to device...`)
|
||
await fileTransferService.transferFile(state.connectedDevice.id, tempBuffer, COMMAND_TYPES.TRANSFER_ANI_VIDEO, (progress) => {
|
||
setState((prev) => ({ ...prev, transferProgress: progress * 100 }))
|
||
})
|
||
console.log(`Transfer successful`)
|
||
// tempFile.delete();
|
||
console.log(`Cleaned up temp file`)
|
||
return
|
||
}
|
||
|
||
let imageUri = media.uri
|
||
|
||
// Check if conversion is needed (if not jpeg)
|
||
// Note: mimeType might not always be reliable, so we can also check filename extension if needed,
|
||
// or just always run manipulator to ensure consistency.
|
||
// Here we check if it is NOT jpeg/jpg
|
||
const isJpeg =
|
||
media.mimeType === 'image/jpeg' ||
|
||
media.mimeType === 'image/jpg' ||
|
||
media.uri.toLowerCase().endsWith('.jpg') ||
|
||
media.uri.toLowerCase().endsWith('.jpeg')
|
||
|
||
if (!isJpeg) {
|
||
console.debug(`Converting image to JPEG...`)
|
||
const context = ImageManipulator.ImageManipulator.manipulate(media.uri).resize({
|
||
width: BLE_UUIDS.SCREEN_SIZE,
|
||
height: BLE_UUIDS.SCREEN_SIZE,
|
||
})
|
||
const imageRef = await context.renderAsync()
|
||
const result = await imageRef.saveAsync({
|
||
compress: 1,
|
||
format: ImageManipulator.SaveFormat.JPEG,
|
||
})
|
||
imageUri = result.uri
|
||
console.debug(`Conversion successful: ${imageUri}`)
|
||
}
|
||
|
||
console.log(`Transferring image to device...`)
|
||
await fileTransferService.transferFile(
|
||
state.connectedDevice.id,
|
||
imageUri,
|
||
COMMAND_TYPES.TRANSFER_JPEG_IMAGE, // Assuming PHOTO_ALBUM is for images, adjust if needed
|
||
(progress) => {
|
||
setState((prev) => ({ ...prev, transferProgress: progress * 100 }))
|
||
},
|
||
)
|
||
|
||
// If we created a temporary file via manipulation, we might want to clean it up?
|
||
// ImageManipulator results are usually in cache, which OS cleans up, but we can't easily delete if we don't own it.
|
||
// For this flow, we just leave it.
|
||
|
||
console.log(`Transfer successful`)
|
||
} catch (e: any) {
|
||
console.error(`Error: ${e.message}`)
|
||
setError(e.message)
|
||
}
|
||
} else {
|
||
console.log(`Unsupported media type: ${media.type}`)
|
||
}
|
||
}
|
||
}, [state.connectedDevice, fileTransferService, convertToANIAsBuffer, setError])
|
||
|
||
// 单个上传接口
|
||
const transferMediaSingle = useCallback(
|
||
async (uriOrUrl: string) => {
|
||
try {
|
||
if (!state.connectedDevice) {
|
||
setError('No device connected')
|
||
return Promise.reject('No device connected')
|
||
}
|
||
const tempDir = new Directory(Paths.cache, 'anis')
|
||
if (!tempDir.exists) tempDir.create()
|
||
|
||
if (!uriOrUrl) return Promise.reject('No uriOrUrl provided')
|
||
|
||
console.debug(`[${state.connectedDevice.id}] processing ${uriOrUrl}...`)
|
||
|
||
// let tempFile: File;
|
||
let tempBuffer: ArrayBuffer
|
||
console.debug(`Converting video: ${uriOrUrl || 'video'}...`)
|
||
setState((prev) => ({ ...prev, loading: { ...prev.loading, converting: true } }))
|
||
// tempFile = await convertToANIAsFile(tempDir, media)
|
||
tempBuffer = await convertImgToANIAsBuffer(uriOrUrl)
|
||
|
||
setState((prev) => ({ ...prev, loading: { ...prev.loading, converting: false, transferring: true } }))
|
||
console.log(`Transferring converted file to device...`)
|
||
|
||
await fileTransferService.transferFile(state.connectedDevice.id, tempBuffer, COMMAND_TYPES.TRANSFER_ANI_VIDEO, (progress) => {
|
||
setState((prev) => ({ ...prev, transferProgress: progress * 100 }))
|
||
})
|
||
setState((prev) => ({ ...prev, loading: { ...prev.loading, transferring: false } }))
|
||
console.log(`Transfer successful`)
|
||
return Promise.resolve()
|
||
} catch (error: any) {
|
||
setState((prev) => ({ ...prev, loading: { ...prev.loading, transferring: false } }))
|
||
console.log(`Transfer failed: ${error.message}`)
|
||
return Promise.reject(error.message)
|
||
}
|
||
},
|
||
[state.connectedDevice, fileTransferService, convertToANIAsBuffer, setError],
|
||
)
|
||
|
||
function guessMimeType(fileName: string): string {
|
||
const ext = fileName.split('.').pop()?.toLowerCase()
|
||
switch (ext) {
|
||
case 'mp4':
|
||
return 'video/mp4'
|
||
case 'mov':
|
||
return 'video/quicktime'
|
||
case 'webm':
|
||
return 'video/webm'
|
||
case 'jpg':
|
||
case 'jpeg':
|
||
return 'image/jpeg'
|
||
case 'png':
|
||
return 'image/png'
|
||
default:
|
||
return 'application/octet-stream'
|
||
}
|
||
}
|
||
|
||
const convertImgToANIAsBuffer = useCallback(async (uriOrUrl: string): Promise<ArrayBuffer> => {
|
||
// 1️⃣ 用 fetch 统一拿 Blob（本地 / 网络都行）
|
||
const res = await fetch(uriOrUrl)
|
||
if (!res.ok) {
|
||
// throw new Error(`Failed to fetch media: ${res.status}`)
|
||
return Promise.reject(`Failed to fetch media: ${res.status}`)
|
||
}
|
||
|
||
const blob = await res.blob()
|
||
|
||
// 2️⃣ 从 url / uri 推断文件名
|
||
const name = uriOrUrl.split('/').pop()?.split('?')[0] || 'media.bin'
|
||
|
||
// 3️⃣ MIME 类型兜底
|
||
const type = blob.type || guessMimeType(name)
|
||
|
||
// 4️⃣ 构造 FormData
|
||
const formData = new FormData()
|
||
formData.append('file', {
|
||
uri: uriOrUrl,
|
||
name,
|
||
type,
|
||
} as any)
|
||
|
||
// 5️⃣ 上传到 ANI 服务
|
||
const aniProd = 'https://bowongai-prod--ani-video-converter-fastapi-app.modal.run/api/convert/ani'
|
||
|
||
const response = await fetch(aniProd, {
|
||
method: 'POST',
|
||
body: formData,
|
||
// headers: {
|
||
// Accept: 'application/json',
|
||
// },
|
||
})
|
||
|
||
if (!response.ok) {
|
||
throw new Error(`Conversion failed: ${response.status}`)
|
||
}
|
||
|
||
// 6️⃣ 返回 ArrayBuffer
|
||
const content = await response.arrayBuffer()
|
||
console.debug(`Converted video size: ${content.byteLength} bytes`)
|
||
|
||
return content
|
||
}, [])
|
||
|
||
const clearLogs = useCallback(() => setState((prev) => ({ ...prev, logs: [] })), [])
|
||
|
||
return {
|
||
...state,
|
||
startScan,
|
||
stopScan,
|
||
connectToDevice,
|
||
disconnectDevice,
|
||
getDeviceInfo,
|
||
getDeviceVersion,
|
||
bindDevice,
|
||
unBindDevice,
|
||
transferMedia,
|
||
transferMediaSingle,
|
||
clearLogs,
|
||
bleSeesionId,
|
||
}
|
||
}
|