react-native-executorch 0.5.1 → 0.5.2

package/lib/hooks/computer_vision/useVerticalOCR.d.ts

@@ -0,0 +1,21 @@
+import { ResourceSource } from '../../types/common';
+import { OCRDetection, OCRLanguage } from '../../types/ocr';
+interface OCRModule {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    forward: (input: string) => Promise<OCRDetection[]>;
+    downloadProgress: number;
+}
+export declare const useVerticalOCR: ({ model, independentCharacters, preventLoad, }: {
+    model: {
+        detectorLarge: ResourceSource;
+        detectorNarrow: ResourceSource;
+        recognizerLarge: ResourceSource;
+        recognizerSmall: ResourceSource;
+        language: OCRLanguage;
+    };
+    independentCharacters?: boolean;
+    preventLoad?: boolean;
+}) => OCRModule;
+export {};

package/lib/hooks/computer_vision/useVerticalOCR.js

@@ -0,0 +1,45 @@
+import { useEffect, useMemo, useState } from 'react';
+import { VerticalOCRController } from '../../controllers/VerticalOCRController';
+export const useVerticalOCR = ({ model, independentCharacters = false, preventLoad = false, }) => {
+    const [error, setError] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    const controllerInstance = useMemo(() => new VerticalOCRController({
+        isReadyCallback: setIsReady,
+        isGeneratingCallback: setIsGenerating,
+        errorCallback: setError,
+    }), []);
+    useEffect(() => {
+        if (preventLoad)
+            return;
+        (async () => {
+            await controllerInstance.load({
+                detectorLarge: model.detectorLarge,
+                detectorNarrow: model.detectorNarrow,
+            }, {
+                recognizerLarge: model.recognizerLarge,
+                recognizerSmall: model.recognizerSmall,
+            }, model.language, independentCharacters, setDownloadProgress);
+        })();
+        return () => {
+            controllerInstance.delete();
+        };
+    }, [
+        controllerInstance,
+        model.detectorLarge,
+        model.detectorNarrow,
+        model.recognizerLarge,
+        model.recognizerSmall,
+        model.language,
+        independentCharacters,
+        preventLoad,
+    ]);
+    return {
+        error,
+        isReady,
+        isGenerating,
+        forward: controllerInstance.forward,
+        downloadProgress,
+    };
+};

package/lib/hooks/general/useExecutorchModule.d.ts

@@ -0,0 +1,13 @@
+import { ResourceSource } from '../../types/common';
+interface Props {
+    modelSource: ResourceSource;
+    preventLoad?: boolean;
+}
+export declare const useExecutorchModule: ({ modelSource, preventLoad, }: Props) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (inputTensor: import("../../types/common").TensorPtr[]) => Promise<import("../../types/common").TensorPtr[]>;
+};
+export {};

package/lib/hooks/general/useExecutorchModule.js

@@ -0,0 +1,7 @@
+import { ExecutorchModule } from '../../modules/general/ExecutorchModule';
+import { useNonStaticModule } from '../useNonStaticModule';
+export const useExecutorchModule = ({ modelSource, preventLoad = false, }) => useNonStaticModule({
+    module: ExecutorchModule,
+    model: { modelSource },
+    preventLoad,
+});

package/lib/hooks/natural_language_processing/useLLM.d.ts

@@ -0,0 +1,10 @@
+import { ResourceSource } from '../../types/common';
+import { LLMType } from '../../types/llm';
+export declare const useLLM: ({ model, preventLoad, }: {
+    model: {
+        modelSource: ResourceSource;
+        tokenizerSource: ResourceSource;
+        tokenizerConfigSource: ResourceSource;
+    };
+    preventLoad?: boolean;
+}) => LLMType;

package/lib/hooks/natural_language_processing/useLLM.js

@@ -0,0 +1,78 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { LLMController } from '../../controllers/LLMController';
+/*
+Hook version of LLMModule
+*/
+export const useLLM = ({ model, preventLoad = false, }) => {
+    const [token, setToken] = useState('');
+    const [response, setResponse] = useState('');
+    const [messageHistory, setMessageHistory] = useState([]);
+    const [isReady, setIsReady] = useState(false);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    const [error, setError] = useState(null);
+    const tokenCallback = useCallback((newToken) => {
+        setToken(newToken);
+        setResponse((prevResponse) => prevResponse + newToken);
+    }, []);
+    const controllerInstance = useMemo(() => new LLMController({
+        tokenCallback: tokenCallback,
+        messageHistoryCallback: setMessageHistory,
+        isReadyCallback: setIsReady,
+        isGeneratingCallback: setIsGenerating,
+    }), [tokenCallback]);
+    useEffect(() => {
+        setDownloadProgress(0);
+        setError(null);
+        if (preventLoad)
+            return;
+        (async () => {
+            try {
+                await controllerInstance.load({
+                    modelSource: model.modelSource,
+                    tokenizerSource: model.tokenizerSource,
+                    tokenizerConfigSource: model.tokenizerConfigSource,
+                    onDownloadProgressCallback: setDownloadProgress,
+                });
+            }
+            catch (e) {
+                setError(e);
+            }
+        })();
+        return () => {
+            controllerInstance.delete();
+        };
+    }, [
+        controllerInstance,
+        model.modelSource,
+        model.tokenizerSource,
+        model.tokenizerConfigSource,
+        preventLoad,
+    ]);
+    // memoization of returned functions
+    const configure = useCallback(({ chatConfig, toolsConfig, }) => controllerInstance.configure({ chatConfig, toolsConfig }), [controllerInstance]);
+    const generate = useCallback((messages, tools) => {
+        setResponse('');
+        return controllerInstance.generate(messages, tools);
+    }, [controllerInstance]);
+    const sendMessage = useCallback((message) => {
+        setResponse('');
+        return controllerInstance.sendMessage(message);
+    }, [controllerInstance]);
+    const deleteMessage = useCallback((index) => controllerInstance.deleteMessage(index), [controllerInstance]);
+    const interrupt = useCallback(() => controllerInstance.interrupt(), [controllerInstance]);
+    return {
+        messageHistory,
+        response,
+        token,
+        isReady,
+        isGenerating,
+        downloadProgress,
+        error,
+        configure: configure,
+        generate: generate,
+        sendMessage: sendMessage,
+        deleteMessage: deleteMessage,
+        interrupt: interrupt,
+    };
+};

package/lib/hooks/natural_language_processing/useSpeechToText.d.ts

@@ -0,0 +1,27 @@
+import { SpeechToTextController } from '../../controllers/SpeechToTextController';
+import { ResourceSource } from '../../types/common';
+import { STREAMING_ACTION } from '../../constants/sttDefaults';
+import { AvailableModels, SpeechToTextLanguage } from '../../types/stt';
+interface SpeechToTextModule {
+    isReady: boolean;
+    isGenerating: boolean;
+    sequence: string;
+    downloadProgress: number;
+    configureStreaming: SpeechToTextController['configureStreaming'];
+    error: Error | undefined;
+    transcribe: (input: number[], audioLanguage?: SpeechToTextLanguage) => ReturnType<SpeechToTextController['transcribe']>;
+    streamingTranscribe: (streamAction: STREAMING_ACTION, input?: number[], audioLanguage?: SpeechToTextLanguage) => ReturnType<SpeechToTextController['streamingTranscribe']>;
+}
+export declare const useSpeechToText: ({ model, overlapSeconds, windowSize, streamingConfig, preventLoad, }: {
+    model: {
+        modelName: AvailableModels;
+        encoderSource: ResourceSource;
+        decoderSource: ResourceSource;
+        tokenizerSource: ResourceSource;
+    };
+    overlapSeconds?: ConstructorParameters<typeof SpeechToTextController>["0"]["overlapSeconds"];
+    windowSize?: ConstructorParameters<typeof SpeechToTextController>["0"]["windowSize"];
+    streamingConfig?: ConstructorParameters<typeof SpeechToTextController>["0"]["streamingConfig"];
+    preventLoad?: boolean;
+}) => SpeechToTextModule;
+export {};

package/lib/hooks/natural_language_processing/useSpeechToText.js

@@ -0,0 +1,49 @@
+import { useEffect, useMemo, useState } from 'react';
+import { SpeechToTextController } from '../../controllers/SpeechToTextController';
+export const useSpeechToText = ({ model, overlapSeconds, windowSize, streamingConfig, preventLoad = false, }) => {
+    const [sequence, setSequence] = useState('');
+    const [isReady, setIsReady] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [error, setError] = useState();
+    const controllerInstance = useMemo(() => new SpeechToTextController({
+        transcribeCallback: setSequence,
+        isReadyCallback: setIsReady,
+        isGeneratingCallback: setIsGenerating,
+        onErrorCallback: setError,
+    }), []);
+    useEffect(() => {
+        controllerInstance.configureStreaming(overlapSeconds, windowSize, streamingConfig);
+    }, [controllerInstance, overlapSeconds, windowSize, streamingConfig]);
+    useEffect(() => {
+        const loadModel = async () => {
+            await controllerInstance.load({
+                modelName: model.modelName,
+                encoderSource: model.encoderSource,
+                decoderSource: model.decoderSource,
+                tokenizerSource: model.tokenizerSource,
+                onDownloadProgressCallback: setDownloadProgress,
+            });
+        };
+        if (!preventLoad) {
+            loadModel();
+        }
+    }, [
+        controllerInstance,
+        model.modelName,
+        model.encoderSource,
+        model.decoderSource,
+        model.tokenizerSource,
+        preventLoad,
+    ]);
+    return {
+        isReady,
+        isGenerating,
+        downloadProgress,
+        configureStreaming: controllerInstance.configureStreaming,
+        sequence,
+        error,
+        transcribe: (waveform, audioLanguage) => controllerInstance.transcribe(waveform, audioLanguage),
+        streamingTranscribe: (streamAction, waveform, audioLanguage) => controllerInstance.streamingTranscribe(streamAction, waveform, audioLanguage),
+    };
+};

package/lib/hooks/natural_language_processing/useTextEmbeddings.d.ts

@@ -0,0 +1,16 @@
+import { ResourceSource } from '../../types/common';
+interface Props {
+    model: {
+        modelSource: ResourceSource;
+        tokenizerSource: ResourceSource;
+    };
+    preventLoad?: boolean;
+}
+export declare const useTextEmbeddings: ({ model, preventLoad }: Props) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (input: string) => Promise<Float32Array<ArrayBufferLike>>;
+};
+export {};

package/lib/hooks/natural_language_processing/useTextEmbeddings.js

@@ -0,0 +1,7 @@
+import { TextEmbeddingsModule } from '../../modules/natural_language_processing/TextEmbeddingsModule';
+import { useNonStaticModule } from '../useNonStaticModule';
+export const useTextEmbeddings = ({ model, preventLoad = false }) => useNonStaticModule({
+    module: TextEmbeddingsModule,
+    model,
+    preventLoad,
+});

package/lib/hooks/natural_language_processing/useTokenizer.d.ts

@@ -0,0 +1,17 @@
+import { ResourceSource } from '../../types/common';
+export declare const useTokenizer: ({ tokenizer, preventLoad, }: {
+    tokenizer: {
+        tokenizerSource: ResourceSource;
+    };
+    preventLoad?: boolean;
+}) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    decode: (tokens: number[], skipSpecialTokens?: boolean | undefined) => Promise<Promise<any>>;
+    encode: (s: string) => Promise<Promise<any>>;
+    getVocabSize: () => Promise<Promise<number>>;
+    idToToken: (tokenId: number) => Promise<Promise<string>>;
+    tokenToId: (token: string) => Promise<Promise<number>>;
+};

package/lib/hooks/natural_language_processing/useTokenizer.js

@@ -0,0 +1,52 @@
+import { useEffect, useMemo, useState } from 'react';
+import { TokenizerModule } from '../../modules/natural_language_processing/TokenizerModule';
+import { ETError, getError } from '../../Error';
+export const useTokenizer = ({ tokenizer, preventLoad = false, }) => {
+    const [error, setError] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    const _tokenizer = useMemo(() => new TokenizerModule(), []);
+    useEffect(() => {
+        if (preventLoad)
+            return;
+        (async () => {
+            setDownloadProgress(0);
+            setError(null);
+            try {
+                setIsReady(false);
+                await _tokenizer.load({ tokenizerSource: tokenizer.tokenizerSource }, setDownloadProgress);
+                setIsReady(true);
+            }
+            catch (err) {
+                setError(err.message);
+            }
+        })();
+    }, [_tokenizer, tokenizer.tokenizerSource, preventLoad]);
+    const stateWrapper = (fn) => {
+        return (...args) => {
+            if (!isReady)
+                throw new Error(getError(ETError.ModuleNotLoaded));
+            if (isGenerating)
+                throw new Error(getError(ETError.ModelGenerating));
+            try {
+                setIsGenerating(true);
+                return fn.apply(_tokenizer, args);
+            }
+            finally {
+                setIsGenerating(false);
+            }
+        };
+    };
+    return {
+        error,
+        isReady,
+        isGenerating,
+        downloadProgress,
+        decode: stateWrapper(TokenizerModule.prototype.decode),
+        encode: stateWrapper(TokenizerModule.prototype.encode),
+        getVocabSize: stateWrapper(TokenizerModule.prototype.getVocabSize),
+        idToToken: stateWrapper(TokenizerModule.prototype.idToToken),
+        tokenToId: stateWrapper(TokenizerModule.prototype.tokenToId),
+    };
+};

package/lib/hooks/useModule.d.ts

@@ -0,0 +1,17 @@
+interface Module {
+    load: (...args: any[]) => Promise<void>;
+    forward: (...input: any[]) => Promise<any>;
+    onDownloadProgress: (cb: (progress: number) => void) => void;
+}
+export declare const useModule: <M extends Module, LoadArgs extends Parameters<M["load"]>, ForwardArgs extends Parameters<M["forward"]>, ForwardReturn extends Awaited<ReturnType<M["forward"]>>>({ module, loadArgs, preventLoad, }: {
+    module: M;
+    loadArgs: LoadArgs;
+    preventLoad?: boolean;
+}) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (...input: ForwardArgs) => Promise<ForwardReturn>;
+};
+export {};

package/lib/hooks/useModule.js

@@ -0,0 +1,45 @@
+import { useEffect, useState } from 'react';
+import { ETError, getError } from '../Error';
+export const useModule = ({ module, loadArgs, preventLoad = false, }) => {
+    const [error, setError] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    useEffect(() => {
+        const loadModule = async () => {
+            try {
+                setIsReady(false);
+                module.onDownloadProgress(setDownloadProgress);
+                await module.load(...loadArgs);
+                setIsReady(true);
+            }
+            catch (err) {
+                setError(err.message);
+            }
+        };
+        if (!preventLoad) {
+            loadModule();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [...loadArgs, preventLoad]);
+    const forward = async (...input) => {
+        if (!isReady)
+            throw new Error(getError(ETError.ModuleNotLoaded));
+        if (isGenerating)
+            throw new Error(getError(ETError.ModelGenerating));
+        try {
+            setIsGenerating(true);
+            return await module.forward(...input);
+        }
+        finally {
+            setIsGenerating(false);
+        }
+    };
+    return {
+        error,
+        isReady,
+        isGenerating,
+        downloadProgress,
+        forward,
+    };
+};

package/lib/hooks/useNonStaticModule.d.ts

@@ -0,0 +1,20 @@
+interface Module {
+    load: (...args: any[]) => Promise<void>;
+    forward: (...args: any[]) => Promise<any>;
+    delete: () => void;
+}
+interface ModuleConstructor<M extends Module> {
+    new (): M;
+}
+export declare const useNonStaticModule: <M extends Module, LoadArgs extends Parameters<M["load"]>, ForwardArgs extends Parameters<M["forward"]>, ForwardReturn extends Awaited<ReturnType<M["forward"]>>>({ module, model, preventLoad, }: {
+    module: ModuleConstructor<M>;
+    model: LoadArgs[0];
+    preventLoad?: boolean;
+}) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (...input: ForwardArgs) => Promise<ForwardReturn>;
+};
+export {};

package/lib/hooks/useNonStaticModule.js

@@ -0,0 +1,49 @@
+import { useEffect, useState, useMemo } from 'react';
+import { ETError, getError } from '../Error';
+export const useNonStaticModule = ({ module, model, preventLoad = false, }) => {
+    const [error, setError] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    const moduleInstance = useMemo(() => new module(), [module]);
+    useEffect(() => {
+        if (preventLoad)
+            return;
+        (async () => {
+            setDownloadProgress(0);
+            setError(null);
+            try {
+                setIsReady(false);
+                await moduleInstance.load(model, setDownloadProgress);
+                setIsReady(true);
+            }
+            catch (err) {
+                setError(err.message);
+            }
+        })();
+        return () => {
+            moduleInstance.delete();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [moduleInstance, ...Object.values(model), preventLoad]);
+    const forward = async (...input) => {
+        if (!isReady)
+            throw new Error(getError(ETError.ModuleNotLoaded));
+        if (isGenerating)
+            throw new Error(getError(ETError.ModelGenerating));
+        try {
+            setIsGenerating(true);
+            return await moduleInstance.forward(...input);
+        }
+        finally {
+            setIsGenerating(false);
+        }
+    };
+    return {
+        error,
+        isReady,
+        isGenerating,
+        downloadProgress,
+        forward,
+    };
+};

package/lib/index.d.ts

@@ -0,0 +1,50 @@
+import { SpeechToTextLanguage } from './types/stt';
+declare global {
+    var loadStyleTransfer: (source: string) => any;
+    var loadImageSegmentation: (source: string) => any;
+    var loadClassification: (source: string) => any;
+    var loadObjectDetection: (source: string) => any;
+    var loadExecutorchModule: (source: string) => any;
+    var loadTokenizerModule: (source: string) => any;
+    var loadImageEmbeddings: (source: string) => any;
+    var loadTextEmbeddings: (modelSource: string, tokenizerSource: string) => any;
+    var loadLLM: (modelSource: string, tokenizerSource: string) => any;
+    var loadSpeechToText: (encoderSource: string, decoderSource: string, modelName: string) => any;
+    var loadOCR: (detectorSource: string, recognizerLarge: string, recognizerMedium: string, recognizerSmall: string, symbols: string) => any;
+    var loadVerticalOCR: (detectorLarge: string, detectorNarrow: string, recognizer: string, symbols: string, independentCharacters?: boolean) => any;
+}
+export * from './hooks/computer_vision/useClassification';
+export * from './hooks/computer_vision/useObjectDetection';
+export * from './hooks/computer_vision/useStyleTransfer';
+export * from './hooks/computer_vision/useImageSegmentation';
+export * from './hooks/computer_vision/useOCR';
+export * from './hooks/computer_vision/useVerticalOCR';
+export * from './hooks/computer_vision/useImageEmbeddings';
+export * from './hooks/natural_language_processing/useLLM';
+export * from './hooks/natural_language_processing/useSpeechToText';
+export * from './hooks/natural_language_processing/useTextEmbeddings';
+export * from './hooks/natural_language_processing/useTokenizer';
+export * from './hooks/general/useExecutorchModule';
+export * from './modules/computer_vision/ClassificationModule';
+export * from './modules/computer_vision/ObjectDetectionModule';
+export * from './modules/computer_vision/StyleTransferModule';
+export * from './modules/computer_vision/ImageSegmentationModule';
+export * from './modules/computer_vision/OCRModule';
+export * from './modules/computer_vision/VerticalOCRModule';
+export * from './modules/general/ExecutorchModule';
+export * from './modules/computer_vision/ImageEmbeddingsModule';
+export * from './modules/natural_language_processing/LLMModule';
+export * from './modules/natural_language_processing/SpeechToTextModule';
+export * from './modules/natural_language_processing/TextEmbeddingsModule';
+export * from './modules/natural_language_processing/TokenizerModule';
+export * from './utils/ResourceFetcher';
+export * from './utils/llm';
+export * from './types/objectDetection';
+export * from './types/ocr';
+export * from './types/imageSegmentation';
+export * from './types/llm';
+export { SpeechToTextLanguage };
+export * from './constants/modelUrls';
+export * from './constants/ocr/models';
+export * from './constants/llmDefaults';
+export { STREAMING_ACTION, MODES, AvailableModels, } from './constants/sttDefaults';

package/lib/index.js

@@ -0,0 +1,60 @@
+import { SpeechToTextLanguage } from './types/stt';
+import { ETInstallerNativeModule } from './native/RnExecutorchModules';
+// eslint-disable no-var
+if (global.loadStyleTransfer == null ||
+    global.loadImageSegmentation == null ||
+    global.loadExecutorchModule == null ||
+    global.loadClassification == null ||
+    global.loadObjectDetection == null ||
+    global.loadTokenizerModule == null ||
+    global.loadTextEmbeddings == null ||
+    global.loadImageEmbeddings == null ||
+    global.loadLLM == null ||
+    global.loadSpeechToText == null ||
+    global.loadOCR == null ||
+    global.loadVerticalOCR == null) {
+    if (!ETInstallerNativeModule) {
+        throw new Error(`Failed to install react-native-executorch: The native module could not be found.`);
+    }
+    ETInstallerNativeModule.install();
+}
+// hooks
+export * from './hooks/computer_vision/useClassification';
+export * from './hooks/computer_vision/useObjectDetection';
+export * from './hooks/computer_vision/useStyleTransfer';
+export * from './hooks/computer_vision/useImageSegmentation';
+export * from './hooks/computer_vision/useOCR';
+export * from './hooks/computer_vision/useVerticalOCR';
+export * from './hooks/computer_vision/useImageEmbeddings';
+export * from './hooks/natural_language_processing/useLLM';
+export * from './hooks/natural_language_processing/useSpeechToText';
+export * from './hooks/natural_language_processing/useTextEmbeddings';
+export * from './hooks/natural_language_processing/useTokenizer';
+export * from './hooks/general/useExecutorchModule';
+// modules
+export * from './modules/computer_vision/ClassificationModule';
+export * from './modules/computer_vision/ObjectDetectionModule';
+export * from './modules/computer_vision/StyleTransferModule';
+export * from './modules/computer_vision/ImageSegmentationModule';
+export * from './modules/computer_vision/OCRModule';
+export * from './modules/computer_vision/VerticalOCRModule';
+export * from './modules/general/ExecutorchModule';
+export * from './modules/computer_vision/ImageEmbeddingsModule';
+export * from './modules/natural_language_processing/LLMModule';
+export * from './modules/natural_language_processing/SpeechToTextModule';
+export * from './modules/natural_language_processing/TextEmbeddingsModule';
+export * from './modules/natural_language_processing/TokenizerModule';
+// utils
+export * from './utils/ResourceFetcher';
+export * from './utils/llm';
+// types
+export * from './types/objectDetection';
+export * from './types/ocr';
+export * from './types/imageSegmentation';
+export * from './types/llm';
+export { SpeechToTextLanguage };
+// constants
+export * from './constants/modelUrls';
+export * from './constants/ocr/models';
+export * from './constants/llmDefaults';
+export { STREAMING_ACTION, MODES, AvailableModels, } from './constants/sttDefaults';

package/lib/module/utils/ResourceFetcher.js

@@ -29,8 +29,9 @@
  *   - Implements linked list behavior via the `.next` attribute
  *   - Automatically processes subsequent downloads when `.next` contains a valid resource
  */
-import { cacheDirectory, createDownloadResumable, moveAsync, FileSystemSessionType, writeAsStringAsync, EncodingType, deleteAsync, readDirectoryAsync } from 'expo-file-system';
+import { cacheDirectory, copyAsync, createDownloadResumable, moveAsync, FileSystemSessionType, writeAsStringAsync, EncodingType, deleteAsync, readDirectoryAsync } from 'expo-file-system';
 import { Asset } from 'expo-asset';
+import { Platform } from 'react-native';
 import { RNEDirectory } from '../constants/directories';
 import { ResourceFetcherUtils, HTTP_CODE, DownloadStatus, SourceType } from './ResourceFetcherUtils';
 export class ResourceFetcher {
@@ -226,17 +227,14 @@ export class ResourceFetcher {
     const uri = asset.uri;
     const filename = ResourceFetcherUtils.getFilenameFromUri(uri);
     const fileUri = `${RNEDirectory}${filename}`;
-    const fileUriWithType = `${fileUri}.${asset.type}`;
+    // On Android, file uri does not contain file extension, so we add it manually
+    const fileUriWithType = Platform.OS === 'android' ? `${fileUri}.${asset.type}` : fileUri;
     if (await ResourceFetcherUtils.checkFileExists(fileUri)) {
       return ResourceFetcherUtils.removeFilePrefix(fileUri);
     }
     await ResourceFetcherUtils.createDirectoryIfNoExists();
-    await asset.downloadAsync();
-    if (!asset.localUri) {
-      throw new Error(`Asset local URI is not available for ${source}`);
-    }
-    await moveAsync({
-      from: asset.localUri,
+    await copyAsync({
+      from: asset.uri,
       to: fileUriWithType
     });
     return ResourceFetcherUtils.removeFilePrefix(fileUriWithType);