import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
private void resizeFor(int size) {
    final int oldLength = mText.length;
    final int newLength = ArrayUtils.idealCharArraySize(size + 1);
    final int delta = newLength - oldLength;
    if (delta == 0) return;

    char[] newText = new char[newLength];
    System.arraycopy(mText, 0, newText, 0, mGapStart);
    final int after = oldLength - (mGapStart + mGapLength);
    System.arraycopy(mText, oldLength - after, newText, newLength - after, after);
    mText = newText;

    mGapLength += delta;
    if (mGapLength < 1)
        new Exception("mGapLength < 1").printStackTrace();

    for (int i = 0; i < mSpanCount; i++) {
        if (mSpanStarts[i] > mGapStart) mSpanStarts[i] += delta;
        if (mSpanEnds[i] > mGapStart) mSpanEnds[i] += delta;
    }
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Puts a key/value pair into the array, optimizing for the case where
 * the key is greater than all existing keys in the array.
 */
public void append(int key, boolean value) {
    if (mSize != 0 && key <= mKeys[mSize - 1]) {
        put(key, value);
        return;
    }

    int pos = mSize;
    if (pos >= mKeys.length) {
        int n = ArrayUtils.idealIntArraySize(pos + 1);

        int[] nkeys = new int[n];
        boolean[] nvalues = new boolean[n];

        // Log.e("SparseBooleanArray", "grow " + mKeys.length + " to " + n);
        System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
        System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

        mKeys = nkeys;
        mValues = nvalues;
    }

    mKeys[pos] = key;
    mValues[pos] = value;
    mSize = pos + 1;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Puts a key/value pair into the array, optimizing for the case where
 * the key is greater than all existing keys in the array.
 */
public void append(int key, int value) {
    if (mSize != 0 && key <= mKeys[mSize - 1]) {
        put(key, value);
        return;
    }

    int pos = mSize;
    if (pos >= mKeys.length) {
        int n = ArrayUtils.idealIntArraySize(pos + 1);

        int[] nkeys = new int[n];
        int[] nvalues = new int[n];

        // Log.e("SparseIntArray", "grow " + mKeys.length + " to " + n);
        System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
        System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

        mKeys = nkeys;
        mValues = nvalues;
    }

    mKeys[pos] = key;
    mValues[pos] = value;
    mSize = pos + 1;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
public static void hookSDcardPermission()
{
	final Class<?> pms = XposedHelpers.findClass("com.android.server.pm.PackageManagerService", null);

	XposedHelpers.findAndHookMethod(pms, "readPermission", "org.xmlpull.v1.XmlPullParser", "java.lang.String", new XC_MethodHook()
	{
		protected void afterHookedMethod(MethodHookParam param) throws Throwable
		{
			String permission = (String) param.args[1];

			if (permission.equals("android.permission.WRITE_EXTERNAL_STORAGE"))
			{
				Class<?> process = XposedHelpers.findClass("android.os.Process", null);
				int gid = (Integer) XposedHelpers.callStaticMethod(process, "getGidForName", "media_rw");
				Object mSettings = XposedHelpers.getObjectField(param.thisObject, "mSettings");
				Object mPermissions = XposedHelpers.getObjectField(mSettings, "mPermissions");
				Object bp = XposedHelpers.callMethod(mPermissions, "get", permission);
				int[] bp_gids = (int[]) XposedHelpers.getObjectField(bp, "gids");
				XposedHelpers.setObjectField(bp, "gids", ArrayUtils.appendInt(bp_gids, gid));
			}
		}
	});
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new LongSparseArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.  If you supply an initial capacity of 0, the
 * sparse array will be initialized with a light-weight representation
 * not requiring any additional array allocations.
 */
public LongSparseArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mKeys = EmptyArray.LONG;
        mValues = EmptyArray.OBJECT;
    } else {
        mKeys = ArrayUtils.newUnpaddedLongArray(initialCapacity);
        mValues = ArrayUtils.newUnpaddedObjectArray(initialCapacity);
    }
    mSize = 0;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new SparseLongArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.  If you supply an initial capacity of 0, the
 * sparse array will be initialized with a light-weight representation
 * not requiring any additional array allocations.
 */
public LongSparseLongArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mKeys = EmptyArray.LONG;
        mValues = EmptyArray.LONG;
    } else {
        mKeys = ArrayUtils.newUnpaddedLongArray(initialCapacity);
        mValues = new long[mKeys.length];
    }
    mSize = 0;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new SparseLongArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.  If you supply an initial capacity of 0, the
 * sparse array will be initialized with a light-weight representation
 * not requiring any additional array allocations.
 */
public SparseLongArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mKeys = EmptyArray.INT;
        mValues = EmptyArray.LONG;
    } else {
        mValues = ArrayUtils.newUnpaddedLongArray(initialCapacity);
        mKeys = new int[mValues.length];
    }
    mSize = 0;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new SparseBooleanArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.  If you supply an initial capacity of 0, the
 * sparse array will be initialized with a light-weight representation
 * not requiring any additional array allocations.
 */
public SparseBooleanArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mKeys = EmptyArray.INT;
        mValues = EmptyArray.BOOLEAN;
    } else {
        mKeys = ArrayUtils.newUnpaddedIntArray(initialCapacity);
        mValues = new boolean[mKeys.length];
    }
    mSize = 0;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new SparseArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.  If you supply an initial capacity of 0, the
 * sparse array will be initialized with a light-weight representation
 * not requiring any additional array allocations.
 */
public SparseArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mKeys = EmptyArray.INT;
        mValues = EmptyArray.OBJECT;
    } else {
        mValues = ArrayUtils.newUnpaddedObjectArray(initialCapacity);
        mKeys = new int[mValues.length];
    }
    mSize = 0;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Creates an empty LongArray with the specified initial capacity.
 */
public LongArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mValues = EmptyArray.LONG;
    } else {
        mValues = ArrayUtils.newUnpaddedLongArray(initialCapacity);
    }
    mSize = 0;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Ensures capacity to append at least <code>count</code> values.
 */
private void ensureCapacity(int count) {
    final int currentSize = mSize;
    final int minCapacity = currentSize + count;
    if (minCapacity >= mValues.length) {
        final int targetCap = currentSize + (currentSize < (MIN_CAPACITY_INCREMENT / 2) ?
                MIN_CAPACITY_INCREMENT : currentSize >> 1);
        final int newCapacity = targetCap > minCapacity ? targetCap : minCapacity;
        final long[] newValues = ArrayUtils.newUnpaddedLongArray(newCapacity);
        System.arraycopy(mValues, 0, newValues, 0, currentSize);
        mValues = newValues;
    }
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new SparseIntArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.  If you supply an initial capacity of 0, the
 * sparse array will be initialized with a light-weight representation
 * not requiring any additional array allocations.
 */
public SparseIntArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mKeys = EmptyArray.INT;
        mValues = EmptyArray.INT;
    } else {
        mKeys = ArrayUtils.newUnpaddedIntArray(initialCapacity);
        mValues = new int[mKeys.length];
    }
    mSize = 0;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
static char[] obtain(int len) {
    char[] buf;

    synchronized (sLock) {
        buf = sTemp;
        sTemp = null;
    }

    if (buf == null || buf.length < len)
        buf = new char[ArrayUtils.idealCharArraySize(len)];

    return buf;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
SpannableStringInternal(CharSequence source,
                                      int start, int end) {
    if (start == 0 && end == source.length())
        mText = source.toString();
    else
        mText = source.toString().substring(start, end);

    int initial = ArrayUtils.idealIntArraySize(0);
    mSpans = new Object[initial];
    mSpanData = new int[initial * 3];

    if (source instanceof Spanned) {
        Spanned sp = (Spanned) source;
        Object[] spans = sp.getSpans(start, end, Object.class);

        for (int i = 0; i < spans.length; i++) {
            int st = sp.getSpanStart(spans[i]);
            int en = sp.getSpanEnd(spans[i]);
            int fl = sp.getSpanFlags(spans[i]);

            if (st < start)
                st = start;
            if (en > end)
                en = end;

            setSpan(spans[i], st - start, en - start, fl);
        }
    }
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new SparseLongArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.  If you supply an initial capacity of 0, the
 * sparse array will be initialized with a light-weight representation
 * not requiring any additional array allocations.
 */
public SparseLongArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mKeys = ContainerHelpers.EMPTY_INTS;
        mValues = ContainerHelpers.EMPTY_LONGS;
    } else {
        initialCapacity = ArrayUtils.idealLongArraySize(initialCapacity);
        mKeys = new int[initialCapacity];
        mValues = new long[initialCapacity];
    }
    mSize = 0;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
private void growKeyAndValueArrays(int minNeededSize) {
    int n = ArrayUtils.idealLongArraySize(minNeededSize);

    int[] nkeys = new int[n];
    long[] nvalues = new long[n];

    System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
    System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

    mKeys = nkeys;
    mValues = nvalues;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new SparseBooleanArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.  If you supply an initial capacity of 0, the
 * sparse array will be initialized with a light-weight representation
 * not requiring any additional array allocations.
 */
public SparseBooleanArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mKeys = ContainerHelpers.EMPTY_INTS;
        mValues = ContainerHelpers.EMPTY_BOOLEANS;
    } else {
        initialCapacity = ArrayUtils.idealIntArraySize(initialCapacity);
        mKeys = new int[initialCapacity];
        mValues = new boolean[initialCapacity];
    }
    mSize = 0;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Adds a mapping from the specified key to the specified value,
 * replacing the previous mapping from the specified key if there
 * was one.
 */
public void put(int key, boolean value) {
    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

    if (i >= 0) {
        mValues[i] = value;
    } else {
        i = ~i;

        if (mSize >= mKeys.length) {
            int n = ArrayUtils.idealIntArraySize(mSize + 1);

            int[] nkeys = new int[n];
            boolean[] nvalues = new boolean[n];

            // Log.e("SparseBooleanArray", "grow " + mKeys.length + " to " + n);
            System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
            System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

            mKeys = nkeys;
            mValues = nvalues;
        }

        if (mSize - i != 0) {
            // Log.e("SparseBooleanArray", "move " + (mSize - i));
            System.arraycopy(mKeys, i, mKeys, i + 1, mSize - i);
            System.arraycopy(mValues, i, mValues, i + 1, mSize - i);
        }

        mKeys[i] = key;
        mValues[i] = value;
        mSize++;
    }
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new SparseArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.  If you supply an initial capacity of 0, the
 * sparse array will be initialized with a light-weight representation
 * not requiring any additional array allocations.
 */
public SparseArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mKeys = ContainerHelpers.EMPTY_INTS;
        mValues = ContainerHelpers.EMPTY_OBJECTS;
    } else {
        initialCapacity = ArrayUtils.idealIntArraySize(initialCapacity);
        mKeys = new int[initialCapacity];
        mValues = new Object[initialCapacity];
    }
    mSize = 0;
}
 

import com.android.internal.util.ArrayUtils; //导入依赖的package包/类
/**
 * Puts a key/value pair into the array, optimizing for the case where
 * the key is greater than all existing keys in the array.
 */
public void append(int key, E value) {
    if (mSize != 0 && key <= mKeys[mSize - 1]) {
        put(key, value);
        return;
    }

    if (mGarbage && mSize >= mKeys.length) {
        gc();
    }

    int pos = mSize;
    if (pos >= mKeys.length) {
        int n = ArrayUtils.idealIntArraySize(pos + 1);

        int[] nkeys = new int[n];
        Object[] nvalues = new Object[n];

        // Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
        System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
        System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

        mKeys = nkeys;
        mValues = nvalues;
    }

    mKeys[pos] = key;
    mValues[pos] = value;
    mSize = pos + 1;
}