下面列出了android.os.Bundle#putCharArray ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public static void fromArrayToBundle(Bundle bundle, String key, Object array) {
if (bundle != null && !TextUtils.isEmpty(key) && array != null) {
if (array instanceof String[]) {
bundle.putStringArray(key, (String[]) ((String[]) array));
} else if (array instanceof byte[]) {
bundle.putByteArray(key, (byte[]) ((byte[]) array));
} else if (array instanceof short[]) {
bundle.putShortArray(key, (short[]) ((short[]) array));
} else if (array instanceof int[]) {
bundle.putIntArray(key, (int[]) ((int[]) array));
} else if (array instanceof long[]) {
bundle.putLongArray(key, (long[]) ((long[]) array));
} else if (array instanceof float[]) {
bundle.putFloatArray(key, (float[]) ((float[]) array));
} else if (array instanceof double[]) {
bundle.putDoubleArray(key, (double[]) ((double[]) array));
} else if (array instanceof boolean[]) {
bundle.putBooleanArray(key, (boolean[]) ((boolean[]) array));
} else if (array instanceof char[]) {
bundle.putCharArray(key, (char[]) ((char[]) array));
} else {
if (!(array instanceof JSONArray)) {
throw new IllegalArgumentException("Unknown array type " + array.getClass());
}
ArrayList arraylist = new ArrayList();
JSONArray jsonArray = (JSONArray) array;
Iterator it = jsonArray.iterator();
while (it.hasNext()) {
JSONObject object = (JSONObject) it.next();
arraylist.add(fromJsonToBundle(object));
}
bundle.putParcelableArrayList(key, arraylist);
}
}
}
public void putCharArray(Bundle state, String key, char[] x) {
state.putCharArray(key + mBaseKey, x);
}
public static void putValueToBundle(
@NonNull Bundle bundle, @NonNull String key, @NonNull Object value) {
if (value instanceof String) {
bundle.putString(key, (String) value);
} else if (value instanceof Integer) {
bundle.putInt(key, (int) value);
} else if (value instanceof Boolean) {
bundle.putBoolean(key, (boolean) value);
} else if (value instanceof Long) {
bundle.putLong(key, (long) value);
} else if (value instanceof Short) {
bundle.putShort(key, (short) value);
} else if (value instanceof Double) {
bundle.putDouble(key, (double) value);
} else if (value instanceof Float) {
bundle.putFloat(key, (float) value);
} else if (value instanceof Character) {
bundle.putChar(key, (char) value);
} else if (value instanceof Byte) {
bundle.putByte(key, (byte) value);
} else if (value instanceof CharSequence) {
bundle.putCharSequence(key, (CharSequence) value);
} else if (value instanceof Bundle) {
bundle.putBundle(key, (Bundle) value);
} else if (value instanceof Parcelable) {
bundle.putParcelable(key, (Parcelable) value);
} else if (value instanceof String[]) {
bundle.putStringArray(key, (String[]) value);
} else if (value instanceof int[]) {
bundle.putIntArray(key, (int[]) value);
} else if (value instanceof boolean[]) {
bundle.putBooleanArray(key, (boolean[]) value);
} else if (value instanceof long[]) {
bundle.putLongArray(key, (long[]) value);
} else if (value instanceof short[]) {
bundle.putShortArray(key, (short[]) value);
} else if (value instanceof double[]) {
bundle.putDoubleArray(key, (double[]) value);
} else if (value instanceof float[]) {
bundle.putFloatArray(key, (float[]) value);
} else if (value instanceof char[]) {
bundle.putCharArray(key, (char[]) value);
} else if (value instanceof byte[]) {
bundle.putByteArray(key, (byte[]) value);
} else if (value instanceof CharSequence[]) {
bundle.putCharSequenceArray(key, (CharSequence[]) value);
} else if (value instanceof Parcelable[]) {
bundle.putParcelableArray(key, (Parcelable[]) value);
} else if (value instanceof ArrayList) {
bundle.putIntegerArrayList(key, (ArrayList<Integer>) value);
} else if (value instanceof SparseArray) {
bundle.putSparseParcelableArray(key, (SparseArray<? extends Parcelable>) value);
} else {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
if (value instanceof IBinder) {
bundle.putBinder(key, (IBinder) value);
return;
}
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
if (value instanceof Size) {
bundle.putSize(key, (Size) value);
return;
} else if (value instanceof SizeF) {
bundle.putSizeF(key, (SizeF) value);
return;
}
}
if (value instanceof Serializable) {
bundle.putSerializable(key, (Serializable) value);
return;
}
throw new RuntimeException(String.format(Locale.getDefault(),
"Arguments extra %s has wrong type %s.", key, value.getClass().getName()));
}
}
public Bundle assembleBundle() {
User user = new User();
user.setAge(90);
user.setGender(1);
user.setName("kitty");
Address address = new Address();
address.setCity("HangZhou");
address.setProvince("ZheJiang");
Bundle extras = new Bundle();
extras.putString("extra", "from extras");
ArrayList<String> stringList = new ArrayList<>();
stringList.add("Java");
stringList.add("C#");
stringList.add("Kotlin");
ArrayList<String> stringArrayList = new ArrayList<>();
stringArrayList.add("American");
stringArrayList.add("China");
stringArrayList.add("England");
ArrayList<Integer> intArrayList = new ArrayList<>();
intArrayList.add(100);
intArrayList.add(101);
intArrayList.add(102);
ArrayList<Integer> intList = new ArrayList<>();
intList.add(10011);
intList.add(10111);
intList.add(10211);
ArrayList<Address> addressList = new ArrayList<>();
addressList.add(new Address("JiangXi", "ShangRao", null));
addressList.add(new Address("ZheJiang", "NingBo", null));
Address[] addressArray = new Address[]{
new Address("Beijing", "Beijing", null),
new Address("Shanghai", "Shanghai", null),
new Address("Guangzhou", "Guangzhou", null)
};
Bundle bundle = new Bundle();
bundle.putSerializable("user", user);
bundle.putParcelable("address", address);
bundle.putParcelableArrayList("addressList", addressList);
bundle.putParcelableArray("addressArray", addressArray);
bundle.putString("param", "chiclaim");
bundle.putStringArray("stringArray", new String[]{"a", "b", "c"});
bundle.putStringArrayList("stringArrayList", stringList);
bundle.putStringArrayList("stringList", stringArrayList);
bundle.putByte("byte", (byte) 2);
bundle.putByteArray("byteArray", new byte[]{1, 2, 3, 4, 5});
bundle.putInt("age", 33);
bundle.putIntArray("intArray", new int[]{10, 11, 12, 13});
bundle.putIntegerArrayList("intList", intList);
bundle.putIntegerArrayList("intArrayList", intArrayList);
bundle.putChar("chara", 'c');
bundle.putCharArray("charArray", "chiclaim".toCharArray());
bundle.putShort("short", (short) 1000000);
bundle.putShortArray("shortArray", new short[]{(short) 10.9, (short) 11.9});
bundle.putDouble("double", 1200000);
bundle.putDoubleArray("doubleArray", new double[]{1232, 9999, 8789, 3.1415926});
bundle.putLong("long", 999999999);
bundle.putLongArray("longArray", new long[]{1000, 2000, 3000});
bundle.putFloat("float", 333);
bundle.putFloatArray("floatArray", new float[]{12.9f, 234.9f});
bundle.putBoolean("boolean", true);
bundle.putBooleanArray("booleanArray", new boolean[]{true, false, true});
return bundle;
}
/**
* Finishes activity with {@link Activity#RESULT_OK}.
*
* @param pattern
* the pattern, if this is in mode creating pattern. In any
* cases, it can be set to {@code null}.
*/
private void finishWithResultOk(char[] pattern) {
if (ACTION_CREATE_PATTERN.equals(getIntent().getAction()))
mIntentResult.putExtra(EXTRA_PATTERN, pattern);
else {
/*
* If the user was "logging in", minimum try count can not be zero.
*/
mIntentResult.putExtra(EXTRA_RETRY_COUNT, mRetryCount + 1);
}
setResult(RESULT_OK, mIntentResult);
/*
* ResultReceiver
*/
ResultReceiver receiver = getIntent().getParcelableExtra(
EXTRA_RESULT_RECEIVER);
if (receiver != null) {
Bundle bundle = new Bundle();
if (ACTION_CREATE_PATTERN.equals(getIntent().getAction()))
bundle.putCharArray(EXTRA_PATTERN, pattern);
else {
/*
* If the user was "logging in", minimum try count can not be
* zero.
*/
bundle.putInt(EXTRA_RETRY_COUNT, mRetryCount + 1);
}
receiver.send(RESULT_OK, bundle);
}
/*
* PendingIntent
*/
PendingIntent pi = getIntent().getParcelableExtra(
EXTRA_PENDING_INTENT_OK);
if (pi != null) {
try {
pi.send(this, RESULT_OK, mIntentResult);
} catch (Throwable t) {
Log.e(CLASSNAME, "Error sending PendingIntent: " + pi, t);
}
}
finish();
}
/**
* Finishes activity with {@link Activity#RESULT_OK}.
*
* @param pattern
* the pattern, if this is in mode creating pattern. In any
* cases, it can be set to {@code null}.
*/
private void finishWithResultOk(char[] pattern) {
if (ACTION_CREATE_PATTERN.equals(getIntent().getAction()))
mIntentResult.putExtra(EXTRA_PATTERN, pattern);
else {
/*
* If the user was "logging in", minimum try count can not be zero.
*/
mIntentResult.putExtra(EXTRA_RETRY_COUNT, mRetryCount + 1);
}
setResult(RESULT_OK, mIntentResult);
/*
* ResultReceiver
*/
ResultReceiver receiver = getIntent().getParcelableExtra(
EXTRA_RESULT_RECEIVER);
if (receiver != null) {
Bundle bundle = new Bundle();
if (ACTION_CREATE_PATTERN.equals(getIntent().getAction()))
bundle.putCharArray(EXTRA_PATTERN, pattern);
else {
/*
* If the user was "logging in", minimum try count can not be
* zero.
*/
bundle.putInt(EXTRA_RETRY_COUNT, mRetryCount + 1);
}
receiver.send(RESULT_OK, bundle);
}
/*
* PendingIntent
*/
PendingIntent pi = getIntent().getParcelableExtra(
EXTRA_PENDING_INTENT_OK);
if (pi != null) {
try {
pi.send(this, RESULT_OK, mIntentResult);
} catch (Throwable t) {
Log.e(CLASSNAME, "Error sending PendingIntent: " + pi, t);
}
}
finish();
}
@Override
public void put(Bundle bundle, String target, String keyPrefix) {
char[] charArray = (keyPrefix + target).toCharArray();
bundle.putCharArray(keyPrefix, charArray);
}
/**
* Finishes activity with {@link Activity#RESULT_OK}.
*
* @param pattern
* the pattern, if this is in mode creating pattern. In any
* cases, it can be set to {@code null}.
*/
private void finishWithResultOk(char[] pattern) {
if (ACTION_CREATE_PATTERN.equals(getIntent().getAction()))
mIntentResult.putExtra(EXTRA_PATTERN, pattern);
else {
/*
* If the user was "logging in", minimum try count can not be zero.
*/
mIntentResult.putExtra(EXTRA_RETRY_COUNT, mRetryCount + 1);
}
setResult(RESULT_OK, mIntentResult);
/*
* ResultReceiver
*/
ResultReceiver receiver = getIntent().getParcelableExtra(
EXTRA_RESULT_RECEIVER);
if (receiver != null) {
Bundle bundle = new Bundle();
if (ACTION_CREATE_PATTERN.equals(getIntent().getAction()))
bundle.putCharArray(EXTRA_PATTERN, pattern);
else {
/*
* If the user was "logging in", minimum try count can not be
* zero.
*/
bundle.putInt(EXTRA_RETRY_COUNT, mRetryCount + 1);
}
receiver.send(RESULT_OK, bundle);
}
/*
* PendingIntent
*/
PendingIntent pi = getIntent().getParcelableExtra(
EXTRA_PENDING_INTENT_OK);
if (pi != null) {
try {
pi.send(this, RESULT_OK, mIntentResult);
} catch (Throwable t) {
if (BuildConfig.DEBUG) {
Log.e(CLASSNAME, "Error sending PendingIntent: " + pi);
Log.e(CLASSNAME, ">>> " + t);
t.printStackTrace();
}
}
}
finish();
}
private static void putCharArray(String key, Bundle bundle) {
bundle.putCharArray(key, getCharArray());
}
@SuppressWarnings("unchecked")
private static void setBundleValue(@NonNull Field field, @NonNull Object obj,
@NonNull Bundle bundle, @NonNull String key, boolean isGson)
throws IllegalAccessException {
if (isGson) {
bundle.putString(key, GsonHelper.toJson(field.get(obj)));
return;
}
Class<?> type = field.getType();
Type[] genericTypes = null;
if (field.getGenericType() instanceof ParameterizedType) {
genericTypes = ((ParameterizedType) field.getGenericType()).getActualTypeArguments();
}
if (type.equals(Boolean.TYPE)) {
bundle.putBoolean(key, field.getBoolean(obj));
} else if (type.equals(boolean[].class)) {
bundle.putBooleanArray(key, (boolean[]) field.get(obj));
} else if (type.equals(Bundle.class)) {
bundle.putBundle(key, (Bundle) field.get(obj));
} else if (type.equals(Byte.TYPE)) {
bundle.putByte(key, field.getByte(obj));
} else if (type.equals(byte[].class)) {
bundle.putByteArray(key, (byte[]) field.get(obj));
} else if (type.equals(Character.TYPE)) {
bundle.putChar(key, field.getChar(obj));
} else if (type.equals(char[].class)) {
bundle.putCharArray(key, (char[]) field.get(obj));
} else if (type.equals(CharSequence.class)) {
bundle.putCharSequence(key, (CharSequence) field.get(obj));
} else if (type.equals(CharSequence[].class)) {
bundle.putCharSequenceArray(key, (CharSequence[]) field.get(obj));
} else if (type.equals(Double.TYPE)) {
bundle.putDouble(key, field.getDouble(obj));
} else if (type.equals(double[].class)) {
bundle.putDoubleArray(key, (double[]) field.get(obj));
} else if (type.equals(Float.TYPE)) {
bundle.putFloat(key, field.getFloat(obj));
} else if (type.equals(float[].class)) {
bundle.putFloatArray(key, (float[]) field.get(obj));
} else if (type.equals(Integer.TYPE)) {
bundle.putInt(key, field.getInt(obj));
} else if (type.equals(int[].class)) {
bundle.putIntArray(key, (int[]) field.get(obj));
} else if (type.equals(Long.TYPE)) {
bundle.putLong(key, field.getLong(obj));
} else if (type.equals(long[].class)) {
bundle.putLongArray(key, (long[]) field.get(obj));
} else if (type.equals(Short.TYPE)) {
bundle.putShort(key, field.getShort(obj));
} else if (type.equals(short[].class)) {
bundle.putShortArray(key, (short[]) field.get(obj));
} else if (type.equals(String.class)) {
bundle.putString(key, (String) field.get(obj));
} else if (type.equals(String[].class)) {
bundle.putStringArray(key, (String[]) field.get(obj));
} else if (Parcelable.class.isAssignableFrom(type)) {
bundle.putParcelable(key, (Parcelable) field.get(obj));
} else if (type.equals(ArrayList.class)
&& genericTypes != null
&& genericTypes[0] instanceof Class
&& Parcelable.class.isAssignableFrom((Class<?>) genericTypes[0])) {
bundle.putParcelableArrayList(key, (ArrayList<? extends Parcelable>) field.get(obj));
} else if (type.isArray() && Parcelable.class.isAssignableFrom(type.getComponentType())) {
bundle.putParcelableArray(key, (Parcelable[]) field.get(obj));
} else if (Serializable.class.isAssignableFrom(type)) {
bundle.putSerializable(key, (Serializable) field.get(obj));
} else {
throw new RuntimeException("Unsupported field type: " + field.getName()
+ ", " + type.getName());
}
}
/**
* Write a field's value into the saved state {@link Bundle}.
*
* @param state {@link Bundle} used to save the state
* @param key key retrieved from {@code fieldDeclaringClass#fieldName}
* @param fieldValue value of field
*/
@Override
public void serialize(@NonNull Bundle state, @NonNull String key, @NonNull char[] fieldValue) {
state.putCharArray(key, fieldValue);
}