gecko/util/GeckoBundle.java

/* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*-
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

package org.mozilla.gecko.util;

import org.mozilla.gecko.annotation.RobocopTarget;
import org.mozilla.gecko.annotation.WrapForJNI;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.os.Build;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import androidx.collection.SimpleArrayMap;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

/**
 * A lighter-weight version of Bundle that adds support for type coercion (e.g.
 * int to double) in order to better cooperate with JS objects.
 */
@RobocopTarget
public final class GeckoBundle implements Parcelable {
    private static final String LOGTAG = "GeckoBundle";
    private static final boolean DEBUG = false;

    @WrapForJNI(calledFrom = "gecko")
    private static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];
    private static final int[] EMPTY_INT_ARRAY = new int[0];
    private static final long[] EMPTY_LONG_ARRAY = new long[0];
    private static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
    private static final String[] EMPTY_STRING_ARRAY = new String[0];
    private static final GeckoBundle[] EMPTY_BUNDLE_ARRAY = new GeckoBundle[0];

    private SimpleArrayMap<String, Object> mMap;

    /**
     * Construct an empty GeckoBundle.
     */
    public GeckoBundle() {
        mMap = new SimpleArrayMap<>();
    }

    /**
     * Construct an empty GeckoBundle with specific capacity.
     *
     * @param capacity Initial capacity.
     */
    public GeckoBundle(final int capacity) {
        mMap = new SimpleArrayMap<>(capacity);
    }

    /**
     * Construct a copy of another GeckoBundle.
     *
     * @param bundle GeckoBundle to copy from.
     */
    public GeckoBundle(final GeckoBundle bundle) {
        mMap = new SimpleArrayMap<>(bundle.mMap);
    }

    @WrapForJNI(calledFrom = "gecko")
    private GeckoBundle(final String[] keys, final Object[] values) {
        final int len = keys.length;
        mMap = new SimpleArrayMap<>(len);
        for (int i = 0; i < len; i++) {
            mMap.put(keys[i], values[i]);
        }
    }

    /**
     * Clear all mappings.
     */
    public void clear() {
        mMap.clear();
    }

    /**
     * Returns whether a mapping exists. Null String, Bundle, or arrays are treated as
     * nonexistent.
     *
     * @param key Key to look for.
     * @return True if the specified key exists and the value is not null.
     */
    public boolean containsKey(final String key) {
        return mMap.get(key) != null;
    }

    /**
     * Returns the value associated with a mapping as an Object.
     *
     * @param key Key to look for.
     * @return Mapping value or null if the mapping does not exist.
     */
    public Object get(final String key) {
        return mMap.get(key);
    }

    /**
     * Returns the value associated with a boolean mapping, or defaultValue if the mapping
     * does not exist.
     *
     * @param key Key to look for.
     * @param defaultValue Value to return if mapping does not exist.
     * @return Boolean value
     */
    public boolean getBoolean(final String key, final boolean defaultValue) {
        final Object value = mMap.get(key);
        return value == null ? defaultValue : (Boolean) value;
    }

    /**
     * Returns the value associated with a boolean mapping, or false if the mapping does
     * not exist.
     *
     * @param key Key to look for.
     * @return Boolean value
     */
    public boolean getBoolean(final String key) {
        return getBoolean(key, false);
    }

    /**
     * Returns the value associated with a Boolean mapping, or defaultValue if the mapping
     * does not exist.
     *
     * @param key Key to look for.
     * @param defaultValue Value to return if mapping does not exist.
     * @return Boolean value
     */
    public Boolean getBooleanObject(final String key, final Boolean defaultValue) {
        final Object value = mMap.get(key);
        return value == null ? defaultValue : (Boolean) value;
    }

    /**
     * Returns the value associated with a Boolean mapping, or null if the mapping does
     * not exist.
     *
     * @param key Key to look for.
     * @return Boolean value
     */
    public Boolean getBooleanObject(final String key) {
        return getBooleanObject(key, null);
    }

    /**
     * Returns the value associated with a boolean array mapping, or null if the mapping
     * does not exist.
     *
     * @param key Key to look for.
     * @return Boolean array value
     */
    public boolean[] getBooleanArray(final String key) {
        final Object value = mMap.get(key);
        return value == null ? null :
                Array.getLength(value) == 0 ? EMPTY_BOOLEAN_ARRAY : (boolean[]) value;
    }

    /**
     * Returns the value associated with a double mapping, or defaultValue if the mapping
     * does not exist.
     *
     * @param key Key to look for.
     * @param defaultValue Value to return if mapping does not exist.
     * @return Double value
     */
    public double getDouble(final String key, final double defaultValue) {
        final Object value = mMap.get(key);
        return value == null ? defaultValue : ((Number) value).doubleValue();
    }

    /**
     * Returns the value associated with a double mapping, or 0.0 if the mapping does not
     * exist.
     *
     * @param key Key to look for.
     * @return Double value
     */
    public double getDouble(final String key) {
        return getDouble(key, 0.0);
    }

    private static double[] getDoubleArray(final int[] array) {
        final int len = array.length;
        final double[] ret = new double[len];
        for (int i = 0; i < len; i++) {
            ret[i] = (double) array[i];
        }
        return ret;
    }

    /**
     * Returns the value associated with a double array mapping, or null if the mapping
     * does not exist.
     *
     * @param key Key to look for.
     * @return Double array value
     */
    public double[] getDoubleArray(final String key) {
        final Object value = mMap.get(key);
        return value == null ? null : Array.getLength(value) == 0 ? EMPTY_DOUBLE_ARRAY :
               value instanceof int[] ? getDoubleArray((int[]) value) : (double[]) value;
    }

    /**
     * Returns the value associated with an int mapping, or defaultValue if the mapping
     * does not exist.
     *
     * @param key Key to look for.
     * @param defaultValue Value to return if mapping does not exist.
     * @return Int value
     */
    public int getInt(final String key, final int defaultValue) {
        final Object value = mMap.get(key);
        return value == null ? defaultValue : ((Number) value).intValue();
    }

    /**
     * Returns the value associated with an int mapping, or 0 if the mapping does not
     * exist.
     *
     * @param key Key to look for.
     * @return Int value
     */
    public int getInt(final String key) {
        return getInt(key, 0);
    }

    /**
     * Returns the value associated with an Integer mapping, or defaultValue if the mapping
     * does not exist.
     *
     * @param key Key to look for.
     * @param defaultValue Value to return if mapping does not exist.
     * @return Int value
     */
    public Integer getInteger(final String key, final Integer defaultValue) {
        final Object value = mMap.get(key);
        return value == null ? defaultValue : ((Integer) value);
    }

    /**
     * Returns the value associated with an Integer mapping, or null if the mapping does not
     * exist.
     *
     * @param key Key to look for.
     * @return Int value
     */
    public Integer getInteger(final String key) {
        return getInteger(key, null);
    }

    private static int[] getIntArray(final double[] array) {
        final int len = array.length;
        final int[] ret = new int[len];
        for (int i = 0; i < len; i++) {
            ret[i] = (int) array[i];
        }
        return ret;
    }

    /**
     * Returns the value associated with an int array mapping, or null if the mapping does
     * not exist.
     *
     * @param key Key to look for.
     * @return Int array value
     */
    public int[] getIntArray(final String key) {
        final Object value = mMap.get(key);
        return value == null ? null : Array.getLength(value) == 0 ? EMPTY_INT_ARRAY :
               value instanceof double[] ? getIntArray((double[]) value) : (int[]) value;
    }

    /**
     * Returns the value associated with an int/double mapping as a long value, or
     * defaultValue if the mapping does not exist.
     *
     * @param key Key to look for.
     * @param defaultValue Value to return if mapping does not exist.
     * @return Long value
     */
    public long getLong(final String key, final long defaultValue) {
        final Object value = mMap.get(key);
        return value == null ? defaultValue : ((Number) value).longValue();
    }

    /**
     * Returns the value associated with an int/double mapping as a long value, or
     * 0 if the mapping does not exist.
     *
     * @param key Key to look for.
     * @return Long value
     */
    public long getLong(final String key) {
        return getLong(key, 0L);
    }

    private static long[] getLongArray(final Object array) {
        final int len = Array.getLength(array);
        final long[] ret = new long[len];
        for (int i = 0; i < len; i++) {
            ret[i] = ((Number) Array.get(array, i)).longValue();
        }
        return ret;
    }

    /**
     * Returns the value associated with an int/double array mapping as a long array, or
     * null if the mapping does not exist.
     *
     * @param key Key to look for.
     * @return Long array value
     */
    public long[] getLongArray(final String key) {
        final Object value = mMap.get(key);
        return value == null ? null :
               Array.getLength(value) == 0 ? EMPTY_LONG_ARRAY : getLongArray(value);
    }

    /**
     * Returns the value associated with a String mapping, or defaultValue if the mapping
     * does not exist.
     *
     * @param key Key to look for.
     * @param defaultValue Value to return if mapping value is null or mapping does not exist.
     * @return String value
     */
    public String getString(final String key, final String defaultValue) {
        // If the key maps to null, technically we should return null because the mapping
        // exists and null is a valid string value. However, people expect the default
        // value to be returned instead, so we make an exception to return the default value.
        final Object value = mMap.get(key);
        return value == null ? defaultValue : (String) value;
    }

    /**
     * Returns the value associated with a String mapping, or null if the mapping does not
     * exist.
     *
     * @param key Key to look for.
     * @return String value
     */
    public String getString(final String key) {
        return getString(key, null);
    }

    // The only case where we convert String[] to/from GeckoBundle[] is if every element
    // is null.
    private static int getNullArrayLength(final Object array) {
        final int len = Array.getLength(array);
        for (int i = 0; i < len; i++) {
            if (Array.get(array, i) != null) {
                throw new ClassCastException("Cannot cast array type");
            }
        }
        return len;
    }

    /**
     * Returns the value associated with a String array mapping, or null if the mapping
     * does not exist.
     *
     * @param key Key to look for.
     * @return String array value
     */
    public String[] getStringArray(final String key) {
        final Object value = mMap.get(key);
        return value == null ? null : Array.getLength(value) == 0 ? EMPTY_STRING_ARRAY :
               !(value instanceof String[]) ? new String[getNullArrayLength(value)] :
                                              (String[]) value;
    }

    /**
     * Returns the value associated with a GeckoBundle mapping, or null if the mapping
     * does not exist.
     *
     * @param key Key to look for.
     * @return GeckoBundle value
     */
    public GeckoBundle getBundle(final String key) {
        return (GeckoBundle) mMap.get(key);
    }

    /**
     * Returns the value associated with a GeckoBundle array mapping, or null if the
     * mapping does not exist.
     *
     * @param key Key to look for.
     * @return GeckoBundle array value
     */
    public GeckoBundle[] getBundleArray(final String key) {
        final Object value = mMap.get(key);
        return value == null ? null : Array.getLength(value) == 0 ? EMPTY_BUNDLE_ARRAY :
               !(value instanceof GeckoBundle[]) ? new GeckoBundle[getNullArrayLength(value)] :
                                                   (GeckoBundle[]) value;
    }

    /**
     * Returns whether this GeckoBundle has no mappings.
     *
     * @return True if no mapping exists.
     */
    public boolean isEmpty() {
        return mMap.isEmpty();
    }

    /**
     * Returns an array of all mapped keys.
     *
     * @return String array containing all mapped keys.
     */
    @WrapForJNI(calledFrom = "gecko")
    public String[] keys() {
        final int len = mMap.size();
        final String[] ret = new String[len];
        for (int i = 0; i < len; i++) {
            ret[i] = mMap.keyAt(i);
        }
        return ret;
    }

    @WrapForJNI(calledFrom = "gecko")
    private Object[] values() {
        final int len = mMap.size();
        final Object[] ret = new Object[len];
        for (int i = 0; i < len; i++) {
            ret[i] = mMap.valueAt(i);
        }
        return ret;
    }

    private void put(final String key, final Object value) {
        // We intentionally disallow a generic put() method for type safety and sanity. For
        // example, we assume elsewhere in the code that a value belongs to a small list of
        // predefined types, and cannot be any arbitrary object. If you want to put an
        // Object in the bundle, check the type of the Object first and call the
        // corresponding put methods. For example,
        //
        //   if (obj instanceof Integer) {
        //     bundle.putInt(key, (Integer) key);
        //   } else if (obj instanceof String) {
        //     bundle.putString(key, (String) obj);
        //   } else {
        //     throw new IllegalArgumentException("unexpected type");
        //   }
        throw new UnsupportedOperationException();
    }

    /**
     * Map a key to a boolean value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putBoolean(final String key, final boolean value) {
        mMap.put(key, value);
    }

    /**
     * Map a key to a boolean array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putBooleanArray(final String key, final boolean[] value) {
        mMap.put(key, value);
    }

    /**
     * Map a key to a boolean array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putBooleanArray(final String key, final Boolean[] value) {
        if (value == null) {
            mMap.put(key, null);
            return;
        }
        final boolean[] array = new boolean[value.length];
        for (int i = 0; i < value.length; i++) {
            array[i] = value[i];
        }
        mMap.put(key, array);
    }

    /**
     * Map a key to a boolean array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putBooleanArray(final String key, final Collection<Boolean> value) {
        if (value == null) {
            mMap.put(key, null);
            return;
        }
        final boolean[] array = new boolean[value.size()];
        int i = 0;
        for (final Boolean element : value) {
            array[i++] = element;
        }
        mMap.put(key, array);
    }

    /**
     * Map a key to a double value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putDouble(final String key, final double value) {
        mMap.put(key, value);
    }

    /**
     * Map a key to a double array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putDoubleArray(final String key, final double[] value) {
        mMap.put(key, value);
    }

    /**
     * Map a key to a double array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putDoubleArray(final String key, final Double[] value) {
        putDoubleArray(key, Arrays.asList(value));
    }

    /**
     * Map a key to a double array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putDoubleArray(final String key, final Collection<Double> value) {
        if (value == null) {
            mMap.put(key, null);
            return;
        }
        final double[] array = new double[value.size()];
        int i = 0;
        for (final Double element : value) {
            array[i++] = element;
        }
        mMap.put(key, array);
    }

    /**
     * Map a key to an int value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putInt(final String key, final int value) {
        mMap.put(key, value);
    }

    /**
     * Map a key to an int array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putIntArray(final String key, final int[] value) {
        mMap.put(key, value);
    }

    /**
     * Map a key to a int array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putIntArray(final String key, final Integer[] value) {
        putIntArray(key, Arrays.asList(value));
    }

    /**
     * Map a key to a int array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putIntArray(final String key, final Collection<Integer> value) {
        if (value == null) {
            mMap.put(key, null);
            return;
        }
        final int[] array = new int[value.size()];
        int i = 0;
        for (final Integer element : value) {
            array[i++] = element;
        }
        mMap.put(key, array);
    }

    /**
     * Map a key to a long value stored as a double value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putLong(final String key, final long value) {
        mMap.put(key, (double) value);
    }

    /**
     * Map a key to a long array value stored as a double array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putLongArray(final String key, final long[] value) {
        if (value == null) {
            mMap.put(key, null);
            return;
        }
        final double[] array = new double[value.length];
        for (int i = 0; i < value.length; i++) {
            array[i] = (double) value[i];
        }
        mMap.put(key, array);
    }

    /**
     * Map a key to a long array value stored as a double array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putLongArray(final String key, final Long[] value) {
        putLongArray(key, Arrays.asList(value));
    }

    /**
     * Map a key to a long array value stored as a double array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putLongArray(final String key, final Collection<Long> value) {
        if (value == null) {
            mMap.put(key, null);
            return;
        }
        final double[] array = new double[value.size()];
        int i = 0;
        for (final Long element : value) {
            array[i++] = (double) element;
        }
        mMap.put(key, array);
    }

    /**
     * Map a key to a String value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putString(final String key, final String value) {
        mMap.put(key, value);
    }

    /**
     * Map a key to a String array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putStringArray(final String key, final String[] value) {
        mMap.put(key, value);
    }

    /**
     * Map a key to a String array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putStringArray(final String key, final Collection<String> value) {
        if (value == null) {
            mMap.put(key, null);
            return;
        }
        final String[] array = new String[value.size()];
        int i = 0;
        for (final String element : value) {
            array[i++] = element;
        }
        mMap.put(key, array);
    }

    /**
     * Map a key to a GeckoBundle value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putBundle(final String key, final GeckoBundle value) {
        mMap.put(key, value);
    }

    /**
     * Map a key to a GeckoBundle array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putBundleArray(final String key, final GeckoBundle[] value) {
        mMap.put(key, value);
    }

    /**
     * Map a key to a GeckoBundle array value.
     *
     * @param key Key to map.
     * @param value Value to map to.
     */
    public void putBundleArray(final String key, final Collection<GeckoBundle> value) {
        if (value == null) {
            mMap.put(key, null);
            return;
        }
        final GeckoBundle[] array = new GeckoBundle[value.size()];
        int i = 0;
        for (final GeckoBundle element : value) {
            array[i++] = element;
        }
        mMap.put(key, array);
    }

    /**
     * Remove a mapping.
     *
     * @param key Key to remove.
     */
    public void remove(final String key) {
        mMap.remove(key);
    }

    /**
     * Returns number of mappings in this GeckoBundle.
     *
     * @return Number of mappings.
     */
    public int size() {
        return mMap.size();
    }

    private static Object normalizeValue(final Object value) {
        if (value instanceof Integer) {
            // We treat int and double as the same type.
            return ((Integer) value).doubleValue();

        } else if (value instanceof int[]) {
            // We treat int[] and double[] as the same type.
            final int[] array = (int[]) value;
            return array.length == 0 ? EMPTY_STRING_ARRAY : getDoubleArray(array);

        } else if (value != null && value.getClass().isArray()) {
            // We treat arrays of all nulls as the same type, including empty arrays.
            final int len = Array.getLength(value);
            for (int i = 0; i < len; i++) {
                if (Array.get(value, i) != null) {
                    return value;
                }
            }
            return len == 0 ? EMPTY_STRING_ARRAY : new String[len];
        }
        return value;
    }

    @Override // Object
    public boolean equals(final Object other) {
        if (!(other instanceof GeckoBundle)) {
            return false;
        }

        // Support library's SimpleArrayMap.equals is buggy, so roll our own version.
        final SimpleArrayMap<String, Object> otherMap = ((GeckoBundle) other).mMap;
        if (mMap == otherMap) {
            return true;
        }
        if (mMap.size() != otherMap.size()) {
            return false;
        }

        for (int i = 0; i < mMap.size(); i++) {
            final String thisKey = mMap.keyAt(i);
            final int otherKey = otherMap.indexOfKey(thisKey);
            if (otherKey < 0) {
                return false;
            }
            final Object thisValue = normalizeValue(mMap.valueAt(i));
            final Object otherValue = normalizeValue(otherMap.valueAt(otherKey));
            if (thisValue == otherValue) {
                continue;
            } else if (thisValue == null || otherValue == null) {
                return false;
            }

            final Class<?> thisClass = thisValue.getClass();
            final Class<?> otherClass = otherValue.getClass();
            if (thisClass != otherClass && !thisClass.equals(otherClass)) {
                return false;
            } else if (!thisClass.isArray()) {
                if (!thisValue.equals(otherValue)) {
                    return false;
                }
                continue;
            }

            // Work with both primitive arrays and Object arrays, unlike Arrays.equals().
            final int thisLen = Array.getLength(thisValue);
            final int otherLen = Array.getLength(otherValue);
            if (thisLen != otherLen) {
                return false;
            }
            for (int j = 0; j < thisLen; j++) {
                final Object thisElem = Array.get(thisValue, j);
                final Object otherElem = Array.get(otherValue, j);
                if (thisElem != otherElem && (thisElem == null ||
                        otherElem == null || !thisElem.equals(otherElem))) {
                    return false;
                }
            }
        }
        return true;
    }

    @Override // Object
    public int hashCode() {
        return mMap.hashCode();
    }

    @Override // Object
    public String toString() {
        return mMap.toString();
    }

    public JSONObject toJSONObject() throws JSONException {
        final JSONObject out = new JSONObject();
        for (int i = 0; i < mMap.size(); i++) {
            final Object value = mMap.valueAt(i);
            final Object jsonValue;

            if (value instanceof GeckoBundle) {
                jsonValue = ((GeckoBundle) value).toJSONObject();
            } else if (value instanceof GeckoBundle[]) {
                final GeckoBundle[] array = (GeckoBundle[]) value;
                final JSONArray jsonArray = new JSONArray();
                for (final GeckoBundle element : array) {
                    jsonArray.put(element == null ? JSONObject.NULL : element.toJSONObject());
                }
                jsonValue = jsonArray;
            } else if (Build.VERSION.SDK_INT >= 19) {
                final Object wrapped = JSONObject.wrap(value);
                jsonValue = wrapped != null ? wrapped : value.toString();
            } else if (value == null) {
                jsonValue = JSONObject.NULL;
            } else if (value.getClass().isArray()) {
                final JSONArray jsonArray = new JSONArray();
                for (int j = 0; j < Array.getLength(value); j++) {
                    jsonArray.put(Array.get(value, j));
                }
                jsonValue = jsonArray;
            } else {
                jsonValue = value;
            }
            out.put(mMap.keyAt(i), jsonValue);
        }
        return out;
    }

    public Bundle toBundle() {
        final Bundle out = new Bundle(mMap.size());
        for (int i = 0; i < mMap.size(); i++) {
            final String key = mMap.keyAt(i);
            final Object val = mMap.valueAt(i);

            if (val == null) {
                out.putString(key, null);
            } else if (val instanceof GeckoBundle) {
                out.putBundle(key, ((GeckoBundle) val).toBundle());
            } else if (val instanceof GeckoBundle[]) {
                final GeckoBundle[] array = (GeckoBundle[]) val;
                final Parcelable[] parcelables = new Parcelable[array.length];
                for (int j = 0; j < array.length; j++) {
                    if (array[j] != null) {
                        parcelables[j] = array[j].toBundle();
                    }
                }
                out.putParcelableArray(key, parcelables);
            } else if (val instanceof Boolean) {
                out.putBoolean(key, (Boolean) val);
            } else if (val instanceof boolean[]) {
                out.putBooleanArray(key, (boolean[]) val);
            } else if (val instanceof Byte || val instanceof Short || val instanceof Integer) {
                out.putInt(key, ((Number) val).intValue());
            } else if (val instanceof int[]) {
                out.putIntArray(key, (int[]) val);
            } else if (val instanceof Float || val instanceof Double || val instanceof Long) {
                out.putDouble(key, ((Number) val).doubleValue());
            } else if (val instanceof double[]) {
                out.putDoubleArray(key, (double[]) val);
            } else if (val instanceof CharSequence || val instanceof Character) {
                out.putString(key, val.toString());
            } else if (val instanceof String[]) {
                out.putStringArray(key, (String[]) val);
            } else {
                throw new UnsupportedOperationException();
            }
        }
        return out;
    }

    public static GeckoBundle fromBundle(final Bundle bundle) {
        if (bundle == null) {
            return null;
        }

        final String[] keys = new String[bundle.size()];
        final Object[] values = new Object[bundle.size()];
        int i = 0;

        for (final String key : bundle.keySet()) {
            final Object value = bundle.get(key);
            keys[i] = key;

            if (value instanceof Bundle || value == null) {
                values[i] = fromBundle((Bundle) value);
            } else if (value instanceof Parcelable[]) {
                final Parcelable[] array = (Parcelable[]) value;
                final GeckoBundle[] out = new GeckoBundle[array.length];
                for (int j = 0; j < array.length; j++) {
                    out[j] = fromBundle((Bundle) array[j]);
                }
                values[i] = out;
            } else if (value instanceof Boolean || value instanceof Integer ||
                    value instanceof Double || value instanceof String ||
                    value instanceof boolean[] || value instanceof int[] ||
                    value instanceof double[] || value instanceof String[]) {
                values[i] = value;
            } else if (value instanceof Byte || value instanceof Short) {
                values[i] = ((Number) value).intValue();
            } else if (value instanceof Float || value instanceof Long) {
                values[i] = ((Number) value).doubleValue();
            } else if (value instanceof CharSequence || value instanceof Character) {
                values[i] = value.toString();
            } else {
                throw new UnsupportedOperationException();
            }

            i++;
        }
        return new GeckoBundle(keys, values);
    }

    private static Object fromJSONValue(final Object value) throws JSONException {
        if (value == null || value == JSONObject.NULL) {
            return null;
        } else if (value instanceof JSONObject) {
            return fromJSONObject((JSONObject) value);
        }
        if (value instanceof JSONArray) {
            final JSONArray array = (JSONArray) value;
            final int len = array.length();
            if (len == 0) {
                return EMPTY_BOOLEAN_ARRAY;
            }
            Object out = null;
            for (int i = 0; i < len; i++) {
                final Object element = fromJSONValue(array.opt(i));
                if (element == null) {
                    continue;
                }
                if (out == null) {
                    Class<?> type = element.getClass();
                    if (type == Boolean.class) {
                        type = boolean.class;
                    } else if (type == Integer.class) {
                        type = int.class;
                    } else if (type == Double.class) {
                        type = double.class;
                    }
                    out = Array.newInstance(type, len);
                }
                Array.set(out, i, element);
            }
            if (out == null) {
                // Treat all-null arrays as String arrays.
                return new String[len];
            }
            return out;
        }
        if (value instanceof Boolean || value instanceof Integer ||
                value instanceof Double || value instanceof String) {
            return value;
        }
        if (value instanceof Byte || value instanceof Short) {
            return ((Number) value).intValue();
        }
        if (value instanceof Float || value instanceof Long) {
            return ((Number) value).doubleValue();
        }
        return value.toString();
    }

    public static GeckoBundle fromJSONObject(final JSONObject obj) throws JSONException {
        if (obj == null || obj == JSONObject.NULL) {
            return null;
        }

        final String[] keys = new String[obj.length()];
        final Object[] values = new Object[obj.length()];

        final Iterator<String> iter = obj.keys();
        for (int i = 0; iter.hasNext(); i++) {
            final String key = iter.next();
            keys[i] = key;
            values[i] = fromJSONValue(obj.opt(key));
        }
        return new GeckoBundle(keys, values);
    }

    @Override // Parcelable
    public int describeContents() {
        return 0;
    }

    @Override // Parcelable
    public void writeToParcel(final Parcel dest, final int flags) {
        final int len = mMap.size();
        dest.writeInt(len);

        for (int i = 0; i < len; i++) {
            dest.writeString(mMap.keyAt(i));
            dest.writeValue(mMap.valueAt(i));
        }
    }

    // AIDL code may call readFromParcel even though it's not part of Parcelable.
    public void readFromParcel(final Parcel source) {
        final ClassLoader loader = getClass().getClassLoader();
        final int len = source.readInt();
        mMap.clear();
        mMap.ensureCapacity(len);

        for (int i = 0; i < len; i++) {
            final String key = source.readString();
            Object val = source.readValue(loader);

            if (val instanceof Parcelable[]) {
                final Parcelable[] array = (Parcelable[]) val;
                val = Arrays.copyOf(array, array.length, GeckoBundle[].class);
            }

            mMap.put(key, val);
        }
    }

    public static final Parcelable.Creator<GeckoBundle> CREATOR =
            new Parcelable.Creator<GeckoBundle>() {
        @Override
        public GeckoBundle createFromParcel(final Parcel source) {
            final GeckoBundle bundle = new GeckoBundle(0);
            bundle.readFromParcel(source);
            return bundle;
        }

        @Override
        public GeckoBundle[] newArray(final int size) {
            return new GeckoBundle[size];
        }
    };
}