refactor source tree organization, switch to meson

src/api-impl/android/content/ActivityNotFoundException.java

@@ -0,0 +1,5 @@
+package android.content;
+
+public class ActivityNotFoundException extends Exception {
+
+}

src/api-impl/android/content/BroadcastReceiver.java

@@ -0,0 +1,5 @@
+package android.content;
+
+public class BroadcastReceiver {
+
+}

src/api-impl/android/content/ComponentName.java

@@ -0,0 +1,262 @@
+/*
+ * Copyright (C) 2006 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 android.content;
+
+import java.io.PrintWriter;
+import java.lang.Comparable;
+
+/**
+ * Identifier for a specific application component
+ * ({@link android.app.Activity}, {@link android.app.Service},
+ * {@link android.content.BroadcastReceiver}, or
+ * {@link android.content.ContentProvider}) that is available.  Two
+ * pieces of information, encapsulated here, are required to identify
+ * a component: the package (a String) it exists in, and the class (a String)
+ * name inside of that package.
+ * 
+ */
+public final class ComponentName implements Cloneable, Comparable<ComponentName> {
+    private final String mPackage;
+    private final String mClass;
+
+    /**
+     * Create a new component identifier.
+     * 
+     * @param pkg The name of the package that the component exists in.  Can
+     * not be null.
+     * @param cls The name of the class inside of <var>pkg</var> that
+     * implements the component.  Can not be null.
+     */
+    public ComponentName(String pkg, String cls) {
+        if (pkg == null) throw new NullPointerException("package name is null");
+        if (cls == null) throw new NullPointerException("class name is null");
+        mPackage = pkg;
+        mClass = cls;
+    }
+
+    /**
+     * Create a new component identifier from a Context and class name.
+     * 
+     * @param pkg A Context for the package implementing the component,
+     * from which the actual package name will be retrieved.
+     * @param cls The name of the class inside of <var>pkg</var> that
+     * implements the component.
+     */
+    public ComponentName(Context pkg, String cls) {
+        if (cls == null) throw new NullPointerException("class name is null");
+        mPackage = pkg.getPackageName();
+        mClass = cls;
+    }
+
+    /**
+     * Create a new component identifier from a Context and Class object.
+     * 
+     * @param pkg A Context for the package implementing the component, from
+     * which the actual package name will be retrieved.
+     * @param cls The Class object of the desired component, from which the
+     * actual class name will be retrieved.
+     */
+    public ComponentName(Context pkg, Class<?> cls) {
+        mPackage = pkg.getPackageName();
+        mClass = cls.getName();
+    }
+
+    public ComponentName clone() {
+        return new ComponentName(mPackage, mClass);
+    }
+
+    /**
+     * Return the package name of this component.
+     */
+    public String getPackageName() {
+        return mPackage;
+    }
+    
+    /**
+     * Return the class name of this component.
+     */
+    public String getClassName() {
+        return mClass;
+    }
+    
+    /**
+     * Return the class name, either fully qualified or in a shortened form
+     * (with a leading '.') if it is a suffix of the package.
+     */
+    public String getShortClassName() {
+        if (mClass.startsWith(mPackage)) {
+            int PN = mPackage.length();
+            int CN = mClass.length();
+            if (CN > PN && mClass.charAt(PN) == '.') {
+                return mClass.substring(PN, CN);
+            }
+        }
+        return mClass;
+    }
+    
+    private static void appendShortClassName(StringBuilder sb, String packageName,
+            String className) {
+        if (className.startsWith(packageName)) {
+            int PN = packageName.length();
+            int CN = className.length();
+            if (CN > PN && className.charAt(PN) == '.') {
+                sb.append(className, PN, CN);
+                return;
+            }
+        }
+        sb.append(className);
+    }
+
+    private static void printShortClassName(PrintWriter pw, String packageName,
+            String className) {
+        if (className.startsWith(packageName)) {
+            int PN = packageName.length();
+            int CN = className.length();
+            if (CN > PN && className.charAt(PN) == '.') {
+                pw.write(className, PN, CN-PN);
+                return;
+            }
+        }
+        pw.print(className);
+    }
+
+    /**
+     * Return a String that unambiguously describes both the package and
+     * class names contained in the ComponentName.  You can later recover
+     * the ComponentName from this string through
+     * {@link #unflattenFromString(String)}.
+     * 
+     * @return Returns a new String holding the package and class names.  This
+     * is represented as the package name, concatenated with a '/' and then the
+     * class name.
+     * 
+     * @see #unflattenFromString(String)
+     */
+    public String flattenToString() {
+        return mPackage + "/" + mClass;
+    }
+    
+    /**
+     * The same as {@link #flattenToString()}, but abbreviates the class
+     * name if it is a suffix of the package.  The result can still be used
+     * with {@link #unflattenFromString(String)}.
+     * 
+     * @return Returns a new String holding the package and class names.  This
+     * is represented as the package name, concatenated with a '/' and then the
+     * class name.
+     * 
+     * @see #unflattenFromString(String)
+     */
+    public String flattenToShortString() {
+        StringBuilder sb = new StringBuilder(mPackage.length() + mClass.length());
+        appendShortString(sb, mPackage, mClass);
+        return sb.toString();
+    }
+
+    /** @hide */
+    public void appendShortString(StringBuilder sb) {
+        appendShortString(sb, mPackage, mClass);
+    }
+
+    /** @hide */
+    public static void appendShortString(StringBuilder sb, String packageName, String className) {
+        sb.append(packageName).append('/');
+        appendShortClassName(sb, packageName, className);
+    }
+
+    /** @hide */
+    public static void printShortString(PrintWriter pw, String packageName, String className) {
+        pw.print(packageName);
+        pw.print('/');
+        printShortClassName(pw, packageName, className);
+    }
+
+    /**
+     * Recover a ComponentName from a String that was previously created with
+     * {@link #flattenToString()}.  It splits the string at the first '/',
+     * taking the part before as the package name and the part after as the
+     * class name.  As a special convenience (to use, for example, when
+     * parsing component names on the command line), if the '/' is immediately
+     * followed by a '.' then the final class name will be the concatenation
+     * of the package name with the string following the '/'.  Thus
+     * "com.foo/.Blah" becomes package="com.foo" class="com.foo.Blah".
+     * 
+     * @param str The String that was returned by flattenToString().
+     * @return Returns a new ComponentName containing the package and class
+     * names that were encoded in <var>str</var>
+     * 
+     * @see #flattenToString()
+     */
+    public static ComponentName unflattenFromString(String str) {
+        int sep = str.indexOf('/');
+        if (sep < 0 || (sep+1) >= str.length()) {
+            return null;
+        }
+        String pkg = str.substring(0, sep);
+        String cls = str.substring(sep+1);
+        if (cls.length() > 0 && cls.charAt(0) == '.') {
+            cls = pkg + cls;
+        }
+        return new ComponentName(pkg, cls);
+    }
+    
+    /**
+     * Return string representation of this class without the class's name
+     * as a prefix.
+     */
+    public String toShortString() {
+        return "{" + mPackage + "/" + mClass + "}";
+    }
+
+    @Override
+    public String toString() {
+        return "ComponentInfo{" + mPackage + "/" + mClass + "}";
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        try {
+            if (obj != null) {
+                ComponentName other = (ComponentName)obj;
+                // Note: no null checks, because mPackage and mClass can
+                // never be null.
+                return mPackage.equals(other.mPackage)
+                        && mClass.equals(other.mClass);
+            }
+        } catch (ClassCastException e) {
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return mPackage.hashCode() + mClass.hashCode();
+    }
+
+    public int compareTo(ComponentName that) {
+        int v;
+        v = this.mPackage.compareTo(that.mPackage);
+        if (v != 0) {
+            return v;
+        }
+        return this.mClass.compareTo(that.mClass);
+    }
+    
+    public int describeContents() {
+        return 0;
+    }
+}

src/api-impl/android/content/ContentResolver.java

@@ -0,0 +1,5 @@
+package android.content;
+
+public class ContentResolver {
+
+}

src/api-impl/android/content/ContentValues.java

@@ -0,0 +1,491 @@
+/*
+ * Copyright (C) 2007 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 android.content;
+
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * This class is used to store a set of values that the {@link ContentResolver}
+ * can process.
+ */
+public final class ContentValues {
+    public static final String TAG = "ContentValues";
+
+    /** Holds the actual values */
+    private HashMap<String, Object> mValues;
+
+    /**
+     * Creates an empty set of values using the default initial size
+     */
+    public ContentValues() {
+        // Choosing a default size of 8 based on analysis of typical
+        // consumption by applications.
+        mValues = new HashMap<String, Object>(8);
+    }
+
+    /**
+     * Creates an empty set of values using the given initial size
+     *
+     * @param size the initial size of the set of values
+     */
+    public ContentValues(int size) {
+        mValues = new HashMap<String, Object>(size, 1.0f);
+    }
+
+    /**
+     * Creates a set of values copied from the given set
+     *
+     * @param from the values to copy
+     */
+    public ContentValues(ContentValues from) {
+        mValues = new HashMap<String, Object>(from.mValues);
+    }
+
+    /**
+     * Creates a set of values copied from the given HashMap. This is used
+     * by the Parcel unmarshalling code.
+     *
+     * @param values the values to start with
+     * {@hide}
+     */
+    private ContentValues(HashMap<String, Object> values) {
+        mValues = values;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (!(object instanceof ContentValues)) {
+            return false;
+        }
+        return mValues.equals(((ContentValues) object).mValues);
+    }
+
+    @Override
+    public int hashCode() {
+        return mValues.hashCode();
+    }
+
+    /**
+     * Adds a value to the set.
+     *
+     * @param key the name of the value to put
+     * @param value the data for the value to put
+     */
+    public void put(String key, String value) {
+        mValues.put(key, value);
+    }
+
+    /**
+     * Adds all values from the passed in ContentValues.
+     *
+     * @param other the ContentValues from which to copy
+     */
+    public void putAll(ContentValues other) {
+        mValues.putAll(other.mValues);
+    }
+
+    /**
+     * Adds a value to the set.
+     *
+     * @param key the name of the value to put
+     * @param value the data for the value to put
+     */
+    public void put(String key, Byte value) {
+        mValues.put(key, value);
+    }
+
+    /**
+     * Adds a value to the set.
+     *
+     * @param key the name of the value to put
+     * @param value the data for the value to put
+     */
+    public void put(String key, Short value) {
+        mValues.put(key, value);
+    }
+
+    /**
+     * Adds a value to the set.
+     *
+     * @param key the name of the value to put
+     * @param value the data for the value to put
+     */
+    public void put(String key, Integer value) {
+        mValues.put(key, value);
+    }
+
+    /**
+     * Adds a value to the set.
+     *
+     * @param key the name of the value to put
+     * @param value the data for the value to put
+     */
+    public void put(String key, Long value) {
+        mValues.put(key, value);
+    }
+
+    /**
+     * Adds a value to the set.
+     *
+     * @param key the name of the value to put
+     * @param value the data for the value to put
+     */
+    public void put(String key, Float value) {
+        mValues.put(key, value);
+    }
+
+    /**
+     * Adds a value to the set.
+     *
+     * @param key the name of the value to put
+     * @param value the data for the value to put
+     */
+    public void put(String key, Double value) {
+        mValues.put(key, value);
+    }
+
+    /**
+     * Adds a value to the set.
+     *
+     * @param key the name of the value to put
+     * @param value the data for the value to put
+     */
+    public void put(String key, Boolean value) {
+        mValues.put(key, value);
+    }
+
+    /**
+     * Adds a value to the set.
+     *
+     * @param key the name of the value to put
+     * @param value the data for the value to put
+     */
+    public void put(String key, byte[] value) {
+        mValues.put(key, value);
+    }
+
+    /**
+     * Adds a null value to the set.
+     *
+     * @param key the name of the value to make null
+     */
+    public void putNull(String key) {
+        mValues.put(key, null);
+    }
+
+    /**
+     * Returns the number of values.
+     *
+     * @return the number of values
+     */
+    public int size() {
+        return mValues.size();
+    }
+
+    /**
+     * Remove a single value.
+     *
+     * @param key the name of the value to remove
+     */
+    public void remove(String key) {
+        mValues.remove(key);
+    }
+
+    /**
+     * Removes all values.
+     */
+    public void clear() {
+        mValues.clear();
+    }
+
+    /**
+     * Returns true if this object has the named value.
+     *
+     * @param key the value to check for
+     * @return {@code true} if the value is present, {@code false} otherwise
+     */
+    public boolean containsKey(String key) {
+        return mValues.containsKey(key);
+    }
+
+    /**
+     * Gets a value. Valid value types are {@link String}, {@link Boolean}, and
+     * {@link Number} implementations.
+     *
+     * @param key the value to get
+     * @return the data for the value
+     */
+    public Object get(String key) {
+        return mValues.get(key);
+    }
+
+    /**
+     * Gets a value and converts it to a String.
+     *
+     * @param key the value to get
+     * @return the String for the value
+     */
+    public String getAsString(String key) {
+        Object value = mValues.get(key);
+        return value != null ? value.toString() : null;
+    }
+
+    /**
+     * Gets a value and converts it to a Long.
+     *
+     * @param key the value to get
+     * @return the Long value, or null if the value is missing or cannot be converted
+     */
+    public Long getAsLong(String key) {
+        Object value = mValues.get(key);
+        try {
+            return value != null ? ((Number) value).longValue() : null;
+        } catch (ClassCastException e) {
+            if (value instanceof CharSequence) {
+                try {
+                    return Long.valueOf(value.toString());
+                } catch (NumberFormatException e2) {
+                    Log.e(TAG, "Cannot parse Long value for " + value + " at key " + key);
+                    return null;
+                }
+            } else {
+                Log.e(TAG, "Cannot cast value for " + key + " to a Long: " + value, e);
+                return null;
+            }
+        }
+    }
+
+    /**
+     * Gets a value and converts it to an Integer.
+     *
+     * @param key the value to get
+     * @return the Integer value, or null if the value is missing or cannot be converted
+     */
+    public Integer getAsInteger(String key) {
+        Object value = mValues.get(key);
+        try {
+            return value != null ? ((Number) value).intValue() : null;
+        } catch (ClassCastException e) {
+            if (value instanceof CharSequence) {
+                try {
+                    return Integer.valueOf(value.toString());
+                } catch (NumberFormatException e2) {
+                    Log.e(TAG, "Cannot parse Integer value for " + value + " at key " + key);
+                    return null;
+                }
+            } else {
+                Log.e(TAG, "Cannot cast value for " + key + " to a Integer: " + value, e);
+                return null;
+            }
+        }
+    }
+
+    /**
+     * Gets a value and converts it to a Short.
+     *
+     * @param key the value to get
+     * @return the Short value, or null if the value is missing or cannot be converted
+     */
+    public Short getAsShort(String key) {
+        Object value = mValues.get(key);
+        try {
+            return value != null ? ((Number) value).shortValue() : null;
+        } catch (ClassCastException e) {
+            if (value instanceof CharSequence) {
+                try {
+                    return Short.valueOf(value.toString());
+                } catch (NumberFormatException e2) {
+                    Log.e(TAG, "Cannot parse Short value for " + value + " at key " + key);
+                    return null;
+                }
+            } else {
+                Log.e(TAG, "Cannot cast value for " + key + " to a Short: " + value, e);
+                return null;
+            }
+        }
+    }
+
+    /**
+     * Gets a value and converts it to a Byte.
+     *
+     * @param key the value to get
+     * @return the Byte value, or null if the value is missing or cannot be converted
+     */
+    public Byte getAsByte(String key) {
+        Object value = mValues.get(key);
+        try {
+            return value != null ? ((Number) value).byteValue() : null;
+        } catch (ClassCastException e) {
+            if (value instanceof CharSequence) {
+                try {
+                    return Byte.valueOf(value.toString());
+                } catch (NumberFormatException e2) {
+                    Log.e(TAG, "Cannot parse Byte value for " + value + " at key " + key);
+                    return null;
+                }
+            } else {
+                Log.e(TAG, "Cannot cast value for " + key + " to a Byte: " + value, e);
+                return null;
+            }
+        }
+    }
+
+    /**
+     * Gets a value and converts it to a Double.
+     *
+     * @param key the value to get
+     * @return the Double value, or null if the value is missing or cannot be converted
+     */
+    public Double getAsDouble(String key) {
+        Object value = mValues.get(key);
+        try {
+            return value != null ? ((Number) value).doubleValue() : null;
+        } catch (ClassCastException e) {
+            if (value instanceof CharSequence) {
+                try {
+                    return Double.valueOf(value.toString());
+                } catch (NumberFormatException e2) {
+                    Log.e(TAG, "Cannot parse Double value for " + value + " at key " + key);
+                    return null;
+                }
+            } else {
+                Log.e(TAG, "Cannot cast value for " + key + " to a Double: " + value, e);
+                return null;
+            }
+        }
+    }
+
+    /**
+     * Gets a value and converts it to a Float.
+     *
+     * @param key the value to get
+     * @return the Float value, or null if the value is missing or cannot be converted
+     */
+    public Float getAsFloat(String key) {
+        Object value = mValues.get(key);
+        try {
+            return value != null ? ((Number) value).floatValue() : null;
+        } catch (ClassCastException e) {
+            if (value instanceof CharSequence) {
+                try {
+                    return Float.valueOf(value.toString());
+                } catch (NumberFormatException e2) {
+                    Log.e(TAG, "Cannot parse Float value for " + value + " at key " + key);
+                    return null;
+                }
+            } else {
+                Log.e(TAG, "Cannot cast value for " + key + " to a Float: " + value, e);
+                return null;
+            }
+        }
+    }
+
+    /**
+     * Gets a value and converts it to a Boolean.
+     *
+     * @param key the value to get
+     * @return the Boolean value, or null if the value is missing or cannot be converted
+     */
+    public Boolean getAsBoolean(String key) {
+        Object value = mValues.get(key);
+        try {
+            return (Boolean) value;
+        } catch (ClassCastException e) {
+            if (value instanceof CharSequence) {
+                return Boolean.valueOf(value.toString());
+            } else if (value instanceof Number) {
+                return ((Number) value).intValue() != 0;
+            } else {
+                Log.e(TAG, "Cannot cast value for " + key + " to a Boolean: " + value, e);
+                return null;
+            }
+        }
+    }
+
+    /**
+     * Gets a value that is a byte array. Note that this method will not convert
+     * any other types to byte arrays.
+     *
+     * @param key the value to get
+     * @return the byte[] value, or null is the value is missing or not a byte[]
+     */
+    public byte[] getAsByteArray(String key) {
+        Object value = mValues.get(key);
+        if (value instanceof byte[]) {
+            return (byte[]) value;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Returns a set of all of the keys and values
+     *
+     * @return a set of all of the keys and values
+     */
+    public Set<Map.Entry<String, Object>> valueSet() {
+        return mValues.entrySet();
+    }
+
+    /**
+     * Returns a set of all of the keys
+     *
+     * @return a set of all of the keys
+     */
+    public Set<String> keySet() {
+        return mValues.keySet();
+    }
+
+    /**
+     * Unsupported, here until we get proper bulk insert APIs.
+     * {@hide}
+     */
+    @Deprecated
+    public void putStringArrayList(String key, ArrayList<String> value) {
+        mValues.put(key, value);
+    }
+
+    /**
+     * Unsupported, here until we get proper bulk insert APIs.
+     * {@hide}
+     */
+    @SuppressWarnings("unchecked")
+    @Deprecated
+    public ArrayList<String> getStringArrayList(String key) {
+        return (ArrayList<String>) mValues.get(key);
+    }
+
+    /**
+     * Returns a string containing a concise, human-readable description of this object.
+     * @return a printable representation of this object.
+     */
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (String name : mValues.keySet()) {
+            String value = getAsString(name);
+            if (sb.length() > 0) sb.append(" ");
+            sb.append(name + "=" + value);
+        }
+        return sb.toString();
+    }
+}

src/api-impl/android/content/Context.java

@@ -0,0 +1,202 @@
+package android.content;
+
+import android.util.Log;
+
+import android.content.pm.PackageManager;
+import android.content.res.AssetManager;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.util.AttributeSet;
+import android.util.DisplayMetrics;
+import android.content.SharedPreferences;
+import android.app.SharedPreferencesImpl;
+import android.os.Looper;
+import android.app.Application;
+
+import android.view.WindowManager;
+import android.view.WindowManagerImpl;
+import android.text.ClipboardManager;
+import android.hardware.SensorManager;
+import android.net.ConnectivityManager;
+import android.app.KeyguardManager;
+import android.telephony.TelephonyManager;
+import android.media.AudioManager;
+import android.app.ActivityManager;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+public class Context extends Object {
+    private final static String TAG = "Context";
+
+	static AssetManager assets;
+	static DisplayMetrics dm;
+	static Configuration config;
+	static Resources r;
+
+	public /*← FIXME?*/ static Application this_application;
+
+	File data_dir = null;
+	File prefs_dir = null;
+	File files_dir = null;
+	File cache_dir = null;
+
+	static {
+		assets = new AssetManager();
+		dm = new DisplayMetrics();
+		config = new Configuration();
+		r = new Resources(assets, dm, config);
+		this_application = new Application(); // TODO: the application context is presumably not identical to the Activity context, what is the difference for us though?
+	}
+
+	public Context() {
+		System.out.println("new Context! this one is: " + this);
+	}
+
+	public Context getApplicationContext() {
+		return (Context)this_application;
+	}
+
+	public ContentResolver getContentResolver() {
+		return new ContentResolver();
+	}
+
+	public Object getSystemService(String name) {
+		switch (name) {
+			case "window":
+				return new WindowManagerImpl();
+			case "clipboard":
+				return new ClipboardManager();
+			case "sensor":
+				return new SensorManager();
+			case "connectivity":
+				return new ConnectivityManager();
+			case "keyguard":
+				return new KeyguardManager();
+			case "phone":
+				return new TelephonyManager();
+			case "audio":
+				return new AudioManager();
+			case "activity":
+				return new ActivityManager();
+			default:
+				System.out.println("!!!!!!! getSystemService: case >"+name+"< is not implemented yet");
+				return null;
+		}
+	}
+
+    public Looper getMainLooper() {
+		System.out.println("returning the main Looper, most definitely doing just that!");
+		return new Looper();
+	}
+
+	public String getPackageName() {
+		return "com.example.demo_app";
+	}
+
+	public final String getString(int resId) {
+		return r.getString(resId);
+	}
+
+	public PackageManager getPackageManager() {
+		return new PackageManager();
+	}
+
+	public Resources getResources() {
+		return r;
+	}
+
+	public AssetManager getAssets() {
+		return assets;
+	}
+
+    private File makeFilename(File base, String name) {
+        if (name.indexOf(File.separatorChar) < 0) {
+            return new File(base, name);
+        }
+        throw new IllegalArgumentException(
+                "File " + name + " contains a path separator");
+    }
+
+    private File getDataDirFile() {
+		if(data_dir == null) {
+			data_dir = new File("data/");
+		}
+		return data_dir;
+    }
+
+    public File getFilesDir() {
+        if (files_dir == null) {
+            files_dir = new File(getDataDirFile(), "files");
+        }
+        if (!files_dir.exists()) {
+            if(!files_dir.mkdirs()) {
+                if (files_dir.exists()) {
+                    // spurious failure; probably racing with another process for this app
+                    return files_dir;
+                }
+                Log.w(TAG, "Unable to create files directory " + files_dir.getPath());
+                return null;
+            }
+        }
+        return files_dir;
+    }
+
+	// FIXME: should be something like /tmp/cache, but may need to create that directory
+	public File getCacheDir() {
+            if (cache_dir == null) {
+                cache_dir = new File("/tmp/");
+            }
+            return cache_dir;
+	}
+
+    private File getPreferencesDir() {
+            if (prefs_dir == null) {
+                prefs_dir = new File(getDataDirFile(), "shared_prefs");
+            }
+            return prefs_dir;
+    }
+
+    public File getSharedPrefsFile(String name) {
+        return makeFilename(getPreferencesDir(), name + ".xml");
+    }
+
+    public SharedPreferences getSharedPreferences(String name, int mode) {
+		System.out.println("\n\n...> getSharedPreferences("+name+",)\n\n");
+        File prefsFile = getSharedPrefsFile(name);
+        return new SharedPreferencesImpl(prefsFile, mode);
+    }
+
+	public ClassLoader getClassLoader() {
+		// not perfect, but it's what we use for now as well, and it works
+		return ClassLoader.getSystemClassLoader();
+	}
+
+	public ComponentName startService(Intent service) {
+		return new ComponentName("","");
+	}
+
+	// FIXME - it should be *trivial* to do actually implement this
+	public FileInputStream openFileInput(String name) {
+		return null;
+	}
+
+	public FileOutputStream openFileOutput(String name, int mode) throws java.io.FileNotFoundException {
+		System.out.println("openFileOutput called for: '"+name+"'");
+		return new FileOutputStream("data/files/" + name);
+	}
+
+	public int checkCallingOrSelfPermission(String permission) {
+		System.out.println("!!! app wants to know if it has a permission: >"+permission+"<");
+
+		return -1; // PackageManager.PERMISSION_DENIED
+	}
+
+	// these may not look like typical stubs, but they definitely are stubs
+	public final TypedArray obtainStyledAttributes (AttributeSet set, int[] attrs) { return new TypedArray(r, new int[1000], new int[1000], 0); }
+	public final TypedArray obtainStyledAttributes (AttributeSet set, int[] attrs, int defStyleAttr, int defStyleRes) { return new TypedArray(r, new int[1000], new int[1000], 0); }
+	public final TypedArray obtainStyledAttributes (int resid, int[] attrs) { return new TypedArray(r, new int[1000], new int[1000], 0); }
+	public final TypedArray obtainStyledAttributes (int[] attrs) { return new TypedArray(r, new int[1000], new int[1000], 0); }
+}

src/api-impl/android/content/DialogInterface.java

@@ -0,0 +1,8 @@
+package android.content;
+
+public interface DialogInterface {
+	public interface OnDismissListener {
+	}
+	public interface OnClickListener {
+	}
+}

src/api-impl/android/content/Intent.java

@@ -0,0 +1,121 @@
+package android.content;
+
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Parcelable;
+
+import java.io.Serializable;
+
+public class Intent {
+	public Intent () {}
+	public Intent (Intent o) {}
+	public Intent (String action) {}
+	public Intent (String action, Uri uri) {}
+	public Intent (Context packageContext, Class<?> cls) {}
+	public Intent (String action, Uri uri, Context packageContext, Class<?> cls) {}
+
+	public Intent setPackage(String packageName) {
+		return this; //??
+	}
+
+	public Intent putExtra (String name, Parcelable value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, long[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, byte value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, double[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, CharSequence value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, boolean[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, int value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, char[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, byte[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, Parcelable[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, Bundle value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, CharSequence[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, float[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, double value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, int[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, String[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, short[] value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, boolean value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, String value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, long value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, char value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, Serializable value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, float value) {
+		return this; //??
+	}
+
+	public Intent putExtra(String name, short value) {
+		return this; //??
+	}
+
+	public Intent setClass (Context packageContext, Class<?> cls) {
+		return this; //??
+	}
+
+}

src/api-impl/android/content/IntentSender.java

@@ -0,0 +1,6 @@
+package android.content;
+
+public class IntentSender {
+	public class SendIntentException {
+	}
+}

src/api-impl/android/content/OperationApplicationException.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2009 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 android.content;
+
+/**
+ * Thrown when an application of a {@link ContentProviderOperation} fails due the specified
+ * constraints.
+ */
+public class OperationApplicationException extends Exception {
+    private final int mNumSuccessfulYieldPoints;
+
+    public OperationApplicationException() {
+        super();
+        mNumSuccessfulYieldPoints = 0;
+    }
+    public OperationApplicationException(String message) {
+        super(message);
+        mNumSuccessfulYieldPoints = 0;
+    }
+    public OperationApplicationException(String message, Throwable cause) {
+        super(message, cause);
+        mNumSuccessfulYieldPoints = 0;
+    }
+    public OperationApplicationException(Throwable cause) {
+        super(cause);
+        mNumSuccessfulYieldPoints = 0;
+    }
+    public OperationApplicationException(int numSuccessfulYieldPoints) {
+        super();
+        mNumSuccessfulYieldPoints = numSuccessfulYieldPoints;
+    }
+    public OperationApplicationException(String message, int numSuccessfulYieldPoints) {
+        super(message);
+        mNumSuccessfulYieldPoints = numSuccessfulYieldPoints;
+    }
+
+    public int getNumSuccessfulYieldPoints() {
+        return mNumSuccessfulYieldPoints;
+    }
+}

src/api-impl/android/content/ServiceConnection.java

@@ -0,0 +1,5 @@
+package android.content;
+
+public interface ServiceConnection {
+
+}

src/api-impl/android/content/SharedPreferences.java

@@ -0,0 +1,371 @@
+/*
+ * Copyright (C) 2006 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 android.content;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Interface for accessing and modifying preference data returned by {@link
+ * Context#getSharedPreferences}.  For any particular set of preferences,
+ * there is a single instance of this class that all clients share.
+ * Modifications to the preferences must go through an {@link Editor} object
+ * to ensure the preference values remain in a consistent state and control
+ * when they are committed to storage.  Objects that are returned from the
+ * various <code>get</code> methods must be treated as immutable by the application.
+ *
+ * <p><em>Note: currently this class does not support use across multiple
+ * processes.  This will be added later.</em>
+ *
+ * <div class="special reference">
+ * <h3>Developer Guides</h3>
+ * <p>For more information about using SharedPreferences, read the
+ * <a href="{@docRoot}guide/topics/data/data-storage.html#pref">Data Storage</a>
+ * developer guide.</p></div>
+ *
+ * @see Context#getSharedPreferences
+ */
+public interface SharedPreferences {
+    /**
+     * Interface definition for a callback to be invoked when a shared
+     * preference is changed.
+     */
+    public interface OnSharedPreferenceChangeListener {
+        /**
+         * Called when a shared preference is changed, added, or removed. This
+         * may be called even if a preference is set to its existing value.
+         *
+         * <p>This callback will be run on your main thread.
+         *
+         * @param sharedPreferences The {@link SharedPreferences} that received
+         *            the change.
+         * @param key The key of the preference that was changed, added, or
+         *            removed.
+         */
+        void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key);
+    }
+    
+    /**
+     * Interface used for modifying values in a {@link SharedPreferences}
+     * object.  All changes you make in an editor are batched, and not copied
+     * back to the original {@link SharedPreferences} until you call {@link #commit}
+     * or {@link #apply}
+     */
+    public interface Editor {
+        /**
+         * Set a String value in the preferences editor, to be written back once
+         * {@link #commit} or {@link #apply} are called.
+         * 
+         * @param key The name of the preference to modify.
+         * @param value The new value for the preference.  Supplying {@code null}
+         *    as the value is equivalent to calling {@link #remove(String)} with
+         *    this key.
+         * 
+         * @return Returns a reference to the same Editor object, so you can
+         * chain put calls together.
+         */
+        Editor putString(String key, String value);
+        
+        /**
+         * Set a set of String values in the preferences editor, to be written
+         * back once {@link #commit} is called.
+         * 
+         * @param key The name of the preference to modify.
+         * @param values The set of new values for the preference.  Passing {@code null}
+         *    for this argument is equivalent to calling {@link #remove(String)} with
+         *    this key.
+         * @return Returns a reference to the same Editor object, so you can
+         * chain put calls together.
+         */
+        Editor putStringSet(String key, Set<String> values);
+        
+        /**
+         * Set an int value in the preferences editor, to be written back once
+         * {@link #commit} or {@link #apply} are called.
+         * 
+         * @param key The name of the preference to modify.
+         * @param value The new value for the preference.
+         * 
+         * @return Returns a reference to the same Editor object, so you can
+         * chain put calls together.
+         */
+        Editor putInt(String key, int value);
+        
+        /**
+         * Set a long value in the preferences editor, to be written back once
+         * {@link #commit} or {@link #apply} are called.
+         * 
+         * @param key The name of the preference to modify.
+         * @param value The new value for the preference.
+         * 
+         * @return Returns a reference to the same Editor object, so you can
+         * chain put calls together.
+         */
+        Editor putLong(String key, long value);
+        
+        /**
+         * Set a float value in the preferences editor, to be written back once
+         * {@link #commit} or {@link #apply} are called.
+         * 
+         * @param key The name of the preference to modify.
+         * @param value The new value for the preference.
+         * 
+         * @return Returns a reference to the same Editor object, so you can
+         * chain put calls together.
+         */
+        Editor putFloat(String key, float value);
+        
+        /**
+         * Set a boolean value in the preferences editor, to be written back
+         * once {@link #commit} or {@link #apply} are called.
+         * 
+         * @param key The name of the preference to modify.
+         * @param value The new value for the preference.
+         * 
+         * @return Returns a reference to the same Editor object, so you can
+         * chain put calls together.
+         */
+        Editor putBoolean(String key, boolean value);
+
+        /**
+         * Mark in the editor that a preference value should be removed, which
+         * will be done in the actual preferences once {@link #commit} is
+         * called.
+         * 
+         * <p>Note that when committing back to the preferences, all removals
+         * are done first, regardless of whether you called remove before
+         * or after put methods on this editor.
+         * 
+         * @param key The name of the preference to remove.
+         * 
+         * @return Returns a reference to the same Editor object, so you can
+         * chain put calls together.
+         */
+        Editor remove(String key);
+
+        /**
+         * Mark in the editor to remove <em>all</em> values from the
+         * preferences.  Once commit is called, the only remaining preferences
+         * will be any that you have defined in this editor.
+         * 
+         * <p>Note that when committing back to the preferences, the clear
+         * is done first, regardless of whether you called clear before
+         * or after put methods on this editor.
+         * 
+         * @return Returns a reference to the same Editor object, so you can
+         * chain put calls together.
+         */
+        Editor clear();
+
+        /**
+         * Commit your preferences changes back from this Editor to the
+         * {@link SharedPreferences} object it is editing.  This atomically
+         * performs the requested modifications, replacing whatever is currently
+         * in the SharedPreferences.
+         *
+         * <p>Note that when two editors are modifying preferences at the same
+         * time, the last one to call commit wins.
+         *
+         * <p>If you don't care about the return value and you're
+         * using this from your application's main thread, consider
+         * using {@link #apply} instead.
+         *
+         * @return Returns true if the new values were successfully written
+         * to persistent storage.
+         */
+        boolean commit();
+
+        /**
+         * Commit your preferences changes back from this Editor to the
+         * {@link SharedPreferences} object it is editing.  This atomically
+         * performs the requested modifications, replacing whatever is currently
+         * in the SharedPreferences.
+         *
+         * <p>Note that when two editors are modifying preferences at the same
+         * time, the last one to call apply wins.
+         *
+         * <p>Unlike {@link #commit}, which writes its preferences out
+         * to persistent storage synchronously, {@link #apply}
+         * commits its changes to the in-memory
+         * {@link SharedPreferences} immediately but starts an
+         * asynchronous commit to disk and you won't be notified of
+         * any failures.  If another editor on this
+         * {@link SharedPreferences} does a regular {@link #commit}
+         * while a {@link #apply} is still outstanding, the
+         * {@link #commit} will block until all async commits are
+         * completed as well as the commit itself.
+         *
+         * <p>As {@link SharedPreferences} instances are singletons within
+         * a process, it's safe to replace any instance of {@link #commit} with
+         * {@link #apply} if you were already ignoring the return value.
+         *
+         * <p>You don't need to worry about Android component
+         * lifecycles and their interaction with <code>apply()</code>
+         * writing to disk.  The framework makes sure in-flight disk
+         * writes from <code>apply()</code> complete before switching
+         * states.
+         *
+         * <p class='note'>The SharedPreferences.Editor interface
+         * isn't expected to be implemented directly.  However, if you
+         * previously did implement it and are now getting errors
+         * about missing <code>apply()</code>, you can simply call
+         * {@link #commit} from <code>apply()</code>.
+         */
+        void apply();
+    }
+
+    /**
+     * Retrieve all values from the preferences.
+     *
+     * <p>Note that you <em>must not</em> modify the collection returned
+     * by this method, or alter any of its contents.  The consistency of your
+     * stored data is not guaranteed if you do.
+     *
+     * @return Returns a map containing a list of pairs key/value representing
+     * the preferences.
+     *
+     * @throws NullPointerException
+     */
+    Map<String, ?> getAll();
+
+    /**
+     * Retrieve a String value from the preferences.
+     * 
+     * @param key The name of the preference to retrieve.
+     * @param defValue Value to return if this preference does not exist.
+     * 
+     * @return Returns the preference value if it exists, or defValue.  Throws
+     * ClassCastException if there is a preference with this name that is not
+     * a String.
+     * 
+     * @throws ClassCastException
+     */
+    String getString(String key, String defValue);
+    
+    /**
+     * Retrieve a set of String values from the preferences.
+     * 
+     * <p>Note that you <em>must not</em> modify the set instance returned
+     * by this call.  The consistency of the stored data is not guaranteed
+     * if you do, nor is your ability to modify the instance at all.
+     *
+     * @param key The name of the preference to retrieve.
+     * @param defValues Values to return if this preference does not exist.
+     * 
+     * @return Returns the preference values if they exist, or defValues.
+     * Throws ClassCastException if there is a preference with this name
+     * that is not a Set.
+     * 
+     * @throws ClassCastException
+     */
+    Set<String> getStringSet(String key, Set<String> defValues);
+    
+    /**
+     * Retrieve an int value from the preferences.
+     * 
+     * @param key The name of the preference to retrieve.
+     * @param defValue Value to return if this preference does not exist.
+     * 
+     * @return Returns the preference value if it exists, or defValue.  Throws
+     * ClassCastException if there is a preference with this name that is not
+     * an int.
+     * 
+     * @throws ClassCastException
+     */
+    int getInt(String key, int defValue);
+    
+    /**
+     * Retrieve a long value from the preferences.
+     * 
+     * @param key The name of the preference to retrieve.
+     * @param defValue Value to return if this preference does not exist.
+     * 
+     * @return Returns the preference value if it exists, or defValue.  Throws
+     * ClassCastException if there is a preference with this name that is not
+     * a long.
+     * 
+     * @throws ClassCastException
+     */
+    long getLong(String key, long defValue);
+    
+    /**
+     * Retrieve a float value from the preferences.
+     * 
+     * @param key The name of the preference to retrieve.
+     * @param defValue Value to return if this preference does not exist.
+     * 
+     * @return Returns the preference value if it exists, or defValue.  Throws
+     * ClassCastException if there is a preference with this name that is not
+     * a float.
+     * 
+     * @throws ClassCastException
+     */
+    float getFloat(String key, float defValue);
+    
+    /**
+     * Retrieve a boolean value from the preferences.
+     * 
+     * @param key The name of the preference to retrieve.
+     * @param defValue Value to return if this preference does not exist.
+     * 
+     * @return Returns the preference value if it exists, or defValue.  Throws
+     * ClassCastException if there is a preference with this name that is not
+     * a boolean.
+     * 
+     * @throws ClassCastException
+     */
+    boolean getBoolean(String key, boolean defValue);
+
+    /**
+     * Checks whether the preferences contains a preference.
+     * 
+     * @param key The name of the preference to check.
+     * @return Returns true if the preference exists in the preferences,
+     *         otherwise false.
+     */
+    boolean contains(String key);
+    
+    /**
+     * Create a new Editor for these preferences, through which you can make
+     * modifications to the data in the preferences and atomically commit those
+     * changes back to the SharedPreferences object.
+     * 
+     * <p>Note that you <em>must</em> call {@link Editor#commit} to have any
+     * changes you perform in the Editor actually show up in the
+     * SharedPreferences.
+     * 
+     * @return Returns a new instance of the {@link Editor} interface, allowing
+     * you to modify the values in this SharedPreferences object.
+     */
+    Editor edit();
+    
+    /**
+     * Registers a callback to be invoked when a change happens to a preference.
+     * 
+     * @param listener The callback that will run.
+     * @see #unregisterOnSharedPreferenceChangeListener
+     */
+    void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener);
+    
+    /**
+     * Unregisters a previous callback.
+     * 
+     * @param listener The callback that should be unregistered.
+     * @see #registerOnSharedPreferenceChangeListener
+     */
+    void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener);
+}

src/api-impl/android/content/pm/ComponentInfo.java

@@ -0,0 +1,170 @@
+/*
+ * 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 android.content.pm;
+
+//import android.graphics.drawable.Drawable;
+import android.util.Printer;
+
+/**
+ * Base class containing information common to all application components
+ * ({@link ActivityInfo}, {@link ServiceInfo}).  This class is not intended
+ * to be used by itself; it is simply here to share common definitions
+ * between all application components.  As such, it does not itself
+ * implement Parcelable, but does provide convenience methods to assist
+ * in the implementation of Parcelable in subclasses.
+ */
+public class ComponentInfo extends PackageItemInfo {
+    /**
+     * Global information about the application/package this component is a
+     * part of.
+     */
+    public ApplicationInfo applicationInfo;
+    
+    /**
+     * The name of the process this component should run in.
+     * From the "android:process" attribute or, if not set, the same
+     * as <var>applicationInfo.processName</var>.
+     */
+    public String processName;
+
+    /**
+     * A string resource identifier (in the package's resources) containing
+     * a user-readable description of the component.  From the "description"
+     * attribute or, if not set, 0.
+     */
+    public int descriptionRes;
+    
+    /**
+     * Indicates whether or not this component may be instantiated.  Note that this value can be
+     * overriden by the one in its parent {@link ApplicationInfo}.
+     */
+    public boolean enabled = true;
+
+    /**
+     * Set to true if this component is available for use by other applications.
+     * Comes from {@link android.R.attr#exported android:exported} of the
+     * &lt;activity&gt;, &lt;receiver&gt;, &lt;service&gt;, or
+     * &lt;provider&gt; tag.
+     */
+    public boolean exported = false;
+    
+    public ComponentInfo() {
+    }
+
+    public ComponentInfo(ComponentInfo orig) {
+        super(orig);
+        applicationInfo = orig.applicationInfo;
+        processName = orig.processName;
+        descriptionRes = orig.descriptionRes;
+        enabled = orig.enabled;
+        exported = orig.exported;
+    }
+
+    @Override public CharSequence loadLabel(PackageManager pm) {/*
+        if (nonLocalizedLabel != null) {
+            return nonLocalizedLabel;
+        }
+        ApplicationInfo ai = applicationInfo;
+        CharSequence label;
+        if (labelRes != 0) {
+            label = pm.getText(packageName, labelRes, ai);
+            if (label != null) {
+                return label;
+            }
+        }
+        if (ai.nonLocalizedLabel != null) {
+            return ai.nonLocalizedLabel;
+        }
+        if (ai.labelRes != 0) {
+            label = pm.getText(packageName, ai.labelRes, ai);
+            if (label != null) {
+                return label;
+            }
+        }
+        return name;
+    */return null;}
+
+    /**
+     * Return whether this component and its enclosing application are enabled.
+     */
+    public boolean isEnabled() {
+        return enabled /*&& applicationInfo.enabled*/;
+    }
+    
+    /**
+     * Return the icon resource identifier to use for this component.  If
+     * the component defines an icon, that is used; else, the application
+     * icon is used.
+     * 
+     * @return The icon associated with this component.
+     */
+    public final int getIconResource() {
+        return icon;// != 0 ? icon : applicationInfo.icon;
+    }
+
+    /**
+     * Return the logo resource identifier to use for this component.  If
+     * the component defines a logo, that is used; else, the application
+     * logo is used.
+     *
+     * @return The logo associated with this component.
+     */
+    public final int getLogoResource() {
+        return logo;// != 0 ? logo : applicationInfo.logo;
+    }
+    
+    protected void dumpFront(Printer pw, String prefix) {
+        super.dumpFront(pw, prefix);
+        pw.println(prefix + "enabled=" + enabled + " exported=" + exported
+                + " processName=" + processName);
+        if (descriptionRes != 0) {
+            pw.println(prefix + "description=" + descriptionRes);
+        }
+    }
+    
+    protected void dumpBack(Printer pw, String prefix) {
+        if (applicationInfo != null) {
+            pw.println(prefix + "ApplicationInfo:");
+            //applicationInfo.dump(pw, prefix + "  ");
+        } else {
+            pw.println(prefix + "ApplicationInfo: null");
+        }
+        super.dumpBack(pw, prefix);
+    }
+    
+    /**
+     * @hide
+     */
+    @Override protected Drawable loadDefaultIcon(PackageManager pm) {
+        return null;//applicationInfo.loadIcon(pm);
+    }
+    
+    /**
+     * @hide
+     */
+    @Override
+    protected Drawable loadDefaultLogo(PackageManager pm) {
+        return null;//applicationInfo.loadLogo(pm);
+    }
+    
+    /**
+     * @hide
+     */
+    @Override protected ApplicationInfo getApplicationInfo() {
+        return applicationInfo;
+    }
+}

src/api-impl/android/content/pm/ConfigurationInfo.java

@@ -0,0 +1,116 @@
+/*
+ * 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 android.content.pm;
+
+/**
+ * Information you can retrieve about hardware configuration preferences
+ * declared by an application. This corresponds to information collected from the
+ * AndroidManifest.xml's <uses-configuration> and <uses-feature> tags.
+ */
+public class ConfigurationInfo {
+    /**
+     * The kind of touch screen attached to the device.
+     * One of: {@link android.content.res.Configuration#TOUCHSCREEN_NOTOUCH},
+     * {@link android.content.res.Configuration#TOUCHSCREEN_STYLUS}, 
+     * {@link android.content.res.Configuration#TOUCHSCREEN_FINGER}. 
+     */
+    public int reqTouchScreen;
+    
+    /**
+     * Application's input method preference.
+     * One of: {@link android.content.res.Configuration#KEYBOARD_UNDEFINED},
+     * {@link android.content.res.Configuration#KEYBOARD_NOKEYS},
+     * {@link android.content.res.Configuration#KEYBOARD_QWERTY},
+     * {@link android.content.res.Configuration#KEYBOARD_12KEY}
+     */
+    public int reqKeyboardType;
+    
+    /**
+     * A flag indicating whether any keyboard is available.
+     * one of: {@link android.content.res.Configuration#NAVIGATION_UNDEFINED},
+     * {@link android.content.res.Configuration#NAVIGATION_DPAD}, 
+     * {@link android.content.res.Configuration#NAVIGATION_TRACKBALL},
+     * {@link android.content.res.Configuration#NAVIGATION_WHEEL}
+     */
+    public int reqNavigation;
+    
+    /**
+     * Value for {@link #reqInputFeatures}: if set, indicates that the application
+     * requires a hard keyboard
+     */
+    public static final int INPUT_FEATURE_HARD_KEYBOARD = 0x00000001;
+    
+    /**
+     * Value for {@link #reqInputFeatures}: if set, indicates that the application
+     * requires a five way navigation device
+     */
+    public static final int INPUT_FEATURE_FIVE_WAY_NAV = 0x00000002;
+    
+    /**
+     * Flags associated with the input features.  Any combination of
+     * {@link #INPUT_FEATURE_HARD_KEYBOARD},
+     * {@link #INPUT_FEATURE_FIVE_WAY_NAV}
+     */
+    public int reqInputFeatures = 0;
+
+    /**
+     * Default value for {@link #reqGlEsVersion};
+     */
+    public static final int GL_ES_VERSION_UNDEFINED = 0;
+    /**
+     * The GLES version used by an application. The upper order 16 bits represent the
+     * major version and the lower order 16 bits the minor version.
+     */
+    public int reqGlEsVersion;
+
+    public ConfigurationInfo() {
+    }
+
+    public ConfigurationInfo(ConfigurationInfo orig) {
+        reqTouchScreen = orig.reqTouchScreen;
+        reqKeyboardType = orig.reqKeyboardType;
+        reqNavigation = orig.reqNavigation;
+        reqInputFeatures = orig.reqInputFeatures;
+        reqGlEsVersion = orig.reqGlEsVersion;
+    }
+
+    public String toString() {
+        return "ConfigurationInfo{"
+            + Integer.toHexString(System.identityHashCode(this))
+            + " touchscreen = " + reqTouchScreen
+            + " inputMethod = " + reqKeyboardType
+            + " navigation = " + reqNavigation
+            + " reqInputFeatures = " + reqInputFeatures
+            + " reqGlEsVersion = " + reqGlEsVersion + "}";
+    }
+
+    public int describeContents() {
+        return 0;
+    }
+
+    /**
+     * This method extracts the major and minor version of reqGLEsVersion attribute
+     * and returns it as a string. Say reqGlEsVersion value of 0x00010002 is returned
+     * as 1.2
+     * @return String representation of the reqGlEsVersion attribute
+     */
+    public String getGlEsVersion() {
+        int major = ((reqGlEsVersion & 0xffff0000) >> 16);
+        int minor = reqGlEsVersion & 0x0000ffff;
+        return String.valueOf(major)+"."+String.valueOf(minor);
+    }
+}

src/api-impl/android/content/pm/FeatureInfo.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2009 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 android.content.pm;
+
+/**
+ * A single feature that can be requested by an application. This corresponds
+ * to information collected from the
+ * AndroidManifest.xml's <uses-feature> tag.
+ */
+public class FeatureInfo {
+    /**
+     * The name of this feature, for example "android.hardware.camera".  If
+     * this is null, then this is an OpenGL ES version feature as described
+     * in {@link #reqGlEsVersion}.
+     */
+    public String name;
+    
+    /**
+     * Default value for {@link #reqGlEsVersion};
+     */
+    public static final int GL_ES_VERSION_UNDEFINED = 0;
+    
+    /**
+     * The GLES version used by an application. The upper order 16 bits represent the
+     * major version and the lower order 16 bits the minor version.  Only valid
+     * if {@link #name} is null.
+     */
+    public int reqGlEsVersion;
+
+    /**
+     * Set on {@link #flags} if this feature has been required by the application.
+     */
+    public static final int FLAG_REQUIRED = 0x0001;
+    
+    /**
+     * Additional flags.  May be zero or more of {@link #FLAG_REQUIRED}.
+     */
+    public int flags;
+    
+    public FeatureInfo() {
+    }
+
+    public FeatureInfo(FeatureInfo orig) {
+        name = orig.name;
+        reqGlEsVersion = orig.reqGlEsVersion;
+        flags = orig.flags;
+    }
+
+    public String toString() {
+        if (name != null) {
+            return "FeatureInfo{"
+                    + Integer.toHexString(System.identityHashCode(this))
+                    + " " + name + " fl=0x" + Integer.toHexString(flags) + "}";
+        } else {
+            return "FeatureInfo{"
+                    + Integer.toHexString(System.identityHashCode(this))
+                    + " glEsVers=" + getGlEsVersion()
+                    + " fl=0x" + Integer.toHexString(flags) + "}";
+        }
+    }
+
+    public int describeContents() {
+        return 0;
+    }
+
+    /**
+     * This method extracts the major and minor version of reqGLEsVersion attribute
+     * and returns it as a string. Say reqGlEsVersion value of 0x00010002 is returned
+     * as 1.2
+     * @return String representation of the reqGlEsVersion attribute
+     */
+    public String getGlEsVersion() {
+        int major = ((reqGlEsVersion & 0xffff0000) >> 16);
+        int minor = reqGlEsVersion & 0x0000ffff;
+        return String.valueOf(major)+"."+String.valueOf(minor);
+    }
+}

src/api-impl/android/content/pm/InstrumentationInfo.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2007 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 android.content.pm;
+
+/**
+ * Information you can retrieve about a particular piece of test
+ * instrumentation.  This corresponds to information collected
+ * from the AndroidManifest.xml's <instrumentation> tag.
+ */
+public class InstrumentationInfo extends PackageItemInfo {
+    /**
+     * The name of the application package being instrumented.  From the
+     * "package" attribute.
+     */
+    public String targetPackage;
+    
+    /**
+     * Full path to the location of this package.
+     */
+    public String sourceDir;
+    
+    /**
+     * Full path to the location of the publicly available parts of this package (i.e. the resources
+     * and manifest).  For non-forward-locked apps this will be the same as {@link #sourceDir).
+     */
+    public String publicSourceDir;
+    /**
+     * Full path to a directory assigned to the package for its persistent
+     * data.
+     */
+    public String dataDir;
+
+    /**
+     * Full path to the directory where the native JNI libraries are stored.
+     * 
+     * {@hide}
+     */
+    public String nativeLibraryDir;
+
+    /**
+     * Specifies whether or not this instrumentation will handle profiling.
+     */
+    public boolean handleProfiling;
+    
+    /** Specifies whether or not to run this instrumentation as a functional test */
+    public boolean functionalTest;
+
+    public InstrumentationInfo() {
+    }
+
+    public InstrumentationInfo(InstrumentationInfo orig) {
+        super(orig);
+        targetPackage = orig.targetPackage;
+        sourceDir = orig.sourceDir;
+        publicSourceDir = orig.publicSourceDir;
+        dataDir = orig.dataDir;
+        nativeLibraryDir = orig.nativeLibraryDir;
+        handleProfiling = orig.handleProfiling;
+        functionalTest = orig.functionalTest;
+    }
+
+    public String toString() {
+        return "InstrumentationInfo{"
+            + Integer.toHexString(System.identityHashCode(this))
+            + " " + packageName + "}";
+    }
+
+    public int describeContents() {
+        return 0;
+    }
+}

src/api-impl/android/content/pm/ManifestDigest.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2012 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 android.content.pm;
+
+import android.util.Slog;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.DigestInputStream;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+
+import libcore.io.IoUtils;
+
+/**
+ * Represents the manifest digest for a package. This is suitable for comparison
+ * of two packages to know whether the manifests are identical.
+ *
+ * @hide
+ */
+public class ManifestDigest {
+    private static final String TAG = "ManifestDigest";
+
+    /** The digest of the manifest in our preferred order. */
+    private final byte[] mDigest;
+
+    /** What we print out first when toString() is called. */
+    private static final String TO_STRING_PREFIX = "ManifestDigest {mDigest=";
+
+    /** Digest algorithm to use. */
+    private static final String DIGEST_ALGORITHM = "SHA-256";
+
+    ManifestDigest(byte[] digest) {
+        mDigest = digest;
+    }
+
+    static ManifestDigest fromInputStream(InputStream fileIs) {
+        if (fileIs == null) {
+            return null;
+        }
+
+        final MessageDigest md;
+        try {
+            md = MessageDigest.getInstance(DIGEST_ALGORITHM);
+        } catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException(DIGEST_ALGORITHM + " must be available", e);
+        }
+
+        final DigestInputStream dis = new DigestInputStream(new BufferedInputStream(fileIs), md);
+        try {
+            byte[] readBuffer = new byte[8192];
+            while (dis.read(readBuffer, 0, readBuffer.length) != -1) {
+                // not using
+            }
+        } catch (IOException e) {
+            Slog.w(TAG, "Could not read manifest");
+            return null;
+        } finally {
+            IoUtils.closeQuietly(dis);
+        }
+
+        final byte[] digest = md.digest();
+        return new ManifestDigest(digest);
+    }
+
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof ManifestDigest)) {
+            return false;
+        }
+
+        final ManifestDigest other = (ManifestDigest) o;
+
+        return this == other || Arrays.equals(mDigest, other.mDigest);
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(mDigest);
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder(TO_STRING_PREFIX.length()
+                + (mDigest.length * 3) + 1);
+
+        sb.append(TO_STRING_PREFIX);
+
+        final int N = mDigest.length;
+        for (int i = 0; i < N; i++) {
+            final byte b = mDigest[i];
+            IntegralToString.appendByteAsHex(sb, b, false);
+            sb.append(',');
+        }
+        sb.append('}');
+
+        return sb.toString();
+    }
+}

src/api-impl/android/content/pm/PackageInfo.java

@@ -0,0 +1,240 @@
+/*
+ * Copyright (C) 2007 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 android.content.pm;
+
+/**
+ * Overall information about the contents of a package.  This corresponds
+ * to all of the information collected from AndroidManifest.xml.
+ */
+public class PackageInfo {
+    /**
+     * The name of this package.  From the <manifest> tag's "name"
+     * attribute.
+     */
+    public String packageName = "com.example.app"; // FIXME
+
+    /**
+     * The version number of this package, as specified by the <manifest>
+     * tag's {@link android.R.styleable#AndroidManifest_versionCode versionCode}
+     * attribute.
+     */
+    public int versionCode = 1; //FIXME
+    
+    /**
+     * The version name of this package, as specified by the <manifest>
+     * tag's {@link android.R.styleable#AndroidManifest_versionName versionName}
+     * attribute.
+     */
+    public String versionName = "v0.FIXME";
+    
+    /**
+     * The shared user ID name of this package, as specified by the <manifest>
+     * tag's {@link android.R.styleable#AndroidManifest_sharedUserId sharedUserId}
+     * attribute.
+     */
+    public String sharedUserId;
+    
+    /**
+     * The shared user ID label of this package, as specified by the <manifest>
+     * tag's {@link android.R.styleable#AndroidManifest_sharedUserLabel sharedUserLabel}
+     * attribute.
+     */
+    public int sharedUserLabel;
+    
+    /**
+     * Information collected from the <application> tag, or null if
+     * there was none.
+     */
+    public ApplicationInfo applicationInfo;
+    
+    /**
+     * The time at which the app was first installed.  Units are as
+     * per {@link System#currentTimeMillis()}.
+     */
+    public long firstInstallTime;
+
+    /**
+     * The time at which the app was last updated.  Units are as
+     * per {@link System#currentTimeMillis()}.
+     */
+    public long lastUpdateTime;
+
+    /**
+     * All kernel group-IDs that have been assigned to this package.
+     * This is only filled in if the flag {@link PackageManager#GET_GIDS} was set.
+     */
+    public int[] gids;
+
+    /**
+     * Array of all {@link android.R.styleable#AndroidManifestActivity
+     * <activity>} tags included under <application>,
+     * or null if there were none.  This is only filled in if the flag
+     * {@link PackageManager#GET_ACTIVITIES} was set.
+     */
+    public ActivityInfo[] activities;
+
+    /**
+     * Array of all {@link android.R.styleable#AndroidManifestReceiver
+     * <receiver>} tags included under <application>,
+     * or null if there were none.  This is only filled in if the flag
+     * {@link PackageManager#GET_RECEIVERS} was set.
+     */
+    public ActivityInfo[] receivers;
+
+    /**
+     * Array of all {@link android.R.styleable#AndroidManifestService
+     * <service>} tags included under <application>,
+     * or null if there were none.  This is only filled in if the flag
+     * {@link PackageManager#GET_SERVICES} was set.
+     */
+    public ServiceInfo[] services;
+
+    /**
+     * Array of all {@link android.R.styleable#AndroidManifestProvider
+     * <provider>} tags included under <application>,
+     * or null if there were none.  This is only filled in if the flag
+     * {@link PackageManager#GET_PROVIDERS} was set.
+     */
+    public ProviderInfo[] providers;
+
+    /**
+     * Array of all {@link android.R.styleable#AndroidManifestInstrumentation
+     * <instrumentation>} tags included under <manifest>,
+     * or null if there were none.  This is only filled in if the flag
+     * {@link PackageManager#GET_INSTRUMENTATION} was set.
+     */
+    public InstrumentationInfo[] instrumentation;
+    
+    /**
+     * Array of all {@link android.R.styleable#AndroidManifestPermission
+     * <permission>} tags included under <manifest>,
+     * or null if there were none.  This is only filled in if the flag
+     * {@link PackageManager#GET_PERMISSIONS} was set.
+     */
+    public PermissionInfo[] permissions;
+    
+    /**
+     * Array of all {@link android.R.styleable#AndroidManifestUsesPermission
+     * <uses-permission>} tags included under <manifest>,
+     * or null if there were none.  This is only filled in if the flag
+     * {@link PackageManager#GET_PERMISSIONS} was set.  This list includes
+     * all permissions requested, even those that were not granted or known
+     * by the system at install time.
+     */
+    public String[] requestedPermissions;
+    
+    /**
+     * Array of flags of all {@link android.R.styleable#AndroidManifestUsesPermission
+     * <uses-permission>} tags included under <manifest>,
+     * or null if there were none.  This is only filled in if the flag
+     * {@link PackageManager#GET_PERMISSIONS} was set.  Each value matches
+     * the corresponding entry in {@link #requestedPermissions}, and will have
+     * the flags {@link #REQUESTED_PERMISSION_REQUIRED} and
+     * {@link #REQUESTED_PERMISSION_GRANTED} set as appropriate.
+     */
+    public int[] requestedPermissionsFlags;
+
+    /**
+     * Flag for {@link #requestedPermissionsFlags}: the requested permission
+     * is required for the application to run; the user can not optionally
+     * disable it.  Currently all permissions are required.
+     */
+    public static final int REQUESTED_PERMISSION_REQUIRED = 1<<0;
+
+    /**
+     * Flag for {@link #requestedPermissionsFlags}: the requested permission
+     * is currently granted to the application.
+     */
+    public static final int REQUESTED_PERMISSION_GRANTED = 1<<1;
+
+    /**
+     * Array of all signatures read from the package file.  This is only filled
+     * in if the flag {@link PackageManager#GET_SIGNATURES} was set.
+     */
+    public Signature[] signatures;
+    
+    /**
+     * Application specified preferred configuration
+     * {@link android.R.styleable#AndroidManifestUsesConfiguration
+     * &lt;uses-configuration&gt;} tags included under &lt;manifest&gt;,
+     * or null if there were none. This is only filled in if the flag
+     * {@link PackageManager#GET_CONFIGURATIONS} was set.  
+     */
+    public ConfigurationInfo[] configPreferences;
+
+    /**
+     * The features that this application has said it requires.
+     */
+    public FeatureInfo[] reqFeatures;
+
+    /**
+     * Constant corresponding to <code>auto</code> in
+     * the {@link android.R.attr#installLocation} attribute.
+     * @hide
+     */
+    public static final int INSTALL_LOCATION_UNSPECIFIED = -1;
+    /**
+     * Constant corresponding to <code>auto</code> in
+     * the {@link android.R.attr#installLocation} attribute.
+     * @hide
+     */
+    public static final int INSTALL_LOCATION_AUTO = 0;
+    /**
+     * Constant corresponding to <code>internalOnly</code> in
+     * the {@link android.R.attr#installLocation} attribute.
+     * @hide
+     */
+    public static final int INSTALL_LOCATION_INTERNAL_ONLY = 1;
+    /**
+     * Constant corresponding to <code>preferExternal</code> in
+     * the {@link android.R.attr#installLocation} attribute.
+     * @hide
+     */
+    public static final int INSTALL_LOCATION_PREFER_EXTERNAL = 2;
+    /**
+     * The install location requested by the activity.  From the
+     * {@link android.R.attr#installLocation} attribute, one of
+     * {@link #INSTALL_LOCATION_AUTO},
+     * {@link #INSTALL_LOCATION_INTERNAL_ONLY},
+     * {@link #INSTALL_LOCATION_PREFER_EXTERNAL}
+     * @hide
+     */
+    public int installLocation = INSTALL_LOCATION_INTERNAL_ONLY;
+
+    /** @hide */
+    public boolean requiredForAllUsers;
+
+    /** @hide */
+    public String restrictedAccountType;
+
+    /** @hide */
+    public String requiredAccountType;
+
+    public PackageInfo() {
+    }
+
+    public String toString() {
+        return "PackageInfo{"
+            + Integer.toHexString(System.identityHashCode(this))
+            + " " + packageName + "}";
+    }
+
+    public int describeContents() {
+        return 0;
+    }
+
+}