Java tutorial
/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.xianzhi.tool.web.img; import java.io.FilterInputStream; import java.io.IOException; import java.io.InputStream; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.AbstractHttpClient; import com.xianzhi.webtool.HttpJsonTool; import com.xianzhi.webtool.HttpsClient; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.net.ConnectivityManager; import android.net.NetworkInfo; import android.net.http.AndroidHttpClient; import android.util.Log; import android.widget.Toast; /** * A simple subclass of {@link ImageResizer} that fetches and resizes images fetched from a URL. */ public class ImageFetcher extends ImageResizer { private static final String TAG = "ImageFetcher"; // private static final int HTTP_CACHE_SIZE = 10 * 1024 * 1024; // 10MB // public static final String HTTP_CACHE_DIR = "http"; /** * Initialize providing a target image width and height for the processing images. * * @param context * @param imageWidth * @param imageHeight */ public ImageFetcher(Context context, int imageWidth, int imageHeight) { super(context, imageWidth, imageHeight); init(context); } /** * Initialize providing a single target image size (used for both width and height); * * @param context * @param imageSize */ public ImageFetcher(Context context, int imageSize) { super(context, imageSize); init(context); } private void init(Context context) { checkConnection(context); } /** * Simple network connection check. * * @param context */ private void checkConnection(Context context) { final ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); final NetworkInfo networkInfo = cm.getActiveNetworkInfo(); if (networkInfo == null || !networkInfo.isConnectedOrConnecting()) { Toast.makeText(context, "No network connection found.", Toast.LENGTH_LONG).show(); Log.e(TAG, "checkConnection - no connection found"); } } /** * The main process method, which will be called by the ImageWorker in the AsyncTask background * thread. * * @param data The data to load the bitmap, in this case, a regular http URL * @return The downloaded and resized bitmap */ private Bitmap processBitmap(String url) { Bitmap bitmap = null; // AndroidHttpClient is not allowed to be used from the main thread final HttpClient client = HttpsClient.getInstance().getHttpsClient(); if (HttpJsonTool.cookieInfo != null) { ((AbstractHttpClient) client).setCookieStore(HttpJsonTool.cookieInfo); } final HttpGet getRequest = new HttpGet(url); try { HttpResponse response = client.execute(getRequest); final int statusCode = response.getStatusLine().getStatusCode(); if (statusCode != HttpStatus.SC_OK) { Log.w("ImageDownloader", "Error " + statusCode + " while retrieving bitmap from " + url); return null; } final HttpEntity entity = response.getEntity(); if (entity != null) { InputStream inputStream = entity.getContent(); try { bitmap = BitmapFactory.decodeStream(new FlushedInputStream(inputStream)); } catch (OutOfMemoryError e) { BitmapFactory.Options options = new BitmapFactory.Options(); options.inSampleSize = 3; bitmap = BitmapFactory.decodeStream(new FlushedInputStream(inputStream), null, options); } finally { if (inputStream != null) { inputStream.close(); inputStream = null; } entity.consumeContent(); } } return bitmap; } catch (IOException e) { getRequest.abort(); Log.w("LOG_TAG", "I/O error while retrieving bitmap from " + url, e); } catch (IllegalStateException e) { getRequest.abort(); Log.w("LOG_TAG", "Incorrect URL: " + url); } catch (Exception e) { getRequest.abort(); Log.w("LOG_TAG", "Error while retrieving bitmap from " + url, e); } finally { if ((client instanceof AndroidHttpClient)) { ((AndroidHttpClient) client).close(); } } return null; } static class FlushedInputStream extends FilterInputStream { public FlushedInputStream(InputStream inputStream) { super(inputStream); } @Override public long skip(long n) throws IOException { Log.i("" + n, ""); long totalBytesSkipped = 0L; while (totalBytesSkipped < n) { long bytesSkipped = in.skip(n - totalBytesSkipped); if (bytesSkipped == 0L) { int b = read(); if (b < 0) { break; // we reached EOF } else { bytesSkipped = 1; // we read one byte } } totalBytesSkipped += bytesSkipped; } return totalBytesSkipped; } } /* private Bitmap processBitmap(String data) { if (BuildConfig.DEBUG) { // Log.d(TAG, "processBitmap - " + data); } // Download a bitmap, write it to a file final File f = downloadBitmap(mContext, data); if (f != null) { // Return a sampled down version return decodeSampledBitmapFromFile(f.toString(), mImageWidth, mImageHeight); } return null; }*/ @Override protected Bitmap processBitmap(Object data) { return processBitmap(String.valueOf(data)); } /** * Download a bitmap from a URL, write it to a disk and return the File pointer. This * implementation uses a simple disk cache. * * @param context The context to use * @param urlString The URL to fetch * @return A File pointing to the fetched bitmap */ /* public static File downloadBitmap(Context context, String urlString) { final File cacheDir = DiskLruCache.getDiskCacheDir(context, HTTP_CACHE_DIR); final DiskLruCache cache = DiskLruCache.openCache(context, cacheDir, HTTP_CACHE_SIZE); final File cacheFile = new File(cache.createFilePath(urlString)); if (cache.containsKey(urlString)) { if (BuildConfig.DEBUG) { Log.d(TAG, "downloadBitmap - found in http cache - " + urlString); } return cacheFile; } if (BuildConfig.DEBUG) { Log.d(TAG, "downloadBitmap - downloading - " + urlString); } Utils.disableConnectionReuseIfNecessary(); HttpURLConnection urlConnection = null; BufferedOutputStream out = null; try { final URL url = new URL(urlString); urlConnection = (HttpURLConnection) url.openConnection(); final InputStream in = new BufferedInputStream(urlConnection.getInputStream(), Utils.IO_BUFFER_SIZE); out = new BufferedOutputStream(new FileOutputStream(cacheFile), Utils.IO_BUFFER_SIZE); int b; while ((b = in.read()) != -1) { out.write(b); } return cacheFile; } catch (final IOException e) { Log.e(TAG, "Error in downloadBitmap - " + e); } finally { if (urlConnection != null) { urlConnection.disconnect(); } if (out != null) { try { out.close(); } catch (final IOException e) { Log.e(TAG, "Error in downloadBitmap - " + e); } } } return null; }*/ }