Example usage for android.util Config LOGD

List of usage examples for android.util Config LOGD

Introduction

In this page you can find the example usage for android.util Config LOGD.

Prototype

boolean LOGD

To view the source code for android.util Config LOGD.

Click Source Link

Usage

From source file:com.tonchidot.nfc_contact_exchanger.lib.PictureUploader.java

private String doFileUploadJson(String url, String fileParamName, byte[] data) {
    try {/*from   w  w w.ja v a  2 s .  co m*/
        String boundary = "BOUNDARY" + new Date().getTime() + "BOUNDARY";
        String lineEnd = "\r\n";
        String twoHyphens = "--";

        URL connUrl = new URL(url);
        HttpURLConnection conn = (HttpURLConnection) connUrl.openConnection();
        conn.setDoInput(true);
        conn.setDoOutput(true);
        conn.setUseCaches(false);
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Connection", "Keep-Alive");
        conn.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + boundary);
        DataOutputStream dos = new DataOutputStream(conn.getOutputStream());
        dos.writeBytes(twoHyphens + boundary + lineEnd);
        dos.writeBytes("Content-Disposition: form-data; name=\"" + fileParamName + "\";filename=\"photo.jpg\""
                + lineEnd);
        dos.writeBytes(lineEnd);
        dos.write(data, 0, data.length);
        dos.writeBytes(lineEnd);
        dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd);
        dos.flush();
        dos.close();

        BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        StringBuilder result = new StringBuilder();
        String line;
        while ((line = rd.readLine()) != null) {
            result.append(line);
        }
        rd.close();
        return result.toString();
    } catch (IOException e) {
        if (Config.LOGD) {
            Log.d(TAG, "IOException : " + e);
        }
    }
    return null;
}

From source file:net.impjq.providers.downloads.DownloadThread.java

/**
 * Executes the download in a separate thread
 *///www.jav  a  2s.c om
public void run() {
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

    int finalStatus = Downloads.Impl.STATUS_UNKNOWN_ERROR;
    boolean countRetry = false;
    int retryAfter = 0;
    int redirectCount = mInfo.mRedirectCount;
    String newUri = null;
    boolean gotData = false;
    String filename = null;
    String mimeType = sanitizeMimeType(mInfo.mMimeType);
    FileOutputStream stream = null;
    AndroidHttpClient client = null;
    PowerManager.WakeLock wakeLock = null;
    Uri contentUri = Uri.parse(Downloads.Impl.CONTENT_URI + "/" + mInfo.mId);

    try {
        boolean continuingDownload = false;
        String headerAcceptRanges = null;
        String headerContentDisposition = null;
        String headerContentLength = null;
        String headerContentLocation = null;
        String headerETag = null;
        String headerTransferEncoding = null;

        byte data[] = new byte[Constants.BUFFER_SIZE];

        int bytesSoFar = 0;

        PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
        wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, Constants.TAG);
        wakeLock.acquire();

        filename = mInfo.mFileName;
        if (filename != null) {
            if (!Helpers.isFilenameValid(filename)) {
                finalStatus = Downloads.Impl.STATUS_FILE_ERROR;
                notifyDownloadCompleted(finalStatus, false, 0, 0, false, filename, null, mInfo.mMimeType);
                return;
            }
            // We're resuming a download that got interrupted
            File f = new File(filename);
            if (f.exists()) {
                long fileLength = f.length();
                if (fileLength == 0) {
                    // The download hadn't actually started, we can restart from scratch
                    f.delete();
                    filename = null;
                } else if (mInfo.mETag == null && !mInfo.mNoIntegrity) {
                    // Tough luck, that's not a resumable download
                    if (Config.LOGD) {
                        Log.d(Constants.TAG, "can't resume interrupted non-resumable download");
                    }
                    f.delete();
                    finalStatus = Downloads.Impl.STATUS_PRECONDITION_FAILED;
                    notifyDownloadCompleted(finalStatus, false, 0, 0, false, filename, null, mInfo.mMimeType);
                    return;
                } else {
                    // All right, we'll be able to resume this download
                    stream = new FileOutputStream(filename, true);
                    bytesSoFar = (int) fileLength;
                    if (mInfo.mTotalBytes != -1) {
                        headerContentLength = Integer.toString(mInfo.mTotalBytes);
                    }
                    headerETag = mInfo.mETag;
                    continuingDownload = true;
                }
            }
        }

        int bytesNotified = bytesSoFar;
        // starting with MIN_VALUE means that the first write will commit
        //     progress to the database
        long timeLastNotification = 0;

        client = AndroidHttpClient.newInstance(userAgent(), mContext);

        if (stream != null && mInfo.mDestination == Downloads.Impl.DESTINATION_EXTERNAL) {
            try {
                stream.close();
                stream = null;
            } catch (IOException ex) {
                if (Constants.LOGV) {
                    Log.v(Constants.TAG, "exception when closing the file before download : " + ex);
                }
                // nothing can really be done if the file can't be closed
            }
        }

        /*
         * This loop is run once for every individual HTTP request that gets sent.
         * The very first HTTP request is a "virgin" request, while every subsequent
         * request is done with the original ETag and a byte-range.
         */
        http_request_loop: while (true) {
            // Set or unset proxy, which may have changed since last GET request.
            // setDefaultProxy() supports null as proxy parameter.
            //Comment it,pjq,20110220,start
            //ConnRouteParams.setDefaultProxy(client.getParams(),
            //         Proxy.getPreferredHttpHost(mContext, mInfo.mUri));
            // Prepares the request and fires it.
            HttpGet request = new HttpGet(mInfo.mUri);

            if (Constants.LOGV) {
                Log.v(Constants.TAG, "initiating download for " + mInfo.mUri);
            }

            if (mInfo.mCookies != null) {
                request.addHeader("Cookie", mInfo.mCookies);
            }
            if (mInfo.mReferer != null) {
                request.addHeader("Referer", mInfo.mReferer);
            }
            if (continuingDownload) {
                if (headerETag != null) {
                    request.addHeader("If-Match", headerETag);
                }
                request.addHeader("Range", "bytes=" + bytesSoFar + "-");
            }

            HttpResponse response;
            try {
                response = client.execute(request);
            } catch (IllegalArgumentException ex) {
                if (Constants.LOGV) {
                    Log.d(Constants.TAG,
                            "Arg exception trying to execute request for " + mInfo.mUri + " : " + ex);
                } else if (Config.LOGD) {
                    Log.d(Constants.TAG,
                            "Arg exception trying to execute request for " + mInfo.mId + " : " + ex);
                }
                finalStatus = Downloads.Impl.STATUS_BAD_REQUEST;
                request.abort();
                break http_request_loop;
            } catch (IOException ex) {
                ex.printStackTrace();
                if (Constants.LOGX) {
                    if (Helpers.isNetworkAvailable(mContext)) {
                        Log.i(Constants.TAG, "Execute Failed " + mInfo.mId + ", Net Up");
                    } else {
                        Log.i(Constants.TAG, "Execute Failed " + mInfo.mId + ", Net Down");
                    }
                }
                if (!Helpers.isNetworkAvailable(mContext)) {
                    finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                } else if (mInfo.mNumFailed < Constants.MAX_RETRIES) {
                    finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                    countRetry = true;
                } else {
                    if (Constants.LOGV) {
                        Log.d(Constants.TAG,
                                "IOException trying to execute request for " + mInfo.mUri + " : " + ex);
                    } else if (Config.LOGD) {
                        Log.d(Constants.TAG,
                                "IOException trying to execute request for " + mInfo.mId + " : " + ex);
                    }
                    finalStatus = Downloads.Impl.STATUS_HTTP_DATA_ERROR;
                }
                request.abort();
                break http_request_loop;
            }

            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode == 503 && mInfo.mNumFailed < Constants.MAX_RETRIES) {
                if (Constants.LOGVV) {
                    Log.v(Constants.TAG, "got HTTP response code 503");
                }
                finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                countRetry = true;
                Header header = response.getFirstHeader("Retry-After");
                if (header != null) {
                    try {
                        if (Constants.LOGVV) {
                            Log.v(Constants.TAG, "Retry-After :" + header.getValue());
                        }
                        retryAfter = Integer.parseInt(header.getValue());
                        if (retryAfter < 0) {
                            retryAfter = 0;
                        } else {
                            if (retryAfter < Constants.MIN_RETRY_AFTER) {
                                retryAfter = Constants.MIN_RETRY_AFTER;
                            } else if (retryAfter > Constants.MAX_RETRY_AFTER) {
                                retryAfter = Constants.MAX_RETRY_AFTER;
                            }
                            retryAfter += Helpers.sRandom.nextInt(Constants.MIN_RETRY_AFTER + 1);
                            retryAfter *= 1000;
                        }
                    } catch (NumberFormatException ex) {
                        // ignored - retryAfter stays 0 in this case.
                    }
                }
                request.abort();
                break http_request_loop;
            }
            if (statusCode == 301 || statusCode == 302 || statusCode == 303 || statusCode == 307) {
                if (Constants.LOGVV) {
                    Log.v(Constants.TAG, "got HTTP redirect " + statusCode);
                }
                if (redirectCount >= Constants.MAX_REDIRECTS) {
                    if (Constants.LOGV) {
                        Log.d(Constants.TAG,
                                "too many redirects for download " + mInfo.mId + " at " + mInfo.mUri);
                    } else if (Config.LOGD) {
                        Log.d(Constants.TAG, "too many redirects for download " + mInfo.mId);
                    }
                    finalStatus = Downloads.Impl.STATUS_TOO_MANY_REDIRECTS;
                    request.abort();
                    break http_request_loop;
                }
                Header header = response.getFirstHeader("Location");
                if (header != null) {
                    if (Constants.LOGVV) {
                        Log.v(Constants.TAG, "Location :" + header.getValue());
                    }
                    try {
                        newUri = new URI(mInfo.mUri).resolve(new URI(header.getValue())).toString();
                    } catch (URISyntaxException ex) {
                        if (Constants.LOGV) {
                            Log.d(Constants.TAG, "Couldn't resolve redirect URI " + header.getValue() + " for "
                                    + mInfo.mUri);
                        } else if (Config.LOGD) {
                            Log.d(Constants.TAG, "Couldn't resolve redirect URI for download " + mInfo.mId);
                        }
                        finalStatus = Downloads.Impl.STATUS_BAD_REQUEST;
                        request.abort();
                        break http_request_loop;
                    }
                    ++redirectCount;
                    finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                    request.abort();
                    break http_request_loop;
                }
            }
            if ((!continuingDownload && statusCode != Downloads.Impl.STATUS_SUCCESS)
                    || (continuingDownload && statusCode != 206)) {
                if (Constants.LOGV) {
                    Log.d(Constants.TAG, "http error " + statusCode + " for " + mInfo.mUri);
                } else if (Config.LOGD) {
                    Log.d(Constants.TAG, "http error " + statusCode + " for download " + mInfo.mId);
                }
                if (Downloads.Impl.isStatusError(statusCode)) {
                    finalStatus = statusCode;
                } else if (statusCode >= 300 && statusCode < 400) {
                    finalStatus = Downloads.Impl.STATUS_UNHANDLED_REDIRECT;
                } else if (continuingDownload && statusCode == Downloads.Impl.STATUS_SUCCESS) {
                    finalStatus = Downloads.Impl.STATUS_PRECONDITION_FAILED;
                } else {
                    finalStatus = Downloads.Impl.STATUS_UNHANDLED_HTTP_CODE;
                }
                request.abort();
                break http_request_loop;
            } else {
                // Handles the response, saves the file
                if (Constants.LOGV) {
                    Log.v(Constants.TAG, "received response for " + mInfo.mUri);
                }

                if (!continuingDownload) {
                    Header header = response.getFirstHeader("Accept-Ranges");
                    if (header != null) {
                        headerAcceptRanges = header.getValue();
                    }
                    header = response.getFirstHeader("Content-Disposition");
                    if (header != null) {
                        headerContentDisposition = header.getValue();
                    }
                    header = response.getFirstHeader("Content-Location");
                    if (header != null) {
                        headerContentLocation = header.getValue();
                    }
                    if (mimeType == null) {
                        header = response.getFirstHeader("Content-Type");
                        if (header != null) {
                            mimeType = sanitizeMimeType(header.getValue());
                        }
                    }
                    header = response.getFirstHeader("ETag");
                    if (header != null) {
                        headerETag = header.getValue();
                    }
                    header = response.getFirstHeader("Transfer-Encoding");
                    if (header != null) {
                        headerTransferEncoding = header.getValue();
                    }
                    if (headerTransferEncoding == null) {
                        header = response.getFirstHeader("Content-Length");
                        if (header != null) {
                            headerContentLength = header.getValue();
                        }
                    } else {
                        // Ignore content-length with transfer-encoding - 2616 4.4 3
                        if (Constants.LOGVV) {
                            Log.v(Constants.TAG, "ignoring content-length because of xfer-encoding");
                        }
                    }
                    if (Constants.LOGVV) {
                        Log.v(Constants.TAG, "Accept-Ranges: " + headerAcceptRanges);
                        Log.v(Constants.TAG, "Content-Disposition: " + headerContentDisposition);
                        Log.v(Constants.TAG, "Content-Length: " + headerContentLength);
                        Log.v(Constants.TAG, "Content-Location: " + headerContentLocation);
                        Log.v(Constants.TAG, "Content-Type: " + mimeType);
                        Log.v(Constants.TAG, "ETag: " + headerETag);
                        Log.v(Constants.TAG, "Transfer-Encoding: " + headerTransferEncoding);
                    }

                    if (!mInfo.mNoIntegrity && headerContentLength == null && (headerTransferEncoding == null
                            || !headerTransferEncoding.equalsIgnoreCase("chunked"))) {
                        if (Config.LOGD) {
                            Log.d(Constants.TAG, "can't know size of download, giving up");
                        }
                        finalStatus = Downloads.Impl.STATUS_LENGTH_REQUIRED;
                        request.abort();
                        break http_request_loop;
                    }

                    DownloadFileInfo fileInfo = Helpers.generateSaveFile(mContext, mInfo.mUri, mInfo.mHint,
                            headerContentDisposition, headerContentLocation, mimeType, mInfo.mDestination,
                            (headerContentLength != null) ? Integer.parseInt(headerContentLength) : 0);
                    if (fileInfo.mFileName == null) {
                        finalStatus = fileInfo.mStatus;
                        request.abort();
                        break http_request_loop;
                    }
                    filename = fileInfo.mFileName;
                    stream = fileInfo.mStream;
                    if (Constants.LOGV) {
                        Log.v(Constants.TAG, "writing " + mInfo.mUri + " to " + filename);
                    }

                    ContentValues values = new ContentValues();
                    values.put(Downloads.Impl._DATA, filename);
                    if (headerETag != null) {
                        values.put(Constants.ETAG, headerETag);
                    }
                    if (mimeType != null) {
                        values.put(Downloads.Impl.COLUMN_MIME_TYPE, mimeType);
                    }
                    int contentLength = -1;
                    if (headerContentLength != null) {
                        contentLength = Integer.parseInt(headerContentLength);
                    }
                    values.put(Downloads.Impl.COLUMN_TOTAL_BYTES, contentLength);
                    mContext.getContentResolver().update(contentUri, values, null, null);
                }

                InputStream entityStream;
                try {
                    entityStream = response.getEntity().getContent();
                } catch (IOException ex) {
                    if (Constants.LOGX) {
                        if (Helpers.isNetworkAvailable(mContext)) {
                            Log.i(Constants.TAG, "Get Failed " + mInfo.mId + ", Net Up");
                        } else {
                            Log.i(Constants.TAG, "Get Failed " + mInfo.mId + ", Net Down");
                        }
                    }
                    if (!Helpers.isNetworkAvailable(mContext)) {
                        finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                    } else if (mInfo.mNumFailed < Constants.MAX_RETRIES) {
                        finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                        countRetry = true;
                    } else {
                        if (Constants.LOGV) {
                            Log.d(Constants.TAG, "IOException getting entity for " + mInfo.mUri + " : " + ex);
                        } else if (Config.LOGD) {
                            Log.d(Constants.TAG,
                                    "IOException getting entity for download " + mInfo.mId + " : " + ex);
                        }
                        finalStatus = Downloads.Impl.STATUS_HTTP_DATA_ERROR;
                    }
                    request.abort();
                    break http_request_loop;
                }
                for (;;) {
                    int bytesRead;
                    try {
                        bytesRead = entityStream.read(data);
                    } catch (IOException ex) {
                        if (Constants.LOGX) {
                            if (Helpers.isNetworkAvailable(mContext)) {
                                Log.i(Constants.TAG, "Read Failed " + mInfo.mId + ", Net Up");
                            } else {
                                Log.i(Constants.TAG, "Read Failed " + mInfo.mId + ", Net Down");
                            }
                        }
                        ContentValues values = new ContentValues();
                        values.put(Downloads.Impl.COLUMN_CURRENT_BYTES, bytesSoFar);
                        mContext.getContentResolver().update(contentUri, values, null, null);
                        if (!mInfo.mNoIntegrity && headerETag == null) {
                            if (Constants.LOGV) {
                                Log.v(Constants.TAG, "download IOException for " + mInfo.mUri + " : " + ex);
                            } else if (Config.LOGD) {
                                Log.d(Constants.TAG,
                                        "download IOException for download " + mInfo.mId + " : " + ex);
                            }
                            if (Config.LOGD) {
                                Log.d(Constants.TAG, "can't resume interrupted download with no ETag");
                            }
                            finalStatus = Downloads.Impl.STATUS_PRECONDITION_FAILED;
                        } else if (!Helpers.isNetworkAvailable(mContext)) {
                            finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                        } else if (mInfo.mNumFailed < Constants.MAX_RETRIES) {
                            finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                            countRetry = true;
                        } else {
                            if (Constants.LOGV) {
                                Log.v(Constants.TAG, "download IOException for " + mInfo.mUri + " : " + ex);
                            } else if (Config.LOGD) {
                                Log.d(Constants.TAG,
                                        "download IOException for download " + mInfo.mId + " : " + ex);
                            }
                            finalStatus = Downloads.Impl.STATUS_HTTP_DATA_ERROR;
                        }
                        request.abort();
                        break http_request_loop;
                    }
                    if (bytesRead == -1) { // success
                        ContentValues values = new ContentValues();
                        values.put(Downloads.Impl.COLUMN_CURRENT_BYTES, bytesSoFar);
                        if (headerContentLength == null) {
                            values.put(Downloads.Impl.COLUMN_TOTAL_BYTES, bytesSoFar);
                        }
                        mContext.getContentResolver().update(contentUri, values, null, null);
                        if ((headerContentLength != null)
                                && (bytesSoFar != Integer.parseInt(headerContentLength))) {
                            if (!mInfo.mNoIntegrity && headerETag == null) {
                                if (Constants.LOGV) {
                                    Log.d(Constants.TAG, "mismatched content length " + mInfo.mUri);
                                } else if (Config.LOGD) {
                                    Log.d(Constants.TAG, "mismatched content length for " + mInfo.mId);
                                }
                                finalStatus = Downloads.Impl.STATUS_LENGTH_REQUIRED;
                            } else if (!Helpers.isNetworkAvailable(mContext)) {
                                finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                            } else if (mInfo.mNumFailed < Constants.MAX_RETRIES) {
                                finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                                countRetry = true;
                            } else {
                                if (Constants.LOGV) {
                                    Log.v(Constants.TAG, "closed socket for " + mInfo.mUri);
                                } else if (Config.LOGD) {
                                    Log.d(Constants.TAG, "closed socket for download " + mInfo.mId);
                                }
                                finalStatus = Downloads.Impl.STATUS_HTTP_DATA_ERROR;
                            }
                            break http_request_loop;
                        }
                        break;
                    }
                    gotData = true;
                    for (;;) {
                        try {
                            if (stream == null) {
                                stream = new FileOutputStream(filename, true);
                            }
                            stream.write(data, 0, bytesRead);
                            if (mInfo.mDestination == Downloads.Impl.DESTINATION_EXTERNAL) {
                                try {
                                    stream.close();
                                    stream = null;
                                } catch (IOException ex) {
                                    if (Constants.LOGV) {
                                        Log.v(Constants.TAG,
                                                "exception when closing the file " + "during download : " + ex);
                                    }
                                    // nothing can really be done if the file can't be closed
                                }
                            }
                            break;
                        } catch (IOException ex) {
                            if (!Helpers.discardPurgeableFiles(mContext, Constants.BUFFER_SIZE)) {
                                finalStatus = Downloads.Impl.STATUS_FILE_ERROR;
                                break http_request_loop;
                            }
                        }
                    }
                    bytesSoFar += bytesRead;
                    long now = System.currentTimeMillis();
                    if (bytesSoFar - bytesNotified > Constants.MIN_PROGRESS_STEP
                            && now - timeLastNotification > Constants.MIN_PROGRESS_TIME) {
                        ContentValues values = new ContentValues();
                        values.put(Downloads.Impl.COLUMN_CURRENT_BYTES, bytesSoFar);
                        mContext.getContentResolver().update(contentUri, values, null, null);
                        bytesNotified = bytesSoFar;
                        timeLastNotification = now;
                    }

                    if (Constants.LOGVV) {
                        Log.v(Constants.TAG, "downloaded " + bytesSoFar + " for " + mInfo.mUri);
                    }
                    synchronized (mInfo) {
                        if (mInfo.mControl == Downloads.Impl.CONTROL_PAUSED) {
                            if (Constants.LOGV) {
                                Log.v(Constants.TAG, "paused " + mInfo.mUri);
                            }
                            finalStatus = Downloads.Impl.STATUS_RUNNING_PAUSED;
                            request.abort();
                            break http_request_loop;
                        }
                    }
                    if (mInfo.mStatus == Downloads.Impl.STATUS_CANCELED) {
                        if (Constants.LOGV) {
                            Log.d(Constants.TAG, "canceled " + mInfo.mUri);
                        } else if (Config.LOGD) {
                            // Log.d(Constants.TAG, "canceled id " + mInfo.mId);
                        }
                        finalStatus = Downloads.Impl.STATUS_CANCELED;
                        break http_request_loop;
                    }
                }
                if (Constants.LOGV) {
                    Log.v(Constants.TAG, "download completed for " + mInfo.mUri);
                }
                finalStatus = Downloads.Impl.STATUS_SUCCESS;
            }
            break;
        }
    } catch (FileNotFoundException ex) {
        if (Config.LOGD) {
            Log.d(Constants.TAG, "FileNotFoundException for " + filename + " : " + ex);
        }
        finalStatus = Downloads.Impl.STATUS_FILE_ERROR;
        // falls through to the code that reports an error
    } catch (RuntimeException ex) { //sometimes the socket code throws unchecked exceptions
        if (Constants.LOGV) {
            Log.d(Constants.TAG, "Exception for " + mInfo.mUri, ex);
        } else if (Config.LOGD) {
            Log.d(Constants.TAG, "Exception for id " + mInfo.mId, ex);
        }
        finalStatus = Downloads.Impl.STATUS_UNKNOWN_ERROR;
        // falls through to the code that reports an error
    } finally {
        mInfo.mHasActiveThread = false;
        if (wakeLock != null) {
            wakeLock.release();
            wakeLock = null;
        }
        if (client != null) {
            client.close();
            client = null;
        }
        try {
            // close the file
            if (stream != null) {
                stream.close();
            }
        } catch (IOException ex) {
            if (Constants.LOGV) {
                Log.v(Constants.TAG, "exception when closing the file after download : " + ex);
            }
            // nothing can really be done if the file can't be closed
        }
        if (filename != null) {
            // if the download wasn't successful, delete the file
            if (Downloads.Impl.isStatusError(finalStatus)) {
                new File(filename).delete();
                filename = null;
            } else if (Downloads.Impl.isStatusSuccess(finalStatus)) {
                //Comment it,pjq,20110220,start
                // transfer the file to the DRM content provider 
                // File file = new File(filename);
                // Intent item =
                // DrmStore.addDrmFile(mContext.getContentResolver(), file,
                // null);
                // if (item == null) {
                // Log.w(Constants.TAG, "unable to add file " + filename +
                // " to DrmProvider");
                // finalStatus = Downloads.Impl.STATUS_UNKNOWN_ERROR;
                // } else {
                // filename = item.getDataString();
                // mimeType = item.getType();
                // }
                //                    
                // file.delete();
            } else if (Downloads.Impl.isStatusSuccess(finalStatus)) {
                // make sure the file is readable
                //Comment it,pjq,20110220,start
                //FileUtils.setPermissions(filename, 0644, -1, -1);

                // Sync to storage after completion
                FileOutputStream downloadedFileStream = null;
                try {
                    downloadedFileStream = new FileOutputStream(filename, true);
                    downloadedFileStream.getFD().sync();
                } catch (FileNotFoundException ex) {
                    Log.w(Constants.TAG, "file " + filename + " not found: " + ex);
                } catch (SyncFailedException ex) {
                    Log.w(Constants.TAG, "file " + filename + " sync failed: " + ex);
                } catch (IOException ex) {
                    Log.w(Constants.TAG, "IOException trying to sync " + filename + ": " + ex);
                } catch (RuntimeException ex) {
                    Log.w(Constants.TAG, "exception while syncing file: ", ex);
                } finally {
                    if (downloadedFileStream != null) {
                        try {
                            downloadedFileStream.close();
                        } catch (IOException ex) {
                            Log.w(Constants.TAG, "IOException while closing synced file: ", ex);
                        } catch (RuntimeException ex) {
                            Log.w(Constants.TAG, "exception while closing file: ", ex);
                        }
                    }
                }
            }
        }
        notifyDownloadCompleted(finalStatus, countRetry, retryAfter, redirectCount, gotData, filename, newUri,
                mimeType);
    }
}

From source file:com.googlecode.talkingrssreader.talkingrss.ReaderHttp.java

public String login(String username, String password) throws ReaderException {
    if (Config.LOGD)
        Log.d(TAG, "Logging in");
    long startTime = SystemClock.uptimeMillis();
    ArrayList<NameValuePair> params = new ArrayList<NameValuePair>();
    params.add(new BasicNameValuePair("accountType", "HOSTED_OR_GOOGLE"));
    params.add(new BasicNameValuePair("Email", username));
    params.add(new BasicNameValuePair("Passwd", password));
    params.add(new BasicNameValuePair("service", "reader"));
    params.add(new BasicNameValuePair("source", AGENT_STRING));
    String reply;/*from  w  ww .j  a  v  a 2s .c  o  m*/
    try {
        reply = readAll(doPost(GOOGLE_LOGIN_URL, params, false));
    } catch (HttpForbiddenException e) {
        return null;
    }
    long now = SystemClock.uptimeMillis();
    if (Config.LOGD)
        Log.d(TAG, String.format("Login request took %dms", now - startTime));
    int index = reply.indexOf("Auth=");
    if (index > -1) {
        int end = reply.indexOf('\n', index);
        if (end > index + 5) {
            String authToken = reply.substring(index + 5, end);
            return authToken;
        }
    }
    throw new ProtocolException("Failed to parse login reply");
}

From source file:com.googlecode.talkingrssreader.talkingrss.ReaderHttp.java

public String getArticlesByTag(String tag, String[] exclude, int howMany, String continuation)
        throws ReaderException {
    // Escaping is unclear. Feed in the form http://blabla.com/bla
    // strangely mustn't be escaped, else they won't be
    // recognized. Spaces in user labels need %20 escaping, unclear
    // about other chars.
    if (tag.startsWith("user/") && tag.contains("/label/")) {
        int index = tag.lastIndexOf("/");
        if (index > 0 && index < tag.length() - 1) {
            String tip = tag.substring(index + 1);
            tip = urlEncode(tip).replace("+", "%20");
            tag = tag.substring(0, index + 1) + tip;
        }/*  ww  w  .  j a  va  2 s  .com*/
    }
    String url = ATOM_URL + tag;
    ArrayList<NameValuePair> params = new ArrayList<NameValuePair>();
    params.add(new BasicNameValuePair("n", String.valueOf(howMany)));
    if (continuation != null)
        params.add(new BasicNameValuePair("c", continuation));
    if (exclude != null) {
        for (String x : exclude) {
            params.add(new BasicNameValuePair("xt", x));
        }
    }
    long startTime = SystemClock.uptimeMillis();
    InputStream is = doGet(url, params);
    long readTime = SystemClock.uptimeMillis();
    String out = readAll(is);
    long now = SystemClock.uptimeMillis();
    if (Config.LOGD)
        Log.d(TAG, String.format("Article fetch: request took %dms, transferred %dbytes in %dms",
                readTime - startTime, out.length(), now - readTime));
    return out;
}

From source file:com.android.providers.contacts.ContactsSyncAdapter.java

@Override
public void getServerDiffs(SyncContext context, SyncData baseSyncData, SyncableContentProvider tempProvider,
        Bundle extras, Object syncInfo, SyncResult syncResult) {
    mPerformedGetServerDiffs = true;//from w ww  .  j ava2 s. c  om
    GDataSyncData syncData = (GDataSyncData) baseSyncData;

    ArrayList<String> feedsToSync = new ArrayList<String>();

    if (extras != null && extras.containsKey("feed")) {
        feedsToSync.add((String) extras.get("feed"));
    } else {
        feedsToSync.add(getGroupsFeedForAccount(getAccount()));
        addContactsFeedsToSync(getContext().getContentResolver(), getAccount(), feedsToSync);
        feedsToSync.add(getPhotosFeedForAccount(getAccount()));
    }

    for (String feed : feedsToSync) {
        context.setStatusText("Downloading\u2026");
        if (getPhotosFeedForAccount(getAccount()).equals(feed)) {
            getServerPhotos(context, feed, MAX_MEDIA_ENTRIES_PER_SYNC, syncData, syncResult);
        } else {
            final Class feedEntryClass = getFeedEntryClass(feed);
            if (feedEntryClass != null) {
                getServerDiffsImpl(context, tempProvider, feedEntryClass, feed, null, getMaxEntriesPerSync(),
                        syncData, syncResult);
            } else {
                if (Config.LOGD) {
                    Log.d(TAG, "ignoring sync request for unknown feed " + feed);
                }
            }
        }
        if (syncResult.hasError()) {
            break;
        }
    }
}

From source file:com.googlecode.talkingrssreader.talkingrss.ReaderHttp.java

public String getList(String list) throws ReaderException {
    String url = API_URL + list;
    ArrayList<NameValuePair> params = new ArrayList<NameValuePair>();
    params.add(new BasicNameValuePair("output", "xml"));
    //all=true/*  www .ja v  a 2 s  . c o  m*/
    long startTime = SystemClock.uptimeMillis();
    InputStream is = doGet(url, params);
    long readTime = SystemClock.uptimeMillis();
    String out = readAll(is);
    long now = SystemClock.uptimeMillis();
    if (Config.LOGD)
        Log.d(TAG, String.format("list fetch: request took %dms, transferred %dbytes in %dms",
                readTime - startTime, out.length(), now - readTime));
    return out;
}

From source file:com.googlecode.talkingrssreader.talkingrss.ReaderHttp.java

private void fetchApiToken() throws ReaderException {
    if (Config.LOGD)
        Log.d(TAG, "Fetching API token");
    apiToken = readAll(doGet(TOKEN_URL, null));
}

From source file:com.googlecode.talkingrssreader.talkingrss.ReaderHttp.java

private void doApiPost(String url, ArrayList<NameValuePair> params) throws ReaderException {
    long startTime = SystemClock.uptimeMillis();
    boolean do_retry = true;
    if (apiToken == null) {
        fetchApiToken();//from w  w w .j  a  v a  2  s .c o m
        do_retry = false;
    }
    try {
        checkApiOk(doPost(url, params, true));
    } catch (HttpException e) {
        if (do_retry && (e.code == HttpStatus.SC_BAD_REQUEST || e.code == HttpStatus.SC_UNAUTHORIZED)) {
            // Get a fresh token
            fetchApiToken();
            checkApiOk(doPost(url, params, true));
        } else {
            throw e;
        }
    }
    long now = SystemClock.uptimeMillis();
    if (Config.LOGD)
        Log.d(TAG, String.format("API request took %dms", now - startTime));
}

From source file:com.googlecode.talkingrssreader.talkingrss.ReaderHttp.java

public void subscribeFeed(String feedId, boolean add) throws ReaderException {
    String action = add ? "subscribe" : "unsubscribe";
    if (Config.LOGD)
        Log.d(TAG, String.format("%s feed: %s", action, feedId));
    if (!feedId.startsWith(FEED_PREFIX))
        throw new IllegalArgumentException();
    ArrayList<NameValuePair> params = new ArrayList<NameValuePair>();
    params.add(new BasicNameValuePair("s", feedId));
    params.add(new BasicNameValuePair("ac", action));
    doApiPost(SUBSCRIPTION_URL, params);
}

From source file:com.googlecode.talkingrssreader.talkingrss.ReaderHttp.java

public void tagItems(ArrayList<String> itemIds, String[] addTags, String[] removeTags) throws ReaderException {
    if (Config.LOGD)
        Log.d(TAG, "Tagging " + String.valueOf(itemIds.size()) + " items");
    ArrayList<NameValuePair> params = new ArrayList<NameValuePair>();
    for (String item : itemIds)
        params.add(new BasicNameValuePair("i", item));
    if (addTags != null) {
        for (String addTag : addTags) {
            params.add(new BasicNameValuePair("a", addTag));
        }//  w  w  w. ja va  2 s  .  com
    }
    if (removeTags != null) {
        for (String removeTag : removeTags) {
            params.add(new BasicNameValuePair("r", removeTag));
        }
    }
    params.add(new BasicNameValuePair("ac", "edit"));
    doApiPost(TAG_URL, params);
}