Code example for Uri

Methods: getPath, getScheme, toString

0
		InputStream stream = openInputStream( context, uri );
		if ( null == stream ) {
			return null; 
		} 
		 
		int orientation = ExifUtils.getExifOrientation( context, uri );
 
		Bitmap bitmap = null;
		int[] imageSize = new int[2];
		final boolean decoded = decodeImageBounds( stream, imageSize );
		IOUtils.closeSilently( stream );
 
		if ( decoded ) {
			int sampleSize;
			if( maxW < 0 || maxH < 0 ) {
				sampleSize = 1;
			} else { 
				sampleSize = computeSampleSize( imageSize[0], imageSize[1], (int) ( maxW * 1.2 ), (int) ( maxH * 1.2 ), orientation );
			} 
 
			BitmapFactory.Options options = getDefaultOptions();
			options.inSampleSize = sampleSize;
 
			bitmap = decodeBitmap( context, uri, options, maxW, maxH, orientation, 0 );
		} 
 
		return bitmap;
	} 
 
	static Bitmap decodeBitmap( Context context, Uri uri, BitmapFactory.Options options, int maxW, int maxH,
			int orientation, int pass ) {
 
		Bitmap bitmap = null;
		Bitmap newBitmap = null;
 
 
		if ( pass > 20 ) {
			return null; 
		} 
 
		InputStream stream = openInputStream( context, uri );
		if( null == stream ) return null;
		 
		try { 
			// decode the bitmap via android BitmapFactory 
			bitmap = BitmapFactory.decodeStream( stream, null, options );
			IOUtils.closeSilently( stream );
 
			if ( bitmap != null ) {
				if( maxW > 0 && maxH > 0 ) {
					newBitmap = BitmapUtils.resizeBitmap( bitmap, maxW, maxH, orientation );
					if ( bitmap != newBitmap ) {
						bitmap.recycle();
					} 
					bitmap = newBitmap;
				} 
			} 
 
		} catch ( OutOfMemoryError error ) {
			IOUtils.closeSilently( stream );
			if ( null != bitmap ) {
				bitmap.recycle();
			} 
			options.inSampleSize += 1;
			bitmap = decodeBitmap( context, uri, options, maxW, maxH, orientation, pass + 1 );
		} 
		return bitmap;
 
	} 
 
	/** 
	 * Return an {@link InputStream} from the given uri. ( can be a local content, a file path or an http url ) 
	 *  
	 * @param context 
	 * @param uri 
	 * @return the {@link InputStream} from the given uri, null if uri cannot be opened 
	 */ 
	public static InputStream openInputStream( Context context, Uri uri ) {
		if ( null == uri ) return null;
		final String scheme = uri.getScheme();
		InputStream stream = null;
		if ( scheme == null || ContentResolver.SCHEME_FILE.equals( scheme ) ) {
			// from file 
			stream = openFileInputStream( uri.getPath() );
		} else if ( ContentResolver.SCHEME_CONTENT.equals( scheme ) ) {
			// from content 
			stream = openContentInputStream( context, uri );
		} else if ( "http".equals( scheme ) || "https".equals( scheme ) ) {
			// from remote uri 
			stream = openRemoteInputStream( uri );
		} 
		return stream;
	} 
 
	public static boolean decodeImageBounds( final InputStream stream, int[] outSize ) {
		BitmapFactory.Options options = new BitmapFactory.Options();
		options.inJustDecodeBounds = true;
		BitmapFactory.decodeStream( stream, null, options );
		if ( options.outHeight > 0 && options.outWidth > 0 ) {
			outSize[0] = options.outWidth;
			outSize[1] = options.outHeight;
			return true; 
		} 
		return false; 
	} 
 
	private static int computeSampleSize( final int bitmapW, final int bitmapH, final int maxW, final int maxH,
			final int orientation ) {
		double w, h;
 
		if ( orientation == 0 || orientation == 180 ) {
			w = bitmapW;
			h = bitmapH;
		} else { 
			w = bitmapH;
			h = bitmapW;
		} 
 
		final int sampleSize = (int) Math.ceil( Math.max( w / maxW, h / maxH ) );
		return sampleSize;
	} 
 
	/** 
	 * Return a {@link FileInputStream} from the given path or null if file not found 
	 *  
	 * @param path 
	 *           the file path 
	 * @return the {@link FileInputStream} of the given path, null if {@link FileNotFoundException} is thrown 
	 */ 
	static InputStream openFileInputStream( String path ) {
		try { 
			return new FileInputStream( path );
		} catch ( FileNotFoundException e ) {
			e.printStackTrace();
		} 
		return null; 
	} 
 
	/** 
	 * Return a {@link BufferedInputStream} from the given uri or null if an exception is thrown 
	 *  
	 * @param context 
	 * @param uri 
	 * @return the {@link InputStream} of the given path. null if file is not found 
	 */ 
	static InputStream openContentInputStream( Context context, Uri uri ) {
		try { 
			return context.getContentResolver().openInputStream( uri );
		} catch ( FileNotFoundException e ) {
			e.printStackTrace();
		} 
		return null; 
	} 
 
	/** 
	 * Return an {@link InputStream} from the given url or null if failed to retrieve the content 
	 *  
	 * @param uri 
	 * @return 
	 */ 
	static InputStream openRemoteInputStream( Uri uri ) {
		java.net.URL finalUrl;
		try { 
			finalUrl = new java.net.URL( uri.toString() );
		} catch ( MalformedURLException e ) {
			e.printStackTrace();
			return null; 
		}