onCreated(fn:() => void):Blob {
    log.verbose('#register blob onCreated', this._blobCreated)
    if(!this._blobCreated)
      this._onCreated.push(fn)
    else {
      fn(this)
    }
    return this
  }

  markAsDerived() {
    this._isDerived = true
  }

  get isDerived() {
    return this._isDerived || false
  }

  /**
   * Get file reference of the Blob object.
   * @nonstandard
   * @return {string} Blob file reference which can be consumed by RNFetchBlob fs
   */
  getRNFetchBlobRef() {
    return this._ref
  }

  /**
   * Create a Blob object which is sliced from current object
   * @param  {number} start    Start byte number
   * @param  {number} end      End byte number
   * @param  {string} contentType Optional, content type of new Blob object
   * @return {Blob}
   */
  slice(start:?number, end:?number, contentType:?string=''):Blob {
    if(this._closed)
      throw 'Blob has been released.'
    log.verbose('slice called', start, end, contentType)


    let resPath = blobCacheDir + getBlobName()
    let pass = false
    log.debug('fs.slice new blob will at', resPath)
    let result = new Blob(RNFetchBlob.wrap(resPath), { type : contentType }, true)
    fs.exists(blobCacheDir)
    .then((exist) => {
      if(exist)
        return Promise.resolve()
      return fs.mkdir(blobCacheDir)
    })
    .then(() => fs.slice(this._ref, resPath, start, end))
    .then((dest) => {
      log.debug('fs.slice done', dest)
      result._invokeOnCreateEvent()
      pass = true
    })
    .catch((err) => {
      console.warn('Blob.slice failed:', err)
      pass = true
    })
    log.debug('slice returning new Blob')

    return result
  }

  /**
   * Read data of the Blob object, this is not standard method.
   * @nonstandard
   * @param  {string} encoding Read data with encoding
   * @return {Promise}
   */
  readBlob(encoding:string):Promise<any> {
    if(this._closed)
      throw 'Blob has been released.'
    return fs.readFile(this._ref, encoding || 'utf8')
  }
Since Blob content will asynchronously write to a file during creation,
use this method to register an event handler for Blob initialized event.
@nonstandard
@param  {(b:Blob) => void} An event handler invoked when Blob created
@return {Blob} The Blob object instance itself