Nessuna descrizione

index.js 16KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567
  1. // Copyright 2016 wkh237@github. All rights reserved.
  2. // Use of this source code is governed by a MIT-style license that can be
  3. // found in the LICENSE file.
  4. import {
  5. NativeModules,
  6. DeviceEventEmitter,
  7. NativeAppEventEmitter,
  8. Platform,
  9. AsyncStorage,
  10. AppState,
  11. } from 'react-native'
  12. import type {
  13. RNFetchBlobNative,
  14. RNFetchBlobConfig,
  15. RNFetchBlobStream,
  16. RNFetchBlobResponseInfo
  17. } from './types'
  18. import URIUtil from './utils/uri'
  19. //import StatefulPromise from './class/StatefulPromise.js'
  20. import fs from './fs'
  21. import getUUID from './utils/uuid'
  22. import base64 from 'base-64'
  23. import polyfill from './polyfill'
  24. import _ from 'lodash'
  25. import android from './android'
  26. import ios from './ios'
  27. import JSONStream from './json-stream'
  28. const {
  29. RNFetchBlobSession,
  30. readStream,
  31. createFile,
  32. unlink,
  33. exists,
  34. mkdir,
  35. session,
  36. writeStream,
  37. readFile,
  38. ls,
  39. isDir,
  40. mv,
  41. cp
  42. } = fs
  43. const Blob = polyfill.Blob
  44. const emitter = DeviceEventEmitter
  45. const RNFetchBlob = NativeModules.RNFetchBlob
  46. // when app resumes, check if there's any expired network task and trigger
  47. // their .expire event
  48. if(Platform.OS === 'ios') {
  49. AppState.addEventListener('change', (e) => {
  50. if(e === 'active')
  51. RNFetchBlob.emitExpiredEvent(()=>{})
  52. })
  53. }
  54. // register message channel event handler.
  55. emitter.addListener("RNFetchBlobMessage", (e) => {
  56. if(e.event === 'warn') {
  57. console.warn(e.detail)
  58. }
  59. else if (e.event === 'error') {
  60. throw e.detail
  61. }
  62. else {
  63. console.log("RNFetchBlob native message", e.detail)
  64. }
  65. })
  66. // Show warning if native module not detected
  67. if(!RNFetchBlob || !RNFetchBlob.fetchBlobForm || !RNFetchBlob.fetchBlob) {
  68. console.warn(
  69. 'rn-fetch-blob could not find valid native module.',
  70. 'please make sure you have linked native modules using `rnpm link`,',
  71. 'and restart RN packager or manually compile IOS/Android project.'
  72. )
  73. }
  74. function wrap(path:string):string {
  75. const prefix = path.startsWith('content://') ? 'RNFetchBlob-content://' : 'RNFetchBlob-file://'
  76. return prefix + path
  77. }
  78. /**
  79. * Calling this method will inject configurations into followed `fetch` method.
  80. * @param {RNFetchBlobConfig} options
  81. * Fetch API configurations, contains the following options :
  82. * @property {boolean} fileCache
  83. * When fileCache is `true`, response data will be saved in
  84. * storage with a random generated file name, rather than
  85. * a BASE64 encoded string.
  86. * @property {string} appendExt
  87. * Set this property to change file extension of random-
  88. * generated file name.
  89. * @property {string} path
  90. * If this property has a valid string format, resonse data
  91. * will be saved to specific file path. Default string format
  92. * is : `RNFetchBlob-file://path-to-file`
  93. * @property {string} key
  94. * If this property is set, it will be converted to md5, to
  95. * check if a file with this name exists.
  96. * If it exists, the absolute path is returned (no network
  97. * activity takes place )
  98. * If it doesn't exist, the file is downloaded as usual
  99. * @property {number} timeout
  100. * Request timeout in millionseconds, by default it's 30000ms.
  101. *
  102. * @return {function} This method returns a `fetch` method instance.
  103. */
  104. function config (options:RNFetchBlobConfig) {
  105. return { fetch : fetch.bind(options) }
  106. }
  107. /**
  108. * Fetch from file system, use the same interface as RNFB.fetch
  109. * @param {RNFetchBlobConfig} [options={}] Fetch configurations
  110. * @param {string} method Should be one of `get`, `post`, `put`
  111. * @param {string} url A file URI string
  112. * @param {string} headers Arguments of file system API
  113. * @param {any} body Data to put or post to file systen.
  114. * @return {Promise}
  115. */
  116. function fetchFile(options = {}, method, url, headers = {}, body):Promise {
  117. if(!URIUtil.isFileURI(url)) {
  118. throw `could not fetch file from an invalid URI : ${url}`
  119. }
  120. url = URIUtil.unwrapFileURI(url)
  121. let promise = null
  122. let cursor = 0
  123. let total = -1
  124. let cacheData = ''
  125. let info = null
  126. let _progress, _uploadProgress, _stateChange
  127. switch(method.toLowerCase()) {
  128. case 'post':
  129. break
  130. case 'put':
  131. break
  132. // read data from file system
  133. default:
  134. promise = fs.stat(url)
  135. .then((stat) => {
  136. total = stat.size
  137. return fs.readStream(url,
  138. headers.encoding || 'utf8',
  139. Math.floor(headers.bufferSize) || 409600,
  140. Math.floor(headers.interval) || 100
  141. )
  142. })
  143. .then((stream) => new Promise((resolve, reject) => {
  144. stream.open()
  145. info = {
  146. state : "2",
  147. headers : { 'source' : 'system-fs' },
  148. status : 200,
  149. respType : 'text',
  150. rnfbEncode : headers.encoding || 'utf8'
  151. }
  152. _stateChange(info)
  153. stream.onData((chunk) => {
  154. _progress && _progress(cursor, total, chunk)
  155. if(headers.noCache)
  156. return
  157. cacheData += chunk
  158. })
  159. stream.onError((err) => { reject(err) })
  160. stream.onEnd(() => {
  161. resolve(new FetchBlobResponse(null, info, cacheData))
  162. })
  163. }))
  164. break
  165. }
  166. promise.progress = (fn) => {
  167. _progress = fn
  168. return promise
  169. }
  170. promise.stateChange = (fn) => {
  171. _stateChange = fn
  172. return promise
  173. }
  174. promise.uploadProgress = (fn) => {
  175. _uploadProgress = fn
  176. return promise
  177. }
  178. return promise
  179. }
  180. /**
  181. * Create a HTTP request by settings, the `this` context is a `RNFetchBlobConfig` object.
  182. * @param {string} method HTTP method, should be `GET`, `POST`, `PUT`, `DELETE`
  183. * @param {string} url Request target url string.
  184. * @param {object} headers HTTP request headers.
  185. * @param {string} body
  186. * Request body, can be either a BASE64 encoded data string,
  187. * or a file path with prefix `RNFetchBlob-file://` (can be changed)
  188. * @return {Promise}
  189. * This promise instance also contains a Customized method `progress`for
  190. * register progress event handler.
  191. */
  192. function fetch(...args:any):Promise {
  193. // create task ID for receiving progress event
  194. let taskId = getUUID()
  195. let options = this || {}
  196. let subscription, subscriptionUpload, stateEvent, partEvent
  197. let respInfo = {}
  198. let [method, url, headers, body] = [...args]
  199. // # 241 normalize null or undefined headers, in case nil or null string
  200. // pass to native context
  201. headers = _.reduce(headers, (result, value, key) => {
  202. result[key] = value || ''
  203. return result
  204. }, {});
  205. // fetch from file system
  206. if(URIUtil.isFileURI(url)) {
  207. return fetchFile(options, method, url, headers, body)
  208. }
  209. // from remote HTTP(S)
  210. let promise = new Promise((resolve, reject) => {
  211. let nativeMethodName = Array.isArray(body) ? 'fetchBlobForm' : 'fetchBlob'
  212. // on progress event listener
  213. subscription = emitter.addListener('RNFetchBlobProgress', (e) => {
  214. if(e.taskId === taskId && promise.onProgress) {
  215. promise.onProgress(e.written, e.total, e.chunk)
  216. }
  217. })
  218. subscriptionUpload = emitter.addListener('RNFetchBlobProgress-upload', (e) => {
  219. if(e.taskId === taskId && promise.onUploadProgress) {
  220. promise.onUploadProgress(e.written, e.total)
  221. }
  222. })
  223. stateEvent = emitter.addListener('RNFetchBlobState', (e) => {
  224. if(e.taskId === taskId)
  225. respInfo = e
  226. promise.onStateChange && promise.onStateChange(e)
  227. })
  228. subscription = emitter.addListener('RNFetchBlobExpire', (e) => {
  229. if(e.taskId === taskId && promise.onExpire) {
  230. promise.onExpire(e)
  231. }
  232. })
  233. partEvent = emitter.addListener('RNFetchBlobServerPush', (e) => {
  234. if(e.taskId === taskId && promise.onPartData) {
  235. promise.onPartData(e.chunk)
  236. }
  237. })
  238. // When the request body comes from Blob polyfill, we should use special its ref
  239. // as the request body
  240. if( body instanceof Blob && body.isRNFetchBlobPolyfill) {
  241. body = body.getRNFetchBlobRef()
  242. }
  243. let req = RNFetchBlob[nativeMethodName]
  244. /**
  245. * Send request via native module, the response callback accepts three arguments
  246. * @callback
  247. * @param err {any} Error message or object, when the request success, this
  248. * parameter should be `null`.
  249. * @param rawType { 'utf8' | 'base64' | 'path'} RNFB request will be stored
  250. * as UTF8 string, BASE64 string, or a file path reference
  251. * in JS context, and this parameter indicates which one
  252. * dose the response data presents.
  253. * @param data {string} Response data or its reference.
  254. */
  255. req(options, taskId, method, url, headers || {}, body, (err, rawType, data) => {
  256. // task done, remove event listeners
  257. subscription.remove()
  258. subscriptionUpload.remove()
  259. stateEvent.remove()
  260. partEvent.remove()
  261. delete promise['progress']
  262. delete promise['uploadProgress']
  263. delete promise['stateChange']
  264. delete promise['part']
  265. delete promise['cancel']
  266. // delete promise['expire']
  267. promise.cancel = () => {}
  268. if(err)
  269. reject(new Error(err, respInfo))
  270. else {
  271. // response data is saved to storage, create a session for it
  272. if(options.path || options.fileCache || options.addAndroidDownloads
  273. || options.key || options.auto && respInfo.respType === 'blob') {
  274. if(options.session)
  275. session(options.session).add(data)
  276. }
  277. respInfo.rnfbEncode = rawType
  278. resolve(new FetchBlobResponse(taskId, respInfo, data))
  279. }
  280. })
  281. })
  282. // extend Promise object, add `progress`, `uploadProgress`, and `cancel`
  283. // method for register progress event handler and cancel request.
  284. // Add second parameter for performance purpose #140
  285. // When there's only one argument pass to this method, use default `interval`
  286. // and `count`, otherwise use the given on.
  287. // TODO : code refactor, move `uploadProgress` and `progress` to StatefulPromise
  288. promise.progress = (...args) => {
  289. let interval = 250
  290. let count = -1
  291. let fn = () => {}
  292. if(args.length === 2) {
  293. interval = args[0].interval || interval
  294. count = args[0].count || count
  295. fn = args[1]
  296. }
  297. else {
  298. fn = args[0]
  299. }
  300. promise.onProgress = fn
  301. RNFetchBlob.enableProgressReport(taskId, interval, count)
  302. return promise
  303. }
  304. promise.uploadProgress = (...args) => {
  305. let interval = 250
  306. let count = -1
  307. let fn = () => {}
  308. if(args.length === 2) {
  309. interval = args[0].interval || interval
  310. count = args[0].count || count
  311. fn = args[1]
  312. }
  313. else {
  314. fn = args[0]
  315. }
  316. promise.onUploadProgress = fn
  317. RNFetchBlob.enableUploadProgressReport(taskId, interval, count)
  318. return promise
  319. }
  320. promise.part = (fn) => {
  321. promise.onPartData = fn
  322. return promise
  323. }
  324. promise.stateChange = (fn) => {
  325. promise.onStateChange = fn
  326. return promise
  327. }
  328. promise.expire = (fn) => {
  329. promise.onExpire = fn
  330. return promise
  331. }
  332. promise.cancel = (fn) => {
  333. fn = fn || function(){}
  334. subscription.remove()
  335. subscriptionUpload.remove()
  336. stateEvent.remove()
  337. RNFetchBlob.cancelRequest(taskId, fn)
  338. }
  339. promise.taskId = taskId
  340. return promise
  341. }
  342. /**
  343. * RNFetchBlob response object class.
  344. */
  345. class FetchBlobResponse {
  346. taskId : string;
  347. path : () => string | null;
  348. type : 'base64' | 'path' | 'utf8';
  349. data : any;
  350. blob : (contentType:string, sliceSize:number) => Promise<Blob>;
  351. text : () => string | Promise<any>;
  352. json : () => any;
  353. base64 : () => any;
  354. flush : () => void;
  355. respInfo : RNFetchBlobResponseInfo;
  356. session : (name:string) => RNFetchBlobSession | null;
  357. readFile : (encode: 'base64' | 'utf8' | 'ascii') => ?Promise<any>;
  358. readStream : (
  359. encode: 'utf8' | 'ascii' | 'base64',
  360. ) => RNFetchBlobStream | null;
  361. constructor(taskId:string, info:RNFetchBlobResponseInfo, data:any) {
  362. this.data = data
  363. this.taskId = taskId
  364. this.type = info.rnfbEncode
  365. this.respInfo = info
  366. this.info = ():RNFetchBlobResponseInfo => {
  367. return this.respInfo
  368. }
  369. this.array = ():Promise<Array> => {
  370. let cType = info.headers['Content-Type'] || info.headers['content-type']
  371. return new Promise((resolve, reject) => {
  372. switch(this.type) {
  373. case 'base64':
  374. // TODO : base64 to array buffer
  375. break
  376. case 'path':
  377. fs.readFile(this.data, 'ascii').then(resolve)
  378. break
  379. default:
  380. // TODO : text to array buffer
  381. break
  382. }
  383. })
  384. }
  385. /**
  386. * Convert result to javascript RNFetchBlob object.
  387. * @return {Promise<Blob>} Return a promise resolves Blob object.
  388. */
  389. this.blob = ():Promise<Blob> => {
  390. let Blob = polyfill.Blob
  391. let cType = info.headers['Content-Type'] || info.headers['content-type']
  392. return new Promise((resolve, reject) => {
  393. switch(this.type) {
  394. case 'base64':
  395. Blob.build(this.data, { type : cType + ';BASE64' }).then(resolve)
  396. break
  397. case 'path':
  398. polyfill.Blob.build(wrap(this.data), { type : cType }).then(resolve)
  399. break
  400. default:
  401. polyfill.Blob.build(this.data, { type : 'text/plain' }).then(resolve)
  402. break
  403. }
  404. })
  405. }
  406. /**
  407. * Convert result to text.
  408. * @return {string} Decoded base64 string.
  409. */
  410. this.text = ():string | Promise<any> => {
  411. let res = this.data
  412. switch(this.type) {
  413. case 'base64':
  414. return base64.decode(this.data)
  415. case 'path':
  416. return fs.readFile(this.data, 'base64').then((b64) => Promise.resolve(base64.decode(b64)))
  417. default:
  418. return this.data
  419. }
  420. }
  421. /**
  422. * Convert result to JSON object.
  423. * @return {object} Parsed javascript object.
  424. */
  425. this.json = ():any => {
  426. switch(this.type) {
  427. case 'base64':
  428. return JSON.parse(base64.decode(this.data))
  429. case 'path':
  430. return fs.readFile(this.data, 'utf8')
  431. .then((text) => Promise.resolve(JSON.parse(text)))
  432. default:
  433. return JSON.parse(this.data)
  434. }
  435. }
  436. /**
  437. * Return BASE64 string directly.
  438. * @return {string} BASE64 string of response body.
  439. */
  440. this.base64 = ():string | Promise<any> => {
  441. switch(this.type) {
  442. case 'base64':
  443. return this.data
  444. case 'path':
  445. return fs.readFile(this.data, 'base64')
  446. default:
  447. return base64.encode(this.data)
  448. }
  449. }
  450. /**
  451. * Remove cahced file
  452. * @return {Promise}
  453. */
  454. this.flush = () => {
  455. let path = this.path()
  456. if(!path || this.type !== 'path')
  457. return
  458. return unlink(path)
  459. }
  460. /**
  461. * get path of response temp file
  462. * @return {string} File path of temp file.
  463. */
  464. this.path = () => {
  465. if(this.type === 'path')
  466. return this.data
  467. return null
  468. }
  469. this.session = (name:string):RNFetchBlobSession | null => {
  470. if(this.type === 'path')
  471. return session(name).add(this.data)
  472. else {
  473. console.warn('only file paths can be add into session.')
  474. return null
  475. }
  476. }
  477. /**
  478. * Start read stream from cached file
  479. * @param {String} encoding Encode type, should be one of `base64`, `ascii`, `utf8`.
  480. * @return {void}
  481. */
  482. this.readStream = (encoding: 'base64' | 'utf8' | 'ascii'):RNFetchBlobStream | null => {
  483. if(this.type === 'path') {
  484. return readStream(this.data, encoding)
  485. }
  486. else {
  487. console.warn('RNFetchblob', 'this response data does not contains any available stream')
  488. return null
  489. }
  490. }
  491. /**
  492. * Read file content with given encoding, if the response does not contains
  493. * a file path, show warning message
  494. * @param {String} encoding Encode type, should be one of `base64`, `ascrii`, `utf8`.
  495. * @return {String}
  496. */
  497. this.readFile = (encoding: 'base64' | 'utf8' | 'ascii') => {
  498. if(this.type === 'path') {
  499. return readFile(this.data, encoding)
  500. }
  501. else {
  502. console.warn('RNFetchblob', 'this response does not contains a readable file')
  503. return null
  504. }
  505. }
  506. }
  507. }
  508. export default {
  509. fetch,
  510. base64,
  511. android,
  512. ios,
  513. config,
  514. session,
  515. fs,
  516. wrap,
  517. polyfill,
  518. JSONStream
  519. }