下面列出了android.os.Bundle#putCharSequenceArray ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* Create a new instance of the dialog, providing arguments.
* @param listener Listener for selection
* @param token Token to be returned on the callback, to differentiate different calls
* @param title Title of the dialog
* @param items String array of the options to show in the dialog
* @param selectedItem Index of the selected item
* @return New dialog
*/
public static GenericSelectDialog newInstance(GenericSelectDialogListener listener,
int token, String title, CharSequence[] items, int selectedItem) {
GenericSelectDialog dialog = new GenericSelectDialog();
// TODO: This isn't going to survive destroys, but it's the easiast way to communicate
dialog.mListener = listener;
Bundle args = new Bundle();
args.putInt(TOKEN_KEY, token);
args.putString(TITLE_KEY, title);
args.putCharSequenceArray(ARRAY_ITEMS, items);
args.putInt(SELECTED_ITEM_KEY, selectedItem);
dialog.setArguments(args);
return dialog;
}
@Override
public final void onSaveInstanceState(@NonNull final Bundle outState) {
outState.putParcelable(ITEM_COLOR_EXTRA, getItemColor());
outState.putIntArray(ICON_RESOURCE_IDS_EXTRA, iconResourceIds);
if (items != null) {
outState.putCharSequenceArray(ITEMS_EXTRA, items);
outState.putBooleanArray(ENABLED_ITEMS_EXTRA, getEnabledItems());
} else if (singleChoiceItems != null) {
outState.putCharSequenceArray(SINGLE_CHOICE_ITEMS_EXTRA, singleChoiceItems);
outState.putBooleanArray(CHECKED_ITEMS_EXTRA, getCheckedItems());
outState.putBooleanArray(ENABLED_ITEMS_EXTRA, getEnabledItems());
} else if (multiChoiceItems != null) {
outState.putCharSequenceArray(MULTI_CHOICE_ITEMS_EXTRA, multiChoiceItems);
outState.putBooleanArray(CHECKED_ITEMS_EXTRA, getCheckedItems());
outState.putBooleanArray(ENABLED_ITEMS_EXTRA, getEnabledItems());
}
}
@Override
protected Bundle prepareArguments() {
Bundle args = new Bundle();
args.putCharSequence(ARG_TITLE, title);
args.putCharSequence(ARG_POSITIVE_BUTTON, confirmButtonText);
args.putCharSequence(ARG_NEGATIVE_BUTTON, cancelButtonText);
args.putCharSequenceArray(ARG_ITEMS, items);
SparseBooleanArrayParcelable sparseArray = new SparseBooleanArrayParcelable();
for (int index = 0; checkedItems != null && index < checkedItems.length; index++) {
sparseArray.put(checkedItems[index], true);
}
args.putParcelable(ARG_CHECKED_ITEMS, sparseArray);
args.putInt(ARG_MODE, mode);
return args;
}
@Override public boolean onPreferenceChange(Preference preference, Object newValue) {
ListPreference list = (ListPreference) preference;
String value = (String) newValue;
// Workaround due to the use of setSummary in onCreate.
switch (value) {
case "handler":
list.setSummary(R.string.gesture_action_handler);
break;
case "widget":
list.setSummary(R.string.gesture_action_widget);
break;
case "status":
list.setSummary(R.string.gesture_action_status);
break;
case "list":
list.setSummary(R.string.gesture_action_list);
break;
case "app":
// Create the Bundle to pass to AppSelectionPreferenceDialog.
Bundle appListBundle = new Bundle();
appListBundle.putString("key", list.getKey());
appListBundle.putCharSequenceArray("entries", appListEntries);
appListBundle.putCharSequenceArray("entryValues", appListEntryValues);
// Call and create AppSelectionPreferenceDialog.
AppSelectionPreferenceDialog appList = new AppSelectionPreferenceDialog();
appList.setTargetFragment(GesturesPreference.this, APPLICATION_DIALOG_CODE);
appList.setArguments(appListBundle);
appList.show(requireFragmentManager(), "AppSelectionDialog");
break;
case "none":
default:
list.setSummary(R.string.gesture_action_default);
break;
}
return true;
}
@Override
protected Bundle prepareArguments() {
Bundle args = new Bundle();
args.putCharSequence(TabDialogFragment.ARG_MESSAGE, mMessage);
args.putCharSequence(TabDialogFragment.ARG_TITLE, mTitle);
args.putCharSequence(TabDialogFragment.ARG_SUB_TITLE, mSubTitle);
args.putCharSequence(TabDialogFragment.ARG_POSITIVE_BUTTON, mPositiveButtonText);
args.putCharSequence(TabDialogFragment.ARG_NEGATIVE_BUTTON, mNegativeButtonText);
args.putCharSequence(TabDialogFragment.ARG_NEUTRAL_BUTTON, mNeutralButtonText);
args.putCharSequenceArray(TabDialogFragment.ARG_TAB_BUTTON, mTabButtonText);
return args;
}
public static ViewAdditionalFiltersDialogFragment newInstance(CharSequence[] additionalFilters) {
Bundle args = new Bundle();
args.putCharSequenceArray("additionalFilters", additionalFilters);
ViewAdditionalFiltersDialogFragment fragment = new ViewAdditionalFiltersDialogFragment();
fragment.setArguments(args);
return fragment;
}
@Override public boolean onPreferenceChange(Preference preference, Object newValue) {
ListPreference list = (ListPreference) preference;
String value = (String) newValue;
// Workaround due to the use of setSummary in onCreate.
switch (value) {
case "handler":
list.setSummary(R.string.gesture_action_handler);
break;
case "widget":
list.setSummary(R.string.gesture_action_widget);
break;
case "status":
list.setSummary(R.string.gesture_action_status);
break;
case "list":
list.setSummary(R.string.gesture_action_list);
break;
case "app":
// Create the Bundle to pass to AppSelectionPreferenceDialog.
Bundle appListBundle = new Bundle();
appListBundle.putString("key", list.getKey());
appListBundle.putCharSequenceArray("entries", appListEntries);
appListBundle.putCharSequenceArray("entryValues", appListEntryValues);
// Call and create AppSelectionPreferenceDialog.
AppSelectionPreferenceDialog appList = new AppSelectionPreferenceDialog();
appList.setTargetFragment(GesturesPreference.this, APPLICATION_DIALOG_CODE);
appList.setArguments(appListBundle);
appList.show(requireFragmentManager(), "AppSelectionDialog");
break;
case "none":
default:
list.setSummary(R.string.gesture_action_default);
break;
}
return true;
}
@Override
public void onSaveInstanceState(@NonNull Bundle outState) {
super.onSaveInstanceState(outState);
outState.putStringArrayList(SAVE_STATE_VALUES, new ArrayList<>(mNewValues));
outState.putBoolean(SAVE_STATE_CHANGED, mPreferenceChanged);
outState.putCharSequenceArray(SAVE_STATE_ENTRIES, mEntries);
outState.putCharSequenceArray(SAVE_STATE_ENTRY_VALUES, mEntryValues);
}
public ItemChoiceDialogFragment(int pendingDataIndex, boolean[] selected, CharSequence[] items,
String descriptionText, Bitmap descriptionImage, boolean multiple) {
Bundle args = new Bundle();
fillArguments(args, pendingDataIndex);
args.putBooleanArray(EXTRA_SELECTED, selected);
args.putCharSequenceArray(EXTRA_ITEMS, items);
args.putString(EXTRA_DESCRIPTION_TEXT, descriptionText);
args.putParcelable(EXTRA_DESCRIPTION_IMAGE, descriptionImage);
args.putBoolean(EXTRA_MULTIPLE, multiple);
setArguments(args);
}
static Bundle toBundle(RemoteInputCompatBase.RemoteInput remoteInput) {
Bundle data = new Bundle();
data.putString(KEY_RESULT_KEY, remoteInput.getResultKey());
data.putCharSequence(KEY_LABEL, remoteInput.getLabel());
data.putCharSequenceArray(KEY_CHOICES, remoteInput.getChoices());
data.putBoolean(KEY_ALLOW_FREE_FORM_INPUT, remoteInput.getAllowFreeFormInput());
data.putBundle(KEY_EXTRAS, remoteInput.getExtras());
return data;
}
/**
* @param tag tag of this dialog. can be used to identify the dialog
* @param title title res id
* @param text message res id
* @param button1 button 1 text res id (on the right)
* @param button2 button 2 text res id (on the left)
* @param selectableItems
* @param selectableItemsRes
* @param selectableItemIconsRes
* @param object additional serialized object
* @param cancelable is dialog is cancelable when tapped outside
* @return a new alert dialog fragment
*/
private static OHCompactAlertDialogFragment newInstance(final String tag, final String title,
final String text, final String button1, final String button2,
final CharSequence[] selectableItems,
final int[] selectableItemsRes,
final int[] selectableItemIconsRes,
final Object object, final boolean cancelable) {
final OHCompactAlertDialogFragment frag = new OHCompactAlertDialogFragment();
frag.setCancelable(true);
final Bundle args = new Bundle();
args.putString(ARG_TAG, tag);
args.putString(ARG_TITLE, title);
args.putString(ARG_BUTTON1, button1);
args.putString(ARG_BUTTON2, button2);
args.putString(ARG_TEXT, text);
args.putCharSequenceArray(ARG_SELECTABLE_ITEMS, selectableItems);
args.putIntArray(ARG_SELECTABLE_ITEM_ICONS_RES, selectableItemIconsRes);
args.putIntArray(ARG_SELECTABLE_ITEMS_RES, selectableItemsRes);
if (object != null) {
if (object instanceof Parcelable) {
args.putParcelable(ARG_OBJECT_P, (Parcelable) object);
} else if (object instanceof Serializable) {
args.putSerializable(ARG_OBJECT_S, (Serializable) object);
} else {
throw new RuntimeException("Attached object can only be parcelable or serializable");
}
}
args.putBoolean(ARG_CANCELLABLE, cancelable);
frag.setArguments(args);
return frag;
}
@ReactMethod
public void showAlert(
ReadableMap options,
Callback errorCallback,
final Callback actionCallback) {
final FragmentManagerHelper fragmentManagerHelper = getFragmentManagerHelper();
if (fragmentManagerHelper == null) {
errorCallback.invoke("Tried to show an alert while not attached to an Activity");
return;
}
final Bundle args = new Bundle();
if (options.hasKey(KEY_TITLE)) {
args.putString(AlertFragment.ARG_TITLE, options.getString(KEY_TITLE));
}
if (options.hasKey(KEY_MESSAGE)) {
args.putString(AlertFragment.ARG_MESSAGE, options.getString(KEY_MESSAGE));
}
if (options.hasKey(KEY_BUTTON_POSITIVE)) {
args.putString(AlertFragment.ARG_BUTTON_POSITIVE, options.getString(KEY_BUTTON_POSITIVE));
}
if (options.hasKey(KEY_BUTTON_NEGATIVE)) {
args.putString(AlertFragment.ARG_BUTTON_NEGATIVE, options.getString(KEY_BUTTON_NEGATIVE));
}
if (options.hasKey(KEY_BUTTON_NEUTRAL)) {
args.putString(AlertFragment.ARG_BUTTON_NEUTRAL, options.getString(KEY_BUTTON_NEUTRAL));
}
if (options.hasKey(KEY_ITEMS)) {
ReadableArray items = options.getArray(KEY_ITEMS);
CharSequence[] itemsArray = new CharSequence[items.size()];
for (int i = 0; i < items.size(); i ++) {
itemsArray[i] = items.getString(i);
}
args.putCharSequenceArray(AlertFragment.ARG_ITEMS, itemsArray);
}
if (options.hasKey(KEY_CANCELABLE)) {
args.putBoolean(KEY_CANCELABLE, options.getBoolean(KEY_CANCELABLE));
}
UiThreadUtil.runOnUiThread(new Runnable() {
@Override
public void run() {
fragmentManagerHelper.showNewAlert(mIsInForeground, args, actionCallback);
}
});
}
public void putCharSequenceArray(Bundle state, String key, CharSequence[] x) {
state.putCharSequenceArray(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()));
}
}
@ReactMethod
public void promptWithArgs(ReadableMap options, final Callback callback) {
final FragmentManagerHelper fragmentManagerHelper = getFragmentManagerHelper();
if (fragmentManagerHelper == null) {
FLog.w(RNPromptModule.class, "Tried to show an alert while not attached to an Activity");
return;
}
final Bundle args = new Bundle();
if (options.hasKey(KEY_TITLE)) {
args.putString(RNPromptFragment.ARG_TITLE, options.getString(KEY_TITLE));
}
if (options.hasKey(KEY_MESSAGE)) {
String message = options.getString(KEY_MESSAGE);
if (!message.isEmpty()) {
args.putString(RNPromptFragment.ARG_MESSAGE, options.getString(KEY_MESSAGE));
}
}
if (options.hasKey(KEY_BUTTON_POSITIVE)) {
args.putString(RNPromptFragment.ARG_BUTTON_POSITIVE, options.getString(KEY_BUTTON_POSITIVE));
}
if (options.hasKey(KEY_BUTTON_NEGATIVE)) {
args.putString(RNPromptFragment.ARG_BUTTON_NEGATIVE, options.getString(KEY_BUTTON_NEGATIVE));
}
if (options.hasKey(KEY_BUTTON_NEUTRAL)) {
args.putString(RNPromptFragment.ARG_BUTTON_NEUTRAL, options.getString(KEY_BUTTON_NEUTRAL));
}
if (options.hasKey(KEY_ITEMS)) {
ReadableArray items = options.getArray(KEY_ITEMS);
CharSequence[] itemsArray = new CharSequence[items.size()];
for (int i = 0; i < items.size(); i++) {
itemsArray[i] = items.getString(i);
}
args.putCharSequenceArray(RNPromptFragment.ARG_ITEMS, itemsArray);
}
if (options.hasKey(KEY_CANCELABLE)) {
args.putBoolean(KEY_CANCELABLE, options.getBoolean(KEY_CANCELABLE));
}
if (options.hasKey(KEY_TYPE)) {
args.putString(KEY_TYPE, options.getString(KEY_TYPE));
}
if (options.hasKey(KEY_STYLE)) {
args.putString(KEY_STYLE, options.getString(KEY_STYLE));
}
if (options.hasKey(KEY_DEFAULT_VALUE)) {
args.putString(KEY_DEFAULT_VALUE, options.getString(KEY_DEFAULT_VALUE));
}
if (options.hasKey(KEY_PLACEHOLDER)) {
args.putString(KEY_PLACEHOLDER, options.getString(KEY_PLACEHOLDER));
}
fragmentManagerHelper.showNewAlert(mIsInForeground, args, callback);
}
/**
* Creates the arguments of the {@code SimpleAlertDialog} as a {@code Bundle}.<br/>
* In most cases, you don't have to call this method directly.
*
* @return Created arguments bundle
*/
@TargetApi(Build.VERSION_CODES.FROYO)
public Bundle createArguments() {
Bundle args = new Bundle();
if (mThemeResId > 0) {
args.putInt(SimpleAlertDialog.ARG_THEME_RES_ID, mThemeResId);
}
if (mTitle != null) {
args.putCharSequence(SimpleAlertDialog.ARG_TITLE, mTitle);
} else if (mTitleResId > 0) {
args.putInt(SimpleAlertDialog.ARG_TITLE_RES_ID, mTitleResId);
}
if (mIcon > 0) {
args.putInt(SimpleAlertDialog.ARG_ICON, mIcon);
}
if (mMessage != null) {
args.putCharSequence(SimpleAlertDialog.ARG_MESSAGE, mMessage);
} else if (mMessageResId > 0) {
args.putInt(SimpleAlertDialog.ARG_MESSAGE_RES_ID, mMessageResId);
}
if (mPositiveButton != null) {
args.putCharSequence(SimpleAlertDialog.ARG_POSITIVE_BUTTON, mPositiveButton);
} else if (mPositiveButtonResId > 0) {
args.putInt(SimpleAlertDialog.ARG_POSITIVE_BUTTON_RES_ID, mPositiveButtonResId);
}
if (mNeutralButton != null) {
args.putCharSequence(SimpleAlertDialog.ARG_NEUTRAL_BUTTON, mNeutralButton);
} else if (mNeutralButtonResId > 0) {
args.putInt(SimpleAlertDialog.ARG_NEUTRAL_BUTTON_RES_ID, mNeutralButtonResId);
}
if (mNegativeButton != null) {
args.putCharSequence(SimpleAlertDialog.ARG_NEGATIVE_BUTTON, mNegativeButton);
} else if (mNegativeButtonResId > 0) {
args.putInt(SimpleAlertDialog.ARG_NEGATIVE_BUTTON_RES_ID, mNegativeButtonResId);
}
if (mItems != null && Build.VERSION_CODES.ECLAIR <= Build.VERSION.SDK_INT) {
args.putCharSequenceArray(SimpleAlertDialog.ARG_ITEMS, mItems);
} else if (mItemsResId > 0) {
args.putInt(SimpleAlertDialog.ARG_ITEMS_RES_ID, mItemsResId);
}
if (mIcons != null) {
args.putIntArray(SimpleAlertDialog.ARG_ICONS, mIcons);
}
args.putBoolean(SimpleAlertDialog.ARG_CANCELABLE, mCancelable);
args.putBoolean(SimpleAlertDialog.ARG_CANCELED_ON_TOUCH_OUTSIDE,
mCanceledOnTouchOutside);
if (mSingleChoiceCheckedItem >= 0) {
args.putInt(SimpleAlertDialog.ARG_SINGLE_CHOICE_CHECKED_ITEM,
mSingleChoiceCheckedItem);
}
if (mEditTextInitialText != null || 0 < mEditTextInputType) {
args.putCharSequence(SimpleAlertDialog.ARG_EDIT_TEXT_INITIAL_TEXT, mEditTextInitialText);
args.putInt(SimpleAlertDialog.ARG_EDIT_TEXT_INPUT_TYPE, mEditTextInputType);
}
args.putBoolean(SimpleAlertDialog.ARG_USE_VIEW, mUseView);
args.putBoolean(SimpleAlertDialog.ARG_USE_ADAPTER, mUseAdapter);
args.putInt(SimpleAlertDialog.ARG_REQUEST_CODE, mRequestCode);
return args;
}
@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 CharSequence[] fieldValue) {
state.putCharSequenceArray(key, fieldValue);
}