For example, if a resource has a value defined for the -land resource qualifier, * this field will have the {@link android.content.pm.ActivityInfo#CONFIG_ORIENTATION} bit set. *
* * @see android.content.pm.ActivityInfo#CONFIG_MCC * @see android.content.pm.ActivityInfo#CONFIG_MNC * @see android.content.pm.ActivityInfo#CONFIG_LOCALE * @see android.content.pm.ActivityInfo#CONFIG_TOUCHSCREEN * @see android.content.pm.ActivityInfo#CONFIG_KEYBOARD * @see android.content.pm.ActivityInfo#CONFIG_KEYBOARD_HIDDEN * @see android.content.pm.ActivityInfo#CONFIG_NAVIGATION * @see android.content.pm.ActivityInfo#CONFIG_ORIENTATION * @see android.content.pm.ActivityInfo#CONFIG_SCREEN_LAYOUT * @see android.content.pm.ActivityInfo#CONFIG_UI_MODE * @see android.content.pm.ActivityInfo#CONFIG_SCREEN_SIZE * @see android.content.pm.ActivityInfo#CONFIG_SMALLEST_SCREEN_SIZE * @see android.content.pm.ActivityInfo#CONFIG_DENSITY * @see android.content.pm.ActivityInfo#CONFIG_LAYOUT_DIRECTION * @see android.content.pm.ActivityInfo#CONFIG_COLOR_MODE * */ public @Config int changingConfigurations = -1; /** * If the Value came from a resource, this holds the corresponding pixel density. * */ public int density; /** * If the Value came from a style resource or a layout resource (set in an XML layout), this * holds the corresponding style or layout resource id against which the attribute was resolved. */ public int sourceResourceId; /* ------------------------------------------------------------ */ /** Return the data for this value as a float. Only use for values * whose type is {@link #TYPE_FLOAT}. */ public final float getFloat() { return Float.intBitsToFloat(data); } private static final float MANTISSA_MULT = 1.0f / (1<To convert the other way, e.g. from pixels to DP, use {@link #deriveDimension(int, float, * DisplayMetrics)}. * * @param unit The unit to convert from. * @param value The value to apply the unit to. * @param metrics Current display metrics to use in the conversion -- * supplies display density and scaling information. * * @return The equivalent pixel value—i.e. the complex floating point value multiplied by the * appropriate metrics depending on its unit—or zero if unit is not valid. */ public static float applyDimension(@ComplexDimensionUnit int unit, float value, DisplayMetrics metrics) { switch (unit) { case COMPLEX_UNIT_PX: return value; case COMPLEX_UNIT_DIP: return value * metrics.density; case COMPLEX_UNIT_SP: if (metrics.fontScaleConverter != null) { return applyDimension( COMPLEX_UNIT_DIP, metrics.fontScaleConverter.convertSpToDp(value), metrics); } else { return value * metrics.scaledDensity; } case COMPLEX_UNIT_PT: return value * metrics.xdpi * INCHES_PER_PT; case COMPLEX_UNIT_IN: return value * metrics.xdpi; case COMPLEX_UNIT_MM: return value * metrics.xdpi * INCHES_PER_MM; } return 0; } /** * Converts a pixel value to the given dimension, e.g. PX to DP. * *
This is the inverse of {@link #applyDimension(int, float, DisplayMetrics)} * * @param unitToConvertTo The unit to convert to. * @param pixelValue The raw pixels value to convert from. * @param metrics Current display metrics to use in the conversion -- * supplies display density and scaling information. * * @return A dimension value equivalent to the given number of pixels * @throws IllegalArgumentException if unitToConvertTo is not valid. */ public static float deriveDimension( @ComplexDimensionUnit int unitToConvertTo, float pixelValue, @NonNull DisplayMetrics metrics) { switch (unitToConvertTo) { case COMPLEX_UNIT_PX: return pixelValue; case COMPLEX_UNIT_DIP: { // Avoid divide-by-zero, and return 0 since that's what the inverse function will do if (metrics.density == 0) { return 0; } return pixelValue / metrics.density; } case COMPLEX_UNIT_SP: if (metrics.fontScaleConverter != null) { final float dpValue = deriveDimension(COMPLEX_UNIT_DIP, pixelValue, metrics); return metrics.fontScaleConverter.convertDpToSp(dpValue); } else { if (metrics.scaledDensity == 0) { return 0; } return pixelValue / metrics.scaledDensity; } case COMPLEX_UNIT_PT: { if (metrics.xdpi == 0) { return 0; } return pixelValue / metrics.xdpi / INCHES_PER_PT; } case COMPLEX_UNIT_IN: { if (metrics.xdpi == 0) { return 0; } return pixelValue / metrics.xdpi; } case COMPLEX_UNIT_MM: { if (metrics.xdpi == 0) { return 0; } return pixelValue / metrics.xdpi / INCHES_PER_MM; } default: throw new IllegalArgumentException("Invalid unitToConvertTo " + unitToConvertTo); } } /** * Converts a pixel value to the given dimension, e.g. PX to DP. * *
This is just an alias of {@link #deriveDimension(int, float, DisplayMetrics)} with an * easier-to-find name. * * @param unitToConvertTo The unit to convert to. * @param pixelValue The raw pixels value to convert from. * @param metrics Current display metrics to use in the conversion -- * supplies display density and scaling information. * * @return A dimension value equivalent to the given number of pixels * @throws IllegalArgumentException if unitToConvertTo is not valid. */ public static float convertPixelsToDimension( @ComplexDimensionUnit int unitToConvertTo, float pixelValue, @NonNull DisplayMetrics metrics) { return deriveDimension(unitToConvertTo, pixelValue, metrics); } /** * Converts a dimension value to raw pixels, e.g. DP to PX. * *
This is just an alias of {@link #applyDimension(int, float, DisplayMetrics)} with an * easier-to-find name. * * @param unitToConvertFrom The unit to convert from. * @param value The dimension value to apply the unit to. * @param metrics Current display metrics to use in the conversion -- * supplies display density and scaling information. * * @return The equivalent pixel value—i.e. the complex floating point value multiplied by the * appropriate metrics depending on its unit—or zero if unit is not valid. */ public static float convertDimensionToPixels( @ComplexDimensionUnit int unitToConvertFrom, float value, @NonNull DisplayMetrics metrics) { return applyDimension(unitToConvertFrom, value, metrics); } /** * Return the data for this value as a dimension. Only use for values * whose type is {@link #TYPE_DIMENSION}. * * @param metrics Current display metrics to use in the conversion -- * supplies display density and scaling information. * * @return The complex floating point value multiplied by the appropriate * metrics depending on its unit. */ public float getDimension(DisplayMetrics metrics) { return complexToDimension(data, metrics); } /** * Construct a complex data integer. This validates the radix and the magnitude of the * mantissa, and sets the {@link TypedValue#COMPLEX_MANTISSA_MASK} and * {@link TypedValue#COMPLEX_RADIX_MASK} components as provided. The units are not set. ** * @param mantissa an integer representing the mantissa. * @param radix a radix option, e.g. {@link TypedValue#COMPLEX_RADIX_23p0}. * @return A complex data integer representing the value. * @hide */ private static int createComplex(@IntRange(from = -0x800000, to = 0x7FFFFF) int mantissa, int radix) { if (mantissa < -0x800000 || mantissa >= 0x800000) { throw new IllegalArgumentException("Magnitude of mantissa is too large: " + mantissa); } if (radix < TypedValue.COMPLEX_RADIX_23p0 || radix > TypedValue.COMPLEX_RADIX_0p23) { throw new IllegalArgumentException("Invalid radix: " + radix); } return ((mantissa & TypedValue.COMPLEX_MANTISSA_MASK) << TypedValue.COMPLEX_MANTISSA_SHIFT) | (radix << TypedValue.COMPLEX_RADIX_SHIFT); } /** * Convert a base value to a complex data integer. This sets the {@link * TypedValue#COMPLEX_MANTISSA_MASK} and {@link TypedValue#COMPLEX_RADIX_MASK} fields of the * data to create a floating point representation of the given value. The units are not set. * *
This is the inverse of {@link TypedValue#complexToFloat(int)}. * * @param value An integer value. * @return A complex data integer representing the value. * @hide */ public static int intToComplex(int value) { if (value < -0x800000 || value >= 0x800000) { throw new IllegalArgumentException("Magnitude of the value is too large: " + value); } return createComplex(value, TypedValue.COMPLEX_RADIX_23p0); } /** * Convert a base value to a complex data integer. This sets the {@link * TypedValue#COMPLEX_MANTISSA_MASK} and {@link TypedValue#COMPLEX_RADIX_MASK} fields of the * data to create a floating point representation of the given value. The units are not set. * *
This is the inverse of {@link TypedValue#complexToFloat(int)}. * * @param value A floating point value. * @return A complex data integer representing the value. * @hide */ public static int floatToComplex(@FloatRange(from = -0x800000, to = 0x7FFFFF) float value) { // validate that the magnitude fits in this representation if (value < (float) -0x800000 - .5f || value >= (float) 0x800000 - .5f) { throw new IllegalArgumentException("Magnitude of the value is too large: " + value); } try { // If there's no fraction, use integer representation, as that's clearer if (value == (float) (int) value) { return createComplex((int) value, TypedValue.COMPLEX_RADIX_23p0); } float absValue = Math.abs(value); // If the magnitude is 0, we don't need any magnitude digits if (absValue < 1f) { return createComplex(Math.round(value * (1 << 23)), TypedValue.COMPLEX_RADIX_0p23); } // If the magnitude is less than 2^8, use 8 magnitude digits if (absValue < (float) (1 << 8)) { return createComplex(Math.round(value * (1 << 15)), TypedValue.COMPLEX_RADIX_8p15); } // If the magnitude is less than 2^16, use 16 magnitude digits if (absValue < (float) (1 << 16)) { return createComplex(Math.round(value * (1 << 7)), TypedValue.COMPLEX_RADIX_16p7); } // The magnitude requires all 23 digits return createComplex(Math.round(value), TypedValue.COMPLEX_RADIX_23p0); } catch (IllegalArgumentException ex) { // Wrap exception so as to include the value argument in the message. throw new IllegalArgumentException("Unable to convert value to complex: " + value, ex); } } /** *
Creates a complex data integer that stores a dimension value and units. * *
The resulting value can be passed to e.g. * {@link TypedValue#complexToDimensionPixelOffset(int, DisplayMetrics)} to calculate the pixel * value for the dimension. * * @param value the value of the dimension * @param units the units of the dimension, e.g. {@link TypedValue#COMPLEX_UNIT_DIP} * @return A complex data integer representing the value and units of the dimension. * @hide */ public static int createComplexDimension( @IntRange(from = -0x800000, to = 0x7FFFFF) int value, @ComplexDimensionUnit int units) { if (units < TypedValue.COMPLEX_UNIT_PX || units > TypedValue.COMPLEX_UNIT_MM) { throw new IllegalArgumentException("Must be a valid COMPLEX_UNIT_*: " + units); } return intToComplex(value) | units; } /** *
Creates a complex data integer that stores a dimension value and units. * *
The resulting value can be passed to e.g.
* {@link TypedValue#complexToDimensionPixelOffset(int, DisplayMetrics)} to calculate the pixel
* value for the dimension.
*
* @param value the value of the dimension
* @param units the units of the dimension, e.g. {@link TypedValue#COMPLEX_UNIT_DIP}
* @return A complex data integer representing the value and units of the dimension.
* @hide
*/
public static int createComplexDimension(
@FloatRange(from = -0x800000, to = 0x7FFFFF) float value,
@ComplexDimensionUnit int units) {
if (units < TypedValue.COMPLEX_UNIT_PX || units > TypedValue.COMPLEX_UNIT_MM) {
throw new IllegalArgumentException("Must be a valid COMPLEX_UNIT_*: " + units);
}
return floatToComplex(value) | units;
}
/**
* Converts a complex data value holding a fraction to its final floating
* point value. The given data must be structured as a
* {@link #TYPE_FRACTION}.
*
* @param data A complex data value holding a unit, magnitude, and
* mantissa.
* @param base The base value of this fraction. In other words, a
* standard fraction is multiplied by this value.
* @param pbase The parent base value of this fraction. In other
* words, a parent fraction (nn%p) is multiplied by this
* value.
*
* @return The complex floating point value multiplied by the appropriate
* base value depending on its unit.
*/
public static float complexToFraction(int data, float base, float pbase)
{
switch ((data>>COMPLEX_UNIT_SHIFT)&COMPLEX_UNIT_MASK) {
case COMPLEX_UNIT_FRACTION:
return complexToFloat(data) * base;
case COMPLEX_UNIT_FRACTION_PARENT:
return complexToFloat(data) * pbase;
}
return 0;
}
/**
* Return the data for this value as a fraction. Only use for values whose
* type is {@link #TYPE_FRACTION}.
*
* @param base The base value of this fraction. In other words, a
* standard fraction is multiplied by this value.
* @param pbase The parent base value of this fraction. In other
* words, a parent fraction (nn%p) is multiplied by this
* value.
*
* @return The complex floating point value multiplied by the appropriate
* base value depending on its unit.
*/
public float getFraction(float base, float pbase)
{
return complexToFraction(data, base, pbase);
}
/**
* Regardless of the actual type of the value, try to convert it to a
* string value. For example, a color type will be converted to a
* string of the form #aarrggbb.
*
* @return CharSequence The coerced string value. If the value is
* null or the type is not known, null is returned.
*/
public final CharSequence coerceToString()
{
int t = type;
if (t == TYPE_STRING) {
return string;
}
return coerceToString(t, data);
}
private static final String[] DIMENSION_UNIT_STRS = new String[] {
"px", "dip", "sp", "pt", "in", "mm"
};
private static final String[] FRACTION_UNIT_STRS = new String[] {
"%", "%p"
};
/**
* Perform type conversion as per {@link #coerceToString()} on an
* explicitly supplied type and data.
*
* @param type The data type identifier.
* @param data The data value.
*
* @return String The coerced string value. If the value is
* null or the type is not known, null is returned.
*/
public static final String coerceToString(int type, int data)
{
switch (type) {
case TYPE_NULL:
return null;
case TYPE_REFERENCE:
return "@" + data;
case TYPE_ATTRIBUTE:
return "?" + data;
case TYPE_FLOAT:
return Float.toString(Float.intBitsToFloat(data));
case TYPE_DIMENSION:
return Float.toString(complexToFloat(data)) + DIMENSION_UNIT_STRS[
(data>>COMPLEX_UNIT_SHIFT)&COMPLEX_UNIT_MASK];
case TYPE_FRACTION:
return Float.toString(complexToFloat(data)*100) + FRACTION_UNIT_STRS[
(data>>COMPLEX_UNIT_SHIFT)&COMPLEX_UNIT_MASK];
case TYPE_INT_HEX:
return "0x" + Integer.toHexString(data);
case TYPE_INT_BOOLEAN:
return data != 0 ? "true" : "false";
}
if (type >= TYPE_FIRST_COLOR_INT && type <= TYPE_LAST_COLOR_INT) {
return "#" + Integer.toHexString(data);
} else if (type >= TYPE_FIRST_INT && type <= TYPE_LAST_INT) {
return Integer.toString(data);
}
return null;
}
public void setTo(TypedValue other)
{
type = other.type;
string = other.string;
data = other.data;
assetCookie = other.assetCookie;
resourceId = other.resourceId;
density = other.density;
}
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("TypedValue{t=0x").append(Integer.toHexString(type));
sb.append("/d=0x").append(Integer.toHexString(data));
if (type == TYPE_STRING) {
sb.append(" \"").append(string != null ? string : "