| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.layoutlib.bridge; |
| |
| import com.android.internal.util.XmlUtils; |
| import com.android.layoutlib.api.IResourceValue; |
| import com.android.layoutlib.api.IStyleResourceValue; |
| |
| import org.kxml2.io.KXmlParser; |
| import org.xmlpull.v1.XmlPullParser; |
| |
| import android.content.res.ColorStateList; |
| import android.content.res.Resources; |
| import android.content.res.TypedArray; |
| import android.graphics.drawable.Drawable; |
| import android.util.DisplayMetrics; |
| import android.util.TypedValue; |
| import android.view.ViewGroup.LayoutParams; |
| |
| import java.io.File; |
| import java.io.FileReader; |
| import java.util.Map; |
| |
| /** |
| * TODO: describe. |
| */ |
| public final class BridgeTypedArray extends TypedArray { |
| |
| @SuppressWarnings("hiding") |
| private BridgeResources mResources; |
| private BridgeContext mContext; |
| @SuppressWarnings("hiding") |
| private IResourceValue[] mData; |
| private String[] mNames; |
| private final boolean mPlatformFile; |
| |
| public BridgeTypedArray(BridgeResources resources, BridgeContext context, int len, |
| boolean platformFile) { |
| super(null, null, null, 0); |
| mResources = resources; |
| mContext = context; |
| mPlatformFile = platformFile; |
| mData = new IResourceValue[len]; |
| mNames = new String[len]; |
| } |
| |
| /** A bridge-specific method that sets a value in the type array */ |
| public void bridgeSetValue(int index, String name, IResourceValue value) { |
| mData[index] = value; |
| mNames[index] = name; |
| } |
| |
| /** |
| * Seals the array after all calls to {@link #bridgeSetValue(int, String, IResourceValue)} have |
| * been done. |
| * <p/>This allows to compute the list of non default values, permitting |
| * {@link #getIndexCount()} to return the proper value. |
| */ |
| public void sealArray() { |
| // fills TypedArray.mIndices which is used to implement getIndexCount/getIndexAt |
| // first count the array size |
| int count = 0; |
| for (IResourceValue data : mData) { |
| if (data != null) { |
| count++; |
| } |
| } |
| |
| // allocate the table with an extra to store the size |
| mIndices = new int[count+1]; |
| mIndices[0] = count; |
| |
| // fill the array with the indices. |
| int index = 1; |
| for (int i = 0 ; i < mData.length ; i++) { |
| if (mData[i] != null) { |
| mIndices[index++] = i; |
| } |
| } |
| } |
| |
| /** |
| * Return the number of values in this array. |
| */ |
| @Override |
| public int length() { |
| return mData.length; |
| } |
| |
| /** |
| * Return the Resources object this array was loaded from. |
| */ |
| @Override |
| public Resources getResources() { |
| return mResources; |
| } |
| |
| /** |
| * Retrieve the styled string value for the attribute at <var>index</var>. |
| * |
| * @param index Index of attribute to retrieve. |
| * |
| * @return CharSequence holding string data. May be styled. Returns |
| * null if the attribute is not defined. |
| */ |
| @Override |
| public CharSequence getText(int index) { |
| if (mData[index] != null) { |
| // FIXME: handle styled strings! |
| return mData[index].getValue(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Retrieve the string value for the attribute at <var>index</var>. |
| * |
| * @param index Index of attribute to retrieve. |
| * |
| * @return String holding string data. Any styling information is |
| * removed. Returns null if the attribute is not defined. |
| */ |
| @Override |
| public String getString(int index) { |
| if (mData[index] != null) { |
| return mData[index].getValue(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Retrieve the boolean value for the attribute at <var>index</var>. |
| * |
| * @param index Index of attribute to retrieve. |
| * @param defValue Value to return if the attribute is not defined. |
| * |
| * @return Attribute boolean value, or defValue if not defined. |
| */ |
| @Override |
| public boolean getBoolean(int index, boolean defValue) { |
| if (mData[index] == null) { |
| return defValue; |
| } |
| |
| String s = mData[index].getValue(); |
| if (s != null) { |
| return XmlUtils.convertValueToBoolean(s, defValue); |
| } |
| |
| return defValue; |
| } |
| |
| /** |
| * Retrieve the integer value for the attribute at <var>index</var>. |
| * |
| * @param index Index of attribute to retrieve. |
| * @param defValue Value to return if the attribute is not defined. |
| * |
| * @return Attribute int value, or defValue if not defined. |
| */ |
| @Override |
| public int getInt(int index, int defValue) { |
| if (mData[index] == null) { |
| return defValue; |
| } |
| |
| String s = mData[index].getValue(); |
| |
| try { |
| return (s == null) ? defValue : XmlUtils.convertValueToInt(s, defValue); |
| } catch (NumberFormatException e) { |
| // pass |
| } |
| |
| // Field is not null and is not an integer. |
| // Check for possible constants and try to find them. |
| // Get the map of attribute-constant -> IntegerValue |
| Map<String, Integer> map = Bridge.getEnumValues(mNames[index]); |
| |
| if (map != null) { |
| // accumulator to store the value of the 1+ constants. |
| int result = 0; |
| |
| // split the value in case this is a mix of several flags. |
| String[] keywords = s.split("\\|"); |
| for (String keyword : keywords) { |
| Integer i = map.get(keyword.trim()); |
| if (i != null) { |
| result |= i.intValue(); |
| } else { |
| mContext.getLogger().warning(String.format( |
| "Unknown constant \"%s\" in attribute \"%2$s\"", |
| keyword, mNames[index])); |
| } |
| } |
| return result; |
| } |
| |
| return defValue; |
| } |
| |
| /** |
| * Retrieve the float value for the attribute at <var>index</var>. |
| * |
| * @param index Index of attribute to retrieve. |
| * |
| * @return Attribute float value, or defValue if not defined.. |
| */ |
| @Override |
| public float getFloat(int index, float defValue) { |
| if (mData[index] == null) { |
| return defValue; |
| } |
| |
| String s = mData[index].getValue(); |
| |
| if (s != null) { |
| try { |
| return Float.parseFloat(s); |
| } catch (NumberFormatException e) { |
| mContext.getLogger().warning(String.format( |
| "Unable to convert \"%s\" into a float in attribute \"%2$s\"", |
| s, mNames[index])); |
| |
| // we'll return the default value below. |
| } |
| } |
| return defValue; |
| } |
| |
| /** |
| * Retrieve the color value for the attribute at <var>index</var>. If |
| * the attribute references a color resource holding a complex |
| * {@link android.content.res.ColorStateList}, then the default color from |
| * the set is returned. |
| * |
| * @param index Index of attribute to retrieve. |
| * @param defValue Value to return if the attribute is not defined or |
| * not a resource. |
| * |
| * @return Attribute color value, or defValue if not defined. |
| */ |
| @Override |
| public int getColor(int index, int defValue) { |
| if (mData[index] == null) { |
| return defValue; |
| } |
| |
| String s = mData[index].getValue(); |
| try { |
| return ResourceHelper.getColor(s); |
| } catch (NumberFormatException e) { |
| mContext.getLogger().warning(String.format( |
| "Unable to convert \"%s\" into a color in attribute \"%2$s\"", |
| s, mNames[index])); |
| |
| // we'll return the default value below. |
| } |
| |
| return defValue; |
| } |
| |
| /** |
| * Retrieve the ColorStateList for the attribute at <var>index</var>. |
| * The value may be either a single solid color or a reference to |
| * a color or complex {@link android.content.res.ColorStateList} description. |
| * |
| * @param index Index of attribute to retrieve. |
| * |
| * @return ColorStateList for the attribute, or null if not defined. |
| */ |
| @Override |
| public ColorStateList getColorStateList(int index) { |
| if (mData[index] == null) { |
| return null; |
| } |
| |
| String value = mData[index].getValue(); |
| |
| if (value == null) { |
| return null; |
| } |
| |
| try { |
| int color = ResourceHelper.getColor(value); |
| return ColorStateList.valueOf(color); |
| } catch (NumberFormatException e) { |
| // if it's not a color value, we'll attempt to read the xml based color below. |
| } |
| |
| // let the framework inflate the ColorStateList from the XML file. |
| try { |
| File f = new File(value); |
| if (f.isFile()) { |
| KXmlParser parser = new KXmlParser(); |
| parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true); |
| parser.setInput(new FileReader(f)); |
| |
| ColorStateList colorStateList = ColorStateList.createFromXml( |
| mContext.getResources(), |
| // FIXME: we need to know if this resource is platform or not |
| new BridgeXmlBlockParser(parser, mContext, false)); |
| return colorStateList; |
| } |
| } catch (Exception e) { |
| // this is an error and not warning since the file existence is checked before |
| // attempting to parse it. |
| mContext.getLogger().error(e); |
| |
| // return null below. |
| } |
| |
| // looks like were unable to resolve the color value. |
| mContext.getLogger().warning(String.format( |
| "Unable to resolve color value \"%1$s\" in attribute \"%2$s\"", |
| value, mNames[index])); |
| |
| return null; |
| } |
| |
| /** |
| * Retrieve the integer value for the attribute at <var>index</var>. |
| * |
| * @param index Index of attribute to retrieve. |
| * @param defValue Value to return if the attribute is not defined or |
| * not a resource. |
| * |
| * @return Attribute integer value, or defValue if not defined. |
| */ |
| @Override |
| public int getInteger(int index, int defValue) { |
| if (mData[index] == null) { |
| return defValue; |
| } |
| |
| String s = mData[index].getValue(); |
| |
| if (s != null) { |
| try { |
| return Integer.parseInt(s); |
| } catch (NumberFormatException e) { |
| mContext.getLogger().warning(String.format( |
| "Unable to convert \"%s\" into a integer in attribute \"%2$s\"", |
| s, mNames[index])); |
| |
| // The default value is returned below. |
| } |
| } |
| |
| return defValue; |
| } |
| |
| /** |
| * Retrieve a dimensional unit attribute at <var>index</var>. Unit |
| * conversions are based on the current {@link DisplayMetrics} |
| * associated with the resources this {@link TypedArray} object |
| * came from. |
| * |
| * @param index Index of attribute to retrieve. |
| * @param defValue Value to return if the attribute is not defined or |
| * not a resource. |
| * |
| * @return Attribute dimension value multiplied by the appropriate |
| * metric, or defValue if not defined. |
| * |
| * @see #getDimensionPixelOffset |
| * @see #getDimensionPixelSize |
| */ |
| @Override |
| public float getDimension(int index, float defValue) { |
| if (mData[index] == null) { |
| return defValue; |
| } |
| |
| String s = mData[index].getValue(); |
| |
| if (s == null) { |
| return defValue; |
| } else if (s.equals(BridgeConstants.FILL_PARENT)) { |
| return LayoutParams.FILL_PARENT; |
| } else if (s.equals(BridgeConstants.WRAP_CONTENT)) { |
| return LayoutParams.WRAP_CONTENT; |
| } |
| |
| if (ResourceHelper.stringToFloat(s, mValue)) { |
| return mValue.getDimension(mResources.mMetrics); |
| } |
| |
| // looks like we were unable to resolve the dimension value |
| mContext.getLogger().warning(String.format( |
| "Unable to resolve dimension value \"%1$s\" in attribute \"%2$s\"", |
| s, mNames[index])); |
| |
| return defValue; |
| } |
| |
| /** |
| * Retrieve a dimensional unit attribute at <var>index</var> for use |
| * as an offset in raw pixels. This is the same as |
| * {@link #getDimension}, except the returned value is converted to |
| * integer pixels for you. An offset conversion involves simply |
| * truncating the base value to an integer. |
| * |
| * @param index Index of attribute to retrieve. |
| * @param defValue Value to return if the attribute is not defined or |
| * not a resource. |
| * |
| * @return Attribute dimension value multiplied by the appropriate |
| * metric and truncated to integer pixels, or defValue if not defined. |
| * |
| * @see #getDimension |
| * @see #getDimensionPixelSize |
| */ |
| @Override |
| public int getDimensionPixelOffset(int index, int defValue) { |
| return (int) getDimension(index, defValue); |
| } |
| |
| /** |
| * Retrieve a dimensional unit attribute at <var>index</var> for use |
| * as a size in raw pixels. This is the same as |
| * {@link #getDimension}, 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. |
| * |
| * @param index Index of attribute to retrieve. |
| * @param defValue Value to return if the attribute is not defined or |
| * not a resource. |
| * |
| * @return Attribute dimension value multiplied by the appropriate |
| * metric and truncated to integer pixels, or defValue if not defined. |
| * |
| * @see #getDimension |
| * @see #getDimensionPixelOffset |
| */ |
| @Override |
| public int getDimensionPixelSize(int index, int defValue) { |
| if (mData[index] == null) { |
| return defValue; |
| } |
| |
| String s = mData[index].getValue(); |
| |
| if (s == null) { |
| return defValue; |
| } else if (s.equals(BridgeConstants.FILL_PARENT)) { |
| return LayoutParams.FILL_PARENT; |
| } else if (s.equals(BridgeConstants.WRAP_CONTENT)) { |
| return LayoutParams.WRAP_CONTENT; |
| } |
| |
| // FIXME huh? |
| |
| float f = getDimension(index, defValue); |
| final int res = (int)(f+0.5f); |
| if (res != 0) return res; |
| if (f == 0) return 0; |
| if (f > 0) return 1; |
| |
| throw new UnsupportedOperationException("Can't convert to dimension: " + |
| Integer.toString(index)); |
| } |
| |
| /** |
| * Special version of {@link #getDimensionPixelSize} for retrieving |
| * {@link android.view.ViewGroup}'s layout_width and layout_height |
| * attributes. This is only here for performance reasons; applications |
| * should use {@link #getDimensionPixelSize}. |
| * |
| * @param index Index of the attribute to retrieve. |
| * @param name Textual name of attribute for error reporting. |
| * |
| * @return Attribute dimension value multiplied by the appropriate |
| * metric and truncated to integer pixels. |
| */ |
| @Override |
| public int getLayoutDimension(int index, String name) { |
| return getDimensionPixelSize(index, 0); |
| } |
| |
| @Override |
| public int getLayoutDimension(int index, int defValue) { |
| return getDimensionPixelSize(index, defValue); |
| } |
| |
| /** |
| * Retrieve a fractional unit attribute at <var>index</var>. |
| * |
| * @param index Index of attribute to retrieve. |
| * @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. |
| * @param defValue Value to return if the attribute is not defined or |
| * not a resource. |
| * |
| * @return Attribute fractional value multiplied by the appropriate |
| * base value, or defValue if not defined. |
| */ |
| @Override |
| public float getFraction(int index, int base, int pbase, float defValue) { |
| if (mData[index] == null) { |
| return defValue; |
| } |
| |
| String value = mData[index].getValue(); |
| if (value == null) { |
| return defValue; |
| } |
| |
| if (ResourceHelper.stringToFloat(value, mValue)) { |
| return mValue.getFraction(base, pbase); |
| } |
| |
| // looks like we were unable to resolve the fraction value |
| mContext.getLogger().warning(String.format( |
| "Unable to resolve fraction value \"%1$s\" in attribute \"%2$s\"", |
| value, mNames[index])); |
| |
| return defValue; |
| } |
| |
| /** |
| * Retrieve the resource identifier for the attribute at |
| * <var>index</var>. Note that attribute resource as resolved when |
| * the overall {@link TypedArray} object is retrieved. As a |
| * result, this function will return the resource identifier of the |
| * final resource value that was found, <em>not</em> necessarily the |
| * original resource that was specified by the attribute. |
| * |
| * @param index Index of attribute to retrieve. |
| * @param defValue Value to return if the attribute is not defined or |
| * not a resource. |
| * |
| * @return Attribute resource identifier, or defValue if not defined. |
| */ |
| @Override |
| public int getResourceId(int index, int defValue) { |
| // get the IResource for this index |
| IResourceValue resValue = mData[index]; |
| |
| // no data, return the default value. |
| if (resValue == null) { |
| return defValue; |
| } |
| |
| // check if this is a style resource |
| if (resValue instanceof IStyleResourceValue) { |
| // get the id that will represent this style. |
| return mContext.getDynamicIdByStyle((IStyleResourceValue)resValue); |
| } |
| |
| // if the attribute was a reference to an id, and not a declaration of an id (@+id), then |
| // the xml attribute value was "resolved" which leads us to a IResourceValue with |
| // getType() returning "id" and getName() returning the id name |
| // (and getValue() returning null!). We need to handle this! |
| if (resValue.getType() != null && resValue.getType().equals(BridgeConstants.RES_ID)) { |
| // if this is a framework id |
| if (mPlatformFile || resValue.isFramework()) { |
| // look for idName in the android R classes |
| return mContext.getFrameworkIdValue(resValue.getName(), defValue); |
| } |
| |
| // look for idName in the project R class. |
| return mContext.getProjectIdValue(resValue.getName(), defValue); |
| } |
| |
| // else, try to get the value, and resolve it somehow. |
| String value = resValue.getValue(); |
| if (value == null) { |
| return defValue; |
| } |
| |
| // if the value is just an integer, return it. |
| try { |
| int i = Integer.parseInt(value); |
| if (Integer.toString(i).equals(value)) { |
| return i; |
| } |
| } catch (NumberFormatException e) { |
| // pass |
| } |
| |
| // Handle the @id/<name>, @+id/<name> and @android:id/<name> |
| // We need to return the exact value that was compiled (from the various R classes), |
| // as these values can be reused internally with calls to findViewById(). |
| // There's a trick with platform layouts that not use "android:" but their IDs are in |
| // fact in the android.R and com.android.internal.R classes. |
| // The field mPlatformFile will indicate that all IDs are to be looked up in the android R |
| // classes exclusively. |
| |
| // if this is a reference to an id, find it. |
| if (value.startsWith("@id/") || value.startsWith("@+") || |
| value.startsWith("@android:id/")) { |
| |
| int pos = value.indexOf('/'); |
| String idName = value.substring(pos + 1); |
| |
| // if this is a framework id |
| if (mPlatformFile || value.startsWith("@android") || value.startsWith("@+android")) { |
| // look for idName in the android R classes |
| return mContext.getFrameworkIdValue(idName, defValue); |
| } |
| |
| // look for idName in the project R class. |
| return mContext.getProjectIdValue(idName, defValue); |
| } |
| |
| // not a direct id valid reference? resolve it |
| Integer idValue = null; |
| |
| if (resValue.isFramework()) { |
| idValue = Bridge.getResourceValue(resValue.getType(), resValue.getName()); |
| } else { |
| idValue = mContext.getProjectCallback().getResourceValue( |
| resValue.getType(), resValue.getName()); |
| } |
| |
| if (idValue != null) { |
| return idValue.intValue(); |
| } |
| |
| mContext.getLogger().warning(String.format( |
| "Unable to resolve id \"%1$s\" for attribute \"%2$s\"", value, mNames[index])); |
| return defValue; |
| } |
| |
| /** |
| * Retrieve the Drawable for the attribute at <var>index</var>. This |
| * gets the resource ID of the selected attribute, and uses |
| * {@link Resources#getDrawable Resources.getDrawable} of the owning |
| * Resources object to retrieve its Drawable. |
| * |
| * @param index Index of attribute to retrieve. |
| * |
| * @return Drawable for the attribute, or null if not defined. |
| */ |
| @Override |
| public Drawable getDrawable(int index) { |
| if (mData[index] == null) { |
| return null; |
| } |
| |
| IResourceValue value = mData[index]; |
| String stringValue = value.getValue(); |
| if (stringValue == null || BridgeConstants.REFERENCE_NULL.equals(stringValue)) { |
| return null; |
| } |
| |
| Drawable d = ResourceHelper.getDrawable(value, mContext, mData[index].isFramework()); |
| |
| if (d != null) { |
| return d; |
| } |
| |
| // looks like we were unable to resolve the drawable |
| mContext.getLogger().warning(String.format( |
| "Unable to resolve drawable \"%1$s\" in attribute \"%2$s\"", value, mNames[index])); |
| |
| return null; |
| } |
| |
| |
| /** |
| * Retrieve the CharSequence[] for the attribute at <var>index</var>. |
| * This gets the resource ID of the selected attribute, and uses |
| * {@link Resources#getTextArray Resources.getTextArray} of the owning |
| * Resources object to retrieve its String[]. |
| * |
| * @param index Index of attribute to retrieve. |
| * |
| * @return CharSequence[] for the attribute, or null if not defined. |
| */ |
| @Override |
| public CharSequence[] getTextArray(int index) { |
| if (mData[index] == null) { |
| return null; |
| } |
| |
| String value = mData[index].getValue(); |
| if (value != null) { |
| return new CharSequence[] { value }; |
| } |
| |
| mContext.getLogger().warning(String.format( |
| String.format("Unknown value for getTextArray(%d) => %s", //DEBUG |
| index, mData[index].getName()))); |
| |
| return null; |
| } |
| |
| /** |
| * Retrieve the raw TypedValue for the attribute at <var>index</var>. |
| * |
| * @param index Index of attribute to retrieve. |
| * @param outValue TypedValue object in which to place the attribute's |
| * data. |
| * |
| * @return Returns true if the value was retrieved, else false. |
| */ |
| @Override |
| public boolean getValue(int index, TypedValue outValue) { |
| if (mData[index] == null) { |
| return false; |
| } |
| |
| String s = mData[index].getValue(); |
| |
| return ResourceHelper.stringToFloat(s, outValue); |
| } |
| |
| /** |
| * Determines whether there is an attribute at <var>index</var>. |
| * |
| * @param index Index of attribute to retrieve. |
| * |
| * @return True if the attribute has a value, false otherwise. |
| */ |
| @Override |
| public boolean hasValue(int index) { |
| return mData[index] != null; |
| } |
| |
| /** |
| * Retrieve the raw TypedValue for the attribute at <var>index</var> |
| * and return a temporary object holding its data. This object is only |
| * valid until the next call on to {@link TypedArray}. |
| * |
| * @param index Index of attribute to retrieve. |
| * |
| * @return Returns a TypedValue object if the attribute is defined, |
| * containing its data; otherwise returns null. (You will not |
| * receive a TypedValue whose type is TYPE_NULL.) |
| */ |
| @Override |
| public TypedValue peekValue(int index) { |
| if (getValue(index, mValue)) { |
| return mValue; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns a message about the parser state suitable for printing error messages. |
| */ |
| @Override |
| public String getPositionDescription() { |
| return "<internal -- stub if needed>"; |
| } |
| |
| /** |
| * Give back a previously retrieved StyledAttributes, for later re-use. |
| */ |
| @Override |
| public void recycle() { |
| // pass |
| } |
| |
| @Override |
| public boolean getValueAt(int index, TypedValue outValue) { |
| // pass |
| return false; |
| } |
| |
| @Override |
| public String toString() { |
| return mData.toString(); |
| } |
| } |
