@rnmapbox/maps 10.0.0-beta.28

package/android/rctmgl/src/main/java-mapboxgl/maplibre/com/mapbox/rctmgl/impl/InstanceManagerImpl.java

@@ -0,0 +1,42 @@
+package com.mapbox.rctmgl.impl;
+
+import android.content.Context;
+
+import com.mapbox.mapboxsdk.Mapbox;
+import com.mapbox.mapboxsdk.WellKnownTileServer;
+import com.mapbox.mapboxsdk.log.Logger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class InstanceManagerImpl {
+  public static void getInstance(Context context, String accessToken) {
+    if (wellKnownTileServer == null) {
+      Logger.w("InstanceManagerImpl", "setAccessToken requires setWellKnownTileServer for MapLibre, see setWellKnownTileServer docs for implications");
+      wellKnownTileServer = WellKnownTileServer.MapLibre.name();
+    }
+    Mapbox.getInstance(context, accessToken,  WellKnownTileServer.valueOf(wellKnownTileServer) );
+  }
+
+  public static Map<String,String> getTileServers() {
+    HashMap<String, String> result = new HashMap();
+    result.put("Mapbox", WellKnownTileServer.Mapbox.name());
+    result.put("MapLibre", WellKnownTileServer.MapLibre.name());
+    result.put("MapTiler", WellKnownTileServer.MapTiler.name());
+    return result;
+  }
+
+  static String wellKnownTileServer = null;
+
+  public static void setWellKnownTileServer(String wellKnownTileServer) {
+    InstanceManagerImpl.wellKnownTileServer = wellKnownTileServer;
+  }
+
+  public static String getAccessToken() {
+    return Mapbox.getApiKey();
+  }
+
+  public static String getLibraryName() {
+    return "maplibre";
+  }
+}

package/android/rctmgl/src/main/java-mapboxgl/maplibre/com/mapbox/rctmgl/impl/LocationEngineCallbackImpl.java

@@ -0,0 +1,12 @@
+package com.mapbox.rctmgl.impl;
+
+import com.mapbox.mapboxsdk.location.engine.LocationEngineCallback;
+import com.mapbox.mapboxsdk.location.engine.LocationEngineResult;
+
+public abstract class LocationEngineCallbackImpl implements LocationEngineCallback<LocationEngineResult> {
+  public void onSuccess(LocationEngineResult result) {
+    onSuccess(new LocationEngineResultImpl(result));
+  }
+
+  abstract public void onSuccess(LocationEngineResultImpl result);
+}

package/android/rctmgl/src/main/java-mapboxgl/maplibre/com/mapbox/rctmgl/impl/LocationEngineResultImpl.java

@@ -0,0 +1,18 @@
+package com.mapbox.rctmgl.impl;
+
+import android.location.Location;
+
+import com.mapbox.mapboxsdk.location.engine.LocationEngineCallback;
+import com.mapbox.mapboxsdk.location.engine.LocationEngineResult;
+
+public class LocationEngineResultImpl {
+  LocationEngineResult impl;
+
+  LocationEngineResultImpl(LocationEngineResult impl) {
+    this.impl = impl;
+  }
+
+  public Location getLastLocation() {
+    return impl.getLastLocation();
+  }
+}

package/android/rctmgl/src/main/java-mapboxgl/maplibre/com/mapbox/rctmgl/impl/LocationManagerImpl.java

@@ -0,0 +1,64 @@
+package com.mapbox.rctmgl.impl;
+
+import android.content.Context;
+
+import android.os.Looper;
+
+import com.mapbox.mapboxsdk.location.engine.LocationEngine;
+import com.mapbox.mapboxsdk.location.engine.LocationEngineProvider;
+import com.mapbox.mapboxsdk.location.engine.LocationEngineResult;
+import com.mapbox.mapboxsdk.location.engine.LocationEngineCallback;
+import com.mapbox.mapboxsdk.location.engine.LocationEngineRequest;
+import com.mapbox.mapboxsdk.location.permissions.PermissionsManager;
+
+public class LocationManagerImpl {
+  LocationEngine locationEngine;
+  LocationEngineRequest locationEngineRequest;
+
+  LocationManagerImpl(LocationEngine locationEngine, LocationEngineRequest locationEngineRequest) {
+    this.locationEngine = locationEngine;
+    this.locationEngineRequest = locationEngineRequest;
+  }
+
+  public static LocationManagerImpl buildEngineRequest(Context context, long default_interval, long fastest_interval, float minDisplacement) {
+    return new LocationManagerImpl(
+      LocationEngineProvider.getBestLocationEngine(context),
+      new LocationEngineRequest.Builder(default_interval)
+                .setFastestInterval(fastest_interval)
+                .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
+                .setDisplacement(minDisplacement)
+                .build()
+    );
+  }
+
+  public void removeExistingListeners(LocationEngineCallbackImpl callback) {
+    locationEngine.removeLocationUpdates(callback);
+  }
+
+  public void addNewListeners(LocationEngineCallbackImpl callback) {
+    locationEngine.requestLocationUpdates(
+            locationEngineRequest,
+            callback,
+            Looper.getMainLooper()
+    );
+  }
+
+  public void dispose(LocationEngineCallbackImpl callback) {
+    if (locationEngine == null) {
+      return;
+    }
+    locationEngine.removeLocationUpdates(callback);
+  }
+
+  public boolean isActive() {
+    return (locationEngine != null);
+  }
+
+  public void getLastLocation(LocationEngineCallbackImpl callback) {
+    locationEngine.getLastLocation(callback); 
+  }
+
+  public LocationEngine getEngine() {
+    return locationEngine;
+  }
+}

package/android/rctmgl/src/main/java-mapboxgl/maplibre/com/mapbox/rctmgl/impl/PermissionsManagerImpl.java

@@ -0,0 +1,10 @@
+package com.mapbox.rctmgl.impl;
+
+import android.content.Context;
+import com.mapbox.mapboxsdk.location.permissions.PermissionsManager;
+
+public class PermissionsManagerImpl {
+  public static boolean areLocationPermissionsGranted(Context context) {
+    return PermissionsManager.areLocationPermissionsGranted(context);
+  }
+}

package/android/rctmgl/src/main/java-mapboxgl/maplibre/com/mapbox/rctmgl/impl/SymbolClickListenerImpl.java

@@ -0,0 +1,18 @@
+package com.mapbox.rctmgl.impl;
+
+import com.mapbox.mapboxsdk.plugins.annotation.OnSymbolClickListener;
+import com.mapbox.mapboxsdk.plugins.annotation.Symbol;
+
+
+public class SymbolClickListenerImpl {
+  public static interface Listener {
+    public boolean onAnnotationClick(Symbol symbol);
+  }
+
+  public static OnSymbolClickListener annotationClickListener(Listener listener) {
+    return new OnSymbolClickListener() {
+      @Override
+      public boolean onAnnotationClick(Symbol symbol) { return listener.onAnnotationClick(symbol); }
+    };
+  }
+}

package/android/rctmgl/src/main/java-mapboxgl/maplibre/com/mapbox/rctmgl/impl/TelemetryImpl.java

@@ -0,0 +1,7 @@
+package com.mapbox.rctmgl.impl;
+
+public class TelemetryImpl {
+  public static void setUserTelemetryRequestState(final boolean enabled) {
+    // No-op in maplibre
+  }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/RCTMGLPackage.java

@@ -0,0 +1,111 @@
+package com.mapbox.rctmgl;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import com.mapbox.rctmgl.components.camera.RCTMGLCameraManager;
+
+import com.mapbox.rctmgl.components.annotation.RCTMGLCalloutManager;
+import com.mapbox.rctmgl.components.annotation.RCTMGLPointAnnotationManager;
+import com.mapbox.rctmgl.components.annotation.RCTMGLMarkerViewManager;
+import com.mapbox.rctmgl.components.images.RCTMGLImagesManager;
+import com.mapbox.rctmgl.components.location.RCTMGLNativeUserLocationManager;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapViewManager;
+import com.mapbox.rctmgl.components.mapview.RCTMGLAndroidTextureMapViewManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLBackgroundLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLCircleLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLFillExtrusionLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLFillLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLHeatmapLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLLineLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLRasterLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLSkyLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLSymbolLayerManager;
+
+import com.mapbox.rctmgl.components.styles.light.RCTMGLLightManager;
+import com.mapbox.rctmgl.components.styles.terrain.RCTMGLTerrainManager;
+
+import com.mapbox.rctmgl.components.styles.sources.RCTMGLImageSourceManager;
+import com.mapbox.rctmgl.components.styles.sources.RCTMGLRasterSourceManager;
+import com.mapbox.rctmgl.components.styles.sources.RCTMGLRasterDemSourceManager;
+import com.mapbox.rctmgl.components.styles.sources.RCTMGLShapeSourceManager;
+import com.mapbox.rctmgl.components.styles.sources.RCTMGLVectorSourceManager;
+
+import com.mapbox.rctmgl.modules.RCTMGLLogging;
+
+import com.mapbox.rctmgl.modules.RCTMGLOfflineModule;
+import com.mapbox.rctmgl.modules.RCTMGLSnapshotModule;
+import com.mapbox.rctmgl.modules.RCTMGLLocationModule;
+
+import com.mapbox.rctmgl.modules.RCTMGLModule;
+
+
+public class RCTMGLPackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactApplicationContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new RCTMGLModule(reactApplicationContext));
+        modules.add(new RCTMGLLocationModule(reactApplicationContext));
+
+        modules.add(new RCTMGLOfflineModule(reactApplicationContext));
+        modules.add(new RCTMGLSnapshotModule(reactApplicationContext));
+
+        modules.add(new RCTMGLLogging(reactApplicationContext));
+
+        return modules;
+    }
+
+    @Deprecated
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactApplicationContext) {
+        List<ViewManager> managers = new ArrayList<>();
+
+        // components
+        managers.add(new RCTMGLCameraManager(reactApplicationContext));
+        managers.add(new RCTMGLAndroidTextureMapViewManager(reactApplicationContext));
+        managers.add(new RCTMGLMapViewManager(reactApplicationContext));
+        managers.add(new RCTMGLMarkerViewManager(reactApplicationContext));
+
+        managers.add(new RCTMGLLightManager());
+
+        managers.add(new RCTMGLPointAnnotationManager(reactApplicationContext));
+        managers.add(new RCTMGLCalloutManager());
+        managers.add(new RCTMGLNativeUserLocationManager());
+
+        // sources
+        managers.add(new RCTMGLVectorSourceManager(reactApplicationContext));
+        managers.add(new RCTMGLShapeSourceManager(reactApplicationContext));
+        managers.add(new RCTMGLRasterDemSourceManager(reactApplicationContext));
+        managers.add(new RCTMGLRasterSourceManager(reactApplicationContext));
+        managers.add(new RCTMGLImageSourceManager());
+
+        // images
+        managers.add(new RCTMGLImagesManager(reactApplicationContext));
+
+        // layers
+        managers.add(new RCTMGLFillLayerManager());
+        managers.add(new RCTMGLFillExtrusionLayerManager());
+        managers.add(new RCTMGLHeatmapLayerManager());
+ 
+        managers.add(new RCTMGLLineLayerManager());
+        managers.add(new RCTMGLCircleLayerManager());
+        managers.add(new RCTMGLSymbolLayerManager());   
+        managers.add(new RCTMGLRasterLayerManager());
+        managers.add(new RCTMGLSkyLayerManager());
+        managers.add(new RCTMGLTerrainManager());
+        managers.add(new RCTMGLBackgroundLayerManager());
+        return managers;
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/AbstractEvent.java

@@ -0,0 +1,35 @@
+package com.mapbox.rctmgl.components;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+import javax.annotation.Nullable;
+
+public class AbstractEvent extends Event<AbstractEvent> {
+    private String mEventName;
+    private final boolean mCanCoalesce;
+    private WritableMap mEvent;
+
+    public AbstractEvent(int viewId, String eventName, boolean canCoalesce, @Nullable WritableMap event) {
+        super(viewId);
+        mEventName = eventName;
+        mCanCoalesce = canCoalesce;
+        mEvent = event;
+    }
+
+    @Override
+    public String getEventName() {
+        return mEventName;
+    }
+
+    @Override
+    public void dispatch(RCTEventEmitter rctEventEmitter) {
+        rctEventEmitter.receiveEvent(getViewTag(), getEventName(), mEvent);
+    }
+
+    @Override
+    public boolean canCoalesce() {
+        return mCanCoalesce;
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/AbstractEventEmitter.java

@@ -0,0 +1,82 @@
+package com.mapbox.rctmgl.components;
+
+import android.view.ViewGroup;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.events.EventDispatcher;
+
+import com.mapbox.rctmgl.events.IEvent;
+import com.mapbox.rctmgl.components.AbstractEvent;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+import javax.annotation.Nonnull;
+
+/**
+ * Created by nickitaliano on 8/23/17.
+ */
+
+abstract public class AbstractEventEmitter<T extends ViewGroup> extends ViewGroupManager<T> {
+    private static final double BRIDGE_TIMEOUT_MS = 10;
+    private Map<String, Long> mRateLimitedEvents;
+    private EventDispatcher mEventDispatcher;
+    private ReactApplicationContext mRCTAppContext;
+
+    public AbstractEventEmitter(ReactApplicationContext reactApplicationContext) {
+        mRateLimitedEvents = new HashMap<>();
+        mRCTAppContext = reactApplicationContext;
+    }
+
+    public void handleEvent(IEvent event) {
+        String eventCacheKey = getEventCacheKey(event);
+
+        // fail safe to protect bridge from being spammed
+        if (shouldDropEvent(eventCacheKey, event)) {
+            return;
+        }
+
+        mRateLimitedEvents.put(eventCacheKey, System.currentTimeMillis());
+        mEventDispatcher.dispatchEvent(new AbstractEvent(event.getID(), event.getKey(), event.canCoalesce(), event.toJSON()));
+    }
+
+    @Override
+    protected void addEventEmitters(ThemedReactContext context, @Nonnull T view) {
+        mEventDispatcher = context.getNativeModule(UIManagerModule.class).getEventDispatcher();
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        Map<String, String> events = customEvents();
+
+        if (events == null) {
+            return null;
+        }
+
+        Map<String, Object> exportedEvents = new HashMap<>();
+
+        for (Map.Entry<String, String> event : events.entrySet()) {
+            exportedEvents.put(event.getKey(), MapBuilder.of("registrationName", event.getValue()));
+        }
+
+        return exportedEvents;
+    }
+
+    @Nullable
+    public abstract Map<String, String> customEvents();
+
+    private boolean shouldDropEvent(String cacheKey, IEvent event) {
+        Long lastEventTimestamp = mRateLimitedEvents.get(cacheKey);
+        return lastEventTimestamp != null && (event.getTimestamp() - lastEventTimestamp) <= BRIDGE_TIMEOUT_MS;
+    }
+
+    private String getEventCacheKey(IEvent event) {
+        return String.format("%s-%s", event.getKey(), event.getType());
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/AbstractMapFeature.java

@@ -0,0 +1,15 @@
+package com.mapbox.rctmgl.components;
+
+import android.content.Context;
+
+import com.facebook.react.views.view.ReactViewGroup;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView ;
+
+public abstract class AbstractMapFeature extends ReactViewGroup {
+    public AbstractMapFeature(Context context) {
+        super(context);
+    }
+
+    public abstract void addToMap(RCTMGLMapView mapView);
+    public abstract void removeFromMap(RCTMGLMapView mapView);
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLCallout.kt

@@ -0,0 +1,6 @@
+package com.mapbox.rctmgl.components.annotation
+
+import android.content.Context
+import com.facebook.react.views.view.ReactViewGroup
+
+class RCTMGLCallout(context: Context?) : ReactViewGroup(context)

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLCalloutManager.java

@@ -0,0 +1,18 @@
+package com.mapbox.rctmgl.components.annotation;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+
+public class RCTMGLCalloutManager extends ViewGroupManager<RCTMGLCallout> {
+    public static final String REACT_CLASS = "RCTMGLCallout";
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    protected RCTMGLCallout createViewInstance(ThemedReactContext reactContext) {
+        return new RCTMGLCallout(reactContext);
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLMarkerView.kt

@@ -0,0 +1,76 @@
+package com.mapbox.rctmgl.components.annotation
+
+import android.content.Context
+import android.view.View
+import com.mapbox.geojson.Point
+import com.mapbox.maps.ViewAnnotationOptions
+import com.mapbox.rctmgl.components.mapview.OnMapReadyCallback
+import com.mapbox.maps.MapboxMap
+import com.mapbox.rctmgl.components.AbstractMapFeature
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.rctmgl.utils.GeoJSONUtils
+
+class RCTMGLMarkerView(context: Context?, private val mManager: RCTMGLMarkerViewManager) : AbstractMapFeature(context), View.OnLayoutChangeListener {
+    private var mMapView: RCTMGLMapView? = null
+    private var mChildView: View? = null
+    private var mCoordinate: Point? = null
+    private lateinit var mAnchor: Array<Float>
+    override fun addView(childView: View, childPosition: Int) {
+        mChildView = childView
+    }
+
+    fun setCoordinate(point: Point?) {
+        mCoordinate = point
+        if (mChildView != null) {
+            val options = ViewAnnotationOptions.Builder().geometry(mCoordinate).build()
+            mMapView?.viewAnnotationManager?.updateViewAnnotation(mChildView!!, options)
+        }
+    }
+
+    fun setAnchor(x: Float, y: Float) {
+        mAnchor = arrayOf(x, y)
+        refresh()
+    }
+
+    fun refresh() {
+        // this will cause position to be recalculated
+        if (mChildView != null) {
+            val width = mChildView!!.width
+            val height = mChildView!!.height
+            val options = ViewAnnotationOptions.Builder().geometry(mCoordinate).width(width).height(height).offsetX(((mAnchor[0] - 0.5) * width).toInt()).offsetY(((mAnchor[1] - 0.5) * height).toInt()).build()
+            mMapView?.viewAnnotationManager?.updateViewAnnotation(mChildView!!, options)
+        }
+    }
+
+    override fun addToMap(mapView: RCTMGLMapView) {
+        mMapView = mapView
+        val rctmglMarkerView = this
+        mMapView?.getMapAsync {
+            if (mChildView != null) {
+                val width = mChildView!!.width
+                val height = mChildView!!.height
+                val options = ViewAnnotationOptions.Builder().geometry(mCoordinate).width(width).height(height).offsetX(((mAnchor[0] - 0.5) * width).toInt()).offsetY(((mAnchor[1] - 0.5) * height).toInt()).build()
+                mChildView!!.addOnLayoutChangeListener(rctmglMarkerView)
+                if (mChildView!!.layoutParams == null && !mChildView!!.isAttachedToWindow) {
+                    mMapView?.offscreenAnnotationViewContainer()?.addView(mChildView)
+                    mMapView?.offscreenAnnotationViewContainer()?.removeView(mChildView)
+                }
+                mMapView?.viewAnnotationManager?.addViewAnnotation(mChildView!!, options)
+            }
+        }
+    }
+
+    override fun removeFromMap(mapView: RCTMGLMapView) {
+        if (mChildView != null) {
+            mMapView?.viewAnnotationManager?.removeViewAnnotation(mChildView!!)
+            mChildView!!.removeOnLayoutChangeListener(this)
+        }
+    }
+
+    override fun onLayoutChange(v: View, left: Int, top: Int, right: Int, bottom: Int, oldLeft: Int, oldTop: Int,
+                                oldRight: Int, oldBottom: Int) {
+        if (left != oldLeft || right != oldRight || top != oldTop || bottom != oldBottom) {
+            refresh()
+        }
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLMarkerViewManager.java

@@ -0,0 +1,45 @@
+package com.mapbox.rctmgl.components.annotation;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.mapbox.rctmgl.components.AbstractEventEmitter;
+import com.mapbox.rctmgl.utils.GeoJSONUtils;
+
+import java.util.Map;
+
+public class RCTMGLMarkerViewManager extends AbstractEventEmitter<RCTMGLMarkerView> {
+    public static final String REACT_CLASS = "RCTMGLMarkerView";
+
+    public RCTMGLMarkerViewManager(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactProp(name="coordinate")
+    public void setCoordinate(RCTMGLMarkerView markerView, String geoJSONStr) {
+        markerView.setCoordinate(GeoJSONUtils.toPointGeometry(geoJSONStr));
+    }
+
+    @ReactProp(name="anchor")
+    public void setAnchor(RCTMGLMarkerView markerView, ReadableMap map) {
+        markerView.setAnchor((float) map.getDouble("x"), (float) map.getDouble("y"));
+    }
+
+    @Override
+    protected RCTMGLMarkerView createViewInstance(ThemedReactContext reactContext) {
+        return new RCTMGLMarkerView(reactContext, this);
+    }
+
+    @Override
+    public Map<String, String> customEvents() {
+        return MapBuilder.<String, String>builder()
+                .build();
+    }
+}