Example usage for org.json JSONArray optJSONObject

List of usage examples for org.json JSONArray optJSONObject

Introduction

In this page you can find the example usage for org.json JSONArray optJSONObject.

Prototype

public JSONObject optJSONObject(int index) 

Source Link

Document

Get the optional JSONObject associated with an index.

Usage

From source file:fr.cph.stock.android.entity.EntityBuilder.java

private List<Account> buildAccounts(JSONArray array) throws JSONException {
    List<Account> accounts = new ArrayList<Account>();
    boolean find = true;
    int i = 0;// w  w  w. j  a v a 2s . co  m
    JSONObject temp;
    while (find) {
        temp = array.optJSONObject(i);
        if (temp != null) {
            Account account = new Account();
            account.setId(temp.getString("id"));
            account.setCurrency(temp.getString("currency"));
            double liquidity = temp.getDouble("liquidity");
            account.setLiquidity(formatLocaleOne.format(liquidity));
            account.setName(temp.getString("name"));
            accounts.add(account);
            i++;
        } else {
            find = false;
        }
    }
    return accounts;
}

From source file:fr.cph.stock.android.entity.EntityBuilder.java

private List<ShareValue> buildShareValues(JSONArray array) throws JSONException {
    List<ShareValue> shareValues = new ArrayList<ShareValue>();
    boolean find = true;
    int i = 0;//from w  w w.java 2 s . co m
    JSONObject temp;
    while (find) {
        temp = array.optJSONObject(i);
        if (temp != null) {
            ShareValue sv = new ShareValue();
            sv.setAccount(temp.getString("account"));
            sv.setCommentary(temp.optString("commentary"));

            JSONObject dateSON = temp.getJSONObject("date");
            sv.setDate(extractDate(dateSON, user.getDatePatternWithoutHourMin()));

            double share = temp.getDouble("shareValue");
            sv.setShareValue(formatLocaleOne.format(share));
            if (share > 100) {
                sv.setUp(true);
            } else {
                sv.setUp(false);
            }

            sv.setPortfolioValue(formatCurrencyOne.format(temp.getDouble("portfolioValue")));
            sv.setShareQuantity(formatLocaleOne.format(temp.getDouble("shareQuantity")));
            sv.setMonthlyYield(formatCurrencyOne.format(temp.getDouble("monthlyYield")));

            shareValues.add(sv);
            i++;
        } else {
            find = false;
        }
    }
    return shareValues;
}

From source file:fr.cph.stock.android.entity.EntityBuilder.java

private List<Equity> buildEquities(JSONArray array) throws JSONException {
    List<Equity> equities = new ArrayList<Equity>();
    boolean find = true;
    int i = 0;/*  w  w w. j a v  a  2 s.co m*/
    JSONObject temp;

    while (find) {
        temp = array.optJSONObject(i);
        if (temp != null) {
            Equity e = new Equity();
            e.setName(temp.getString("name"));

            double unitCostPrice = temp.getDouble("unitCostPrice");
            e.setUnitCostPrice(formatLocaleTwo.format(unitCostPrice));

            e.setValue(formatLocaleZero.format(temp.getDouble("value")));
            double plusMinusValue = temp.getDouble("plusMinusValue");
            String plusMinusValueStr = formatLocaleOne.format(plusMinusValue) + "%";
            if (plusMinusValue > 0) {
                e.setPlusMinusValue("+" + plusMinusValueStr);
            } else {
                e.setPlusMinusValue(plusMinusValueStr);
            }
            e.setUp(plusMinusValue > 0 ? true : false);

            double quantity = temp.getDouble("quantity");
            e.setQuantity(formatLocaleOne.format(quantity));

            double yieldYear = temp.getDouble("yieldYear");
            e.setYieldYear(formatLocaleOne.format(yieldYear) + "%");

            double yieldUnitCostPrice = temp.getDouble("yieldUnitCostPrice");
            e.setYieldUnitCostPrice(formatLocaleOne.format(yieldUnitCostPrice) + "%");

            double quote = temp.getDouble("quote");
            e.setQuote(formatLocaleTwo.format(quote));

            double plusMinusUnitCostPriceValue = temp.getDouble("plusMinusUnitCostPriceValue");
            if (plusMinusValue > 0) {
                e.setPlusMinusUnitCostPriceValue("+" + formatLocaleZero.format(plusMinusUnitCostPriceValue));
            } else {
                e.setPlusMinusUnitCostPriceValue(formatLocaleZero.format(plusMinusUnitCostPriceValue));
            }
            Double variation = temp.optDouble("variation");
            if (!variation.isNaN()) {
                if (variation >= 0) {
                    e.setUpVariation(true);
                    e.setVariation("+" + formatLocaleTwo.format(variation) + "%");
                } else {
                    e.setUpVariation(false);
                    e.setVariation(formatLocaleTwo.format(variation) + "%");
                }
            } else {
                e.setUpVariation(true);
                e.setVariation("+0%");
            }
            equities.add(e);
            i++;
        } else {
            find = false;
        }
    }
    return equities;
}

From source file:weavebytes.com.futureerp.activities.DashBoardActivity.java

public void JsonParsing() {
    new AsyncTask<Void, Void, String>() {
        @Override//from w  w w . ja v a2  s  . c  o m
        protected void onPreExecute() {
            super.onPreExecute();
            progress.setMessage("Please Wait..");
            progress.setProgressStyle(ProgressDialog.STYLE_SPINNER);
            progress.setCancelable(true);
            progress.show();
        }

        @Override
        protected String doInBackground(Void... params) {

            if (isOnline()) {
                HttpClient httpClient = new DefaultHttpClient();
                HttpGet httpget = new HttpGet(Config.URL + Config.U_ID);
                HttpResponse response = null;
                try {
                    response = httpClient.execute(httpget);
                    //Converting Response To JsonString
                    return ConvertResponse_TO_JSON.entityToString(response.getEntity());
                } catch (ClientProtocolException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return "Bad Network";
            } else {
                return "Check Your Connection";
            }
        }

        @Override
        protected void onPostExecute(String JasonString) {
            try {
                progress.dismiss();

                try {
                    JSONArray JArray;
                    JArray = new JSONArray(JasonString);
                    for (int i = 0; i < JArray.length(); i++) {

                        JSONObject obj = JArray.optJSONObject(i);
                        String name = obj.optString("name").toString();
                        arrayList.add(name);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                MyAdapter myAdapter = new MyAdapter(DashBoardActivity.this, arrayList, Config.IMG_ID);
                list = (ListView) (findViewById(R.id.list));
                list.setAdapter(myAdapter);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }.execute();
}

From source file:synapticloop.b2.response.B2ListPartsResponse.java

public B2ListPartsResponse(String json) throws B2ApiException {
    super(json);//  w  ww .j  ava  2s. c  o m

    this.nextPartNumber = this.readInt(B2ResponseProperties.KEY_NEXT_PART_NUMBER);

    JSONArray filesArray = this.readObjects(B2ResponseProperties.KEY_PARTS);

    files = new ArrayList<B2UploadPartResponse>();
    for (int i = 0; i < filesArray.length(); i++) {
        files.add(new B2UploadPartResponse(filesArray.optJSONObject(i)));
    }

    this.warnOnMissedKeys();
}

From source file:com.company.project.core.connector.JSONHelper.java

public static JSONArray joinJSONArrays(JSONArray a, JSONArray b) {
    JSONArray comb = new JSONArray();
    for (int i = 0; i < a.length(); i++) {
        comb.put(a.optJSONObject(i));
    }//from w w w .j a  v  a2s  .c o  m
    for (int i = 0; i < b.length(); i++) {
        comb.put(b.optJSONObject(i));
    }
    return comb;
}

From source file:app.sunstreak.yourpisd.net.LoginDebugger.java

static void debug(String[] args)
        throws MalformedURLException, IOException, InterruptedException, ExecutionException, JSONException {
    if (args.length == 2) {
        mEmail = args[0];//from  w  w  w. ja  va2s .  com
        mPassword = args[1];
        System.out.println("|" + mEmail + "|" + mPassword + "|");
    } else {
        Scanner sc = new Scanner(System.in);
        System.out.print("Please enter username:\t");
        mEmail = sc.next();
        System.out.print("Please enter password:\t");
        mPassword = sc.next();
        sc.close();
    }

    session = Session.createSession(mEmail, mPassword);

    int loginSuccess = session.login();
    if (loginSuccess == 1)
        System.out.println("Successful login!");
    else {
        System.out.println("Login failed.");
        System.exit(-1);
    }

    session.tryLoginGradebook();

    for (Student st : session.getStudents()) {
        st.loadGradeSummary();

        for (int i = 0; i < 8; i++)
            System.out.println(st.getClassesForTerm(i));

        for (int i = 0; i < st.getClassMatch().length; i++) {
            System.out.printf("%20s",
                    st.getClassList().optJSONObject(st.getClassMatch()[i]).getString("title"));
            System.out.print("   ");
            JSONArray classGrade = st.getClassList().optJSONObject(st.getClassMatch()[i]).optJSONArray("terms");

            if (classGrade.optJSONObject(0).getString("description").equals("4th Six Weeks"))
                System.out.printf("%20s", "");

            for (int j = 0; j < classGrade.length(); j++) {
                int score = classGrade.optJSONObject(j).optInt("average", -1);
                System.out.printf("%5s", displayScore(score));
            }

            if (classGrade.length() == 4
                    && classGrade.optJSONObject(0).getString("description").equals("1st Six Weeks"))
                System.out.printf("%20s", "");

            System.out.printf("  S1:%5s", displayScore(
                    st.getClassList().optJSONObject(st.getClassMatch()[i]).optInt("firstSemesterAverage", -1)));
            System.out.printf("  S2:%5s\n", displayScore(st.getClassList().optJSONObject(st.getClassMatch()[i])
                    .optInt("secondSemesterAverage", -1)));
        }

        boolean attendanceLoaded = false;
        while (!attendanceLoaded) {
            try {
                st.loadAttendanceSummary();
                attendanceLoaded = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        /*
        String[] classNames = st.getAttendanceSummaryClassNames();
        int[][] attendanceSummary = st.getAttendanceSummary();
        for (int j = 0; j < Parser.AttendanceData.COLS.length; j++) {
           System.out.printf("%20s", "");
           System.out.printf("%5s", Parser.AttendanceData.COLS[j]);
           System.out.println();
        }
        for (int i = 0; i < classNames.length; i++) {
           System.out.printf("%20s", classNames[i]);
           for (int j = 0; j < attendanceSummary[i].length; j++) {
              System.out.printf("%5d", attendanceSummary[i][j]);
           }
           System.out.println();
        }
        */
    }
}

From source file:com.namelessdev.mpdroid.cover.SpotifyCover.java

private static List<String> extractAlbumIds(final String response) {
    final JSONObject jsonRoot;
    final JSONArray jsonAlbums;
    JSONObject jsonAlbum;/*from w  ww  . j a v  a  2 s.c o  m*/
    String albumId;
    final List<String> albumIds = new ArrayList<>();

    try {
        jsonRoot = new JSONObject(response);
        jsonAlbums = jsonRoot.optJSONArray("albums");
        if (jsonAlbums != null) {
            for (int a = 0; a < jsonAlbums.length(); a++) {
                jsonAlbum = jsonAlbums.optJSONObject(a);
                if (jsonAlbum != null) {
                    albumId = jsonAlbum.optString("href");
                    if (albumId != null && !albumId.isEmpty()) {
                        albumId = albumId.replace("spotify:album:", "");
                        albumIds.add(albumId);
                    }
                }
            }
        }
    } catch (final Exception e) {
        if (CoverManager.DEBUG) {
            Log.e(TAG, "Failed to get cover URL from Spotify.", e);
        }
    }

    return albumIds;
}

From source file:org.apache.cordova.filetransfer.FileTransfer.java

/**
 * 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
 *
 * 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
 *//*from w w  w .j a v a  2  s  .c  o m*/
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");

    final CordovaResourceApi resourceApi = webView.getResourceApi();

    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 Uri targetUri = resourceApi.remapUri(Uri.parse(target));
    // Accept a path or a URI for the source.
    Uri tmpSrc = Uri.parse(source);
    final Uri sourceUri = resourceApi
            .remapUri(tmpSrc.getScheme() != null ? tmpSrc : Uri.fromFile(new File(source)));

    int uriType = CordovaResourceApi.getUriType(targetUri);
    final boolean useHttps = uriType == CordovaResourceApi.URI_TYPE_HTTPS;
    if (uriType != CordovaResourceApi.URI_TYPE_HTTP && !useHttps) {
        JSONObject error = createFileTransferError(INVALID_URL_ERR, source, target, null, 0, null);
        Log.e(LOG_TAG, "Unsupported URI: " + targetUri);
        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 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
                conn = resourceApi.createHttpConnection(targetUri);
                if (useHttps && trustEveryone) {
                    // Setup the HTTPS connection class to trust everyone
                    HttpsURLConnection https = (HttpsURLConnection) conn;
                    oldSocketFactory = trustAllHosts(https);
                    // Save the current hostnameVerifier
                    oldHostnameVerifier = https.getHostnameVerifier();
                    // Setup the connection not to verify hostnames
                    https.setHostnameVerifier(DO_NOT_VERIFY);
                }

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

                // if we specified a Content-Type header, don't do multipart form upload
                boolean multipartFormUpload = (headers == null) || !headers.has("Content-Type");
                if (multipartFormUpload) {
                    conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + BOUNDARY);
                }

                // Set the cookies on the response
                String cookie = getCookies(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
                OpenForReadResult readResult = resourceApi.openForRead(sourceUri);

                int stringLength = beforeDataBytes.length + tailParamsBytes.length;
                if (readResult.length >= 0) {
                    fixedLength = (int) readResult.length;
                    if (multipartFormUpload)
                        fixedLength += 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.connection = conn;
                    }

                    if (multipartFormUpload) {
                        //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 = readResult.inputStream.available();
                    int bufferSize = Math.min(bytesAvailable, MAX_BUFFER_SIZE);
                    byte[] buffer = new byte[bufferSize];

                    // read file and write it into form...
                    int bytesRead = readResult.inputStream.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 = readResult.inputStream.available();
                        bufferSize = Math.min(bytesAvailable, MAX_BUFFER_SIZE);
                        bytesRead = readResult.inputStream.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);
                    }

                    if (multipartFormUpload) {
                        // send multipart form data necessary after file data...
                        sendStream.write(tailParamsBytes);
                        totalBytes += tailParamsBytes.length;
                    }
                    sendStream.flush();
                } finally {
                    safeClose(readResult.inputStream);
                    safeClose(sendStream);
                }
                synchronized (context) {
                    context.connection = 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.connection = conn;
                    }

                    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 {
                    synchronized (context) {
                        context.connection = 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, e);
                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, e);
                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, t);
                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);
                    }
                }
            }
        }
    });
}

From source file:org.apache.cordova.filetransfer.FileTransfer.java

/**
 * 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
 *///from ww  w .  j a va  2  s  . co  m
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 headers = args.optJSONObject(4);

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

                    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());
                            }
                        }
                        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;
                        outputStream = resourceApi.openOutputStream(targetUri);
                        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 {
                        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);
            }
        }
    });
}