Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Copyright (C) 2006 The Android Open Source Project
3
    *
4
    * Licensed under the Apache License, Version 2.0 (the "License");
5
    * you may not use this file except in compliance with the License.
6
    * You may obtain a copy of the License at
7
    *
8
    *      http://www.apache.org/licenses/LICENSE-2.0
9
    *
10
   * Unless required by applicable law or agreed to in writing, software
11
   * distributed under the License is distributed on an "AS IS" BASIS,
12
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
   * See the License for the specific language governing permissions and
14
   * limitations under the License.
15
   */
16
  
17
  package android.content.res;
18
  
19
  
21
  
24
  
28
  import android.os.Build;
29
  import android.os.Bundle;
33
  import android.util.Log;
38
  
42
  import java.util.Locale;

Class for accessing an application's resources. This sits on top of the asset manager of the application (accessible through getAssets()) and provides a higher-level API for getting typed data from the assets. 
48
  
49
  public class Resources {
50
      static final String TAG = "Resources";
51
      private static final boolean DEBUG_LOAD = false;
52
      private static final boolean DEBUG_CONFIG = false;
53
      private static final boolean TRACE_FOR_PRELOAD = false;
54
  
55
      // Use the current SDK version code.  If we are a development build,
56
      // also allow the previous SDK version + 1.
57
      private static final int sSdkVersion = ..
58
              + ("REL".equals(..) ? 0 : 1);
59
      private static final Object mSync = new Object();
60
      private static Resources mSystem = null;
61
      
62
      // Information about preloaded resources.  Note that they are not
63
      // protected by a lock, because while preloading in zygote we are all
64
      // single-threaded, and after that these are immutable.
65
      private static final LongSparseArray<Drawable.ConstantState> sPreloadedDrawables
66
              = new LongSparseArray<Drawable.ConstantState>();
67
      private static final SparseArray<ColorStateList> mPreloadedColorStateLists
68
              = new SparseArray<ColorStateList>();
69
      private static boolean mPreloaded;
70
  
71
      /*package*/ final TypedValue mTmpValue = new TypedValue();
72
  
73
      // These are protected by the mTmpValue lock.
75
              = new LongSparseArray<WeakReference<Drawable.ConstantState> >();
77
              = new SparseArray<WeakReference<ColorStateList> >();
78
      private boolean mPreloading;
79
  
80
      /*package*/ TypedArray mCachedStyledAttributes = null;
81
  
82
      private int mLastCachedXmlBlockIndex = -1;
83
      private final int[] mCachedXmlBlockIds = { 0, 0, 0, 0 };
84
      private final XmlBlock[] mCachedXmlBlocks = new XmlBlock[4];
85
  
86
      /*package*/ final AssetManager mAssets;
87
      private final Configuration mConfiguration = new Configuration();
88
      /*package*/ final DisplayMetrics mMetrics = new DisplayMetrics();
90
      
92
      private Display mDefaultDisplay;
93
  
94
      private static final LongSparseArray<Object> EMPTY_ARRAY = new LongSparseArray<Object>() {
95
          @Override
96
          public void put(long k, Object o) {
97
              throw new UnsupportedOperationException();
98
          }
99
          @Override
100
         public void append(long k, Object o) {
101
             throw new UnsupportedOperationException();
102
         }
103
     };
104
 
105
     @SuppressWarnings("unchecked")
106
     private static <T> LongSparseArray<T> emptySparseArray() {
107
         return (LongSparseArray<T>) ;
108
     }

    
This exception is thrown by the resource APIs when a requested resource can not be found. 
113
 
114
     public static class NotFoundException extends RuntimeException {
115
         public NotFoundException() {
116
         }
117
 
118
         public NotFoundException(String name) {
119
             super(name);
120
         }
121
     }

    
Create a new Resources object on top of an existing set of assets in an AssetManager.

Parameters:
assets Previously created AssetManager.
metrics Current display metrics to consider when selecting/computing resource values.
config Desired device configuration to consider when selecting/computing resource values (optional).
132
 
133
     public Resources(AssetManager assets, DisplayMetrics metrics,
134
             Configuration config) {
135
         this(assets, metrics, config, (CompatibilityInfo) null);
136
     }

    
Creates a new Resources object with CompatibilityInfo.

Parameters:
assets Previously created AssetManager.
metrics Current display metrics to consider when selecting/computing resource values.
config Desired device configuration to consider when selecting/computing resource values (optional).
compInfo this resource's compatibility info. It will use the default compatibility info when it's null.
Hide:
149
 
150
     public Resources(AssetManager assets, DisplayMetrics metrics,
151
             Configuration config, CompatibilityInfo compInfo) {
152
          = assets;
153
         .setToDefaults();
154
         if (compInfo == null) {
156
         } else {
157
              = compInfo;
158
         }
159
         updateConfiguration(config, metrics);
160
         assets.ensureStringBlocks();
161
     }

    
Return a global shared Resources object that provides access to only system resources (no application resources), and is not configured for the current screen (can not use dimension units, does not change based on orientation, etc). 
168
 
169
     public static Resources getSystem() {
170
         synchronized () {
171
             Resources ret = ;
172
             if (ret == null) {
173
                 ret = new Resources();
174
                  = ret;
175
             }
176
 
177
             return ret;
178
         }
179
     }

    
Return the string value associated with a particular resource ID. The returned object will be a String if this is a plain string; it will be some other type of CharSequence if it is styled.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
CharSequence The string data associated with the resource, plus possibly styled text information.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
195
 
196
     public CharSequence getText(int id) throws NotFoundException {
197
         CharSequence res = .getResourceText(id);
198
         if (res != null) {
199
             return res;
200
         }
201
         throw new NotFoundException("String resource ID #0x"
202
                                     + Integer.toHexString(id));
203
     }

    

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
CharSequence The string data associated with the resource, plus possibly styled text information.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
214
 
215
     public CharSequence getQuantityText(int id, int quantity) throws NotFoundException {
216
         PluralRules rule = getPluralRule();
217
         CharSequence res = .getResourceBagText(id, rule.attrForNumber(quantity));
218
         if (res != null) {
219
             return res;
220
         }
221
         res = .getResourceBagText(id, .);
222
         if (res != null) {
223
             return res;
224
         }
225
         throw new NotFoundException("Plural resource ID #0x" + Integer.toHexString(id)
226
                 + " quantity=" + quantity
227
                 + " item=" + PluralRules.stringForQuantity(rule.quantityForNumber(quantity)));
228
     }
229
 
230
     private PluralRules getPluralRule() {
231
         synchronized () {
232
             if ( == null) {
233
                  = PluralRules.ruleForLocale(.);
234
             }
235
             return ;
236
         }
237
     }

    
Return the string value associated with a particular resource ID. It will be stripped of any styled text information.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
String The string data associated with the resource, stripped of styled text information.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
252
 
253
     public String getString(int id) throws NotFoundException {
254
         CharSequence res = getText(id);
255
         if (res != null) {
256
             return res.toString();
257
         }
258
         throw new NotFoundException("String resource ID #0x"
259
                                     + Integer.toHexString(id));
260
     }


    
Return the string value associated with a particular resource ID, substituting the format arguments as defined in java.util.Formatter and java.lang.String.format(java.lang.String,java.lang.Object[]). It will be stripped of any styled text information.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
formatArgs The format arguments that will be used for substitution.
Returns:
String The string data associated with the resource, stripped of styled text information.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
280
 
281
     public String getString(int id, Object... formatArgs) throws NotFoundException {
282
         String raw = getString(id);
283
         return String.format(., raw, formatArgs);
284
     }

    
Return the string value associated with a particular resource ID for a particular numerical quantity, substituting the format arguments as defined in java.util.Formatter and java.lang.String.format(java.lang.String,java.lang.Object[]). It will be stripped of any styled text information.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
quantity The number used to get the correct string for the current language's plural rules.
formatArgs The format arguments that will be used for substitution.
Returns:
String The string data associated with the resource, stripped of styled text information.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
304
 
305
     public String getQuantityString(int id, int quantity, Object... formatArgs)
306
             throws NotFoundException {
307
         String raw = getQuantityText(id, quantity).toString();
308
         return String.format(., raw, formatArgs);
309
     }

    
Return the string value associated with a particular resource ID for a particular numerical quantity.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
quantity The number used to get the correct string for the current language's plural rules.
Returns:
String The string data associated with the resource, stripped of styled text information.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
325
 
326
     public String getQuantityString(int id, int quantity) throws NotFoundException {
327
         return getQuantityText(id, quantity).toString();
328
     }

    
Return the string value associated with a particular resource ID. The returned object will be a String if this is a plain string; it will be some other type of CharSequence if it is styled.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
def The default CharSequence to return.
Returns:
CharSequence The string data associated with the resource, plus possibly styled text information, or def if id is 0 or not found.
343
 
344
     public CharSequence getText(int id, CharSequence def) {
345
         CharSequence res = id != 0 ? .getResourceText(id) : null;
346
         return res != null ? res : def;
347
     }

    
Return the styled text array associated with a particular resource ID.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
The styled text array associated with the resource.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
359
 
360
     public CharSequence[] getTextArray(int id) throws NotFoundException {
361
         CharSequence[] res = .getResourceTextArray(id);
362
         if (res != null) {
363
             return res;
364
         }
365
         throw new NotFoundException("Text array resource ID #0x"
366
                                     + Integer.toHexString(id));
367
     }

    
Return the string array associated with a particular resource ID.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
The string array associated with the resource.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
379
 
380
     public String[] getStringArray(int id) throws NotFoundException {
381
         String[] res = .getResourceStringArray(id);
382
         if (res != null) {
383
             return res;
384
         }
385
         throw new NotFoundException("String array resource ID #0x"
386
                                     + Integer.toHexString(id));
387
     }

    
Return the int array associated with a particular resource ID.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
The int array associated with the resource.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
399
 
400
     public int[] getIntArray(int id) throws NotFoundException {
401
         int[] res = .getArrayIntResource(id);
402
         if (res != null) {
403
             return res;
404
         }
405
         throw new NotFoundException("Int array resource ID #0x"
406
                                     + Integer.toHexString(id));
407
     }

    
Return an array of heterogeneous values.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
Returns a TypedArray holding an array of the array values. Be sure to call TypedArray.recycle() when done with it.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
421
 
422
     public TypedArray obtainTypedArray(int id) throws NotFoundException {
423
         int len = .getArraySize(id);
424
         if (len < 0) {
425
             throw new NotFoundException("Array resource ID #0x"
426
                                         + Integer.toHexString(id));
427
         }
428
         
429
         TypedArray array = getCachedStyledAttributes(len);
430
         array.mLength = .retrieveArray(id, array.mData);
431
         array.mIndices[0] = 0;
432
         
433
         return array;
434
     }

    
Retrieve a dimensional for a particular resource ID. Unit conversions are based on the current android.util.DisplayMetrics associated with the resources.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
Resource dimension value multiplied by the appropriate metric.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
getDimensionPixelOffset(int)
getDimensionPixelSize(int)
452
 
453
     public float getDimension(int id) throws NotFoundException {
454
         synchronized () {
455
             TypedValue value = ;
456
             getValue(id, value, true);
457
             if (value.type == .) {
458
                 return TypedValue.complexToDimension(value.data, );
459
             }
460
             throw new NotFoundException(
461
                     "Resource ID #0x" + Integer.toHexString(id) + " type #0x"
462
                     + Integer.toHexString(value.type) + " is not valid");
463
         }
464
     }

    
Retrieve a dimensional for a particular resource ID for use as an offset in raw pixels. This is the same as getDimension(int), except the returned value is converted to integer pixels for you. An offset conversion involves simply truncating the base value to an integer.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
Resource dimension value multiplied by the appropriate metric and truncated to integer pixels.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
getDimension(int)
getDimensionPixelSize(int)
484
 
485
     public int getDimensionPixelOffset(int id) throws NotFoundException {
486
         synchronized () {
487
             TypedValue value = ;
488
             getValue(id, value, true);
489
             if (value.type == .) {
490
                 return TypedValue.complexToDimensionPixelOffset(
491
                         value.data, );
492
             }
493
             throw new NotFoundException(
494
                     "Resource ID #0x" + Integer.toHexString(id) + " type #0x"
495
                     + Integer.toHexString(value.type) + " is not valid");
496
         }
497
     }

    
Retrieve a dimensional for a particular resource ID for use as a size in raw pixels. This is the same as getDimension(int), except the returned value is converted to integer pixels for use as a size. A size conversion involves rounding the base value, and ensuring that a non-zero base value is at least one pixel in size.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
Resource dimension value multiplied by the appropriate metric and truncated to integer pixels.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
getDimension(int)
getDimensionPixelOffset(int)
518
 
519
     public int getDimensionPixelSize(int id) throws NotFoundException {
520
         synchronized () {
521
             TypedValue value = ;
522
             getValue(id, value, true);
523
             if (value.type == .) {
524
                 return TypedValue.complexToDimensionPixelSize(
525
                         value.data, );
526
             }
527
             throw new NotFoundException(
528
                     "Resource ID #0x" + Integer.toHexString(id) + " type #0x"
529
                     + Integer.toHexString(value.type) + " is not valid");
530
         }
531
     }

    
Retrieve a fractional unit for a particular resource ID.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
base The base value of this fraction. In other words, a standard fraction is multiplied by this value.
pbase The parent base value of this fraction. In other words, a parent fraction (nn%p) is multiplied by this value.
Returns:
Attribute fractional value multiplied by the appropriate base value.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
549
 
550
     public float getFraction(int id, int base, int pbase) {
551
         synchronized () {
552
             TypedValue value = ;
553
             getValue(id, value, true);
554
             if (value.type == .) {
555
                 return TypedValue.complexToFraction(value.data, base, pbase);
556
             }
557
             throw new NotFoundException(
558
                     "Resource ID #0x" + Integer.toHexString(id) + " type #0x"
559
                     + Integer.toHexString(value.type) + " is not valid");
560
         }
561
     }
    
    
Return a drawable object associated with a particular resource ID. Various types of objects will be returned depending on the underlying resource -- for example, a solid color, PNG image, scalable image, etc. The Drawable API hides these implementation details.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
Drawable An object that can be used to draw this resource.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
576
 
577
     public Drawable getDrawable(int id) throws NotFoundException {
578
         synchronized () {
579
             TypedValue value = ;
580
             getValue(id, value, true);
581
             return loadDrawable(value, id);
582
         }
583
     }

    
Return a movie object associated with the particular resource ID.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
592
 
593
     public Movie getMovie(int id) throws NotFoundException {
594
         InputStream is = openRawResource(id);
595
         Movie movie = Movie.decodeStream(is);
596
         try {
597
             is.close();
598
         }
599
         catch (java.io.IOException e) {
600
             // don't care, since the return value is valid
601
         }
602
         return movie;
603
     }

    
Return a color integer associated with a particular resource ID. If the resource holds a complex ColorStateList, then the default color from the set is returned.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
Returns a single color value in the form 0xAARRGGBB.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
618
 
619
     public int getColor(int id) throws NotFoundException {
620
         synchronized () {
621
             TypedValue value = ;
622
             getValue(id, value, true);
623
             if (value.type >= .
624
                 && value.type <= .) {
625
                 return value.data;
626
             } else if (value.type == .) {
627
                 ColorStateList csl = loadColorStateList(, id);
628
                 return csl.getDefaultColor();
629
             }
630
             throw new NotFoundException(
631
                 "Resource ID #0x" + Integer.toHexString(id) + " type #0x"
632
                 + Integer.toHexString(value.type) + " is not valid");
633
         }
634
     }

    
Return a color state list associated with a particular resource ID. The resource may contain either a single raw color value, or a complex ColorStateList holding multiple possible colors.

Parameters:
id The desired resource identifier of a ColorStateList, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
Returns a ColorStateList object containing either a single solid color or multiple colors that can be selected based on a state.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
649
 
650
     public ColorStateList getColorStateList(int id) throws NotFoundException {
651
         synchronized () {
652
             TypedValue value = ;
653
             getValue(id, value, true);
654
             return loadColorStateList(value, id);
655
         }
656
     }

    
Return a boolean associated with a particular resource ID. This can be used with any integral resource value, and will return true if it is non-zero.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
Returns the boolean value contained in the resource.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
670
 
671
     public boolean getBoolean(int id) throws NotFoundException {
672
         synchronized () {
673
             TypedValue value = ;
674
             getValue(id, value, true);
675
             if (value.type >= .
676
                 && value.type <= .) {
677
                 return value.data != 0;
678
             }
679
             throw new NotFoundException(
680
                 "Resource ID #0x" + Integer.toHexString(id) + " type #0x"
681
                 + Integer.toHexString(value.type) + " is not valid");
682
         }
683
     }

    
Return an integer associated with a particular resource ID.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
Returns the integer value contained in the resource.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
695
 
696
     public int getInteger(int id) throws NotFoundException {
697
         synchronized () {
698
             TypedValue value = ;
699
             getValue(id, value, true);
700
             if (value.type >= .
701
                 && value.type <= .) {
702
                 return value.data;
703
             }
704
             throw new NotFoundException(
705
                 "Resource ID #0x" + Integer.toHexString(id) + " type #0x"
706
                 + Integer.toHexString(value.type) + " is not valid");
707
         }
708
     }

    
Return an XmlResourceParser through which you can read a view layout description for the given resource ID. This parser has limited functionality -- in particular, you can't change its input, and only the high-level events are available.

This function is really a simple wrapper for calling getXml(int) with a layout resource.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
A new parser object through which you can read the XML data.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
getXml(int)
729
 
730
     public XmlResourceParser getLayout(int id) throws NotFoundException {
731
         return loadXmlResourceParser(id, "layout");
732
     }

    
Return an XmlResourceParser through which you can read an animation description for the given resource ID. This parser has limited functionality -- in particular, you can't change its input, and only the high-level events are available.

This function is really a simple wrapper for calling getXml(int) with an animation resource.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
A new parser object through which you can read the XML data.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
getXml(int)
753
 
754
     public XmlResourceParser getAnimation(int id) throws NotFoundException {
755
         return loadXmlResourceParser(id, "anim");
756
     }

    
Return an XmlResourceParser through which you can read a generic XML resource for the given resource ID.

The XmlPullParser implementation returned here has some limited functionality. In particular, you can't change its input, and only high-level parsing events are available (since the document was pre-parsed for you at build time, which involved merging text and stripping comments).

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
Returns:
A new parser object through which you can read the XML data.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
android.util.AttributeSet
778
 
779
     public XmlResourceParser getXml(int id) throws NotFoundException {
780
         return loadXmlResourceParser(id, "xml");
781
     }

    
Open a data stream for reading a raw resource. This can only be used with resources whose value is the name of an asset files -- that is, it can be used to open drawable, sound, and raw resources; it will fail on string and color resources.

Parameters:
id The resource identifier to open, as generated by the appt tool.
Returns:
InputStream Access to the resource data.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
796
 
797
     public InputStream openRawResource(int id) throws NotFoundException {
798
         synchronized () {
799
             return openRawResource(id, );
800
         }
801
     }

    
Open a data stream for reading a raw resource. This can only be used with resources whose value is the name of an asset file -- that is, it can be used to open drawable, sound, and raw resources; it will fail on string and color resources.

Parameters:
id The resource identifier to open, as generated by the appt tool.
value The TypedValue object to hold the resource information.
Returns:
InputStream Access to the resource data.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
815
 
816
     public InputStream openRawResource(int id, TypedValue value) throws NotFoundException {
817
         getValue(id, value, true);
818
 
819
         try {
820
             return .openNonAsset(value.assetCookie, value.string.toString(),
821
                     .);
822
         } catch (Exception e) {
823
             NotFoundException rnf = new NotFoundException("File " + value.string.toString() +
824
                     " from drawable resource ID #0x" + Integer.toHexString(id));
825
             rnf.initCause(e);
826
             throw rnf;
827
         }
828
     }

    
Open a file descriptor for reading a raw resource. This can only be used with resources whose value is the name of an asset files -- that is, it can be used to open drawable, sound, and raw resources; it will fail on string and color resources.

This function only works for resources that are stored in the package as uncompressed data, which typically includes things like mp3 files and png images.

Parameters:
id The resource identifier to open, as generated by the appt tool.
Returns:
AssetFileDescriptor A new file descriptor you can use to read the resource. This includes the file descriptor itself, as well as the offset and length of data where the resource appears in the file. A null is returned if the file exists but is compressed.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
850
 
851
     public AssetFileDescriptor openRawResourceFd(int id) throws NotFoundException {
852
         synchronized () {
853
             TypedValue value = ;
854
             getValue(id, value, true);
855
 
856
             try {
857
                 return .openNonAssetFd(
858
                     value.assetCookie, value.string.toString());
859
             } catch (Exception e) {
860
                 NotFoundException rnf = new NotFoundException(
861
                     "File " + value.string.toString()
862
                     + " from drawable resource ID #0x"
863
                     + Integer.toHexString(id));
864
                 rnf.initCause(e);
865
                 throw rnf;
866
             }
867
 
868
         }
869
     }

    
Return the raw data associated with a particular resource ID.

Parameters:
id The desired resource identifier, as generated by the aapt tool. This integer encodes the package, type, and resource entry. The value 0 is an invalid identifier.
outValue Object in which to place the resource data.
resolveRefs If true, a resource that is a reference to another resource will be followed so that you receive the actual final resource data. If false, the TypedValue will be filled in with the reference itself.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
885
 
886
     public void getValue(int id, TypedValue outValue, boolean resolveRefs)
887
             throws NotFoundException {
888
         boolean found = .getResourceValue(id, outValue, resolveRefs);
889
         if (found) {
890
             return;
891
         }
892
         throw new NotFoundException("Resource ID #0x"
893
                                     + Integer.toHexString(id));
894
     }

    
Return the raw data associated with a particular resource ID. See getIdentifier() for information on how names are mapped to resource IDs, and getString(int) for information on how string resources are retrieved.

Note: use of this function is discouraged. It is much more efficient to retrieve resources by identifier than by name.

Parameters:
name The name of the desired resource. This is passed to getIdentifier() with a default type of "string".
outValue Object in which to place the resource data.
resolveRefs If true, a resource that is a reference to another resource will be followed so that you receive the actual final resource data. If false, the TypedValue will be filled in with the reference itself.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
915
 
916
     public void getValue(String name, TypedValue outValue, boolean resolveRefs)
917
             throws NotFoundException {
918
         int id = getIdentifier(name, "string", null);
919
         if (id != 0) {
920
             getValue(id, outValue, resolveRefs);
921
             return;
922
         }
923
         throw new NotFoundException("String resource name " + name);
924
     }

    
This class holds the current attribute values for a particular theme. In other words, a Theme is a set of values for resource attributes; these are used in conjunction with TypedArray to resolve the final value for an attribute.

The Theme's attributes come into play in two ways: (1) a styled attribute can explicit reference a value in the theme through the "?themeAttribute" syntax; (2) if no value has been defined for a particular styled attribute, as a last resort we will try to find that attribute's value in the Theme.

You will normally use the obtainStyledAttributes(int[]) APIs to retrieve XML attributes with style and theme information applied. 

940
 
941
     public final class Theme {
        
Place new attribute values into the theme. The style resource specified by resid will be retrieved from this Theme's resources, its values placed into the Theme object.

The semantics of this function depends on the force argument: If false, only values that are not already defined in the theme will be copied from the system resource; otherwise, if any of the style's attributes are already defined in the theme, the current values in the theme will be overwritten.

Parameters:
resid The resource ID of a style resource from which to obtain attribute values.
force If true, values in the style resource will always be used in the theme; otherwise, they will only be used if not already defined in the theme.
958
 
959
         public void applyStyle(int resid, boolean force) {
960
             AssetManager.applyThemeStyle(, resid, force);
961
         }

        
Set this theme to hold the same contents as the theme other. If both of these themes are from the same Resources object, they will be identical after this function returns. If they are from different Resources, only the resources they have in common will be set in this theme.

Parameters:
other The existing Theme to copy from.
971
 
972
         public void setTo(Theme other) {
973
             AssetManager.copyTheme(, other.mTheme);
974
         }

        
Return a StyledAttributes holding the values defined by Theme which are listed in attrs.

Be sure to call StyledAttributes.recycle() when you are done with the array.

Parameters:
attrs The desired attributes.
Returns:
Returns a TypedArray holding an array of the attribute values. Be sure to call TypedArray.recycle() when done with it.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
Resources.obtainAttributes(android.util.AttributeSet,int[])
obtainStyledAttributes(int,int[])
obtainStyledAttributes(android.util.AttributeSet,int[],int,int)
994
 
995
         public TypedArray obtainStyledAttributes(int[] attrs) {
996
             int len = attrs.length;
997
             TypedArray array = getCachedStyledAttributes(len);
998
             array.mRsrcs = attrs;
999
             AssetManager.applyStyle(, 0, 0, 0, attrs,
1000
                    array.mData, array.mIndices);
1001
            return array;
1002
        }

        
Return a StyledAttributes holding the values defined by the style resource resid which are listed in attrs.

Be sure to call StyledAttributes.recycle() when you are done with the array.

Parameters:
resid The desired style resource.
attrs The desired attributes in the style.
Returns:
Returns a TypedArray holding an array of the attribute values. Be sure to call TypedArray.recycle() when done with it.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
Resources.obtainAttributes(android.util.AttributeSet,int[])
obtainStyledAttributes(int[])
obtainStyledAttributes(android.util.AttributeSet,int[],int,int)
1024
        public TypedArray obtainStyledAttributes(int resid, int[] attrs)
1025
                throws NotFoundException {
1026
            int len = attrs.length;
1027
            TypedArray array = getCachedStyledAttributes(len);
1028
            array.mRsrcs = attrs;
1030
            AssetManager.applyStyle(, 0, resid, 0, attrs,
1031
                    array.mData, array.mIndices);
1032
            if (false) {
1033
                int[] data = array.mData;
1034
                
1035
                ..println("**********************************************************");
1036
                ..println("**********************************************************");
1037
                ..println("**********************************************************");
1038
                ..println("Attributes:");
1039
                String s = "  Attrs:";
1040
                int i;
1041
                for (i=0; i<attrs.length; i++) {
1042
                    s = s + " 0x" + Integer.toHexString(attrs[i]);
1043
                }
1044
                ..println(s);
1045
                s = "  Found:";
1046
                TypedValue value = new TypedValue();
1047
                for (i=0; i<attrs.length; i++) {
1048
                    int d = i*.;
1049
                    value.type = data[d+.];
1050
                    value.data = data[d+.];
1051
                    value.assetCookie = data[d+.];
1052
                    value.resourceId = data[d+.];
1053
                    s = s + " 0x" + Integer.toHexString(attrs[i])
1054
                        + "=" + value;
1055
                }
1056
                ..println(s);
1057
            }
1058
            return array;
1059
        }

        
Return a StyledAttributes holding the attribute values in set that are listed in attrs. In addition, if the given AttributeSet specifies a style class (through the "style" attribute), that style will be applied on top of the base attributes it defines.

Be sure to call StyledAttributes.recycle() when you are done with the array.

When determining the final value of a particular attribute, there are four inputs that come into play:

  1. Any attribute values in the given AttributeSet.
  2. The style resource specified in the AttributeSet (named "style").
  3. The default style specified by defStyleAttr and defStyleRes
  4. The base values in this theme.

Each of these inputs is considered in-order, with the first listed taking precedence over the following ones. In other words, if in the AttributeSet you have supplied <Button textColor="#ff000000">, then the button's text will always be black, regardless of what is specified in any of the styles.

Parameters:
set The base set of attribute values. May be null.
attrs The desired attributes to be retrieved.
defStyleAttr An attribute in the current theme that contains a reference to a style resource that supplies defaults values for the StyledAttributes. Can be 0 to not look for defaults.
defStyleRes A resource identifier of a style resource that supplies default values for the StyledAttributes, used only if defStyleAttr is 0 or can not be found in the theme. Can be 0 to not look for defaults.
Returns:
Returns a TypedArray holding an array of the attribute values. Be sure to call TypedArray.recycle() when done with it.
See also:
Resources.obtainAttributes(android.util.AttributeSet,int[])
obtainStyledAttributes(int[])
obtainStyledAttributes(int,int[])
1109
        public TypedArray obtainStyledAttributes(AttributeSet set,
1110
                int[] attrs, int defStyleAttr, int defStyleRes) {
1111
            int len = attrs.length;
1112
            TypedArray array = getCachedStyledAttributes(len);
1114
            // XXX note that for now we only work with compiled XML files.
1115
            // To support generic XML files we will need to manually parse
1116
            // out the attributes from the XML file (applying type information
1117
            // contained in the resources and such).
1118
            XmlBlock.Parser parser = (XmlBlock.Parser)set;
1119
            AssetManager.applyStyle(
1120
                , defStyleAttr, defStyleRes,
1121
                parser != null ? parser.mParseState : 0, attrs,
1122
                        array.mData, array.mIndices);
1124
            array.mRsrcs = attrs;
1125
            array.mXml = parser;
1127
            if (false) {
1128
                int[] data = array.mData;
1129
                
1130
                ..println("Attributes:");
1131
                String s = "  Attrs:";
1132
                int i;
1133
                for (i=0; i<set.getAttributeCount(); i++) {
1134
                    s = s + " " + set.getAttributeName(i);
1135
                    int id = set.getAttributeNameResource(i);
1136
                    if (id != 0) {
1137
                        s = s + "(0x" + Integer.toHexString(id) + ")";
1138
                    }
1139
                    s = s + "=" + set.getAttributeValue(i);
1140
                }
1141
                ..println(s);
1142
                s = "  Found:";
1143
                TypedValue value = new TypedValue();
1144
                for (i=0; i<attrs.length; i++) {
1145
                    int d = i*.;
1146
                    value.type = data[d+.];
1147
                    value.data = data[d+.];
1148
                    value.assetCookie = data[d+.];
1149
                    value.resourceId = data[d+.];
1150
                    s = s + " 0x" + Integer.toHexString(attrs[i])
1151
                        + "=" + value;
1152
                }
1153
                ..println(s);
1154
            }
1156
            return array;
1157
        }

        
Retrieve the value of an attribute in the Theme. The contents of outValue are ultimately filled in by Resources.getValue(int,android.util.TypedValue,boolean).

Parameters:
resid The resource identifier of the desired theme attribute.
outValue Filled in with the ultimate resource value supplied by the attribute.
resolveRefs If true, resource references will be walked; if false, outValue may be a TYPE_REFERENCE. In either case, it will never be a TYPE_ATTRIBUTE.
Returns:
boolean Returns true if the attribute was found and outValue is valid, else false.
1176
        public boolean resolveAttribute(int resid, TypedValue outValue,
1177
                boolean resolveRefs) {
1178
            boolean got = .getThemeValue(, resid, outValue, resolveRefs);
1179
            if (false) {
1180
                ..println(
1181
                    "resolveAttribute #" + Integer.toHexString(resid)
1182
                    + " got=" + got + ", type=0x" + Integer.toHexString(outValue.type)
1183
                    + ", data=0x" + Integer.toHexString(outValue.data));
1184
            }
1185
            return got;
1186
        }

        
Print contents of this theme out to the log. For debugging only.

Parameters:
priority The log priority to use.
tag The log tag to use.
prefix Text to prefix each line printed.
1195
        public void dump(int priority, String tag, String prefix) {
1196
            AssetManager.dumpTheme(, priority, tag, prefix);
1197
        }
1198
        
1199
        protected void finalize() throws Throwable {
1200
            super.finalize();
1201
            .releaseTheme();
1202
        }
1204
        /*package*/ Theme() {
1205
             = Resources.this.;
1206
             = .createTheme();
1207
        }
1209
        private final AssetManager mAssets;
1210
        private final int mTheme;
1211
    }

    
Generate a new Theme object for this set of Resources. It initially starts out empty.

Returns:
Theme The newly created Theme container.
1219
    public final Theme newTheme() {
1220
        return new Theme();
1221
    }

    
Retrieve a set of basic attribute values from an AttributeSet, not performing styling of them using a theme and/or style resources.

Parameters:
set The current attribute values to retrieve.
attrs The specific attributes to be retrieved.
Returns:
Returns a TypedArray holding an array of the attribute values. Be sure to call TypedArray.recycle() when done with it.
See also:
Resources.Theme.obtainStyledAttributes(android.util.AttributeSet,int[],int,int)
1235
    public TypedArray obtainAttributes(AttributeSet set, int[] attrs) {
1236
        int len = attrs.length;
1237
        TypedArray array = getCachedStyledAttributes(len);
1239
        // XXX note that for now we only work with compiled XML files.
1240
        // To support generic XML files we will need to manually parse
1241
        // out the attributes from the XML file (applying type information
1242
        // contained in the resources and such).
1243
        XmlBlock.Parser parser = (XmlBlock.Parser)set;
1244
        .retrieveAttributes(parser.mParseState, attrs,
1245
                array.mData, array.mIndices);
1247
        array.mRsrcs = attrs;
1248
        array.mXml = parser;
1250
        return array;
1251
    }

    
Store the newly updated configuration. 
1256
    public void updateConfiguration(Configuration config,
1257
            DisplayMetrics metrics) {
1258
        synchronized () {
1259
            int configChanges = 0xfffffff;
1260
            if (config != null) {
1261
                configChanges = .updateFrom(config);
1262
            }
1263
            if (. == null) {
1264
                . = Locale.getDefault();
1265
            }
1266
            if (metrics != null) {
1267
                .setTo(metrics);
1268
                .updateMetrics(,
1269
                        ., .);
1270
            }
1273
            String locale = null;
1274
            if (. != null) {
1275
                locale = ..getLanguage();
1276
                if (..getCountry() != null) {
1277
                    locale += "-" + ..getCountry();
1278
                }
1279
            }
1280
            int width, height;
1281
            if (. >= .) {
1282
                width = .;
1283
                height = .;
1284
            } else {
1285
                //noinspection SuspiciousNameCombination
1286
                width = .;
1287
                //noinspection SuspiciousNameCombination
1288
                height = .;
1289
            }
1290
            int keyboardHidden = .;
1291
            if (keyboardHidden == .
1292
                    && .
1293
                            == .) {
1294
                keyboardHidden = .;
1295
            }
1297
                    locale, .,
1298
                    .,
1299
                    (int)(.*160), .,
1300
                    keyboardHidden, ., width, height,
1301
                    ., ., );
1302
            int N = .size();
1303
            if () {
1304
                Log.d(, "Cleaning up drawables config changes: 0x"
1305
                        + Integer.toHexString(configChanges));
1306
            }
1307
            for (int i=0; i<N; i++) {
1308
                WeakReference<Drawable.ConstantState> ref = .valueAt(i);
1309
                if (ref != null) {
1310
                    Drawable.ConstantState cs = ref.get();
1311
                    if (cs != null) {
1312
                        if (Configuration.needNewResources(
1313
                                configChanges, cs.getChangingConfigurations())) {
1314
                            if () {
1315
                                Log.d(, "FLUSHING #0x"
1316
                                        + Long.toHexString(.keyAt(i))
1317
                                        + " / " + cs + " with changes: 0x"
1318
                                        + Integer.toHexString(cs.getChangingConfigurations()));
1319
                            }
1320
                            .setValueAt(i, null);
1321
                        } else if () {
1322
                            Log.d(, "(Keeping #0x"
1323
                                    + Long.toHexString(.keyAt(i))
1324
                                    + " / " + cs + " with changes: 0x"
1325
                                    + Integer.toHexString(cs.getChangingConfigurations())
1326
                                    + ")");
1327
                        }
1328
                    }
1329
                }
1330
            }
1331
            .clear();
1332
            .clear();
1333
            flushLayoutCache();
1334
        }
1335
        synchronized () {
1336
            if ( != null) {
1337
                 = PluralRules.ruleForLocale(config.locale);
1338
            }
1339
        }
1340
    }

    
Update the system resources configuration if they have previously been initialized.

Hide:
1348
    public static void updateSystemConfiguration(Configuration config, DisplayMetrics metrics) {
1349
        if ( != null) {
1350
            .updateConfiguration(config, metrics);
1351
            //Log.i(TAG, "Updated system resources " + mSystem
1352
            //        + ": " + mSystem.getConfiguration());
1353
        }
1354
    }

    
Return the current display metrics that are in effect for this resource object. The returned object should be treated as read-only.

Returns:
The resource's current display metrics.
1363
        return ;
1364
    }

    
Return the current configuration that is in effect for this resource object. The returned object should be treated as read-only.

Returns:
The resource's current configuration.
1372
    public Configuration getConfiguration() {
1373
        return ;
1374
    }
    
    
Return the compatibility mode information for the application. The returned object should be treated as read-only.

Returns:
compatibility info. null if the app does not require compatibility mode.
Hide:
1384
        return ;
1385
    }

    
This is just for testing.

Hide:
1391
    public void setCompatibilityInfo(CompatibilityInfo ci) {
1392
         = ci;
1394
    }
    
    
Return a resource identifier for the given resource name. A fully qualified resource name is of the form "package:type/entry". The first two components (package and type) are optional if defType and defPackage, respectively, are specified here.

Note: use of this function is discouraged. It is much more efficient to retrieve resources by identifier than by name.

Parameters:
name The name of the desired resource.
defType Optional default resource type to find, if "type/" is not included in the name. Can be null to require an explicit type.
defPackage Optional default package to find, if "package:" is not included in the name. Can be null to require an explicit package.
Returns:
int The associated resource identifier. Returns 0 if no such resource was found. (0 is not a valid resource ID.)
1416
    public int getIdentifier(String name, String defType, String defPackage) {
1417
        try {
1418
            return Integer.parseInt(name);
1419
        } catch (Exception e) {
1420
            // Ignore
1421
        }
1422
        return .getResourceIdentifier(name, defType, defPackage);
1423
    }

    
Return the full name for a given resource identifier. This name is a single string of the form "package:type/entry".

Parameters:
resid The resource identifier whose name is to be retrieved.
Returns:
A string holding the name of the resource.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
getResourcePackageName(int)
getResourceTypeName(int)
getResourceEntryName(int)
1439
    public String getResourceName(int resid) throws NotFoundException {
1440
        String str = .getResourceName(resid);
1441
        if (str != null) return str;
1442
        throw new NotFoundException("Unable to find resource ID #0x"
1443
                + Integer.toHexString(resid));
1444
    }
    
    
Return the package name for a given resource identifier.

Parameters:
resid The resource identifier whose package name is to be retrieved.
Returns:
A string holding the package name of the resource.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
getResourceName(int)
1458
    public String getResourcePackageName(int resid) throws NotFoundException {
1459
        String str = .getResourcePackageName(resid);
1460
        if (str != null) return str;
1461
        throw new NotFoundException("Unable to find resource ID #0x"
1462
                + Integer.toHexString(resid));
1463
    }
    
    
Return the type name for a given resource identifier.

Parameters:
resid The resource identifier whose type name is to be retrieved.
Returns:
A string holding the type name of the resource.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
getResourceName(int)
1477
    public String getResourceTypeName(int resid) throws NotFoundException {
1478
        String str = .getResourceTypeName(resid);
1479
        if (str != null) return str;
1480
        throw new NotFoundException("Unable to find resource ID #0x"
1481
                + Integer.toHexString(resid));
1482
    }
    
    
Return the entry name for a given resource identifier.

Parameters:
resid The resource identifier whose entry name is to be retrieved.
Returns:
A string holding the entry name of the resource.
Throws:
Resources.NotFoundException Throws NotFoundException if the given ID does not exist.
See also:
getResourceName(int)
1496
    public String getResourceEntryName(int resid) throws NotFoundException {
1497
        String str = .getResourceEntryName(resid);
1498
        if (str != null) return str;
1499
        throw new NotFoundException("Unable to find resource ID #0x"
1500
                + Integer.toHexString(resid));
1501
    }
    
    
Parse a series of <extra> tags from an XML file. You call this when you are at the parent tag of the extra tags, and it return once all of the child tags have been parsed. This will call parseBundleExtra(java.lang.String,android.util.AttributeSet,android.os.Bundle) for each extra tag encountered.

Parameters:
parser The parser from which to retrieve the extras.
outBundle A Bundle in which to place all parsed extras.
Throws:
org.xmlpull.v1.XmlPullParserException
java.io.IOException
1514
    public void parseBundleExtras(XmlResourceParser parser, Bundle outBundle)
1515
            throws XmlPullParserException, IOException {
1516
        int outerDepth = parser.getDepth();
1517
        int type;
1518
        while ((type=parser.next()) != .
1519
               && (type != . || parser.getDepth() > outerDepth)) {
1520
            if (type == . || type == .) {
1521
                continue;
1522
            }
1523
            
1524
            String nodeName = parser.getName();
1525
            if (nodeName.equals("extra")) {
1526
                parseBundleExtra("extra", parser, outBundle);
1527
                XmlUtils.skipCurrentTag(parser);
1529
            } else {
1530
                XmlUtils.skipCurrentTag(parser);
1531
            }
1532
        }        
1533
    }
    
    
Parse a name/value pair out of an XML tag holding that data. The AttributeSet must be holding the data defined by android.R.styleable. The following value types are supported:

Parameters:
tagName The name of the tag these attributes come from; this is only used for reporting error messages.
attrs The attributes from which to retrieve the name/value pair.
outBundle The Bundle in which to place the parsed value.
Throws:
org.xmlpull.v1.XmlPullParserException If the attributes are not valid.
1556
    public void parseBundleExtra(String tagName, AttributeSet attrs,
1557
            Bundle outBundle) throws XmlPullParserException {
1558
        TypedArray sa = obtainAttributes(attrs,
1559
                .....);
1561
        String name = sa.getString(
1562
                .....);
1563
        if (name == null) {
1564
            sa.recycle();
1565
            throw new XmlPullParserException("<" + tagName
1566
                    + "> requires an android:name attribute at "
1567
                    + attrs.getPositionDescription());
1568
        }
1570
        TypedValue v = sa.peekValue(
1571
                .....);
1572
        if (v != null) {
1573
            if (v.type == .) {
1574
                CharSequence cs = v.coerceToString();
1575
                outBundle.putCharSequence(name, cs);
1576
            } else if (v.type == .) {
1577
                outBundle.putBoolean(name, v.data != 0);
1578
            } else if (v.type >= .
1579
                    && v.type <= .) {
1580
                outBundle.putInt(name, v.data);
1581
            } else if (v.type == .) {
1582
                outBundle.putFloat(name, v.getFloat());
1583
            } else {
1584
                sa.recycle();
1585
                throw new XmlPullParserException("<" + tagName
1586
                        + "> only supports string, integer, float, color, and boolean at "
1587
                        + attrs.getPositionDescription());
1588
            }
1589
        } else {
1590
            sa.recycle();
1591
            throw new XmlPullParserException("<" + tagName
1592
                    + "> requires an android:value or android:resource attribute at "
1593
                    + attrs.getPositionDescription());
1594
        }
1596
        sa.recycle();
1597
    }
    
    
Retrieve underlying AssetManager storage for these resources. 
1602
    public final AssetManager getAssets() {
1603
        return ;
1604
    }

    
Call this to remove all cached loaded layout resources from the Resources object. Only intended for use with performance testing tools. 
1611
    public final void flushLayoutCache() {
1612
        synchronized () {
1613
            // First see if this block is in our cache.
1614
            final int num = .;
1615
            for (int i=0; i<num; i++) {
1616
                [i] = -0;
1617
                XmlBlock oldBlock = [i];
1618
                if (oldBlock != null) {
1619
                    oldBlock.close();
1620
                }
1621
                [i] = null;
1622
            }
1623
        }
1624
    }

    
Start preloading of resource data using this Resources object. Only for use by the zygote process for loading common system resources. 
1631
    public final void startPreloading() {
1632
        synchronized () {
1633
            if () {
1634
                throw new IllegalStateException("Resources already preloaded");
1635
            }
1636
             = true;
1637
             = true;
1638
        }
1639
    }
    
    
Called by zygote when it is done preloading resources, to change back to normal Resources operation. 
1645
    public final void finishPreloading() {
1646
        if () {
1647
             = false;
1648
            flushLayoutCache();
1649
        }
1650
    }
1651
    
1652
    /*package*/ Drawable loadDrawable(TypedValue value, int id)
1653
            throws NotFoundException {
1655
        if () {
1656
            // Log only framework resources
1657
            if ((id >>> 24) == 0x1) {
1658
                final String name = getResourceName(id);
1659
                if (name != null) android.util.Log.d("PreloadDrawable", name);
1660
            }
1661
        }
1663
        final long key = (((long) value.assetCookie) << 32) | value.data;
1664
        Drawable dr = getCachedDrawable(key);
1666
        if (dr != null) {
1667
            return dr;
1668
        }
1670
        Drawable.ConstantState cs = .get(key);
1671
        if (cs != null) {
1672
            dr = cs.newDrawable(this);
1673
        } else {
1674
            if (value.type >= . &&
1675
                    value.type <= .) {
1676
                dr = new ColorDrawable(value.data);
1677
            }
1679
            if (dr == null) {
1680
                if (value.string == null) {
1681
                    throw new NotFoundException(
1682
                            "Resource is not a Drawable (color or path): " + value);
1683
                }
1685
                String file = value.string.toString();
1687
                if () Log.v(, "Loading drawable for cookie "
1688
                        + value.assetCookie + ": " + file);
1690
                if (file.endsWith(".xml")) {
1691
                    try {
1692
                        XmlResourceParser rp = loadXmlResourceParser(
1693
                                file, id, value.assetCookie, "drawable");
1694
                        dr = Drawable.createFromXml(this, rp);
1695
                        rp.close();
1696
                    } catch (Exception e) {
1697
                        NotFoundException rnf = new NotFoundException(
1698
                            "File " + file + " from drawable resource ID #0x"
1699
                            + Integer.toHexString(id));
1700
                        rnf.initCause(e);
1701
                        throw rnf;
1702
                    }
1704
                } else {
1705
                    try {
1706
                        InputStream is = .openNonAsset(
1707
                                value.assetCookie, file, .);
1708
        //                System.out.println("Opened file " + file + ": " + is);
1709
                        dr = Drawable.createFromResourceStream(this, value, is,
1710
                                file, null);
1711
                        is.close();
1712
        //                System.out.println("Created stream: " + dr);
1713
                    } catch (Exception e) {
1714
                        NotFoundException rnf = new NotFoundException(
1715
                            "File " + file + " from drawable resource ID #0x"
1716
                            + Integer.toHexString(id));
1717
                        rnf.initCause(e);
1718
                        throw rnf;
1719
                    }
1720
                }
1721
            }
1722
        }
1724
        if (dr != null) {
1725
            dr.setChangingConfigurations(value.changingConfigurations);
1726
            cs = dr.getConstantState();
1727
            if (cs != null) {
1728
                if () {
1729
                    .put(key, cs);
1730
                } else {
1731
                    synchronized () {
1732
                        //Log.i(TAG, "Saving cached drawable @ #" +
1733
                        //        Integer.toHexString(key.intValue())
1734
                        //        + " in " + this + ": " + cs);
1735
                        .put(key, new WeakReference<Drawable.ConstantState>(cs));
1736
                    }
1737
                }
1738
            }
1739
        }
1741
        return dr;
1742
    }
1744
    private Drawable getCachedDrawable(long key) {
1745
        synchronized () {
1746
            WeakReference<Drawable.ConstantState> wr = .get(key);
1747
            if (wr != null) {   // we have the key
1748
                Drawable.ConstantState entry = wr.get();
1749
                if (entry != null) {
1750
                    //Log.i(TAG, "Returning cached drawable @ #" +
1751
                    //        Integer.toHexString(((Integer)key).intValue())
1752
                    //        + " in " + this + ": " + entry);
1753
                    return entry.newDrawable(this);
1754
                }
1755
                else {  // our entry has been purged
1756
                    .delete(key);
1757
                }
1758
            }
1759
        }
1760
        return null;
1761
    }
1763
    /*package*/ ColorStateList loadColorStateList(TypedValue value, int id)
1764
            throws NotFoundException {
1765
        if () {
1766
            // Log only framework resources
1767
            if ((id >>> 24) == 0x1) {
1768
                final String name = getResourceName(id);
1769
                if (name != null) android.util.Log.d("PreloadColorStateList", name);
1770
            }
1771
        }
1773
        final int key = (value.assetCookie << 24) | value.data;
1775
        ColorStateList csl;
1777
        if (value.type >= . &&
1778
                value.type <= .) {
1780
            csl = .get(key);
1781
            if (csl != null) {
1782
                return csl;
1783
            }
1785
            csl = ColorStateList.valueOf(value.data);
1786
            if () {
1787
                .put(key, csl);
1788
            }
1790
            return csl;
1791
        }
1793
        csl = getCachedColorStateList(key);
1794
        if (csl != null) {
1795
            return csl;
1796
        }
1798
        csl = .get(key);
1799
        if (csl != null) {
1800
            return csl;
1801
        }
1803
        if (value.string == null) {
1804
            throw new NotFoundException(
1805
                    "Resource is not a ColorStateList (color or path): " + value);
1806
        }
1807
        
1808
        String file = value.string.toString();
1810
        if (file.endsWith(".xml")) {
1811
            try {
1812
                XmlResourceParser rp = loadXmlResourceParser(
1813
                        file, id, value.assetCookie, "colorstatelist"); 
1814
                csl = ColorStateList.createFromXml(this, rp);
1815
                rp.close();
1816
            } catch (Exception e) {
1817
                NotFoundException rnf = new NotFoundException(
1818
                    "File " + file + " from color state list resource ID #0x"
1819
                    + Integer.toHexString(id));
1820
                rnf.initCause(e);
1821
                throw rnf;
1822
            }
1823
        } else {
1824
            throw new NotFoundException(
1825
                    "File " + file + " from drawable resource ID #0x"
1826
                    + Integer.toHexString(id) + ": .xml extension required");
1827
        }
1829
        if (csl != null) {
1830
            if () {
1831
                .put(key, csl);
1832
            } else {
1833
                synchronized () {
1834
                    //Log.i(TAG, "Saving cached color state list @ #" +
1835
                    //        Integer.toHexString(key.intValue())
1836
                    //        + " in " + this + ": " + csl);
1837
                    .put(
1838
                        key, new WeakReference<ColorStateList>(csl));
1839
                }
1840
            }
1841
        }
1843
        return csl;
1844
    }
1846
    private ColorStateList getCachedColorStateList(int key) {
1847
        synchronized () {
1848
            WeakReference<ColorStateList> wr = .get(key);
1849
            if (wr != null) {   // we have the key
1850
                ColorStateList entry = wr.get();
1851
                if (entry != null) {
1852
                    //Log.i(TAG, "Returning cached color state list @ #" +
1853
                    //        Integer.toHexString(((Integer)key).intValue())
1854
                    //        + " in " + this + ": " + entry);
1855
                    return entry;
1856
                }
1857
                else {  // our entry has been purged
1858
                    .delete(key);
1859
                }
1860
            }
1861
        }
1862
        return null;
1863
    }
1865
    /*package*/ XmlResourceParser loadXmlResourceParser(int id, String type)
1866
            throws NotFoundException {
1867
        synchronized () {
1868
            TypedValue value = ;
1869
            getValue(id, value, true);
1870
            if (value.type == .) {
1871
                return loadXmlResourceParser(value.string.toString(), id,
1872
                        value.assetCookie, type);
1873
            }
1874
            throw new NotFoundException(
1875
                    "Resource ID #0x" + Integer.toHexString(id) + " type #0x"
1876
                    + Integer.toHexString(value.type) + " is not valid");
1877
        }
1878
    }
1879
    
1880
    /*package*/ XmlResourceParser loadXmlResourceParser(String file, int id,
1881
            int assetCookie, String type) throws NotFoundException {
1882
        if (id != 0) {
1883
            try {
1884
                // These may be compiled...
1885
                synchronized () {
1886
                    // First see if this block is in our cache.
1887
                    final int num = .;
1888
                    for (int i=0; i<num; i++) {
1889
                        if ([i] == id) {
1890
                            //System.out.println("**** REUSING XML BLOCK!  id="
1891
                            //                   + id + ", index=" + i);
1892
                            return [i].newParser();
1893
                        }
1894
                    }
1896
                    // Not in the cache, create a new block and put it at
1897
                    // the next slot in the cache.
1898
                    XmlBlock block = .openXmlBlockAsset(
1899
                            assetCookie, file);
1900
                    if (block != null) {
1901
                        int pos = +1;
1902
                        if (pos >= num) pos = 0;
1903
                         = pos;
1904
                        XmlBlock oldBlock = [pos];
1905
                        if (oldBlock != null) {
1906
                            oldBlock.close();
1907
                        }
1908
                        [pos] = id;
1909
                        [pos] = block;
1910
                        //System.out.println("**** CACHING NEW XML BLOCK!  id="
1911
                        //                   + id + ", index=" + pos);
1912
                        return block.newParser();
1913
                    }
1914
                }
1915
            } catch (Exception e) {
1916
                NotFoundException rnf = new NotFoundException(
1917
                        "File " + file + " from xml type " + type + " resource ID #0x"
1918
                        + Integer.toHexString(id));
1919
                rnf.initCause(e);
1920
                throw rnf;
1921
            }
1922
        }
1924
        throw new NotFoundException(
1925
                "File " + file + " from xml type " + type + " resource ID #0x"
1926
                + Integer.toHexString(id));
1927
    }

    
Returns the display adjusted for the Resources' metrics.

Hide:
1933
    public Display getDefaultDisplay(Display defaultDisplay) {
1934
        if ( == null) {
1936
                // the app supports the display. just use the default one.
1937
                 = defaultDisplay;
1938
            } else {
1939
                // display needs adjustment.
1940
                 = Display.createMetricsBasedDisplay(
1941
                        defaultDisplay.getDisplayId(), );
1942
            }
1943
        }
1944
        return ;
1945
    }
1947
    private TypedArray getCachedStyledAttributes(int len) {
1948
        synchronized () {
1949
            TypedArray attrs = ;
1950
            if (attrs != null) {
1951
                 = null;
1953
                attrs.mLength = len;
1954
                int fullLen = len * .;
1955
                if (attrs.mData.length >= fullLen) {
1956
                    return attrs;
1957
                }
1958
                attrs.mData = new int[fullLen];
1959
                attrs.mIndices = new int[1+len];
1960
                return attrs;
1961
            }
1962
            return new TypedArray(this,
1963
                    new int[len*.],
1964
                    new int[1+len], len);
1965
        }
1966
    }
1968
    private Resources() {
1969
         = AssetManager.getSystem();
1970
        // NOTE: Intentionally leaving this uninitialized (all values set
1971
        // to zero), so that anyone who tries to do something that requires
1972
        // metrics will get a very wrong value.
1974
        .setToDefaults();
1975
        updateConfiguration(null, null);
1976
        .ensureStringBlocks();
1978
    }
New to GrepCode? Check out our FAQ X