@Override
  public ParcelFileDescriptor openDocument(
      String documentId, String mode, CancellationSignal signal) throws FileNotFoundException {
    final File file = getFileForDocId(documentId);
    final File visibleFile = getFileForDocId(documentId, true);

    final int pfdMode = ParcelFileDescriptor.parseMode(mode);
    if (pfdMode == ParcelFileDescriptor.MODE_READ_ONLY || visibleFile == null) {
      return ParcelFileDescriptor.open(file, pfdMode);
    } else {
      try {
        // When finished writing, kick off media scanner
        return ParcelFileDescriptor.open(
            file,
            pfdMode,
            mHandler,
            new OnCloseListener() {
              @Override
              public void onClose(IOException e) {
                final Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
                intent.setData(Uri.fromFile(visibleFile));
                getContext().sendBroadcast(intent);
              }
            });
      } catch (IOException e) {
        throw new FileNotFoundException("Failed to open for writing: " + e);
      }
    }
  }
 @Override
 public ParcelFileDescriptor openDocument(
     final String documentId, final String mode, final CancellationSignal signal)
     throws FileNotFoundException {
   File file = new File(documentId);
   final boolean isWrite = (mode.indexOf('w') != -1);
   if (isWrite) {
     return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_WRITE);
   } else {
     return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
   }
 }
Esempio n. 3
0
  private ParcelFileDescriptor getTempStoreFd() {
    String fileName = getScrapPath(getContext());
    /// M: Code analyze 002, fix bug unknown, If the filename is null,it
    // should run null @{
    if (fileName == null) {
      return null;
    }
    /// @}
    ParcelFileDescriptor pfd = null;

    try {
      File file = new File(fileName);

      // make sure the path is valid and directories created for this file.
      File parentFile = file.getParentFile();
      if (!parentFile.exists() && !parentFile.mkdirs()) {
        Log.e(TAG, "[TempFileProvider] tempStoreFd: " + parentFile.getPath() + "does not exist!");
        return null;
      }

      pfd =
          ParcelFileDescriptor.open(
              file,
              ParcelFileDescriptor.MODE_READ_WRITE | android.os.ParcelFileDescriptor.MODE_CREATE);
    } catch (Exception ex) {
      Log.e(TAG, "getTempStoreFd: error creating pfd for " + fileName, ex);
    }

    return pfd;
  }
 private FileOutputStream zznR()
 {
     if (zzabc == null)
     {
         throw new IllegalStateException("setTempDir() must be called before writing this object to a parcel");
     }
     File file;
     FileOutputStream fileoutputstream;
     try
     {
         file = File.createTempFile("teleporter", ".tmp", zzabc);
     }
     catch (IOException ioexception)
     {
         throw new IllegalStateException("Could not create temporary file", ioexception);
     }
     try
     {
         fileoutputstream = new FileOutputStream(file);
         zzEo = ParcelFileDescriptor.open(file, 0x10000000);
     }
     catch (FileNotFoundException filenotfoundexception)
     {
         throw new IllegalStateException("Temporary file is somehow already deleted");
     }
     file.delete();
     return fileoutputstream;
 }
  @Override
  public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {

    String LOG_TAG = CLASS_NAME + " ";

    Log.d(LOG_TAG, "Called with uri: '" + uri + "'." + uri.getLastPathSegment());

    // Check incoming Uri against the matcher
    switch (uriMatcher.match(uri)) {

        // If it returns 1 - then it matches the Uri defined in onCreate
      case 1:

        // The desired file name is specified by the last segment of the
        // path
        //
        // Take this and build the path to the file
        String fileLocation =
            getContext().getCacheDir() + File.separator + uri.getLastPathSegment();

        // Create & return a ParcelFileDescriptor pointing to the file
        // Note: I don't care what mode they ask for - they're only getting
        // read only
        ParcelFileDescriptor pfd =
            ParcelFileDescriptor.open(new File(fileLocation), ParcelFileDescriptor.MODE_READ_ONLY);
        return pfd;

        // Otherwise unrecognised Uri
      default:
        Log.v(LOG_TAG, "Unsupported uri: '" + uri + "'.");
        throw new FileNotFoundException("Unsupported uri: " + uri.toString());
    }
  }
Esempio n. 6
0
  @Override
  public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
    List<String> pseg = uri.getPathSegments();
    if (pseg.size() < 2) {
      throw new FileNotFoundException("invalid uri error " + uri);
    }

    File path = getFileFromUri(uri);

    Log.v("openFile(uri=" + uri + ", file=" + path + ")");
    int imode = 0;
    if (mode.contains("w")) {
      imode |= ParcelFileDescriptor.MODE_WRITE_ONLY;
      if (!path.exists()) {
        try {
          path.createNewFile();
        } catch (IOException e) {
          e.printStackTrace();
          throw new FileNotFoundException("Error creating " + uri);
        }
      } else {
        throw new FileNotFoundException("File with name " + path + " already exists");
      }
    } else if (mode.contains("r")) {
      if (!path.exists()) {
        throw new FileNotFoundException("File not found " + uri);
      }
    }

    if (mode.contains("r")) imode |= ParcelFileDescriptor.MODE_READ_ONLY;
    if (mode.contains("+")) imode |= ParcelFileDescriptor.MODE_APPEND;

    return ParcelFileDescriptor.open(path, imode);
  }
Esempio n. 7
0
 /* to save images (or maybe only thumbnails */
 @Override
 public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
   File file = new File(this.getContext().getFilesDir(), uri.getPath());
   ParcelFileDescriptor parcel =
       ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
   return parcel;
 }
 // Provide access to the private file as read only
 @Override
 public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
   if (!mode.equals("r")) {
     throw new SecurityException("Only read access is allowed");
   }
   return ParcelFileDescriptor.open(generatePictureFile(uri), ParcelFileDescriptor.MODE_READ_ONLY);
 }
Esempio n. 9
0
 /**
  * Full size bitmap.
  *
  * @param maxNumberOfPixels the max number of pixels
  * @param rotateAsNeeded the rotate as needed
  * @return the bitmap
  */
 public Bitmap fullSizeBitmap(int maxNumberOfPixels, boolean rotateAsNeeded) {
   Logger.v(TAG, "fullSizeBitmap entry");
   int minSideLength = getProperWindowSize();
   String path = mUri.getPath();
   ParcelFileDescriptor pfdInput = null;
   try {
     pfdInput = ParcelFileDescriptor.open(new File(path), ParcelFileDescriptor.MODE_READ_ONLY);
   } catch (FileNotFoundException e) {
     Logger.e(TAG, "got exception decoding bitmap ");
     e.printStackTrace();
   }
   Bitmap bitmap = null;
   bitmap = makeBitmap(minSideLength, maxNumberOfPixels, null, null, pfdInput, null);
   if (bitmap != null && rotateAsNeeded) {
     Bitmap rotatedBitmap = rotate(bitmap, getDegreesRotated());
     if (rotatedBitmap != null && rotatedBitmap != bitmap) {
       Logger.v(TAG, "fullSizeBitmap rotate");
       bitmap.recycle();
       bitmap = rotatedBitmap;
     } else {
       Logger.d(TAG, "fullSizeBitmap no need to roate");
     }
   }
   Logger.v(TAG, "fullSizeBitmap exit");
   return bitmap;
 }
Esempio n. 10
0
 /**
  * Open an attachment file. There are two "modes" - "raw", which returns an actual file, and
  * "thumbnail", which attempts to generate a thumbnail image.
  *
  * <p>Thumbnails are cached for easy space recovery and cleanup.
  *
  * <p>TODO: The thumbnail mode returns null for its failure cases, instead of throwing
  * FileNotFoundException, and should be fixed for consistency.
  *
  * @throws FileNotFoundException
  */
 @Override
 public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
   List<String> segments = uri.getPathSegments();
   String accountId = segments.get(0);
   String id = segments.get(1);
   String format = segments.get(2);
   if (FORMAT_THUMBNAIL.equals(format)) {
     int width = Integer.parseInt(segments.get(3));
     int height = Integer.parseInt(segments.get(4));
     String filename = "thmb_" + accountId + "_" + id;
     File dir = getContext().getCacheDir();
     File file = new File(dir, filename);
     if (!file.exists()) {
       Uri attachmentUri = getAttachmentUri(Long.parseLong(accountId), Long.parseLong(id));
       Cursor c =
           query(attachmentUri, new String[] {AttachmentProviderColumns.DATA}, null, null, null);
       if (c != null) {
         try {
           if (c.moveToFirst()) {
             attachmentUri = Uri.parse(c.getString(0));
           } else {
             return null;
           }
         } finally {
           c.close();
         }
       }
       String type = getContext().getContentResolver().getType(attachmentUri);
       try {
         InputStream in = getContext().getContentResolver().openInputStream(attachmentUri);
         Bitmap thumbnail = createThumbnail(type, in);
         thumbnail = Bitmap.createScaledBitmap(thumbnail, width, height, true);
         FileOutputStream out = new FileOutputStream(file);
         thumbnail.compress(Bitmap.CompressFormat.PNG, 100, out);
         out.close();
         in.close();
       } catch (IOException ioe) {
         return null;
       }
     }
     return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
   } else {
     return ParcelFileDescriptor.open(
         new File(getContext().getDatabasePath(accountId + ".db_att"), id),
         ParcelFileDescriptor.MODE_READ_ONLY);
   }
 }
Esempio n. 11
0
 /**
  * Set photo to be published
  *
  * @param file
  */
 public Builder setImage(File file) {
   try {
     mParcelable = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
   } catch (FileNotFoundException e) {
     Logger.logError(Photo.class, "Failed to create photo from file", e);
   }
   return this;
 }
  /**
   * Constructor.
   *
   * @author Ian Copland
   * @param in_file - The file which this descriptor should point to.
   * @param in_mode - The file mode.
   * @param in_listener - The listener which should be notified of the closed event.
   * @throws FileNotFoundException - Thrown if the file cannot be found. Note that this is the only
   *     case in which the closed event will not be fired.
   */
  public ListenableParcelFileDescriptor(File in_file, int in_mode, OnClose in_listener)
      throws FileNotFoundException {
    super(ParcelFileDescriptor.open(in_file, in_mode));

    assert (in_listener != null)
        : "Cannot create a ListenableParcelFileDescriptor without a listener.";

    m_listener = in_listener;
  }
 @Override
 public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
   int fileIndex = sUriMatcher.match(uri);
   if (fileIndex != -1 && sPaths[fileIndex] != null) {
     return ParcelFileDescriptor.open(
         new File(sPaths[fileIndex]), ParcelFileDescriptor.MODE_READ_ONLY);
   }
   return super.openFile(uri, mode);
 }
  @Nullable
  @Override
  public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {

    Log.d(this, "openFile:" + uri.getLastPathSegment());

    File dir = new File(Environment.getExternalStorageDirectory().getAbsoluteFile(), "/radar");
    return ParcelFileDescriptor.open(
        new File(dir, uri.getLastPathSegment()), ParcelFileDescriptor.MODE_READ_ONLY);
  }
  @Override
  public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
    File f = new File(getContext().getFilesDir(), uri.getPath());

    if (f.exists()) {
      return (ParcelFileDescriptor.open(f, ParcelFileDescriptor.MODE_READ_ONLY));
    }

    throw new FileNotFoundException(uri.getPath());
  }
 // Check: openPipeHelper in
 // https://github.com/android/platform_frameworks_base/blob/master/core/java/android/content/ContentProvider.java
 // for example to use IOCipher
 @Override
 public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
   return ParcelFileDescriptor.open(
       new java.io.File(
           getNonVirtualFileSystemInternalDir(),
           SocialReader.CONTENT_BUNDLE_FILE_PREFIX
               + uri.getLastPathSegment()
               + "."
               + SocialReader.CONTENT_SHARING_EXTENSION),
       ParcelFileDescriptor.MODE_READ_ONLY);
 }
 @Override
 public AssetFileDescriptor openDocumentThumbnail(
     final String documentId, final Point sizeHint, final CancellationSignal signal)
     throws FileNotFoundException {
   // Assume documentId points to an image file. Build a thumbnail no
   // larger than twice the sizeHint
   BitmapFactory.Options options = new BitmapFactory.Options();
   options.inJustDecodeBounds = true;
   BitmapFactory.decodeFile(documentId, options);
   final int targetHeight = 2 * sizeHint.y;
   final int targetWidth = 2 * sizeHint.x;
   final int height = options.outHeight;
   final int width = options.outWidth;
   options.inSampleSize = 1;
   if (height > targetHeight || width > targetWidth) {
     final int halfHeight = height / 2;
     final int halfWidth = width / 2;
     // Calculate the largest inSampleSize value that is a power of 2 and
     // keeps both
     // height and width larger than the requested height and width.
     while ((halfHeight / options.inSampleSize) > targetHeight
         || (halfWidth / options.inSampleSize) > targetWidth) {
       options.inSampleSize *= 2;
     }
   }
   options.inJustDecodeBounds = false;
   Bitmap bitmap = BitmapFactory.decodeFile(documentId, options);
   // Write out the thumbnail to a temporary file
   File tempFile = null;
   FileOutputStream out = null;
   try {
     tempFile = File.createTempFile("thumbnail", null, getContext().getCacheDir());
     out = new FileOutputStream(tempFile);
     bitmap.compress(Bitmap.CompressFormat.PNG, 90, out);
   } catch (IOException e) {
     Log.e(LocalStorageProvider.class.getSimpleName(), "Error writing thumbnail", e);
     return null;
   } finally {
     if (out != null)
       try {
         out.close();
       } catch (IOException e) {
         Log.e(LocalStorageProvider.class.getSimpleName(), "Error closing thumbnail", e);
       }
   }
   // It appears the Storage Framework UI caches these results quite
   // aggressively so there is little reason to
   // write your own caching layer beyond what you need to return a single
   // AssetFileDescriptor
   return new AssetFileDescriptor(
       ParcelFileDescriptor.open(tempFile, ParcelFileDescriptor.MODE_READ_ONLY),
       0,
       AssetFileDescriptor.UNKNOWN_LENGTH);
 }
Esempio n. 18
0
 private ParcelFileDescriptor getPFD() {
   try {
     if (mUri.getScheme().equals("file")) {
       String path = mUri.getPath();
       return ParcelFileDescriptor.open(new File(path), ParcelFileDescriptor.MODE_READ_ONLY);
     } else {
       return mContentResolver.openFileDescriptor(mUri, "r");
     }
   } catch (FileNotFoundException ex) {
     return null;
   }
 }
Esempio n. 19
0
  public static ParcelFileDescriptor openParcelFd(String path) {
    forceFile(path);
    try {
      Logger.D(TAG, "Opening file from file system: " + absolutePath(path));

      File file = new File(path);
      return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
    } catch (FileNotFoundException e) {
      Logger.E(TAG, "Can not open ParcelFileDescriptor" + e.getMessage());
      return null;
    }
  }
  @NonNull
  private ParcelFileDescriptor safeOpenFileHelper(@NonNull Uri uri, @NonNull String mode)
      throws FileNotFoundException {
    Cursor c = query(uri, new String[] {"_data"}, null, null, null);
    int count = (c != null) ? c.getCount() : 0;
    if (count != 1) {
      // If there is not exactly one result, throw an appropriate
      // exception.
      if (c != null) {
        c.close();
      }
      if (count == 0) {
        throw new FileNotFoundException("No entry for " + uri);
      }
      throw new FileNotFoundException("Multiple items at " + uri);
    }

    c.moveToFirst();
    int i = c.getColumnIndex("_data");
    String path = (i >= 0 ? c.getString(i) : null);
    c.close();

    if (path == null) {
      throw new FileNotFoundException("Column _data not found.");
    }

    File filePath = new File(path);
    try {
      // The MmsProvider shouldn't open a file that isn't MMS data, so we verify that the
      // _data path actually points to MMS data. That safeguards ourselves from callers who
      // inserted or updated a URI (more specifically the _data column) with disallowed paths.
      // TODO(afurtado): provide a more robust mechanism to avoid disallowed _data paths to
      // be inserted/updated in the first place, including via SQL injection.
      if (!filePath
          .getCanonicalPath()
          .startsWith(getContext().getDir(PARTS_DIR_NAME, 0).getCanonicalPath())) {
        Log.e(
            TAG,
            "openFile: path "
                + filePath.getCanonicalPath()
                + " does not start with "
                + getContext().getDir(PARTS_DIR_NAME, 0).getCanonicalPath());
        // Don't care return value
        return null;
      }
    } catch (IOException e) {
      Log.e(TAG, "openFile: create path failed " + e, e);
      return null;
    }

    int modeBits = ParcelFileDescriptor.parseMode(mode);
    return ParcelFileDescriptor.open(filePath, modeBits);
  }
Esempio n. 21
0
 @TargetApi(Build.VERSION_CODES.LOLLIPOP)
 private static boolean weOwnFileLollipop(Uri uri) {
   try {
     File file = new File(uri.getPath());
     FileDescriptor fd =
         ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY).getFileDescriptor();
     StructStat st = Os.fstat(fd);
     return st.st_uid == android.os.Process.myUid();
   } catch (FileNotFoundException e) {
     return false;
   } catch (Exception e) {
     return true;
   }
 }
 @Override
 public ParcelFileDescriptor openFile(final Uri uri, final String mode)
     throws FileNotFoundException {
   try {
     this.setApplicationActivated();
     Log.d(TAG, "Writing filters...");
     final File filterFile = Engine.getOrCreateCachedFilterFile(getContext());
     Log.d(TAG, "Delivering filters...");
     return ParcelFileDescriptor.open(filterFile, ParcelFileDescriptor.MODE_READ_ONLY);
   } catch (IOException e) {
     Log.e(TAG, "File creation failed: " + e.getMessage(), e);
     return null;
   }
 }
Esempio n. 23
0
 @Override
 public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
   if (!"r".equals(mode)) {
     throw new FileNotFoundException(
         "The SLIC FileContentProvider does not support mode \"" + mode + "\" for " + uri);
   }
   String rootOmPath = System.getProperty("root.openmeap.path");
   String filename = uri.toString().substring(BASE_URI_LEN);
   String relFN = filename.replace(rootOmPath, "");
   filename = rootOmPath + FILE_SEP + getInternalStorageFileName(relFN);
   File file = new File(filename);
   ParcelFileDescriptor toRet =
       ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
   return toRet;
 }
 public Bitmap getMusicImg(String mAlbumArtURI) {
   File file = new File(mAlbumArtURI);
   Bitmap bt = null;
   try {
     ParcelFileDescriptor fd =
         ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
     bt = BitmapFactory.decodeFileDescriptor(fd.getFileDescriptor(), null, null);
     if (bt == null) {
     } else {
     }
   } catch (FileNotFoundException e) {
     e.printStackTrace();
   }
   return bt;
 }
Esempio n. 25
0
  /** Remotely opens a file */
  @Override
  public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
    if (Constants.LOGVV) {
      logVerboseOpenFileInfo(uri, mode);
    }

    Cursor cursor = query(uri, new String[] {"_data"}, null, null, null);
    String path;
    try {
      int count = (cursor != null) ? cursor.getCount() : 0;
      if (count != 1) {
        // If there is not exactly one result, throw an appropriate
        // exception.
        if (count == 0) {
          throw new FileNotFoundException("No entry for " + uri);
        }
        throw new FileNotFoundException("Multiple items at " + uri);
      }

      cursor.moveToFirst();
      path = cursor.getString(0);
    } finally {
      if (cursor != null) {
        cursor.close();
      }
    }

    if (path == null) {
      throw new FileNotFoundException("No filename found.");
    }
    if (!Helpers.isFilenameValid(path)) {
      throw new FileNotFoundException("Invalid filename.");
    }
    if (!"r".equals(mode)) {
      throw new FileNotFoundException("Bad mode for " + uri + ": " + mode);
    }

    ParcelFileDescriptor ret =
        ParcelFileDescriptor.open(new File(path), ParcelFileDescriptor.MODE_READ_ONLY);

    if (ret == null) {
      if (Constants.LOGV) {
        Log.v(Constants.TAG, "couldn't open file");
      }
      throw new FileNotFoundException("couldn't open file");
    }
    return ret;
  }
Esempio n. 26
0
  @Override
  public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
    File file;

    List<String> segments = uri.getPathSegments();
    String accountUuid = segments.get(0);
    String attachmentId = segments.get(1);
    String format = segments.get(2);

    if (FORMAT_THUMBNAIL.equals(format)) {
      int width = Integer.parseInt(segments.get(3));
      int height = Integer.parseInt(segments.get(4));

      file = getThumbnailFile(getContext(), accountUuid, attachmentId);
      if (!file.exists()) {
        String type = getType(accountUuid, attachmentId, FORMAT_VIEW, null);
        try {
          FileInputStream in = new FileInputStream(getFile(accountUuid, attachmentId));
          try {
            Bitmap thumbnail = createThumbnail(type, in);
            if (thumbnail != null) {
              thumbnail = Bitmap.createScaledBitmap(thumbnail, width, height, true);
              FileOutputStream out = new FileOutputStream(file);
              try {
                thumbnail.compress(Bitmap.CompressFormat.PNG, 100, out);
              } finally {
                out.close();
              }
            }
          } finally {
            try {
              in.close();
            } catch (Throwable ignore) {
              /* ignore */
            }
          }
        } catch (IOException ioe) {
          return null;
        }
      }
    } else {
      file = getFile(accountUuid, attachmentId);
    }

    return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
  }
Esempio n. 27
0
 private int openOrDownloadInner(JobContext jc) {
   String scheme = mUri.getScheme();
   if (ContentResolver.SCHEME_CONTENT.equals(scheme)
       || ContentResolver.SCHEME_ANDROID_RESOURCE.equals(scheme)
       || ContentResolver.SCHEME_FILE.equals(scheme)) {
     try {
       if (MIME_TYPE_JPEG.equalsIgnoreCase(mContentType)) {
         InputStream is = mApplication.getContentResolver().openInputStream(mUri);
         mRotation = Exif.getOrientation(is);
         Utils.closeSilently(is);
       }
       mFileDescriptor = mApplication.getContentResolver().openFileDescriptor(mUri, "r");
       if (jc.isCancelled()) return STATE_INIT;
       return STATE_DOWNLOADED;
     } catch (FileNotFoundException e) {
       Log.w(TAG, "fail to open: " + mUri, e);
       return STATE_ERROR;
     }
   } else {
     try {
       URL url = new URI(mUri.toString()).toURL();
       mCacheEntry = mApplication.getDownloadCache().download(jc, url);
       if (jc.isCancelled()) return STATE_INIT;
       if (mCacheEntry == null) {
         Log.w(TAG, "download failed " + url);
         return STATE_ERROR;
       }
       if (MIME_TYPE_JPEG.equalsIgnoreCase(mContentType)) {
         InputStream is = new FileInputStream(mCacheEntry.cacheFile);
         mRotation = Exif.getOrientation(is);
         Utils.closeSilently(is);
       }
       mFileDescriptor =
           ParcelFileDescriptor.open(mCacheEntry.cacheFile, ParcelFileDescriptor.MODE_READ_ONLY);
       return STATE_DOWNLOADED;
     } catch (Throwable t) {
       Log.w(TAG, "download error", t);
       return STATE_ERROR;
     }
   }
 }
 @SmallTest
 @Feature({"Cronet"})
 public void testFileDescriptorProvider() throws Exception {
   ParcelFileDescriptor descriptor =
       ParcelFileDescriptor.open(mFile, ParcelFileDescriptor.MODE_READ_ONLY);
   assertTrue(descriptor.getFileDescriptor().valid());
   TestUrlRequestCallback callback = new TestUrlRequestCallback();
   UrlRequest.Builder builder =
       new UrlRequest.Builder(
           NativeTestServer.getRedirectToEchoBody(),
           callback,
           callback.getExecutor(),
           mTestFramework.mCronetEngine);
   UploadDataProvider dataProvider = UploadDataProviders.create(descriptor);
   builder.setUploadDataProvider(dataProvider, callback.getExecutor());
   builder.addHeader("Content-Type", "useless/string");
   builder.build().start();
   callback.blockForDone();
   assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
   assertEquals(LOREM, callback.mResponseAsString);
 }
 @Override
 public ParcelFileDescriptor openFile(@NonNull Uri uri, @NonNull String mode)
     throws FileNotFoundException {
   File file = new File(uri.getPath());
   return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
 }
Esempio n. 30
0
 public ParcelFileDescriptor openFile(Uri uri, String s)
 {
     return ParcelFileDescriptor.open(mStrategy.getFileForUri(uri), modeToMode(s));
 }