Example #1
0
  /**
   * Executes the request and returns PluginResult.
   *
   * @param action The action to execute.
   * @param args JSONArry of arguments for the plugin.
   * @param callbackId The callback id used when calling back into JavaScript.
   * @return A PluginResult object with a status and message.
   */
  public PluginResult execute(String action, JSONArray args, String callbackId) {
    PluginResult.Status status = PluginResult.Status.OK;
    String result = "";

    try {
      if (action.equals("showWebPage")) {
        this.browserCallbackId = callbackId;

        // If the ChildBrowser is already open then throw an error
        if (dialog != null && dialog.isShowing()) {
          return new PluginResult(PluginResult.Status.ERROR, "ChildBrowser is already open");
        }

        result = this.showWebPage(args.getString(0), args.optJSONObject(1));

        if (result.length() > 0) {
          status = PluginResult.Status.ERROR;
          return new PluginResult(status, result);
        } else {
          PluginResult pluginResult = new PluginResult(status, result);
          pluginResult.setKeepCallback(true);
          return pluginResult;
        }
      } else if (action.equals("close")) {
        closeDialog();

        JSONObject obj = new JSONObject();
        obj.put("type", CLOSE_EVENT);

        PluginResult pluginResult = new PluginResult(status, obj);
        pluginResult.setKeepCallback(false);
        return pluginResult;
      } else if (action.equals("openExternal")) {
        result = this.openExternal(args.getString(0), args.optBoolean(1));
        if (result.length() > 0) {
          status = PluginResult.Status.ERROR;
        }
      } else {
        status = PluginResult.Status.INVALID_ACTION;
      }
      return new PluginResult(status, result);
    } catch (JSONException e) {
      return new PluginResult(PluginResult.Status.JSON_EXCEPTION);
    }
  }
  /**
   * 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);
                }
              }
            });
  }
  /**
   * Uploads the specified file to the server URL provided using an HTTP multipart request.
   *
   * @param source Full path of the file on the file system
   * @param target URL of the server to receive the file
   * @param args JSON Array of args
   * @param callbackContext callback id for optional progress reports
   *     <p>args[2] fileKey Name of file request parameter args[3] fileName File name to be used on
   *     server args[4] mimeType Describes file content type args[5] params key:value pairs of
   *     user-defined parameters
   * @return FileUploadResult containing result of upload request
   */
  private void upload(
      final String source, final String target, JSONArray args, CallbackContext callbackContext)
      throws JSONException {
    Log.d(LOG_TAG, "upload " + source + " to " + target);

    // Setup the options
    final String fileKey = getArgument(args, 2, "file");
    final String fileName = getArgument(args, 3, "image.jpg");
    final String mimeType = getArgument(args, 4, "image/jpeg");
    final JSONObject params =
        args.optJSONObject(5) == null ? new JSONObject() : args.optJSONObject(5);
    final boolean trustEveryone = args.optBoolean(6);
    // Always use chunked mode unless set to false as per API
    final boolean chunkedMode = args.optBoolean(7) || args.isNull(7);
    // Look for headers on the params map for backwards compatibility with older Cordova versions.
    final JSONObject headers =
        args.optJSONObject(8) == null ? params.optJSONObject("headers") : args.optJSONObject(8);
    final String objectId = args.getString(9);
    final String httpMethod = getArgument(args, 10, "POST");

    Log.d(LOG_TAG, "fileKey: " + fileKey);
    Log.d(LOG_TAG, "fileName: " + fileName);
    Log.d(LOG_TAG, "mimeType: " + mimeType);
    Log.d(LOG_TAG, "params: " + params);
    Log.d(LOG_TAG, "trustEveryone: " + trustEveryone);
    Log.d(LOG_TAG, "chunkedMode: " + chunkedMode);
    Log.d(LOG_TAG, "headers: " + headers);
    Log.d(LOG_TAG, "objectId: " + objectId);
    Log.d(LOG_TAG, "httpMethod: " + httpMethod);

    final URL url;
    try {
      url = new URL(target);
    } 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 boolean useHttps = url.getProtocol().equals("https");

    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;
                }
                HttpURLConnection conn = null;
                HostnameVerifier oldHostnameVerifier = null;
                SSLSocketFactory oldSocketFactory = null;
                int totalBytes = 0;
                int fixedLength = -1;
                try {
                  // Create return object
                  FileUploadResult result = new FileUploadResult();
                  FileProgressResult progress = new FileProgressResult();

                  // ------------------ CLIENT REQUEST
                  // Open a HTTP connection to the URL based on protocol
                  if (useHttps) {
                    // Using standard HTTPS connection. Will not allow self signed certificate
                    if (!trustEveryone) {
                      conn = (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);
                      conn = https;
                    }
                  }
                  // Return a standard HTTP connection
                  else {
                    conn = httpClient.open(url);
                  }

                  // Allow Inputs
                  conn.setDoInput(true);

                  // Allow Outputs
                  conn.setDoOutput(true);

                  // Don't use a cached copy.
                  conn.setUseCaches(false);

                  // Use a post method.
                  conn.setRequestMethod(httpMethod);
                  conn.setRequestProperty(
                      "Content-Type", "multipart/form-data;boundary=" + BOUNDARY);

                  // Set the cookies on the response
                  String cookie = CookieManager.getInstance().getCookie(target);
                  if (cookie != null) {
                    conn.setRequestProperty("Cookie", cookie);
                  }

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

                  /*
                   * Store the non-file portions of the multipart data as a string, so that we can add it
                   * to the contentSize, since it is part of the body of the HTTP request.
                   */
                  StringBuilder beforeData = new StringBuilder();
                  try {
                    for (Iterator<?> iter = params.keys(); iter.hasNext(); ) {
                      Object key = iter.next();
                      if (!String.valueOf(key).equals("headers")) {
                        beforeData.append(LINE_START).append(BOUNDARY).append(LINE_END);
                        beforeData
                            .append("Content-Disposition: form-data; name=\"")
                            .append(key.toString())
                            .append('"');
                        beforeData.append(LINE_END).append(LINE_END);
                        beforeData.append(params.getString(key.toString()));
                        beforeData.append(LINE_END);
                      }
                    }
                  } catch (JSONException e) {
                    Log.e(LOG_TAG, e.getMessage(), e);
                  }

                  beforeData.append(LINE_START).append(BOUNDARY).append(LINE_END);
                  beforeData
                      .append("Content-Disposition: form-data; name=\"")
                      .append(fileKey)
                      .append("\";");
                  beforeData.append(" filename=\"").append(fileName).append('"').append(LINE_END);
                  beforeData
                      .append("Content-Type: ")
                      .append(mimeType)
                      .append(LINE_END)
                      .append(LINE_END);
                  byte[] beforeDataBytes = beforeData.toString().getBytes("UTF-8");
                  byte[] tailParamsBytes =
                      (LINE_END + LINE_START + BOUNDARY + LINE_START + LINE_END).getBytes("UTF-8");

                  // Get a input stream of the file on the phone
                  InputStream sourceInputStream =
                      webView.resolveUri(Uri.parse(source)).getInputStream();

                  int stringLength = beforeDataBytes.length + tailParamsBytes.length;
                  if (sourceInputStream instanceof FileInputStream) {
                    fixedLength =
                        (int) ((FileInputStream) sourceInputStream).getChannel().size()
                            + stringLength;
                    progress.setLengthComputable(true);
                    progress.setTotal(fixedLength);
                  }
                  Log.d(LOG_TAG, "Content Length: " + fixedLength);
                  // setFixedLengthStreamingMode causes and OutOfMemoryException on pre-Froyo
                  // devices.
                  // http://code.google.com/p/android/issues/detail?id=3164
                  // It also causes OOM if HTTPS is used, even on newer devices.
                  boolean useChunkedMode =
                      chunkedMode
                          && (Build.VERSION.SDK_INT < Build.VERSION_CODES.FROYO || useHttps);
                  useChunkedMode = useChunkedMode || (fixedLength == -1);

                  if (useChunkedMode) {
                    conn.setChunkedStreamingMode(MAX_BUFFER_SIZE);
                    // Although setChunkedStreamingMode sets this header, setting it explicitly here
                    // works
                    // around an OutOfMemoryException when using https.
                    conn.setRequestProperty("Transfer-Encoding", "chunked");
                  } else {
                    conn.setFixedLengthStreamingMode(fixedLength);
                  }

                  conn.connect();

                  OutputStream sendStream = null;
                  try {
                    sendStream = conn.getOutputStream();
                    synchronized (context) {
                      if (context.aborted) {
                        return;
                      }
                      context.currentOutputStream = sendStream;
                    }
                    // We don't want to change encoding, we just want this to write for all Unicode.
                    sendStream.write(beforeDataBytes);
                    totalBytes += beforeDataBytes.length;

                    // create a buffer of maximum size
                    int bytesAvailable = sourceInputStream.available();
                    int bufferSize = Math.min(bytesAvailable, MAX_BUFFER_SIZE);
                    byte[] buffer = new byte[bufferSize];

                    // read file and write it into form...
                    int bytesRead = sourceInputStream.read(buffer, 0, bufferSize);

                    long prevBytesRead = 0;
                    while (bytesRead > 0) {
                      result.setBytesSent(totalBytes);
                      sendStream.write(buffer, 0, bytesRead);
                      totalBytes += bytesRead;
                      if (totalBytes > prevBytesRead + 102400) {
                        prevBytesRead = totalBytes;
                        Log.d(LOG_TAG, "Uploaded " + totalBytes + " of " + fixedLength + " bytes");
                      }
                      bytesAvailable = sourceInputStream.available();
                      bufferSize = Math.min(bytesAvailable, MAX_BUFFER_SIZE);
                      bytesRead = sourceInputStream.read(buffer, 0, bufferSize);

                      // Send a progress event.
                      progress.setLoaded(totalBytes);
                      PluginResult progressResult =
                          new PluginResult(PluginResult.Status.OK, progress.toJSONObject());
                      progressResult.setKeepCallback(true);
                      context.sendPluginResult(progressResult);
                    }

                    // send multipart form data necessary after file data...
                    sendStream.write(tailParamsBytes);
                    totalBytes += tailParamsBytes.length;
                    sendStream.flush();
                  } finally {
                    safeClose(sourceInputStream);
                    safeClose(sendStream);
                  }
                  context.currentOutputStream = null;
                  Log.d(LOG_TAG, "Sent " + totalBytes + " of " + fixedLength);

                  // ------------------ read the SERVER RESPONSE
                  String responseString;
                  int responseCode = conn.getResponseCode();
                  Log.d(LOG_TAG, "response code: " + responseCode);
                  Log.d(LOG_TAG, "response headers: " + conn.getHeaderFields());
                  TrackingInputStream inStream = null;
                  try {
                    inStream = getInputStream(conn);
                    synchronized (context) {
                      if (context.aborted) {
                        return;
                      }
                      context.currentInputStream = inStream;
                    }

                    ByteArrayOutputStream out =
                        new ByteArrayOutputStream(Math.max(1024, conn.getContentLength()));
                    byte[] buffer = new byte[1024];
                    int bytesRead = 0;
                    // write bytes to file
                    while ((bytesRead = inStream.read(buffer)) > 0) {
                      out.write(buffer, 0, bytesRead);
                    }
                    responseString = out.toString("UTF-8");
                  } finally {
                    context.currentInputStream = null;
                    safeClose(inStream);
                  }

                  Log.d(LOG_TAG, "got response from server");
                  Log.d(
                      LOG_TAG, responseString.substring(0, Math.min(256, responseString.length())));

                  // send request and retrieve response
                  result.setResponseCode(responseCode);
                  result.setResponse(responseString);

                  context.sendPluginResult(
                      new PluginResult(PluginResult.Status.OK, result.toJSONObject()));
                } catch (FileNotFoundException e) {
                  JSONObject error =
                      createFileTransferError(FILE_NOT_FOUND_ERR, source, target, conn);
                  Log.e(LOG_TAG, error.toString(), e);
                  context.sendPluginResult(
                      new PluginResult(PluginResult.Status.IO_EXCEPTION, error));
                } catch (IOException e) {
                  JSONObject error = createFileTransferError(CONNECTION_ERR, source, target, conn);
                  Log.e(LOG_TAG, error.toString(), e);
                  Log.e(
                      LOG_TAG,
                      "Failed after uploading " + totalBytes + " of " + fixedLength + " bytes.");
                  context.sendPluginResult(
                      new PluginResult(PluginResult.Status.IO_EXCEPTION, error));
                } catch (JSONException e) {
                  Log.e(LOG_TAG, e.getMessage(), e);
                  context.sendPluginResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
                } catch (Throwable t) {
                  // Shouldn't happen, but will
                  JSONObject error = createFileTransferError(CONNECTION_ERR, source, target, conn);
                  Log.e(LOG_TAG, error.toString(), t);
                  context.sendPluginResult(
                      new PluginResult(PluginResult.Status.IO_EXCEPTION, error));
                } finally {
                  synchronized (activeRequests) {
                    activeRequests.remove(objectId);
                  }

                  if (conn != null) {
                    // Revert back to the proper verifier and socket factories
                    // Revert back to the proper verifier and socket factories
                    if (trustEveryone && useHttps) {
                      HttpsURLConnection https = (HttpsURLConnection) conn;
                      https.setHostnameVerifier(oldHostnameVerifier);
                      https.setSSLSocketFactory(oldSocketFactory);
                    }
                  }
                }
              }
            });
  }
  @Override
  public boolean execute(String action, JSONArray args, final CallbackContext callbackContext)
      throws JSONException {

    this.cordova.setActivityResultCallback(this);
    this.callbackContext = callbackContext;

    if (action.equals("createAsync")) {

      // Don't catch JSONException since it is already handled by Cordova
      String authority = args.getString(0);
      // Due to
      // https://github.com/AzureAD/azure-activedirectory-library-for-android/blob/master/src/src/com/microsoft/aad/adal/AuthenticationContext.java#L158
      // AuthenticationContext constructor validates authority by default
      boolean validateAuthority = args.optBoolean(1, true);
      return createAsync(authority, validateAuthority);

    } else if (action.equals("acquireTokenAsync")) {

      String authority = args.getString(0);
      String resourceUrl = args.getString(1);
      String clientId = args.getString(2);
      String redirectUrl = args.getString(3);
      String userId = args.optString(4, null);
      userId = userId.equals("null") ? null : userId;
      String extraQueryParams = args.optString(5, null);
      extraQueryParams = extraQueryParams.equals("null") ? null : extraQueryParams;

      return acquireTokenAsync(
          authority, resourceUrl, clientId, redirectUrl, userId, extraQueryParams);

    } else if (action.equals("acquireTokenSilentAsync")) {

      String authority = args.getString(0);
      String resourceUrl = args.getString(1);
      String clientId = args.getString(2);
      String userId = args.getString(3);

      // This is a workaround for Cordova bridge issue. When null us passed from JS side
      // it is being translated to "null" string
      userId = userId.equals("null") ? null : userId;

      return acquireTokenSilentAsync(authority, resourceUrl, clientId, userId);

    } else if (action.equals("tokenCacheClear")) {

      String authority = args.getString(0);
      return clearTokenCache(authority);

    } else if (action.equals("tokenCacheReadItems")) {

      String authority = args.getString(0);
      return readTokenCacheItems(authority);

    } else if (action.equals("tokenCacheDeleteItem")) {

      String authority = args.getString(0);
      String itemAuthority = args.getString(1);
      String resource = args.getString(2);
      resource = resource.equals("null") ? null : resource;
      String clientId = args.getString(3);
      String userId = args.getString(4);
      boolean isMultipleResourceRefreshToken = args.getBoolean(5);

      return deleteTokenCacheItem(
          authority, itemAuthority, resource, clientId, userId, isMultipleResourceRefreshToken);
    }

    return false;
  }
  /**
   * 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 CordovaResourceApi resourceApi = webView.getResourceApi();

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

    final Uri sourceUri = resourceApi.remapUri(Uri.parse(source));
    // Accept a path or a URI for the source.
    Uri tmpTarget = Uri.parse(target);
    final Uri targetUri =
        resourceApi.remapUri(
            tmpTarget.getScheme() != null ? tmpTarget : Uri.fromFile(new File(target)));

    int uriType = CordovaResourceApi.getUriType(sourceUri);
    final boolean useHttps = uriType == CordovaResourceApi.URI_TYPE_HTTPS;
    final boolean isLocalTransfer = !useHttps && uriType != CordovaResourceApi.URI_TYPE_HTTP;
    if (uriType == CordovaResourceApi.URI_TYPE_UNKNOWN) {
      JSONObject error = createFileTransferError(INVALID_URL_ERR, source, target, null, 0, null);
      Log.e(LOG_TAG, "Unsupported URI: " + sourceUri);
      callbackContext.sendPluginResult(new PluginResult(PluginResult.Status.IO_EXCEPTION, error));
      return;
    }

    /* This code exists for compatibility between 3.x and 4.x versions of Cordova.
     * Previously the CordovaWebView class had a method, getWhitelist, which would
     * return a Whitelist object. Since the fixed whitelist is removed in Cordova 4.x,
     * the correct call now is to shouldAllowRequest from the plugin manager.
     */
    Boolean shouldAllowRequest = null;
    if (isLocalTransfer) {
      shouldAllowRequest = true;
    }
    if (shouldAllowRequest == null) {
      try {
        Method gwl = webView.getClass().getMethod("getWhitelist");
        Whitelist whitelist = (Whitelist) gwl.invoke(webView);
        shouldAllowRequest = whitelist.isUrlWhiteListed(source);
      } catch (NoSuchMethodException e) {
      } catch (IllegalAccessException e) {
      } catch (InvocationTargetException e) {
      }
    }
    if (shouldAllowRequest == null) {
      try {
        Method gpm = webView.getClass().getMethod("getPluginManager");
        PluginManager pm = (PluginManager) gpm.invoke(webView);
        Method san = pm.getClass().getMethod("shouldAllowRequest", String.class);
        shouldAllowRequest = (Boolean) san.invoke(pm, source);
      } catch (NoSuchMethodException e) {
      } catch (IllegalAccessException e) {
      } catch (InvocationTargetException e) {
      }
    }

    if (!Boolean.TRUE.equals(shouldAllowRequest)) {
      Log.w(LOG_TAG, "Source URL is not in white list: '" + source + "'");
      JSONObject error = createFileTransferError(CONNECTION_ERR, source, target, null, 401, null);
      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;
                }
                HttpURLConnection connection = null;
                HostnameVerifier oldHostnameVerifier = null;
                SSLSocketFactory oldSocketFactory = null;
                File file = null;
                Long downloaded = 0L;
                PluginResult result = null;
                TrackingInputStream inputStream = null;
                boolean cached = false;

                OutputStream outputStream = null;
                try {
                  OpenForReadResult readResult = null;

                  file = resourceApi.mapUriToFile(targetUri);
                  context.targetFile = file;

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

                  FileProgressResult progress = new FileProgressResult();

                  if (isLocalTransfer) {
                    readResult = resourceApi.openForRead(sourceUri);
                    if (readResult.length != -1) {
                      progress.setLengthComputable(true);
                      progress.setTotal(readResult.length);
                    } else {
                      progress.setLengthComputable(false);
                      progress.setTotal(-1);
                    }
                    inputStream = new SimpleTrackingInputStream(readResult.inputStream);
                  } else {
                    // connect to server
                    // Open a HTTP connection to the URL based on protocol
                    connection = resourceApi.createHttpConnection(sourceUri);
                    if (useHttps && trustEveryone) {
                      // Setup the HTTPS connection class to trust everyone
                      HttpsURLConnection https = (HttpsURLConnection) connection;
                      oldSocketFactory = trustAllHosts(https);
                      // Save the current hostnameVerifier
                      oldHostnameVerifier = https.getHostnameVerifier();
                      // Setup the connection not to verify hostnames
                      https.setHostnameVerifier(DO_NOT_VERIFY);
                    }

                    connection.setRequestMethod("GET");

                    // TODO: Make OkHttp use this CookieManager by default.
                    String cookie = getCookies(sourceUri.toString());

                    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);
                    }

                    if (options.getBoolean("resume") && file.exists()) {
                      downloaded = file.length();
                      connection.setRequestProperty("Range", "bytes=" + downloaded + "-");
                    }

                    connection.connect();
                    if (connection.getResponseCode() == HttpURLConnection.HTTP_NOT_MODIFIED) {
                      cached = true;
                      connection.disconnect();
                      Log.d(LOG_TAG, "Resource not modified: " + source);
                      JSONObject error =
                          createFileTransferError(
                              NOT_MODIFIED_ERR, source, target, connection, null);
                      result = new PluginResult(PluginResult.Status.ERROR, error);
                    } else {
                      if (connection.getContentEncoding() == null
                          || connection.getContentEncoding().equalsIgnoreCase("gzip")) {
                        // Only trust content-length header if we understand
                        // the encoding -- identity or gzip
                        if (connection.getContentLength() != -1) {
                          progress.setLengthComputable(true);
                          progress.setTotal(connection.getContentLength() + downloaded);
                        } else {
                          progress.setLengthComputable(false);
                          progress.setTotal(-1);
                        }
                      }
                      inputStream = getInputStream(connection);
                    }
                  }

                  if (!cached) {
                    try {
                      synchronized (context) {
                        if (context.aborted) {
                          return;
                        }
                        context.connection = connection;
                      }

                      // write bytes to file
                      byte[] buffer = new byte[MAX_BUFFER_SIZE];
                      int bytesRead = 0;
                      boolean append = downloaded > 0;
                      outputStream = resourceApi.openOutputStream(targetUri, append);
                      while ((bytesRead = inputStream.read(buffer)) > 0) {
                        outputStream.write(buffer, 0, bytesRead);
                        // Send a progress event.
                        progress.setLoaded(inputStream.getTotalRawBytesRead() + downloaded);
                        PluginResult progressResult =
                            new PluginResult(PluginResult.Status.OK, progress.toJSONObject());
                        progressResult.setKeepCallback(true);
                        context.sendPluginResult(progressResult);
                      }
                    } catch (IOException e) {
                      outputStream.flush();
                    } finally {
                      synchronized (context) {
                        context.connection = null;
                      }
                      safeClose(inputStream);
                      safeClose(outputStream);
                    }

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

                    // create FileEntry object
                    Class webViewClass = webView.getClass();
                    PluginManager pm = null;
                    try {
                      Method gpm = webViewClass.getMethod("getPluginManager");
                      pm = (PluginManager) gpm.invoke(webView);
                    } catch (NoSuchMethodException e) {
                    } catch (IllegalAccessException e) {
                    } catch (InvocationTargetException e) {
                    }
                    if (pm == null) {
                      try {
                        Field pmf = webViewClass.getField("pluginManager");
                        pm = (PluginManager) pmf.get(webView);
                      } catch (NoSuchFieldException e) {
                      } catch (IllegalAccessException e) {
                      }
                    }
                    file = resourceApi.mapUriToFile(targetUri);
                    context.targetFile = file;
                    FileUtils filePlugin = (FileUtils) pm.getPlugin("File");
                    if (filePlugin != null) {
                      JSONObject fileEntry = filePlugin.getEntryForFile(file);
                      if (fileEntry != null) {
                        result = new PluginResult(PluginResult.Status.OK, fileEntry);
                      } else {
                        JSONObject error =
                            createFileTransferError(
                                CONNECTION_ERR, source, target, connection, null);
                        Log.e(LOG_TAG, "File plugin cannot represent download path");
                        result = new PluginResult(PluginResult.Status.IO_EXCEPTION, error);
                      }
                    } else {
                      Log.e(LOG_TAG, "File plugin not found; cannot save downloaded file");
                      result =
                          new PluginResult(
                              PluginResult.Status.ERROR,
                              "File plugin not found; cannot save downloaded file");
                    }
                  }
                } catch (FileNotFoundException e) {
                  JSONObject error =
                      createFileTransferError(FILE_NOT_FOUND_ERR, source, target, connection, e);
                  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, e);
                  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, e);
                  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, null));
                  }
                  // Remove incomplete download.
                  if (!cached
                      && result.getStatus() != PluginResult.Status.OK.ordinal()
                      && file != null) {
                    file.delete();
                  }
                  context.sendPluginResult(result);
                }
              }
            });
  }
Example #6
0
 public boolean optBoolean(int index) {
   return baseArgs.optBoolean(index);
 }