Beispiel #1
0
  /**
   * Using reflection to persist Uri permission in order to support backward compatibility since
   * this API is available only from Kitkat onwards. Try to persist Uri access permission for the
   * client to be able to read the contents from this Uri even after the client is restarted after
   * device reboot.
   *
   * @param file Uri of file to transfer
   * @throws RcsServiceException
   */
  public static void tryToTakePersistableContentUriPermission(Context context, Uri file)
      throws RcsServiceException {
    if (!(ContentResolver.SCHEME_CONTENT.equals(file.getScheme()))) {
      return;
    }
    if (android.os.Build.VERSION.SDK_INT < KITKAT_VERSION_CODE) {
      return;
    }
    try {
      ContentResolver contentResolver = context.getContentResolver();
      Method takePersistableUriPermissionMethod =
          contentResolver
              .getClass()
              .getMethod(
                  TAKE_PERSISTABLE_URI_PERMISSION_METHOD_NAME,
                  TAKE_PERSISTABLE_URI_PERMISSION_PARAM_TYPES);
      Object[] methodArgs =
          new Object[] {
            file, Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION
          };
      takePersistableUriPermissionMethod.invoke(contentResolver, methodArgs);

    } catch (NoSuchMethodException e) {
      throw new RcsServiceException(e);

    } catch (IllegalAccessException e) {
      throw new RcsServiceException(e);

    } catch (InvocationTargetException e) {
      throw new RcsServiceException(e);
    }
  }
 public static int getUriType(Uri uri) {
   assertNonRelative(uri);
   String scheme = uri.getScheme();
   if (ContentResolver.SCHEME_CONTENT.equals(scheme)) {
     return URI_TYPE_CONTENT;
   }
   if (ContentResolver.SCHEME_ANDROID_RESOURCE.equals(scheme)) {
     return URI_TYPE_RESOURCE;
   }
   if (ContentResolver.SCHEME_FILE.equals(scheme)) {
     if (uri.getPath().startsWith("/android_asset/")) {
       return URI_TYPE_ASSET;
     }
     return URI_TYPE_FILE;
   }
   if ("data".equals(scheme)) {
     return URI_TYPE_DATA;
   }
   if ("http".equals(scheme)) {
     return URI_TYPE_HTTP;
   }
   if ("https".equals(scheme)) {
     return URI_TYPE_HTTPS;
   }
   return URI_TYPE_UNKNOWN;
 }
  public static InputStream openInputStream(Uri uri) {

    if (uri == null) return null;

    String scheme = uri.getScheme();
    InputStream stream = null;

    if (scheme == null || ContentResolver.SCHEME_FILE.equals(scheme)) {

      // from file
      stream = openFileInputStream(uri.getPath());

    } else if (ContentResolver.SCHEME_CONTENT.equals(scheme)) {

      // from content
      stream = openContentInputStream(uri);

    } else if (Constants.SCHEME_HTTP.equals(scheme) || Constants.SCHEME_HTTPS.equals(scheme)) {

      // from remote uri
      stream = openRemoteInputStream(uri);

    } else if (Constants.SCHEME_RESOURCE.equals(scheme)) {

      stream = openResourceStream(uri);

    } else if (Constants.SCHEME_ASSETS.equals(scheme)) {

      stream = openAssetsStream(uri);
    }

    return stream;
  }
Beispiel #4
0
 public static String getRealFilePath(Context context, final Uri uri) {
   if (uri == null) {
     return null;
   }
   final String scheme = uri.getScheme();
   String path = null;
   if (scheme == null) {
     path = uri.getPath();
   } else if (ContentResolver.SCHEME_FILE.equals(scheme)) {
     path = uri.getPath();
   } else if (ContentResolver.SCHEME_CONTENT.equals(scheme)) {
     Cursor cursor =
         context
             .getContentResolver()
             .query(uri, new String[] {ImageColumns.DATA}, null, null, null);
     if (null != cursor) {
       if (cursor.moveToFirst()) {
         int index = cursor.getColumnIndex(ImageColumns.DATA);
         if (index > -1) {
           path = cursor.getString(index);
         }
       }
       cursor.close();
     }
   }
   return path;
 }
  public static String getFilePathFromUrl(Context context, Uri uri) {
    String path = null;
    String scheme = uri.getScheme();
    if (ContentResolver.SCHEME_CONTENT.equals(scheme)) {
      String projection[] = {
        ImageColumns.DATA,
      };
      Cursor c = context.getContentResolver().query(uri, projection, null, null, null);
      if (c != null && c.moveToFirst()) {
        path = c.getString(0);
      }
      if (c != null) c.close();
    } else if (ContentResolver.SCHEME_FILE.equals(scheme)) {
      path = uri.getPath();
    }

    return path;
  }
Beispiel #6
0
 public static String getPathFromUri(Context context, Uri uri) {
   String path = null;
   String uriScheme = uri.getScheme();
   if (ContentResolver.SCHEME_FILE.equals(uriScheme)) {
     path = uri.getSchemeSpecificPart();
   } else if (ContentResolver.SCHEME_CONTENT.equals(uriScheme)) {
     String[] projection = {MediaStore.Images.Media.DATA};
     Cursor cursor = context.getContentResolver().query(uri, projection, null, null, null);
     if (cursor != null) {
       if (cursor.moveToFirst()) {
         path = cursor.getString(0);
       }
       cursor.close();
     }
   } else {
     path = uri.getPath();
   }
   return path;
 }
 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;
     }
   }
 }
Beispiel #8
0
  /**
   * Fetch the file size from URI
   *
   * @param context Context
   * @param file URI
   * @return fileSize long
   * @throws IllegalArgumentException
   */
  public static long getFileSize(Context context, Uri file) throws IllegalArgumentException {
    Cursor cursor = null;
    try {
      cursor = context.getContentResolver().query(file, null, null, null, null);
      if (ContentResolver.SCHEME_CONTENT.equals(file.getScheme())) {
        if (cursor != null && cursor.moveToFirst()) {
          return Long.valueOf(cursor.getString(cursor.getColumnIndexOrThrow(OpenableColumns.SIZE)));
        } else {
          throw new IllegalArgumentException("Error in retrieving file size form the URI");
        }
      } else if (ContentResolver.SCHEME_FILE.equals(file.getScheme())) {
        return (new File(file.getPath())).length();
      }
      throw new IllegalArgumentException("Unsupported URI scheme");

    } finally {
      if (cursor != null) {
        cursor.close();
      }
    }
  }
Beispiel #9
0
  /**
   * Fetch the file name from URI
   *
   * @param context Context
   * @param file URI
   * @return fileName String
   * @throws IllegalArgumentException
   */
  public static String getFileName(Context context, Uri file) throws IllegalArgumentException {
    Cursor cursor = null;
    try {
      cursor = context.getContentResolver().query(file, null, null, null, null);
      if (ContentResolver.SCHEME_CONTENT.equals(file.getScheme())) {
        if (cursor != null && cursor.moveToFirst()) {
          return cursor.getString(cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME));
        } else {
          throw new IllegalArgumentException("Error in retrieving file name from the URI");
        }
      } else if (ContentResolver.SCHEME_FILE.equals(file.getScheme())) {
        return file.getLastPathSegment();
      }
      throw new IllegalArgumentException("Unsupported URI scheme");

    } finally {
      if (cursor != null) {
        cursor.close();
      }
    }
  }
Beispiel #10
0
 /** 通过Uri获得文件路径* */
 public static String getRealFilePath(final Context context, final Uri uri) {
   if (null == uri) return null;
   final String scheme = uri.getScheme();
   String data = null;
   if (scheme == null) data = uri.getPath();
   else if (ContentResolver.SCHEME_FILE.equals(scheme)) {
     data = uri.getPath();
   } else if (ContentResolver.SCHEME_CONTENT.equals(scheme)) {
     Cursor cursor =
         context
             .getContentResolver()
             .query(uri, new String[] {MediaStore.Images.ImageColumns.DATA}, null, null, null);
     if (null != cursor) {
       if (cursor.moveToFirst()) {
         int index = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
         if (index > -1) {
           data = cursor.getString(index);
         }
       }
       cursor.close();
     }
   }
   return data;
 }
  /**
   * Downloads a file form a given URL and saves it to the specified directory.
   *
   * @param source URL of the server to receive the file
   * @param target Full path of the file on the file system
   */
  private void download(
      final String source, final String target, JSONArray args, CallbackContext callbackContext)
      throws JSONException {
    Log.d(LOG_TAG, "download " + source + " to " + target);

    final boolean trustEveryone = args.optBoolean(2);
    final String objectId = args.getString(3);
    final JSONObject headers = args.optJSONObject(4);

    final URL url;
    try {
      url = new URL(source);
    } catch (MalformedURLException e) {
      JSONObject error = createFileTransferError(INVALID_URL_ERR, source, target, null, 0);
      Log.e(LOG_TAG, error.toString(), e);
      callbackContext.sendPluginResult(new PluginResult(PluginResult.Status.IO_EXCEPTION, error));
      return;
    }
    final String sourceProtocol = url.getProtocol();
    final boolean useHttps = "https".equals(sourceProtocol);
    final boolean useResolvers =
        ContentResolver.SCHEME_FILE.equals(sourceProtocol)
            || ContentResolver.SCHEME_CONTENT.equals(sourceProtocol)
            || ContentResolver.SCHEME_ANDROID_RESOURCE.equals(sourceProtocol);

    // TODO: refactor to also allow resources & content:
    if (!useResolvers && !Config.isUrlWhiteListed(source)) {
      Log.w(LOG_TAG, "Source URL is not in white list: '" + source + "'");
      JSONObject error = createFileTransferError(CONNECTION_ERR, source, target, null, 401);
      callbackContext.sendPluginResult(new PluginResult(PluginResult.Status.IO_EXCEPTION, error));
      return;
    }

    final RequestContext context = new RequestContext(source, target, callbackContext);
    synchronized (activeRequests) {
      activeRequests.put(objectId, context);
    }

    cordova
        .getThreadPool()
        .execute(
            new Runnable() {
              public void run() {
                if (context.aborted) {
                  return;
                }
                URLConnection connection = null;
                HostnameVerifier oldHostnameVerifier = null;
                SSLSocketFactory oldSocketFactory = null;
                File file = null;
                PluginResult result = null;

                try {
                  UriResolver sourceResolver = null;
                  UriResolver targetResolver = webView.resolveUri(Uri.parse(target));
                  TrackingInputStream inputStream = null;

                  file = targetResolver.getLocalFile();
                  context.targetFile = file;

                  Log.d(LOG_TAG, "Download file:" + url);

                  FileProgressResult progress = new FileProgressResult();

                  if (useResolvers) {
                    sourceResolver = webView.resolveUri(Uri.parse(source));
                    long len = sourceResolver.computeLength();
                    if (len != -1) {
                      progress.setLengthComputable(true);
                      progress.setTotal(len);
                    }
                    inputStream = new SimpleTrackingInputStream(sourceResolver.getInputStream());
                  } else {
                    // connect to server
                    // Open a HTTP connection to the URL based on protocol
                    if (useHttps) {
                      // Using standard HTTPS connection. Will not allow self signed certificate
                      if (!trustEveryone) {
                        connection = (HttpsURLConnection) httpClient.open(url);
                      }
                      // Use our HTTPS connection that blindly trusts everyone.
                      // This should only be used in debug environments
                      else {
                        // Setup the HTTPS connection class to trust everyone
                        HttpsURLConnection https = (HttpsURLConnection) httpClient.open(url);
                        oldSocketFactory = trustAllHosts(https);
                        // Save the current hostnameVerifier
                        oldHostnameVerifier = https.getHostnameVerifier();
                        // Setup the connection not to verify hostnames
                        https.setHostnameVerifier(DO_NOT_VERIFY);
                        connection = https;
                      }
                    }
                    // Return a standard HTTP connection
                    else {
                      connection = httpClient.open(url);
                    }

                    if (connection instanceof HttpURLConnection) {
                      ((HttpURLConnection) connection).setRequestMethod("GET");
                    }

                    // Add cookie support
                    String cookie = CookieManager.getInstance().getCookie(source);
                    if (cookie != null) {
                      connection.setRequestProperty("cookie", cookie);
                    }

                    // This must be explicitly set for gzip progress tracking to work.
                    connection.setRequestProperty("Accept-Encoding", "gzip");

                    // Handle the other headers
                    if (headers != null) {
                      addHeadersToRequest(connection, headers);
                    }

                    connection.connect();

                    if (connection.getContentEncoding() == null
                        || connection.getContentEncoding().equalsIgnoreCase("gzip")) {
                      // Only trust content-length header if we understand
                      // the encoding -- identity or gzip
                      progress.setLengthComputable(true);
                      progress.setTotal(connection.getContentLength());
                    }
                    inputStream = getInputStream(connection);
                  }

                  OutputStream outputStream = null;

                  try {
                    outputStream = targetResolver.getOutputStream();
                    synchronized (context) {
                      if (context.aborted) {
                        return;
                      }
                      context.currentInputStream = inputStream;
                    }

                    // write bytes to file
                    byte[] buffer = new byte[MAX_BUFFER_SIZE];
                    int bytesRead = 0;
                    while ((bytesRead = inputStream.read(buffer)) > 0) {
                      outputStream.write(buffer, 0, bytesRead);
                      // Send a progress event.
                      progress.setLoaded(inputStream.getTotalRawBytesRead());
                      PluginResult progressResult =
                          new PluginResult(PluginResult.Status.OK, progress.toJSONObject());
                      progressResult.setKeepCallback(true);
                      context.sendPluginResult(progressResult);
                    }
                  } finally {
                    context.currentInputStream = null;
                    safeClose(inputStream);
                    safeClose(outputStream);
                  }

                  Log.d(LOG_TAG, "Saved file: " + target);

                  // create FileEntry object
                  JSONObject fileEntry = FileUtils.getEntry(file);

                  result = new PluginResult(PluginResult.Status.OK, fileEntry);
                } catch (FileNotFoundException e) {
                  JSONObject error =
                      createFileTransferError(FILE_NOT_FOUND_ERR, source, target, connection);
                  Log.e(LOG_TAG, error.toString(), e);
                  result = new PluginResult(PluginResult.Status.IO_EXCEPTION, error);
                } catch (IOException e) {
                  JSONObject error =
                      createFileTransferError(CONNECTION_ERR, source, target, connection);
                  Log.e(LOG_TAG, error.toString(), e);
                  result = new PluginResult(PluginResult.Status.IO_EXCEPTION, error);
                } catch (JSONException e) {
                  Log.e(LOG_TAG, e.getMessage(), e);
                  result = new PluginResult(PluginResult.Status.JSON_EXCEPTION);
                } catch (Throwable e) {
                  JSONObject error =
                      createFileTransferError(CONNECTION_ERR, source, target, connection);
                  Log.e(LOG_TAG, error.toString(), e);
                  result = new PluginResult(PluginResult.Status.IO_EXCEPTION, error);
                } finally {
                  synchronized (activeRequests) {
                    activeRequests.remove(objectId);
                  }

                  if (connection != null) {
                    // Revert back to the proper verifier and socket factories
                    if (trustEveryone && useHttps) {
                      HttpsURLConnection https = (HttpsURLConnection) connection;
                      https.setHostnameVerifier(oldHostnameVerifier);
                      https.setSSLSocketFactory(oldSocketFactory);
                    }
                  }

                  if (result == null) {
                    result =
                        new PluginResult(
                            PluginResult.Status.ERROR,
                            createFileTransferError(CONNECTION_ERR, source, target, connection));
                  }
                  // Remove incomplete download.
                  if (result.getStatus() != PluginResult.Status.OK.ordinal() && file != null) {
                    file.delete();
                  }
                  context.sendPluginResult(result);
                }
              }
            });
  }
Beispiel #12
0
 private boolean isLocalUri(String scheme) {
   return ContentResolver.SCHEME_FILE.equals(scheme)
       || ContentResolver.SCHEME_CONTENT.equals(scheme)
       || ContentResolver.SCHEME_ANDROID_RESOURCE.equals(scheme);
 }
    @Override
    public void run() {
      try {
        final int BUF_SIZE = 100 * 1024;
        buf = new byte[BUF_SIZE];
        String scheme = u.getScheme();
        if (ContentResolver.SCHEME_CONTENT.equals(scheme)) {
          BitmapFactory.Options options = new BitmapFactory.Options();
          options.inTempStorage = buf;
          InputStream is = null;
          for (int b = 1; b < 0x80000; b <<= 1) {
            try {
              options.inSampleSize = b;
              is = getContentResolver().openInputStream(u);
              if (is == null) {
                Log.e(TAG, "Failed to get the content stream for: " + u);
                return;
              }
              bmp = BitmapFactory.decodeStream(is, null, options);
              if (bmp != null) return;
            } catch (Throwable e) {
            } finally {
              if (is != null) is.close();
            }
            Log.w(TAG, "Cant decode stream to bitmap. b=" + b);
          }
        } else {
          File f = null;
          setPriority(Thread.MAX_PRIORITY);
          boolean local = CA.isLocal(scheme);
          if (local) { // pre-cache in a file
            f = new File(u.getPath());
          } else {
            CommanderAdapter ca = null;
            FileOutputStream fos = null;
            InputStream is = null;
            try {
              ca = CA.CreateAdapterInstance(CA.GetAdapterTypeId(scheme), ctx);
              if (ca == null) return;
              Credentials crd = null;
              try {
                crd = (Credentials) getIntent().getParcelableExtra(Credentials.KEY);
              } catch (Exception e) {
                Log.e(TAG, "on taking credentials from parcel", e);
              }
              ca.setCredentials(crd);

              // output - temporary file
              File pictvw_f = ctx.getDir("pictvw", Context.MODE_PRIVATE);
              if (pictvw_f == null) return;
              f = new File(pictvw_f, "file.tmp");
              fos = new FileOutputStream(f);
              // input - the content from adapter
              is = ca.getContent(u);
              if (is == null) return;
              int n;
              boolean available_supported = is.available() > 0;
              while ((n = is.read(buf)) != -1) {
                // Log.v( "readStreamToBuffer", "Read " + n + " bytes" );
                // sendProgress( tot += n );
                Thread.sleep(1);
                fos.write(buf, 0, n);
                if (available_supported) {
                  for (int i = 0; i < 10; i++) {
                    if (is.available() > 0) break;
                    // Log.v( "readStreamToBuffer", "Waiting the rest " + i );
                    Thread.sleep(20);
                  }
                  if (is.available() == 0) {
                    // Log.v( "readStreamToBuffer", "No more data!" );
                    break;
                  }
                }
              }
            } catch (Throwable e) {
              throw e;
            } finally {
              if (ca != null) {
                if (is != null) ca.closeStream(is);
                ca.prepareToDestroy();
              }
              if (fos != null) fos.close();
            }
          }
          if (f != null) {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inTempStorage = buf;
            for (int b = 1; b < 0x80000; b <<= 1) {
              try {
                options.inSampleSize = b;
                bmp = BitmapFactory.decodeFile(f.getAbsolutePath(), options);
              } catch (Throwable e) {
              }
              if (bmp != null) {
                if (!local) f.delete();
                return;
              }
            }
          }
        }
      } catch (Throwable e) {
        Log.e(TAG, u != null ? u.toString() : null, e);
        msgText = e.getLocalizedMessage();
      } finally {
        sendProgress(-1);
      }
    }