Examples with OutputStream java.io.OutputStream used on opensource projects

Example 51 with OutputStream

use of java.io.OutputStream in project cordova-android-chromeview by thedracle.

the class FileTransfer method upload.

/**
     * 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
     */
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();
                // 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);
                    } else // Use our HTTPS connection that blindly trusts everyone.
                    // This should only be used in debug environments
                    {
                        // 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;
                    }
                } else // Return a standard HTTP connection
                {
                    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 = ChromeCookieManager.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 = getPathFromUri(source);
                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
                    if (trustEveryone && useHttps) {
                        HttpsURLConnection https = (HttpsURLConnection) conn;
                        https.setHostnameVerifier(oldHostnameVerifier);
                        https.setSSLSocketFactory(oldSocketFactory);
                    }
                }
            }
        }
    });
}

Example 52 with OutputStream

use of java.io.OutputStream in project bazel by bazelbuild.

the class WriteBuildInfoHeaderAction method newDeterministicWriter.

@Override
public DeterministicWriter newDeterministicWriter(ActionExecutionContext ctx) throws IOException {
    WorkspaceStatusAction.Context context = ctx.getExecutor().getContext(WorkspaceStatusAction.Context.class);
    final Map<String, WorkspaceStatusAction.Key> keys = new LinkedHashMap<>();
    if (writeVolatileInfo) {
        keys.putAll(context.getVolatileKeys());
    }
    if (writeStableInfo) {
        keys.putAll(context.getStableKeys());
    }
    final Map<String, String> values = new LinkedHashMap<>();
    for (Artifact valueFile : valueArtifacts) {
        values.putAll(WorkspaceStatusAction.parseValues(valueFile.getPath()));
    }
    final boolean redacted = valueArtifacts.isEmpty();
    return new DeterministicWriter() {

        @Override
        public void writeOutputFile(OutputStream out) throws IOException {
            Writer writer = new OutputStreamWriter(out, UTF_8);
            for (Map.Entry<String, WorkspaceStatusAction.Key> key : keys.entrySet()) {
                if (!key.getValue().isInLanguage("C++")) {
                    continue;
                }
                String value = redacted ? key.getValue().getRedactedValue() : values.containsKey(key.getKey()) ? values.get(key.getKey()) : key.getValue().getDefaultValue();
                switch(key.getValue().getType()) {
                    case VERBATIM:
                    case INTEGER:
                        break;
                    case STRING:
                        value = quote(value);
                        break;
                    default:
                        throw new IllegalStateException();
                }
                define(writer, key.getKey(), value);
            }
            writer.flush();
        }
    };
}

Example 53 with OutputStream

use of java.io.OutputStream in project bazel by bazelbuild.

the class DeprecationValidatorTest method deprecationWarningForSamePackageInDifferentRepository.

@Test
public void deprecationWarningForSamePackageInDifferentRepository() throws Exception {
    try (OutputStream output = scratch.resolve("WORKSPACE").getOutputStream(true)) {
        output.write("\nlocal_repository(name = 'r', path = '/r')\n".getBytes(StandardCharsets.UTF_8));
    }
    scratch.file("/r/WORKSPACE", "workspace(name = 'r')");
    scratch.file("/r/a/BUILD", "filegroup(name='b', deprecation='deprecation warning printed')");
    invalidatePackages();
    checkWarning("a", "a", "target '//a:a' depends on deprecated target '@r//a:b': deprecation warning printed", "filegroup(name='a', srcs=['@r//a:b'])");
}

Example 54 with OutputStream

use of java.io.OutputStream in project bazel by bazelbuild.

the class StubApplication method copy.

private static void copy(File src, File dst) throws IOException {
    Log.v("StubApplication", "Copying " + src + " -> " + dst);
    InputStream in = null;
    OutputStream out = null;
    try {
        in = new FileInputStream(src);
        out = new FileOutputStream(dst);
        // Transfer bytes from in to out
        byte[] buf = new byte[1048576];
        int len;
        while ((len = in.read(buf)) > 0) {
            out.write(buf, 0, len);
        }
    } finally {
        if (in != null) {
            in.close();
        }
        if (out != null) {
            out.close();
        }
    }
}

Example 55 with OutputStream

use of java.io.OutputStream in project glide by bumptech.

the class ReEncodingGifResourceEncoder method encodeTransformedToFile.

private boolean encodeTransformedToFile(GifDrawable drawable, File file) {
    long startTime = LogTime.getLogTime();
    OutputStream os = null;
    boolean success = false;
    try {
        os = new BufferedOutputStream(new FileOutputStream(file));
        success = encodeTransformedToStream(drawable, os);
        os.close();
    } catch (IOException e) {
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "Failed to encode GIF", e);
        }
    } finally {
        if (os != null) {
            try {
                os.close();
            } catch (IOException e) {
            // Ignored.
            }
        }
    }
    if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Log.v(TAG, "Re-encoded GIF with " + drawable.getFrameCount() + " frames and " + drawable.getBuffer().limit() + " bytes in " + LogTime.getElapsedMillis(startTime) + " ms");
    }
    return success;
}