react-native-ota-hot-update 1.0.8 → 1.1.0

package/README.md

@@ -78,9 +78,10 @@ After you have done everything related to version manager, you just handle the w
 
 ```bash
     import hotUpdate from 'react-native-ota-hot-update';
+    import ReactNativeBlobUtil from 'react-native-blob-util';
     
     
-    hotUpdate.downloadBundleUri(url, version, {
+    hotUpdate.downloadBundleUri(ReactNativeBlobUtil, url, version, {
       updateSuccess: () => {
         console.log('update success!');
       },
@@ -102,14 +103,14 @@ The important thing: this library will control `version` by it self, need always
 
 ## Functions
 
-| key          | Return | Action                                                                                                           | Parameters                                                         |
-| ------------ |--------|------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------|
-| downloadBundleUri    | void   | Download bundle and install it                                                                                   | (uri: string, version: number, option?: **UpdateOption**)          |
-| setupBundlePath    | boolean | Install your bundle path if you control the downloading by your self, ignore that if you use `downloadBundleUri` | path: string, the path of bundlejs file that you downloaded before |
-| removeUpdate | void   | Remove you update and use the previos version                                                                    | restartAfterRemoved?: boolean, restart to apply your changing      |
-| resetApp       | void   | Restart the app to apply the changing                                                                            | empty                                                              |
-| getCurrentVersion       | number | Get the current version that let you use to compare and control the logic updating                               | empty                                                              |
-| setCurrentVersion       | boolean       | Set the current version that let you use to compare and control the logic updating                               | version: number                                                              |
+| key          | Return | Action                                                                                                           | Parameters                                                                                  |
+| ------------ |--------|------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
+| downloadBundleUri    | void   | Download bundle and install it                                                                                   | (downloadManager: **DownloadManager**, uri: string, version: number, option?: **UpdateOption**) |
+| setupBundlePath    | boolean | Install your bundle path if you control the downloading by your self, ignore that if you use `downloadBundleUri` | path: string, the path of bundlejs file that you downloaded before                          |
+| removeUpdate | void   | Remove you update and use the previos version                                                                    | restartAfterRemoved?: boolean, restart to apply your changing                               |
+| resetApp       | void   | Restart the app to apply the changing                                                                            | empty                                                                                       |
+| getCurrentVersion       | number | Get the current version that let you use to compare and control the logic updating                               | empty                                                                                       |
+| setCurrentVersion       | boolean       | Set the current version that let you use to compare and control the logic updating                               | version: number                                                                             |
 
 
 ## UpdateOption
@@ -121,8 +122,11 @@ The important thing: this library will control `version` by it self, need always
 | updateFail(message: string)               | No       | Callback | Will trigger when install update failed                                                          |
 | restartAfterInstall            | No       | boolean  | default is `false`, if `true` will restart the app after install success to apply the new change |
 | progress            | No       | void     | A callback to show progress when downloading bundle                                              |
+| extensionBundle            | No       | string   | extension of bundle js file, default is .bundle, for expo project you might set .hbc             |
 
+## DownloadManager
 
+The same method as `react-native-blob-util` or `rn-fetch-blob`
 
 ## License
 

package/android/src/main/java/com/rnhotupdate/HotUpdateModule.java

@@ -50,7 +50,7 @@ public class HotUpdateModule extends ReactContextBaseJavaModule {
             return false;
         }
     }
-    private String unzip(File zipFile) {
+    private String unzip(File zipFile, String extension) {
         File destDir = zipFile.getParentFile(); // Directory of the zip file
 
         String bundleFilePath = null;
@@ -78,7 +78,7 @@ public class HotUpdateModule extends ReactContextBaseJavaModule {
                         }
                     }
                 }
-                if (newFile.getAbsolutePath().contains(".bundle")) {
+                if (newFile.getAbsolutePath().contains(extension)) {
                     bundleFilePath = newFile.getAbsolutePath();
                 }
             }
@@ -90,12 +90,12 @@ public class HotUpdateModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void setupBundlePath(String path, Promise promise) {
+    public void setupBundlePath(String path, String extension, Promise promise) {
         if (path != null) {
             deleteOldBundleIfneeded();
             File file = new File(path);
             if (file.exists() && file.isFile()) {
-                String fileUnzip = unzip(file);
+                String fileUnzip = unzip(file, extension != null ? extension : ".bundle");
                 Log.d("setupBundlePath: ", fileUnzip);
                 if (fileUnzip != null) {
                     file.delete();

package/ios/RNhotupdate.m

@@ -97,7 +97,7 @@ RCT_EXPORT_MODULE()
         return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
     }
 }
-- (NSString *)searchForJsBundleInDirectory:(NSString *)directoryPath {
+- (NSString *)searchForJsBundleInDirectory:(NSString *)directoryPath extension:(NSString *)extension {
     NSFileManager *fileManager = [NSFileManager defaultManager];
     NSError *error;
 
@@ -114,11 +114,11 @@ RCT_EXPORT_MODULE()
         if ([fileManager fileExistsAtPath:filePath isDirectory:&isDirectory]) {
             if (isDirectory) {
                 // Recursively search in subdirectories
-                NSString *foundPath = [self searchForJsBundleInDirectory:filePath];
+                NSString *foundPath = [self searchForJsBundleInDirectory:filePath extension:extension];
                 if (foundPath) {
                     return foundPath;
                 }
-            } else if ([filePath hasSuffix:@".jsbundle"]) {
+            } else if ([filePath hasSuffix:extension]) {
                 // Return the path if it's a .jsbundle file
                 return filePath;
             }
@@ -127,7 +127,7 @@ RCT_EXPORT_MODULE()
 
     return nil;
 }
-- (NSString *)unzipFileAtPath:(NSString *)zipFilePath {
+- (NSString *)unzipFileAtPath:(NSString *)zipFilePath extension:(NSString *)extension  {
     // Define the directory where the files will be extracted
     NSString *extractedFolderPath = [[zipFilePath stringByDeletingPathExtension] stringByAppendingPathExtension:@"unzip"];
 
@@ -151,7 +151,7 @@ RCT_EXPORT_MODULE()
         return nil;
     }
     // Find .jsbundle files in the extracted directory
-        NSString *jsbundleFilePath = [self searchForJsBundleInDirectory:extractedFolderPath];
+    NSString *jsbundleFilePath = [self searchForJsBundleInDirectory:extractedFolderPath extension:extension];
 
         // Delete the zip file after extraction
         NSError *removeError = nil;
@@ -165,11 +165,11 @@ RCT_EXPORT_MODULE()
 }
 
 // Expose setupBundlePath method to JavaScript
-RCT_EXPORT_METHOD(setupBundlePath:(NSString *)path withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(setupBundlePath:(NSString *)path extension:(NSString *)extension withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject) {
     if ([self isFilePathValid:path]) {
         [self removeBundleIfNeeded];
         //Unzip file
-        NSString *extractedFilePath = [self unzipFileAtPath:path];
+        NSString *extractedFilePath = [self unzipFileAtPath:path extension:(extension != nil) ? extension : @".jsbundle"];
         NSLog(@"file extraction----- %@", extractedFilePath);
         if (extractedFilePath) {
             NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ota-hot-update",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "Hot update for react native",
   "main": "src/index",
   "repository": "https://github.com/vantuan88291/react-native-ota-hot-update",
@@ -11,7 +11,6 @@
   },
   "homepage": "https://github.com/vantuan88291/react-native-ota-hot-update",
   "peerDependencies": {
-    "react-native-blob-util": ">=0.19.11",
     "react-native": ">=0.63.4"
   },
   "create-react-native-library": {

package/src/download.d.ts

@@ -0,0 +1,860 @@
+
+interface DownloadManager {
+    fetch(method: Methods, url: string, headers?: { [key: string]: string }, body?: any | null): StatefulPromise<FetchBlobResponse>;
+
+    base64: { encode(input: string): string; decode(input: string): string };
+    android: AndroidApi;
+    ios: IOSApi;
+
+    config(options: ReactNativeBlobUtilConfig): DownloadManager;
+
+    session(name: string): ReactNativeBlobUtilSession;
+
+    fs: FS;
+    MediaCollection: MediaCollection;
+
+    wrap(path: string): string;
+
+    net: Net;
+    polyfill: Polyfill;
+    // this require external module https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/oboe
+    JSONStream: any;
+}
+
+export interface Polyfill {
+    Blob: PolyfillBlob;
+    File: PolyfillFile;
+    XMLHttpRequest: PolyfillXMLHttpRequest;
+    ProgressEvent: PolyfillProgressEvent;
+    Event: PolyfillEvent;
+    FileReader: PolyfillFileReader;
+    Fetch: PolyfillFetch;
+}
+
+export declare class PolyfillFetch extends ReactNativeBlobUtilFetchPolyfill {
+    constructor(config: ReactNativeBlobUtilConfig);
+}
+
+export declare class ReactNativeBlobUtilFetchPolyfill {
+    constructor(config: ReactNativeBlobUtilConfig);
+
+    build(): (url: string, options: ReactNativeBlobUtilConfig) => StatefulPromise<ReactNativeBlobUtilFetchRepsonse>;
+}
+
+export interface ReactNativeBlobUtilFetchRepsonse {
+    arrayBuffer(): Promise<any[]>;
+
+    blob(): Promise<PolyfillBlob>;
+
+    json(): Promise<any>;
+
+    rawResp(): Promise<FetchBlobResponse>;
+
+    text(): Promise<string>;
+
+    bodyUsed: boolean;
+    headers: any;
+    ok: boolean;
+    resp: FetchBlobResponse;
+    rnfbResp: FetchBlobResponse;
+    rnfbRespInfo: ReactNativeBlobUtilResponseInfo;
+    status: number;
+    type: string;
+}
+
+/**
+ * ReactNativeBlobUtil response object class.
+ */
+export interface FetchBlobResponse {
+    taskId: string;
+
+    /**
+     * get path of response temp file
+     * @return File path of temp file.
+     */
+    path(): string;
+
+    type: "base64" | "path" | "utf8";
+    data: any;
+
+    /**
+     * Convert result to javascript ReactNativeBlobUtil object.
+     * @return Return a promise resolves Blob object.
+     */
+    blob(contentType: string, sliceSize: number): Promise<PolyfillBlob>;
+
+    /**
+     * Convert result to text.
+     * @return Decoded base64 string.
+     */
+    text(): string | Promise<any>;
+
+    /**
+     * Convert result to JSON object.
+     * @return Parsed javascript object.
+     */
+    json(): any;
+
+    /**
+     * Return BASE64 string directly.
+     * @return BASE64 string of response body.
+     */
+    base64(): any;
+
+    /**
+     * Remove cahced file
+     */
+    flush(): void;
+
+    respInfo: ReactNativeBlobUtilResponseInfo;
+
+    info(): ReactNativeBlobUtilResponseInfo;
+
+    session(name: string): ReactNativeBlobUtilSession | null;
+
+    /**
+     * Read file content with given encoding, if the response does not contains
+     * a file path, show warning message
+     * @param  encode Encode type, should be one of `base64`, `ascrii`, `utf8`.
+     */
+    readFile(encode: Encoding): Promise<any> | null;
+
+    /**
+     * Start read stream from cached file
+     * @param  encode Encode type, should be one of `base64`, `ascrii`, `utf8`.
+     */
+    readStream(encode: Encoding): ReactNativeBlobUtilStream | null;
+}
+
+export interface PolyfillFileReader extends EventTarget {
+    isRNFBPolyFill: boolean;
+
+    onloadstart(e: Event): void;
+
+    onprogress(e: Event): void;
+
+    onload(e: Event): void;
+
+    onabort(e: Event): void;
+
+    onerror(e: Event): void;
+
+    onloadend(e: Event): void;
+
+    abort(): void;
+
+    readAsArrayBuffer(b: PolyfillBlob): void;
+
+    readAsBinaryString(b: PolyfillBlob): void;
+
+    readAsText(b: PolyfillBlob, label?: string): void;
+
+    readAsDataURL(b: PolyfillBlob): void;
+
+    readyState: number;
+    result: number;
+}
+
+export declare namespace PolyfillFileReader {
+    const EMPTY: number;
+    const LOADING: number;
+    const DONE: number;
+}
+
+export declare class PolyfillEvent {}
+
+export interface PolyfillProgressEvent extends EventTarget {
+    lengthComputable: boolean;
+    loaded: number;
+    total: number;
+}
+
+export declare class PolyfillBlob implements EventTarget {
+    /**
+     * ReactNativeBlobUtil Blob polyfill, create a Blob directly from file path, BASE64
+     * encoded data, and string. The conversion is done implicitly according to
+     * given `mime`. However, the blob creation is asynchronously, to register
+     * event `onCreated` is need to ensure the Blob is creadted.
+     *
+     * @param data Content of Blob object
+     * @param cType Content type settings of Blob object, `text/plain` by default
+     * @param defer When this argument set to `true`, blob constructor will not invoke blob created event automatically.
+     */
+    constructor(data: any, cType: any, defer: boolean);
+
+    /**
+     * Since Blob content will asynchronously write to a file during creation,
+     * use this method to register an event handler for Blob initialized event.
+     * @param  fn An event handler invoked when Blob created
+     * @return The Blob object instance itself
+     */
+    onCreated(fn: () => void): PolyfillBlob;
+
+    markAsDerived(): void;
+
+    /**
+     * Get file reference of the Blob object.
+     * @return Blob file reference which can be consumed by ReactNativeBlobUtil fs
+     */
+    getReactNativeBlobUtilRef(): string;
+
+    /**
+     * Create a Blob object which is sliced from current object
+     * @param  start    Start byte number
+     * @param  end      End byte number
+     * @param  contentType Optional, content type of new Blob object
+     */
+    slice(start?: number, end?: number, contentType?: string): PolyfillBlob;
+
+    /**
+     * Read data of the Blob object, this is not standard method.
+     * @param  encoding Read data with encoding
+     */
+    readBlob(encoding: string): Promise<any>;
+
+    /**
+     * Release the resource of the Blob object.
+     * @nonstandard
+     */
+    close(): Promise<void>;
+}
+
+export declare namespace PolyfillBlob {
+    function clearCache(): void;
+
+    function build(data: any, cType: any): Promise<PolyfillBlob>;
+
+    function setLog(level: number): void;
+}
+
+export declare class PolyfillFile extends PolyfillBlob {}
+
+export interface PolyfillXMLHttpRequest extends PolyfillXMLHttpRequestEventTarget {
+    upload: PolyfillXMLHttpRequestEventTarget;
+    readonly UNSENT: number;
+    readonly OPENED: number;
+    readonly HEADERS_RECEIVED: number;
+    readonly LOADING: number;
+    readonly DONE: number;
+
+    /**
+     * XMLHttpRequest.open, always async, user and password not supported. When
+     * this method invoked, headers should becomes empty again.
+     * @param  method Request method
+     * @param  url Request URL
+     * @param  async Always async
+     * @param  user NOT SUPPORTED
+     * @param  password NOT SUPPORTED
+     */
+    open(method: string, url: string, async: true, user: any, password: any): void;
+
+    /**
+     * Invoke this function to send HTTP request, and set body.
+     * @param body Body in ReactNativeBlobUtil flavor
+     */
+    send(body: any): void;
+
+    overrideMimeType(mime: string): void;
+
+    setRequestHeader(name: string, value: string): void;
+
+    abort(): void;
+
+    getResponseHeader(field: string): string | null;
+
+    getAllResponseHeaders(): string | null;
+
+    onreadystatechange(e: Event): void;
+
+    readyState: number;
+    status: number;
+    statusText: string;
+    response: any;
+    responseText: any;
+    responseURL: string;
+    responseHeaders: any;
+    timeout: number;
+    responseType: string;
+}
+
+export declare namespace PolyfillXMLHttpRequest {
+    const binaryContentTypes: string[];
+    const UNSENT: number;
+    const OPENED: number;
+    const HEADERS_RECEIVED: number;
+    const LOADING: number;
+    const DONE: number;
+
+    function setLog(level: number): void;
+
+    function addBinaryContentType(substr: string): void;
+
+    function removeBinaryContentType(): void;
+}
+
+export interface PolyfillXMLHttpRequestEventTarget extends EventTarget {
+    onabort(e: Event): void;
+
+    onerror(e: Event): void;
+
+    onload(e: Event): void;
+
+    onloadstart(e: Event): void;
+
+    onprogress(e: Event): void;
+
+    ontimeout(e: Event): void;
+
+    onloadend(e: Event): void;
+}
+
+export interface Net {
+    /**
+     * Get cookie according to the given url.
+     * @param  domain Domain of the cookies to be removed, remove all
+     * @return     Cookies of a specific domain.
+     */
+    getCookies(domain: string): Promise<string[]>;
+
+    /**
+     * Remove cookies for a specific domain
+     * @param  domain Domain of the cookies to be removed, remove all
+     * cookies when this is null.
+     */
+    removeCookies(domain?: string): Promise<null>;
+}
+
+type HashAlgorithm = "md5" | "sha1" | "sha224" | "sha256" | "sha384" | "sha512";
+
+export interface FS {
+    ReactNativeBlobUtilSession: ReactNativeBlobUtilSession;
+
+    /**
+     * Remove file at path.
+     * @param    path:string Path of target file.
+     */
+    unlink(path: string): Promise<void>;
+
+    /**
+     * Create a directory.
+     * @param  path Path of directory to be created
+     */
+    mkdir(path: string): Promise<void>;
+
+    /**
+     * Get a file cache session
+     * @param  name Stream ID
+     */
+    session(name: string): ReactNativeBlobUtilSession;
+
+    ls(path: string): Promise<string[]>;
+
+    /**
+     * Read the file from the given path and calculate a cryptographic hash sum over its contents.
+     *
+     * @param path Path to the file
+     * @param algorithm The hash algorithm to use
+     */
+    hash(path: string, algorithm: HashAlgorithm): Promise<string>;
+
+    /**
+     * Create file stream from file at `path`.
+     * @param  path   The file path.
+     * @param  encoding Data encoding, should be one of `base64`, `utf8`, `ascii`
+     * @param  bufferSize Size of stream buffer.
+     * @return ReactNativeBlobUtilStream stream instance.
+     */
+    readStream(path: string, encoding: Encoding, bufferSize?: number, tick?: number): Promise<ReactNativeBlobUtilReadStream>;
+
+    mv(path: string, dest: string): Promise<boolean>;
+
+    cp(path: string, dest: string): Promise<boolean>;
+
+    /**
+     * Create write stream to a file.
+     * @param  path Target path of file stream.
+     * @param  encoding Encoding of input data.
+     * @param  append  A flag represent if data append to existing ones.
+     * @return A promise resolves a `WriteStream` object.
+     */
+    writeStream(path: string, encoding: Encoding, append?: boolean): Promise<ReactNativeBlobUtilWriteStream>;
+
+    /**
+     * Write data to file.
+     * @param  path  Path of the file.
+     * @param  data Data to write to the file.
+     * @param  encoding Encoding of data (Optional).
+     */
+    writeFile(path: string, data: string | number[], encoding?: Encoding): Promise<void>;
+
+    /**
+     * Processes the data and then writes to the file.
+     * @param  path  Path of the file.
+     * @param  data Data to write to the file.
+     * @param  encoding Encoding of data (Optional).
+     */
+    writeFileWithTransform(path: string, data: string | number[], encoding?: Encoding): Promise<void>;
+
+    appendFile(path: string, data: string | number[], encoding?: Encoding | "uri"): Promise<number>;
+
+    /**
+     * Wrapper method of readStream.
+     * @param  path Path of the file.
+     * @param  encoding Encoding of read stream.
+     */
+    readFile(path: string, encoding: Encoding, bufferSize?: number): Promise<any>;
+
+    /**
+     * Reads from a file and then processes the data before returning
+     * @param  path Path of the file.
+     * @param  encoding Encoding of read stream.
+     */
+    readFileWithTransform(path: string, encoding: Encoding, bufferSize?: number): Promise<any>;
+
+    /**
+     * Check if file exists and if it is a folder.
+     * @param  path Path to check
+     */
+    exists(path: string): Promise<boolean>;
+
+    createFile(path: string, data: string, encoding: Encoding): Promise<void>;
+
+    isDir(path: string): Promise<boolean>;
+
+    /**
+     * Show statistic data of a path.
+     * @param  path Target path
+     */
+    stat(path: string): Promise<ReactNativeBlobUtilStat>;
+
+    lstat(path: string): Promise<ReactNativeBlobUtilStat[]>;
+
+    /**
+     * Android only method, request media scanner to scan the file.
+     * @param  pairs Array contains Key value pairs with key `path` and `mime`.
+     */
+    scanFile(pairs: Array<{ [key: string]: string }>): Promise<void>;
+
+    dirs: Dirs;
+
+    slice(src: string, dest: string, start: number, end: number): Promise<void>;
+
+    asset(path: string): string;
+
+    df(): Promise<RNFetchBlobDf>;
+
+    /**
+     * Returns the path for the app group.
+     * @param  {string} groupName Name of app group
+     */
+    pathForAppGroup(groupName: string): Promise<string>;
+}
+
+export interface RNFetchBlobDfIOS {
+    free?: number;
+    total?: number;
+}
+
+export interface RNFetchBlobDfAndroid {
+    external_free?: string;
+    external_total?: string;
+    internal_free?: string;
+    internal_total?: string;
+}
+
+export type RNFetchBlobDf = RNFetchBlobDfIOS & RNFetchBlobDfAndroid;
+
+export interface Dirs {
+    DocumentDir: string;
+    CacheDir: string;
+    PictureDir: string;
+    LibraryDir: string;
+    MusicDir: string;
+    MovieDir: string;
+    DownloadDir: string;
+    DCIMDir: string;
+    SDCardDir: string;
+    MainBundleDir: string;
+
+    LegacyPictureDir: string;
+    LegacyMusicDir: string;
+    LegacyMovieDir: string;
+    LegacyDownloadDir: string;
+    LegacyDCIMDir: string;
+    LegacySDCardDir: string; // Depracated
+}
+
+export interface ReactNativeBlobUtilWriteStream {
+    id: string;
+    encoding: string;
+    append: boolean;
+
+    write(data: string): Promise<void>;
+
+    close(): Promise<void>;
+}
+
+export interface ReactNativeBlobUtilReadStream {
+    path: string;
+    encoding: Encoding;
+    bufferSize?: number;
+    closed: boolean;
+    tick: number;
+
+    open(): void;
+
+    onData(fn: (chunk: string | number[]) => void): void;
+
+    onError(fn: (err: any) => void): void;
+
+    onEnd(fn: () => void): void;
+}
+
+export type Encoding = "utf8" | "ascii" | "base64";
+
+/* tslint:disable-next-line interface-name*/
+export interface IOSApi {
+    /**
+     * Open a file in {@link https://developer.apple.com/reference/uikit/uidocumentinteractioncontroller UIDocumentInteractionController},
+     * this is the default document viewer of iOS, supports several kinds of files. On Android, there's an similar method {@link android.actionViewIntent}.
+     * @param path This is a required field, the path to the document. The path should NOT contain any scheme prefix.
+     * @param  {string} scheme URI scheme that needs to support, optional
+     */
+    previewDocument(path: string, scheme?: string): void;
+
+    /**
+     * Show options menu for interact with the file.
+     * @param path This is a required field, the path to the document. The path should NOT contain any scheme prefix.
+     * @param  {string} scheme URI scheme that needs to support, optional
+     */
+    openDocument(path: string, scheme?: string): Promise<void>;
+
+    /**
+     * Displays an options menu using [UIDocumentInteractionController](https://developer.apple.com/reference/uikit/uidocumentinteractioncontroller).[presentOptionsMenu](https://developer.apple.com/documentation/uikit/uidocumentinteractioncontroller/1616814-presentoptionsmenu)
+     * @param  {string} path Path of the file to be open.
+     * @param  {string} scheme URI scheme that needs to support, optional
+     */
+    presentOptionsMenu(path: string, scheme?: string): void;
+
+    /**
+     * Displays a menu for opening the document using [UIDocumentInteractionController](https://developer.apple.com/reference/uikit/uidocumentinteractioncontroller).[presentOpenInMenu](https://developer.apple.com/documentation/uikit/uidocumentinteractioncontroller/1616807-presentopeninmenu)
+     * @param  {string} path Path of the file to be open.
+     * @param  {string} scheme URI scheme that needs to support, optional
+     */
+    presentOpenInMenu(path: string, scheme?: string): void;
+
+    /**
+     * Displays a full-screen preview of the target document using [UIDocumentInteractionController](https://developer.apple.com/reference/uikit/uidocumentinteractioncontroller).[presentPreview](https://developer.apple.com/documentation/uikit/uidocumentinteractioncontroller/1616828-presentpreview)
+     * @param  {string} path Path of the file to be open.
+     * @param  {string} scheme URI scheme that needs to support, optional
+     */
+    presentPreview(path: string, scheme?: string): void;
+
+    /**
+     * Marks the file to be excluded from icloud/itunes backup. Works recursively if path is to a directory
+     * @param {string} path  Path to a file or directory to mark to be excluded.
+     */
+    excludeFromBackupKey(path: string): Promise<void>;
+}
+
+export interface AndroidDownloadOption {
+    /**
+     * Title string to be displayed when the file added to Downloads app.
+     */
+    title: string;
+
+    /**
+     * File description to be displayed when the file added to Downloads app.
+     */
+    description: string;
+
+    /**
+     * MIME string of the file.
+     */
+    mime: string;
+
+    /**
+     * URI string of the file.
+     */
+    path: string;
+
+    /**
+     * Boolean value that determines if notification will be displayed.
+     */
+    showNotification: boolean;
+}
+
+export interface AndroidApi {
+    /**
+     * When sending an ACTION_VIEW intent with given file path and MIME type, system will try to open an
+     * App to handle the file. For example, open Gallery app to view an image, or install APK.
+     * @param path Path of the file to be opened.
+     * @param mime Basically system will open an app according to this MIME type.
+     * @param chooserTitle title for chooser, if not set the chooser won't be displayed (see [Android docs](https://developer.android.com/reference/android/content/Intent.html#createChooser(android.content.Intent,%20java.lang.CharSequence)))
+     */
+    actionViewIntent(path: string, mime: string, chooserTitle?: string): Promise<boolean | null>;
+
+    /**
+     *
+     * This method brings up OS default file picker and resolves a file URI when the user selected a file.
+     * However, it does not resolve or reject when user dismiss the file picker via pressing hardware back button,
+     * but you can still handle this behavior via AppState.
+     * @param mime MIME type filter, only the files matches the MIME will be shown.
+     */
+    getContentIntent(mime: string): Promise<any>;
+
+    /**
+     * Using this function to add an existing file to Downloads app.
+     * @param options An object that for setting the title, description, mime, and notification of the item.
+     */
+    addCompleteDownload(options: AndroidDownloadOption): Promise<void>;
+
+    getSDCardDir(): Promise<string>;
+
+    getSDCardApplicationDir(): Promise<string>;
+}
+
+type Methods = "POST" | "GET" | "DELETE" | "PUT" | "PATCH" | "post" | "get" | "delete" | "put" | "patch";
+
+/**
+ * A declare class inherits Promise, it has extra method like progress, uploadProgress,
+ * and cancel which can help managing an asynchronous task's state.
+ */
+export interface StatefulPromise<T> extends Promise<T> {
+    /**
+     * Cancel the request when invoke this method.
+     */
+    cancel(cb?: (reason: any) => void): StatefulPromise<FetchBlobResponse>;
+
+    /**
+     * Add an event listener which triggers when data receiving from server.
+     */
+    progress(callback: (received: string, total: string) => void): StatefulPromise<FetchBlobResponse>;
+
+    /**
+     * Add an event listener with custom configuration
+     */
+    progress(config: { count?: number; interval?: number }, callback: (received: number, total: number) => void): StatefulPromise<FetchBlobResponse>;
+
+    /**
+     * Add an event listener with custom configuration.
+     */
+    uploadProgress(callback: (sent: number, total: number) => void): StatefulPromise<FetchBlobResponse>;
+
+    /**
+     * Add an event listener with custom configuration
+     */
+    uploadProgress(config: { count?: number; interval?: number }, callback: (sent: number, total: number) => void): StatefulPromise<FetchBlobResponse>;
+
+    /**
+     * An IOS only API, when IOS app turns into background network tasks will be terminated after ~180 seconds,
+     * in order to handle these expired tasks, you can register an event handler, which will be called after the
+     * app become active.
+     */
+    expire(callback: () => void): StatefulPromise<void>;
+}
+
+export declare class ReactNativeBlobUtilSession {
+    constructor(name: string, list: string[]);
+
+    add(path: string): ReactNativeBlobUtilSession;
+
+    remove(path: string): ReactNativeBlobUtilSession;
+
+    dispose(): Promise<void>;
+
+    list(): string[];
+
+    name: string;
+
+    static getSession(name: string): any;
+
+    static setSession(name: string): void;
+
+    static removeSession(name: string): void;
+}
+
+/**
+ * A set of configurations that will be injected into a fetch method, with the following properties.
+ */
+export interface ReactNativeBlobUtilConfig {
+    Progress?: { count?: number; interval?: number };
+    UploadProgress?: { count?: number; interval?: number };
+
+    /**
+     * When this property is true, the downloaded data will overwrite the existing file. (true by default)
+     */
+    overwrite?: boolean;
+
+    /**
+     * Set timeout of the request (in milliseconds).
+     */
+    timeout?: number;
+
+    /**
+     * Set this property to true to display a network indicator on status bar, this feature is only supported on IOS.
+     */
+    indicator?: boolean;
+
+    /**
+     * Set this property to true will allow the request create connection with server have self-signed SSL
+     * certification. This is not recommended to use in production.
+     */
+    trusty?: boolean;
+
+    /**
+     * Set this property to true will only do requests through the WiFi interface, and fail otherwise.
+     */
+    wifiOnly?: boolean;
+
+    /**
+     * Set this property so redirects are not automatically followed.
+     */
+    followRedirect?: boolean;
+
+    /**
+     * Set this property to true will makes response data of the fetch stored in a temp file, by default the temp
+     * file will stored in App's own root folder with file name template ReactNativeBlobUtil_tmp${timestamp}.
+     */
+    fileCache?: boolean;
+
+    /**
+     * Set this property to true if you want the data to be processed before it gets written onto disk.
+     * This only has effect if the FileTransformer has been registered and the library is configured to write
+     * response onto disk.
+     */
+    transformFile?: boolean;
+
+    /**
+     * Set this property to change temp file extension that created by fetch response data.
+     */
+    appendExt?: string;
+
+    /**
+     * When this property has value, fetch API will try to store response data in the path ignoring fileCache and
+     * appendExt property.
+     */
+    path?: string;
+
+    session?: string;
+
+    addAndroidDownloads?: AddAndroidDownloads;
+
+    /**
+     * Fix IOS request timeout issue #368 by change default request setting to defaultSessionConfiguration, and make backgroundSessionConfigurationWithIdentifier optional
+     */
+    IOSBackgroundTask?: boolean;
+}
+
+export interface AddAndroidDownloads {
+    /**
+     * download file using Android download manager or not.
+     */
+    useDownloadManager?: boolean;
+    /**
+     * title of the file
+     */
+    title?: string;
+    /**
+     * File description of the file.
+     */
+    description?: string;
+    /**
+     * The destination which the file will be downloaded, it SHOULD be a location on external storage (DCIMDir).
+     */
+    path?: string;
+    /**
+     * MIME type of the file. By default is text/plain
+     */
+    mime?: string;
+    /**
+     * A boolean value, see Officail Document
+     * (https://developer.android.com/reference/android/app/DownloadManager.html#addCompletedDownload(java.lang.String, java.lang.String, boolean, java.lang.String, java.lang.String, long, boolean))
+     */
+    mediaScannable?: boolean;
+    /**
+     * Only for Android >= Q; Enforces the file being stored to the MediaCollection Downloads. This might overwrite any value given in "path"
+     */
+    storeInDownloads?: boolean;
+    /**
+     * A boolean value decide whether show a notification when download complete.
+     */
+    notification?: boolean;
+}
+
+export interface ReactNativeBlobUtilResponseInfo {
+    taskId: string;
+    state: string;
+    headers: any;
+    redirects: string[];
+    status: number;
+    respType: "text" | "blob" | "" | "json";
+    rnfbEncode: "path" | "base64" | "ascii" | "utf8";
+    timeout: boolean;
+}
+
+export interface ReactNativeBlobUtilStream {
+    onData(): void;
+
+    onError(): void;
+
+    onEnd(): void;
+}
+
+export declare class ReactNativeBlobUtilFile {}
+
+export declare class ReactNativeBlobUtilStat {
+    lastModified: number;
+    size: number;
+    type: "directory" | "file";
+    path: string;
+    filename: string;
+}
+
+export type Mediatype = "Audio" | "Image" | "Video" | "Download";
+
+export interface MediaCollection {
+    /**
+     * Creates a new File in the collection.
+     * Promise will resolve to content UIR or error message
+     * @param filedata descriptor for the media store entry
+     * @param mediatype
+     * @param path path of the file being copied
+     */
+    copyToMediaStore(filedata: filedescriptor, mediatype: Mediatype, path: string): Promise<string>;
+
+    /**
+     * Creates a new File in the collection.
+     * @param filedata
+     * @param mediatype
+     */
+    createMediafile(filedata: filedescriptor, mediatype: Mediatype): Promise<string>;
+
+    /**
+     * Copies an existing file to a mediastore file
+     * @param uri URI of the destination mediastore file
+     * @param path Path to the existing file which should be copied
+     */
+    writeToMediafile(uri: string, path: string): Promise<string>;
+
+    /**
+     * Copies and transforms an existing file to a mediastore file. Make sure FileTransformer is set
+     * @param uri URI of the destination mediastore file
+     * @param path Path to the existing file which should be copied
+     */
+    writeToMediafileWithTransform(uri: string, path: string): Promise<string>;
+
+    /**
+     * Copies a file from the mediastore to the apps internal storage
+     * @param contenturi URI of the mediastore file
+     * @param destpath Path for the file in the internal storage
+     */
+    copyToInternal(contenturi: string, destpath: string): Promise<string>;
+
+    /**
+     * Gets the blob data for a given URI in the mediastore
+     * @param contenturi
+     * @param encoding
+     */
+    getBlob(contenturi: string, encoding: string): Promise<string>;
+}

package/src/index.tsx

@@ -1,10 +1,10 @@
 import { NativeModules, Platform } from 'react-native';
-import ReactNativeBlobUtil from 'react-native-blob-util';
+import {DownloadManager} from './download';
 const LINKING_ERROR =
-  'The package \'rn-hotupdate\' doesn\'t seem to be linked. Make sure: \n\n' +
-  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
-  '- You rebuilt the app after installing the package\n' +
-  '- You are not using Expo Go\n';
+    'The package \'rn-hotupdate\' doesn\'t seem to be linked. Make sure: \n\n' +
+    Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+    '- You rebuilt the app after installing the package\n' +
+    '- You are not using Expo Go\n';
 
 export interface UpdateOption {
   headers?: object
@@ -12,19 +12,20 @@ export interface UpdateOption {
   updateSuccess?(): void
   updateFail?(message?: string): void
   restartAfterInstall?: boolean
+  extensionBundle?: string,
 }
 const RNhotupdate = NativeModules.RNhotupdate
-  ? NativeModules.RNhotupdate
-  : new Proxy(
-      {},
-      {
-        get() {
-          throw new Error(LINKING_ERROR);
-        },
-      }
+    ? NativeModules.RNhotupdate
+    : new Proxy(
+        {},
+        {
+          get() {
+            throw new Error(LINKING_ERROR);
+          },
+        }
     );
-const downloadBundleFile = async (uri: string, headers?: object, callback?: (received: string, total: string) => void) => {
-  const res = await  ReactNativeBlobUtil
+const downloadBundleFile = async (downloadManager: DownloadManager, uri: string, headers?: object, callback?: (received: string, total: string) => void) => {
+  const res = await downloadManager
       .config({
         fileCache: Platform.OS === 'android',
       })
@@ -38,8 +39,8 @@ const downloadBundleFile = async (uri: string, headers?: object, callback?: (rec
       });
   return res.path();
 };
-function setupBundlePath(path: string): Promise<boolean> {
-  return RNhotupdate.setupBundlePath(path);
+function setupBundlePath(path: string, extension?: string): Promise<boolean> {
+  return RNhotupdate.setupBundlePath(path, extension);
 }
 function deleteBundlePath(): Promise<boolean> {
   return RNhotupdate.deleteBundle();
@@ -73,7 +74,7 @@ const installFail = (option?: UpdateOption, e?: any) => {
   option?.updateFail?.(JSON.stringify(e));
   console.error('Download bundle fail', JSON.stringify(e));
 };
-async function downloadBundleUri(uri: string, version: number, option?: UpdateOption) {
+async function downloadBundleUri(downloadManager: DownloadManager, uri: string, version: number, option?: UpdateOption) {
   if (!uri) {
     installFail(option, 'Please give a valid URL!');
     return;
@@ -88,9 +89,9 @@ async function downloadBundleUri(uri: string, version: number, option?: UpdateOp
     return;
   }
   try {
-    const path = await downloadBundleFile(uri, option?.headers, option?.progress);
+    const path = await downloadBundleFile(downloadManager, uri, option?.headers, option?.progress);
     if (path) {
-      setupBundlePath(path).then(success => {
+      setupBundlePath(path, option?.extensionBundle).then(success => {
         if (success) {
           setCurrentVersion(version);
           option?.updateSuccess?.();