pushwoosh-react-native-plugin 1.2.5 → 2.2.17

package/src/android/src/main/java/com/pushwoosh/reactnativeplugin/ConversionUtil.java

@@ -1,5 +1,11 @@
 package com.pushwoosh.reactnativeplugin;
 
+import android.os.Bundle;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
@@ -8,160 +14,220 @@ import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.bridge.WritableNativeMap;
+import com.pushwoosh.inbox.data.InboxMessage;
 import com.pushwoosh.internal.utils.JsonUtils;
 import com.pushwoosh.internal.utils.PWLog;
+import com.pushwoosh.tags.TagsBundle;
 
+import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 public final class ConversionUtil {
 
-    public static Map<String, Object> toMap(ReadableMap readableMap) {
-        ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
-        Map<String, Object> result = new HashMap<>();
-        while (iterator.hasNextKey()) {
-            String key = iterator.nextKey();
-            ReadableType type = readableMap.getType(key);
-            switch (type) {
-                case Null:
-                    result.put(key, null);
-                    break;
-                case Boolean:
-                    result.put(key, readableMap.getBoolean(key));
-                    break;
-                case Number:
-                    result.put(key, readableMap.getDouble(key));
-                    break;
-                case String:
-                    result.put(key, readableMap.getString(key));
-                    break;
-                case Map:
-                    result.put(key, toMap(readableMap.getMap(key)));
-                    break;
-                case Array:
-                    result.put(key, toArray(readableMap.getArray(key)));
-                    break;
-                default:
-                    PWLog.error(PushwooshPlugin.TAG, "Could not convert object with key: " + key + ".");
-            }
-
-        }
-        return result;
-    }
-
-    public static List<Object> toArray(ReadableArray readableArray) {
-        List<Object> result = new ArrayList<>(readableArray.size());
-        for (int i = 0; i < readableArray.size(); i++) {
-            ReadableType indexType = readableArray.getType(i);
-            switch(indexType) {
-                case Null:
-                    result.add(i, null);
-                    break;
-                case Boolean:
-                    result.add(i, readableArray.getBoolean(i));
-                    break;
-                case Number:
-                    result.add(i, readableArray.getDouble(i));
-                    break;
-                case String:
-                    result.add(i, readableArray.getString(i));
-                    break;
-                case Map:
-                    result.add(i, toMap(readableArray.getMap(i)));
-                    break;
-                case Array:
-                    result.add(i, toArray(readableArray.getArray(i)));
-                    break;
-                default:
-                    PWLog.error(PushwooshPlugin.TAG, "Could not convert object at index " + i + ".");
-            }
-        }
-        return result;
-    }
-
-    public static Map<String, Object> stringToMap(String string) {
-        try {
-            JSONObject json = new JSONObject(string);
-            return JsonUtils.jsonToMap(json);
-        }
-        catch (JSONException e) {
-            PWLog.exception(e);
-        }
-
-        return Collections.<String, Object>emptyMap();
-    }
-
-    public static WritableMap toWritableMap(Map<String, Object> map) {
-        WritableNativeMap result = new WritableNativeMap();
-
-        for(Map.Entry<String, Object> entry : map.entrySet()) {
-            String key = entry.getKey();
-            Object value = entry.getValue();
-            if (value == null) {
-                result.putNull(key);
-            }
-            else if (value instanceof Map) {
-                result.putMap(key, toWritableMap((Map)value));
-            }
-            else if (value instanceof List) {
-                result.putArray(key, toWritableArray((List) value));
-            }
-            else if (value instanceof Boolean) {
-                result.putBoolean(key, (Boolean)value);
-            }
-            else if (value instanceof Integer) {
-                result.putInt(key, (Integer)value);
-            }
-            else if (value instanceof String) {
-                result.putString(key, (String)value);
-            }
-            else if (value instanceof Double) {
-                result.putDouble(key, (Double)value);
-            }
-            else {
-                PWLog.error(PushwooshPlugin.TAG, "Could not convert object " + value.toString());
-            }
-        }
-
-        return result;
-    }
-
-    public static WritableArray toWritableArray(List<Object> array) {
-        WritableNativeArray result = new WritableNativeArray();
-
-        for (Object value : array) {
-            if (value == null) {
-                result.pushNull();
-            }
-            else if (value instanceof Map) {
-                result.pushMap(toWritableMap((Map) value));
-            }
-            else if (value instanceof List) {
-                result.pushArray(toWritableArray((List) value));
-            }
-            else if (value instanceof Boolean) {
-                result.pushBoolean((Boolean) value);
-            }
-            else if (value instanceof Integer) {
-                result.pushInt((Integer) value);
-            }
-            else if (value instanceof String) {
-                result.pushString((String) value);
-            }
-            else if (value instanceof Double) {
-                result.pushDouble((Double) value);
-            }
-            else {
-                PWLog.error(PushwooshPlugin.TAG, "Could not convert object " + value.toString());
-            }
-        }
-
-        return result;
-    }
+	public static TagsBundle convertToTagsBundle(ReadableMap readableMap) {
+		return new TagsBundle.Builder()
+				.putAll(toJsonObject(readableMap))
+				.build();
+	}
+
+	public static JSONObject toJsonObject(ReadableMap readableMap) {
+		ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+		JSONObject result = new JSONObject();
+		while (iterator.hasNextKey()) {
+			String key = iterator.nextKey();
+			ReadableType type = readableMap.getType(key);
+			try {
+				switch (type) {
+					case Null:
+						result.put(key, JSONObject.NULL);
+						break;
+					case Boolean:
+						result.put(key, readableMap.getBoolean(key));
+						break;
+					case Number:
+						result.put(key, readableMap.getDouble(key));
+						break;
+					case String:
+						result.put(key, readableMap.getString(key));
+						break;
+					case Map:
+						result.put(key, toJsonObject(readableMap.getMap(key)));
+						break;
+					case Array:
+						result.put(key, toArray(readableMap.getArray(key)));
+						break;
+					default:
+						PWLog.error(PushwooshPlugin.TAG, "Could not convert object with key: " + key + ".");
+				}
+
+			} catch (JSONException e) {
+				PWLog.error(PushwooshPlugin.TAG, "Could not convert object with key: " + key + ".", e);
+			}
+
+		}
+		return result;
+	}
+
+	public static JSONArray toArray(ReadableArray readableArray) {
+		JSONArray result = new JSONArray();
+		for (int i = 0; i < readableArray.size(); i++) {
+			ReadableType indexType = readableArray.getType(i);
+			try {
+				switch (indexType) {
+					case Null:
+						result.put(i, JSONObject.NULL);
+						break;
+					case Boolean:
+						result.put(i, readableArray.getBoolean(i));
+						break;
+					case Number:
+						result.put(i, readableArray.getDouble(i));
+						break;
+					case String:
+						result.put(i, readableArray.getString(i));
+						break;
+					case Map:
+						result.put(i, toJsonObject(readableArray.getMap(i)));
+						break;
+					case Array:
+						result.put(i, toArray(readableArray.getArray(i)));
+						break;
+					default:
+						PWLog.error(PushwooshPlugin.TAG, "Could not convert object at index " + i + ".");
+				}
+			} catch (JSONException e) {
+				PWLog.error(PushwooshPlugin.TAG, "Could not convert object at index " + i + ".", e);
+			}
+		}
+		return result;
+	}
+
+	public static JSONObject stringToJSONObject(String string) {
+		try {
+			JSONObject json = new JSONObject(string);
+			return json;
+		} catch (JSONException e) {
+			PWLog.exception(e);
+		}
+
+		return new JSONObject();
+	}
+
+	public static WritableMap toWritableMap(JSONObject jsonObject) {
+		WritableNativeMap result = new WritableNativeMap();
+
+		Iterator<String> keys = jsonObject.keys();
+		while (keys.hasNext()) {
+			String key = keys.next();
+			try {
+				Object value = jsonObject.get(key);
+
+				if (value == null || JSONObject.NULL.equals(value)) {
+					result.putNull(key);
+				} else if (value instanceof JSONObject) {
+					result.putMap(key, toWritableMap((JSONObject) value));
+				} else if (value instanceof JSONArray) {
+					result.putArray(key, toWritableArray((JSONArray) value));
+				} else if (value instanceof Boolean) {
+					result.putBoolean(key, (Boolean) value);
+				} else if (value instanceof Integer) {
+					result.putInt(key, (Integer) value);
+				} else if (value instanceof Long) {
+					result.putString(key, String.valueOf(value));
+				} else if (value instanceof String) {
+					result.putString(key, (String) value);
+				} else if (value instanceof Double) {
+					result.putDouble(key, (Double) value);
+				} else {
+					PWLog.error(PushwooshPlugin.TAG, "Could not convert object " + value.toString());
+				}
+
+			} catch (JSONException e) {
+				PWLog.error(PushwooshPlugin.TAG, "Could not convert object with key " + key, e);
+			}
+		}
+
+		return result;
+	}
+
+	public static WritableArray toWritableArray(JSONArray array) {
+		WritableNativeArray result = new WritableNativeArray();
+
+		for (int i = 0; i < array.length(); i++) {
+			try {
+				Object value = array.get(i);
+				if (value == null) {
+					result.pushNull();
+				} else if (value instanceof JSONObject) {
+					result.pushMap(toWritableMap((JSONObject) value));
+				} else if (value instanceof JSONArray) {
+					result.pushArray(toWritableArray((JSONArray) value));
+				} else if (value instanceof Boolean) {
+					result.pushBoolean((Boolean) value);
+				} else if (value instanceof Integer) {
+					result.pushInt((Integer) value);
+				} else if (value instanceof Long) {
+					result.pushString(String.valueOf(value));
+				} else if (value instanceof String) {
+					result.pushString((String) value);
+				} else if (value instanceof Double) {
+					result.pushDouble((Double) value);
+				} else {
+					PWLog.error(PushwooshPlugin.TAG, "Could not convert object " + value.toString());
+				}
+			} catch (JSONException e) {
+				e.printStackTrace();
+				PWLog.error(PushwooshPlugin.TAG, "Could not convert object with index i " + i + " in array " + array.toString(), e);
+			}
+		}
+
+		return result;
+	}
+
+	public static WritableMap inboxMessageToWritableMap(InboxMessage message) {
+		return toWritableMap(inboxMessageToJson(message));
+	}
+
+	public static JSONObject inboxMessageToJson(InboxMessage message) {
+		JSONObject object = new JSONObject();
+		try {
+			object.put("code", message.getCode())
+					.put("title", message.getTitle())
+					.put("imageUrl", message.getImageUrl())
+					.put("message",message.getMessage())
+					.put("sendDate",message.getISO8601SendDate())
+					.put("type", message.getType().getCode())
+					.put("bannerUrl", message.getBannerUrl())
+					.put("isRead",message.isRead())
+					.put("actionParams",message.getActionParams())
+					.put("isActionPerformed",message.isActionPerformed());
+
+			Bundle bundle = JsonUtils.jsonStringToBundle( message.getActionParams());
+			String customData = bundle.getString("u");
+			if (customData != null) {
+				object.put("customData", customData);
+			}
+		} catch (JSONException e) {
+			Log.e("PushwooshInbox", "Failed to fetch inbox message :" + e.getMessage());
+		}
+		return object;
+	}
+	
+	public static ArrayList<String> messageCodesArrayToArrayList(ReadableArray readableArray) {
+		ArrayList<String> result = new ArrayList<>();
+		for (int i = 0; i < readableArray.size(); i++) {
+			ReadableType indexType = readableArray.getType(i);
+			try {
+				if (indexType == ReadableType.String) {
+					result.add(readableArray.getString(i));
+				} else {
+					PWLog.error(PushwooshPlugin.TAG, "Could not convert object at index " + i + ".");
+				}
+			} catch (Exception e) {
+				PWLog.error(PushwooshPlugin.TAG, "Could not convert object at index " + i + ".", e);
+			}
+		}
+		return result;
+	}
 }

package/src/android/src/main/java/com/pushwoosh/reactnativeplugin/CustomFirebaseMessagingService.java

@@ -0,0 +1,29 @@
+package com.pushwoosh.plugin.pushnotifications;
+
+import androidx.annotation.NonNull;
+
+import com.google.firebase.messaging.FirebaseMessagingService;
+import com.google.firebase.messaging.RemoteMessage;
+import com.pushwoosh.firebase.PushwooshFcmHelper;
+
+public class CustomFirebaseMessagingService extends FirebaseMessagingService {
+    @Override
+    public void onMessageReceived(@NonNull RemoteMessage remoteMessage) {
+        if (PushwooshFcmHelper.isPushwooshMessage(remoteMessage)){
+            PushwooshFcmHelper.onMessageReceived(this, remoteMessage);
+        } else {
+            //handle push from a different service here
+        }
+    }
+
+    @Override
+    public void onNewToken(@NonNull String s) {
+        super.onNewToken(s);
+        PushwooshFcmHelper.onTokenRefresh(s);
+        sendTokenToAnotherService();
+    }
+
+    public void sendTokenToAnotherService() {
+        //handle push registration of another service here
+    }
+}

package/src/android/src/main/java/com/pushwoosh/reactnativeplugin/EventDispatcher.java

@@ -1,12 +1,15 @@
 package com.pushwoosh.reactnativeplugin;
 
-import com.facebook.react.bridge.Callback;
-
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
 public class EventDispatcher {
 
     private  Map<String, List<Callback>> subscribers = new HashMap<String, List<Callback>>();
@@ -41,4 +44,9 @@ public class EventDispatcher {
             list.clear();
         }
     }
+
+    public void sendJSEvent(ReactContext reactContext, String event, WritableMap params) {
+        reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(event, params);
+    }
 }

package/src/android/src/main/java/com/pushwoosh/reactnativeplugin/InboxUiStyleManager.java

@@ -0,0 +1,162 @@
+package com.pushwoosh.reactnativeplugin;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.pushwoosh.inbox.ui.PushwooshInboxStyle;
+import com.pushwoosh.inbox.ui.model.customizing.formatter.InboxDateFormatter;
+
+import java.io.IOException;
+import java.net.URL;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+class InboxUiStyleManager {
+    private static final String LIST_ERROR_MESSAGE_KEY = "listErrorMessage";
+    private static final String LIST_EMPTY_MESSAGE_KEY = "listEmptyMessage";
+    private static final String DATE_FORMAT_KEY = "dateFormat";
+    private static final String DEFAULT_IMAGE_ICON_KEY = "defaultImageIcon";
+    private static final String LIST_ERROR_IMAGE_KEY = "listErrorImage";
+    private static final String LIST_EMPTY_IMAGE_KEY = "listEmptyImage";
+    private static final String ACCENT_COLOR_KEY = "accentColor";
+    private static final String HIGHLIGHT_COLOR_KEY = "highlightColor";
+    private static final String BACKGROUND_COLOR_KEY = "backgroundColor";
+    private static final String DIVIDER_COLOR_KEY = "dividerColor";
+    private static final String DATE_COLOR_KEY = "dateColor";
+    private static final String READ_DATE_COLOR_KEY = "readDateColor";
+    private static final String TITLE_COLOR_KEY = "titleColor";
+    private static final String READ_TITLE_COLOR_KEY = "readTitleColor";
+    private static final String DESCRIPTION_COLOR_KEY = "descriptionColor";
+    private static final String READ_DESCRIPTION_COLOR_KEY = "readDescriptionColor";
+    private static final String BAR_BACKGROUND_COLOR = "barBackgroundColor";
+    private static final String BAR_ACCENT_COLOR = "barAccentColor";
+    private static final String BAR_TEXT_COLOR = "barTextColor";
+
+    public static final String URI_KEY = "uri";
+
+    private Context context;
+
+    public InboxUiStyleManager(Context context){
+        this.context = context;
+    }
+
+    public void setStyle(ReadableMap mapStyle) {
+        setDateFormat(mapStyle);
+        setImages(mapStyle);
+        setTexts(mapStyle);
+        setColors(mapStyle);
+    }
+
+    private void setDateFormat(ReadableMap mapStyle) {
+        if (!mapStyle.hasKey(DATE_FORMAT_KEY)) {
+            return;
+        }
+        String dateFormat = mapStyle.getString(DATE_FORMAT_KEY);
+        if (dateFormat != null && !dateFormat.isEmpty()) {
+            ReactInboxDateFormatter inboxDateFormatter = new ReactInboxDateFormatter(dateFormat);
+            PushwooshInboxStyle.INSTANCE.setDateFormatter(inboxDateFormatter);
+        }
+    }
+
+    private void setTexts(ReadableMap mapStyle) {
+        PushwooshInboxStyle PWInboxStyle = PushwooshInboxStyle.INSTANCE;
+        if (mapStyle.hasKey(LIST_ERROR_MESSAGE_KEY))
+            PWInboxStyle.setListErrorMessage(mapStyle.getString(LIST_ERROR_MESSAGE_KEY));
+        if (mapStyle.hasKey(LIST_EMPTY_MESSAGE_KEY))
+            PWInboxStyle.setListEmptyText(mapStyle.getString(LIST_EMPTY_MESSAGE_KEY));
+    }
+
+    private void setImages(ReadableMap mapStyle) {
+        PushwooshInboxStyle PWInboxStyle = PushwooshInboxStyle.INSTANCE;
+        Drawable defaultImageIcon = getImage(mapStyle, DEFAULT_IMAGE_ICON_KEY);
+        if (defaultImageIcon != null)
+            PWInboxStyle.setDefaultImageIconDrawable(defaultImageIcon);
+
+        Drawable listErrorImage = getImage(mapStyle, LIST_ERROR_IMAGE_KEY);
+        if (listErrorImage != null)
+            PWInboxStyle.setListErrorImageDrawable(listErrorImage);
+
+        Drawable listEmptyImage = getImage(mapStyle, LIST_EMPTY_IMAGE_KEY);
+        if (listEmptyImage != null)
+            PWInboxStyle.setListEmptyImageDrawable(listEmptyImage);
+    }
+
+    private Drawable getImage(ReadableMap mapStyle, String key) {
+        if (!mapStyle.hasKey(key)) {
+            return null;
+        }
+        ReadableMap defaultImageIcon = mapStyle.getMap(key);
+        String uri = defaultImageIcon.getString(URI_KEY);
+        try {
+            return getDrawable(uri);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    private Drawable getDrawable(String uri) throws IOException {
+        URL url = new URL(uri);
+        Bitmap bitmap = BitmapFactory.decodeStream(url.openConnection().getInputStream());
+        Drawable drawable = null;
+        if (context != null) {
+            drawable = new BitmapDrawable(context.getResources(), bitmap);
+        }
+        return drawable;
+    }
+
+    private void setColors(ReadableMap mapStyle) {
+        PushwooshInboxStyle PWInboxStyle = PushwooshInboxStyle.INSTANCE;
+
+        if (mapStyle.hasKey(ACCENT_COLOR_KEY))
+            PWInboxStyle.setAccentColor(mapStyle.getInt(ACCENT_COLOR_KEY));
+        if (mapStyle.hasKey(HIGHLIGHT_COLOR_KEY))
+            PWInboxStyle.setHighlightColor(mapStyle.getInt(HIGHLIGHT_COLOR_KEY));
+        if (mapStyle.hasKey(BACKGROUND_COLOR_KEY))
+            PWInboxStyle.setBackgroundColor(mapStyle.getInt(BACKGROUND_COLOR_KEY));
+        if (mapStyle.hasKey(DIVIDER_COLOR_KEY))
+            PWInboxStyle.setDividerColor(mapStyle.getInt(DIVIDER_COLOR_KEY));
+
+        if (mapStyle.hasKey(DATE_COLOR_KEY))
+            PWInboxStyle.setDateColor(mapStyle.getInt(DATE_COLOR_KEY));
+        if (mapStyle.hasKey(READ_DATE_COLOR_KEY))
+            PWInboxStyle.setReadDateColor(mapStyle.getInt(READ_DATE_COLOR_KEY));
+
+        if (mapStyle.hasKey(TITLE_COLOR_KEY))
+            PWInboxStyle.setTitleColor(mapStyle.getInt(TITLE_COLOR_KEY));
+        if (mapStyle.hasKey(READ_TITLE_COLOR_KEY))
+            PWInboxStyle.setReadTitleColor(mapStyle.getInt(READ_TITLE_COLOR_KEY));
+
+        if (mapStyle.hasKey(DESCRIPTION_COLOR_KEY))
+            PWInboxStyle.setDescriptionColor(mapStyle.getInt(DESCRIPTION_COLOR_KEY));
+        if (mapStyle.hasKey(READ_DESCRIPTION_COLOR_KEY))
+            PWInboxStyle.setReadDescriptionColor(mapStyle.getInt(READ_DESCRIPTION_COLOR_KEY));
+
+        if (mapStyle.hasKey(BAR_BACKGROUND_COLOR))
+            PWInboxStyle.setBarBackgroundColor(mapStyle.getInt(BAR_BACKGROUND_COLOR));
+        if (mapStyle.hasKey(BAR_ACCENT_COLOR))
+            PWInboxStyle.setBarAccentColor(mapStyle.getInt(BAR_ACCENT_COLOR));
+        if (mapStyle.hasKey(BAR_TEXT_COLOR))
+            PWInboxStyle.setBarTextColor(mapStyle.getInt(BAR_TEXT_COLOR));
+    }
+
+    private class ReactInboxDateFormatter implements InboxDateFormatter {
+
+        private SimpleDateFormat simpleDateFormat;
+
+        public ReactInboxDateFormatter(String dateFormat) {
+            Locale aDefault = Locale.getDefault();
+            simpleDateFormat = new SimpleDateFormat(dateFormat, aDefault);
+        }
+
+        @Override
+        public String transform(Date date) {
+            return simpleDateFormat.format(date);
+        }
+    }
+}

package/src/android/src/main/java/com/pushwoosh/reactnativeplugin/InlineInAppManager.java

@@ -0,0 +1,48 @@
+package com.pushwoosh.reactnativeplugin;
+
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import java.util.Map;
+
+public class InlineInAppManager extends SimpleViewManager<RCTInlineInAppView> {
+    public static final String REACT_CLASS = "PWInlineInAppView";
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    public RCTInlineInAppView createViewInstance(ThemedReactContext context) {
+        RCTInlineInAppView view = new RCTInlineInAppView(context);
+        return view;
+    }
+
+    @ReactProp(name = "identifier")
+    public void setIdentifier(final RCTInlineInAppView view, String identifier) {
+        view.setIdentifier(identifier);
+    }
+
+    public Map getExportedCustomBubblingEventTypeConstants() {
+        return MapBuilder.builder()
+                .put(
+                        "onLoaded",
+                        MapBuilder.of(
+                                "phasedRegistrationNames",
+                                MapBuilder.of("bubbled", "onLoaded")))
+                .put(
+                        "onClosed",
+                        MapBuilder.of(
+                                "phasedRegistrationNames",
+                                MapBuilder.of("bubbled", "onClosed")))
+                .put(
+                        "onSizeChanged",
+                        MapBuilder.of(
+                                "phasedRegistrationNames",
+                                MapBuilder.of("bubbled", "onSizeChanged")))
+                .build();
+    }
+}