Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Get the URI of an image stored in drawable

I am adding a couple of sample items in my application so it doesn't look so empty when the user look at it the first time. The list with the sample items should have an image and the image I am going to use is already stored in the /res/drawable-folder of the application.

Since I already have a method that load the items images from a URI i'd like to get the URI to the /res/drawable/myImage.jpg but I don't seem to be able to get it right.

The flow is as follows: Create item with string that represents the URI of the image. Send list of items to an List The list loads the image in a background task by converting the string to URL and then run url.openStream();

I have tried a few options for the URI without any success. "android.resource://....." says unknow protocoll "file://" file not found

So right now I'm a little bit lost about how to fix this..

like image 243
Roland Avatar asked Jul 06 '11 20:07

Roland


People also ask

How do I get the URI of a drawable image?

You should use ContentResolver to open resource URIs: Uri uri = Uri. parse("android. resource://your.package.here/drawable/image_name"); InputStream stream = getContentResolver().

How do I get URI resources?

Occasionally however, you will need to get the actual URI of a resource. All you need to do is replace the package name with your app's package name, as defined in the manifest, and the resource ID of the resource you would like to use. Uri resourceURI = Uri. parse("android.

What is the URI of an image?

URI or Uniform Resource Identifier is a compact sequence of characters that identifies an abstract or physical resource. It can be further classified as a locator, a name, or both. Basically URI (in some cases URL or URN) will point to the image location, or will be the name of the image (why not both?).

How do I find my pictures from the drawable folder on Android?

Then you can see the drawable folder under app —> res folder in the panel below the subview. Copy images from any directory you saved and right-click the drawable folder, click the Paste menu item in the popup menu list then accept all popup dialog. After that, you can see the images added in the drawable folder.


2 Answers

You should use ContentResolver to open resource URIs:

Uri uri = Uri.parse("android.resource://your.package.here/drawable/image_name"); InputStream stream = getContentResolver().openInputStream(uri); 

Also you can open file and content URIs using this method.

like image 71
Michael Avatar answered Nov 18 '22 13:11

Michael


/**  * get uri to drawable or any other resource type if u wish   * @param context - context  * @param drawableId - drawable res id  * @return - uri   */ public static final Uri getUriToDrawable(@NonNull Context context,                                           @AnyRes int drawableId) {     Uri imageUri = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE              + "://" + context.getResources().getResourcePackageName(drawableId)             + '/' + context.getResources().getResourceTypeName(drawableId)             + '/' + context.getResources().getResourceEntryName(drawableId) );     return imageUri; } 

based on above - tweaked version for any resource:

 /**  * get uri to any resource type Via Context Resource instance  * @param context - context  * @param resId - resource id  * @throws Resources.NotFoundException if the given ID does not exist.  * @return - Uri to resource by given id   */ public static final Uri getUriToResource(@NonNull Context context,                                           @AnyRes int resId)                            throws Resources.NotFoundException {     /** Return a Resources instance for your application's package. */     Resources res = context.getResources();     Uri resUri = getUriToResource(res,resId);     return resUri; }   /**  * get uri to any resource type via given Resource Instance  * @param res - resources instance  * @param resId - resource id  * @throws Resources.NotFoundException if the given ID does not exist.  * @return - Uri to resource by given id   */ public static final Uri getUriToResource(@NonNull Resources res,                                           @AnyRes int resId)                            throws Resources.NotFoundException {     /**      * Creates a Uri which parses the given encoded URI string.      * @param uriString an RFC 2396-compliant, encoded URI      * @throws NullPointerException if uriString is null      * @return Uri for this given uri string      */     Uri resUri = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE +             "://" + res.getResourcePackageName(resId)             + '/' + res.getResourceTypeName(resId)             + '/' + res.getResourceEntryName(resId));     /** return uri */     return resUri; } 

some info:

From the Java Language spec.:  "17.5 Final Field Semantics  ... when the object is seen by another thread, that thread will always see the correctly constructed version of that object's final fields. It will also see versions of any object or array referenced by those final fields that are at least as up-to-date as the final fields are."  In that same vein, all non-transient fields within Uri implementations should be final and immutable so as to ensure true immutability for clients even when they don't use proper concurrency control.  For reference, from RFC 2396:  "4.3. Parsing a URI Reference     A URI reference is typically parsed according to the four main    components and fragment identifier in order to determine what    components are present and whether the reference is relative or    absolute.  The individual components are then parsed for their    subparts and, if not opaque, to verify their validity.     Although the BNF defines what is allowed in each component, it is    ambiguous in terms of differentiating between an authority component    and a path component that begins with two slash characters.  The    greedy algorithm is used for disambiguation: the left-most matching    rule soaks up as much of the URI reference string as it is capable of    matching.  In other words, the authority component wins." 

...

3. URI Syntactic Components     The URI syntax is dependent upon the scheme.      In general, absolute URI are written as follows:       <scheme>:<scheme-specific-part>     An absolute URI contains the name of the scheme being used (<scheme>)    followed by a colon (":") and then a string  (the <scheme-specific-part>)     whose interpretation depends on the scheme.     The URI syntax does not require that the scheme-specific-part have any    general structure or set of semantics which is common among all URI.    However, a subset of URI do share a common syntax for representing    hierarchical relationships within the namespace.  This "generic URI"    syntax consists of a sequence of four main components:       <scheme>://<authority><path>?<query> 

sources:

  • http://www.rfc-base.org/rfc-2396.html

DISPUTE

this answer is correct, however the part about final fields is not - it has nothing to do with the answer – Boris Treukhov

@BorisTreukhov - please elaborate to us what u mean by "the part about final fields is not correct" - question - how to get uri to ...? construct the way it could be parsed (how is uri parsed ? see answer)

package android.net;  /**  * Immutable URI reference. A URI reference includes a URI and a fragment, the  * component of the URI following a '#'. Builds and parses URI references  * which conform to  * <a href="http://www.faqs.org/rfcs/rfc2396.html">RFC 2396</a>.  *  * <p>In the interest of performance, this class performs little to no  * validation. Behavior is undefined for invalid input. This class is very  * forgiving--in the face of invalid input, it will return garbage  * rather than throw an exception unless otherwise specified.  */  public abstract class Uri implements Parcelable, Comparable<Uri> { ... } 
like image 38
ceph3us Avatar answered Nov 18 '22 14:11

ceph3us