@rnmapbox/maps 10.0.0-beta.28

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/styles/sources/RCTMGLShapeSource.java

@@ -0,0 +1,316 @@
+package com.mapbox.rctmgl.components.styles.sources;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.Size;
+import androidx.core.content.res.ResourcesCompat;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.mapbox.geojson.Feature;
+import com.mapbox.geojson.FeatureCollection;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.Style;
+import com.mapbox.mapboxsdk.style.expressions.Expression;
+import com.mapbox.mapboxsdk.style.sources.GeoJsonOptions;
+import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
+import com.mapbox.mapboxsdk.utils.BitmapUtils;
+import com.mapbox.rctmgl.R;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView;
+import com.mapbox.rctmgl.events.AndroidCallbackEvent;
+import com.mapbox.rctmgl.events.FeatureClickEvent;
+import com.mapbox.rctmgl.utils.ClusterPropertyEntry;
+import com.mapbox.rctmgl.utils.DownloadMapImageTask;
+import com.mapbox.rctmgl.utils.ImageEntry;
+
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by nickitaliano on 9/19/17.
+ */
+
+public class RCTMGLShapeSource extends RCTSource<GeoJsonSource> {
+    private URL mURL;
+    private RCTMGLShapeSourceManager mManager;
+
+    private String mShape;
+
+    private Boolean mCluster;
+    private Integer mClusterRadius;
+    private Integer mClusterMaxZoom;
+    private List<Map.Entry<String, ClusterPropertyEntry>> mClusterProperties;
+
+    private Integer mMaxZoom;
+    private Integer mBuffer;
+    private Double mTolerance;
+    private Boolean mLineMetrics;
+
+    private static Bitmap mImagePlaceholder;
+    private List<Map.Entry<String, ImageEntry>> mImages;
+    private List<Map.Entry<String, BitmapDrawable>> mNativeImages;
+
+    public RCTMGLShapeSource(Context context, RCTMGLShapeSourceManager manager) {
+        super(context);
+        mManager = manager;
+    }
+
+    @Override
+    public void addToMap(final RCTMGLMapView mapView) {
+        // Wait for style before adding the source to the map
+        mapView.getMapboxMap().getStyle(new Style.OnStyleLoaded() {
+            @Override
+            public void onStyleLoaded(@NonNull Style style) {
+                MapboxMap map = mapView.getMapboxMap();
+                RCTMGLShapeSource.super.addToMap(mapView);
+            }
+        });
+    }
+
+    @Override
+    public GeoJsonSource makeSource() {
+        GeoJsonOptions options = getOptions();
+
+        if (mShape != null) {
+            return new GeoJsonSource(mID, mShape, options);
+        }
+
+        return new GeoJsonSource(mID, mURL, options);
+    }
+
+    public void setURL(URL url) {
+        mURL = url;
+
+        if (mSource != null && mMapView != null && !mMapView.isDestroyed() ) {
+            mSource.setUrl(mURL);
+        }
+    }
+
+    public void setShape(String geoJSONStr) {
+        mShape = geoJSONStr;
+
+        if (mSource != null && mMapView != null && !mMapView.isDestroyed() ) {
+            mSource.setGeoJson(mShape);
+        }
+    }
+
+    public void setCluster(boolean cluster) {
+        mCluster = cluster;
+    }
+
+    public void setClusterRadius(int clusterRadius) {
+        mClusterRadius = clusterRadius;
+    }
+
+    public void setClusterMaxZoom(int clusterMaxZoom) {
+        mClusterMaxZoom = clusterMaxZoom;
+    }
+
+    public void setClusterProperties(List<Map.Entry<String, ClusterPropertyEntry>> clusterProperties) {
+        mClusterProperties = clusterProperties;
+    }
+
+    public void setMaxZoom(int maxZoom) {
+        mMaxZoom = maxZoom;
+    }
+
+    public void setBuffer(int buffer) {
+        mBuffer = buffer;
+    }
+
+    public void setTolerance(double tolerance) {
+        mTolerance = tolerance;
+    }
+
+    public void setLineMetrics(boolean lineMetrics) {
+        mLineMetrics = lineMetrics;
+    }
+
+    public void onPress(OnPressEvent event) {
+        mManager.handleEvent(FeatureClickEvent.makeShapeSourceEvent(this, event));
+    }
+
+    private GeoJsonOptions getOptions() {
+        GeoJsonOptions options = new GeoJsonOptions();
+
+        if (mCluster != null) {
+            options.withCluster(mCluster);
+        }
+
+        if (mClusterRadius != null) {
+            options.withClusterRadius(mClusterRadius);
+        }
+
+        if (mClusterMaxZoom != null) {
+            options.withClusterMaxZoom(mClusterMaxZoom);
+        }
+
+        if (mClusterProperties != null) {
+            for (Map.Entry<String, ClusterPropertyEntry> entry : mClusterProperties) {
+                ClusterPropertyEntry property = entry.getValue();
+
+                options.withClusterProperty(entry.getKey(), property.operator, property.mapping);
+            }
+        }
+
+        if (mMaxZoom != null) {
+            options.withMaxZoom(mMaxZoom);
+        }
+
+        if (mBuffer != null) {
+            options.withBuffer(mBuffer);
+        }
+
+        if (mTolerance != null) {
+            options.withTolerance(mTolerance.floatValue());
+        }
+
+        if (mLineMetrics != null) {
+            options.withLineMetrics(mLineMetrics);
+        }
+
+        return options;
+    }
+
+    public void querySourceFeatures(String callbackID,
+                                    @Nullable Expression filter) {
+        if (mSource == null) {
+            WritableMap payload = new WritableNativeMap();
+            payload.putString("error", "source is not yet loaded");
+            AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+            mManager.handleEvent(event);
+            return;
+        }
+        List<Feature> features = mSource.querySourceFeatures(filter);
+        WritableMap payload = new WritableNativeMap();
+        payload.putString("data", FeatureCollection.fromFeatures(features).toJson());
+
+        AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+        mManager.handleEvent(event);
+    }
+
+    public void getClusterExpansionZoom(String callbackID, String featureJSON) {
+        if (mSource == null) {
+            WritableMap payload = new WritableNativeMap();
+            payload.putString("error", "source is not yet loaded");
+            AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+            mManager.handleEvent(event);
+            return;
+        }
+        Feature feature = Feature.fromJson(featureJSON);
+
+        int zoom = mSource.getClusterExpansionZoom(feature);
+
+        WritableMap payload = new WritableNativeMap();
+        payload.putInt("data", zoom);
+
+        AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+        mManager.handleEvent(event);
+    }
+
+    public void getClusterLeaves(String callbackID, String featureJSON, int number, int offset) {
+        if (mSource == null) {
+            WritableMap payload = new WritableNativeMap();
+            payload.putString("error", "source is not yet loaded");
+            AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+            mManager.handleEvent(event);
+            return;
+        }
+        Feature clusterFeature = Feature.fromJson(featureJSON);
+        FeatureCollection leaves = mSource.getClusterLeaves(clusterFeature, number, offset);
+        WritableMap payload = new WritableNativeMap();
+        payload.putString("data", leaves.toJson());
+
+        AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+        mManager.handleEvent(event);
+    }
+
+    public void getClusterChildren(String callbackID, String featureJSON) {
+        if (mSource == null) {
+            WritableMap payload = new WritableNativeMap();
+            payload.putString("error", "source is not yet loaded");
+            AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+            mManager.handleEvent(event);
+            return;
+        }
+        Feature clusterFeature = Feature.fromJson(featureJSON);
+        FeatureCollection leaves = mSource.getClusterChildren(clusterFeature);
+        WritableMap payload = new WritableNativeMap();
+        payload.putString("data", leaves.toJson());
+
+        AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+        mManager.handleEvent(event);
+    }
+
+    // Deprecated. Will be removed in 9+ ver.
+    public void getClusterExpansionZoomById(String callbackID, int clusterId) {
+        if (mSource == null) {
+            WritableMap payload = new WritableNativeMap();
+            payload.putString("error", "source is not yet loaded");
+            AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+            mManager.handleEvent(event);
+            return;
+        }
+        List<Feature> features = mSource.querySourceFeatures(Expression.eq(Expression.id(), clusterId));
+        int zoom = -1;
+        if (features.size() > 0) {
+            zoom = mSource.getClusterExpansionZoom(features.get(0));
+        }
+
+        if (zoom == -1) {
+            WritableMap payload = new WritableNativeMap();
+            payload.putString("error", "Could not get zoom for cluster id " + clusterId);
+            AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+            mManager.handleEvent(event);
+            return;
+        }
+
+        WritableMap payload = new WritableNativeMap();
+        payload.putInt("data", zoom);
+
+        AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+        mManager.handleEvent(event);
+    }
+
+    // Deprecated. Will be removed in 9+ ver.
+    public void getClusterLeavesById(String callbackID, int clusterId, int number, int offset) {
+        if (mSource == null) {
+            WritableMap payload = new WritableNativeMap();
+            payload.putString("error", "source is not yet loaded");
+            AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+            mManager.handleEvent(event);
+            return;
+        }
+        Feature clusterFeature = mSource.querySourceFeatures(Expression.eq(Expression.get("cluster_id"), clusterId)).get(0);
+        FeatureCollection leaves = mSource.getClusterLeaves(clusterFeature, number, offset);
+        WritableMap payload = new WritableNativeMap();
+        payload.putString("data", leaves.toJson());
+
+        AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+        mManager.handleEvent(event);
+    }
+
+    // Deprecated. Will be removed in 9+ ver.
+    public void getClusterChildrenById(String callbackID, int clusterId) {
+        if (mSource == null) {
+            WritableMap payload = new WritableNativeMap();
+            payload.putString("error", "source is not yet loaded");
+            AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+            mManager.handleEvent(event);
+            return;
+        }
+        Feature clusterFeature = mSource.querySourceFeatures(Expression.eq(Expression.get("cluster_id"), clusterId)).get(0);
+        FeatureCollection leaves = mSource.getClusterChildren(clusterFeature);
+        WritableMap payload = new WritableNativeMap();
+        payload.putString("data", leaves.toJson());
+
+        AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+        mManager.handleEvent(event);
+    }
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/styles/sources/RCTMGLShapeSourceManager.java

@@ -0,0 +1,253 @@
+package com.mapbox.rctmgl.components.styles.sources;
+
+import android.content.Context;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.media.Image;
+import android.util.Log;
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.mapbox.mapboxsdk.style.expressions.Expression;
+import com.mapbox.rctmgl.components.AbstractEventEmitter;
+import com.mapbox.rctmgl.components.annotation.RCTMGLCallout;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView;
+import com.mapbox.rctmgl.components.styles.layers.RCTLayer;
+import com.mapbox.rctmgl.events.constants.EventKeys;
+import com.mapbox.rctmgl.utils.ClusterPropertyEntry;
+import com.mapbox.rctmgl.utils.ExpressionParser;
+import com.mapbox.rctmgl.utils.ImageEntry;
+import com.mapbox.rctmgl.utils.ResourceUtils;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by nickitaliano on 9/19/17.
+ */
+
+public class RCTMGLShapeSourceManager extends AbstractEventEmitter<RCTMGLShapeSource> {
+    public static final String LOG_TAG = "RCTMGLShapeSourceManager";
+    public static final String REACT_CLASS = "RCTMGLShapeSource";
+
+    private ReactApplicationContext mContext;
+
+    public RCTMGLShapeSourceManager(ReactApplicationContext context) {
+        super(context);
+        mContext = context;
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    protected RCTMGLShapeSource createViewInstance(ThemedReactContext reactContext) {
+        return new RCTMGLShapeSource(reactContext, this);
+    }
+
+    @Override
+    public View getChildAt(RCTMGLShapeSource source, int childPosition) {
+        return source.getLayerAt(childPosition);
+    }
+
+    @Override
+    public int getChildCount(RCTMGLShapeSource source) {
+        return source.getLayerCount();
+    }
+
+    @Override
+    public void addView(RCTMGLShapeSource source, View childView, int childPosition) {
+        source.addLayer(childView, getChildCount(source));
+    }
+
+    @Override
+    public void removeViewAt(RCTMGLShapeSource source, int childPosition) {
+        source.removeLayer(childPosition);
+    }
+
+    @ReactProp(name = "id")
+    public void setId(RCTMGLShapeSource source, String id) {
+        source.setID(id);
+    }
+
+    @ReactProp(name = "url")
+    public void setURL(RCTMGLShapeSource source, String urlStr) {
+        try {
+            source.setURL(new URL(urlStr));
+        } catch (MalformedURLException e) {
+            Log.w(LOG_TAG, e.getLocalizedMessage());
+        }
+    }
+
+    @ReactProp(name = "shape")
+    public void setGeometry(RCTMGLShapeSource source, String geoJSONStr) {
+        source.setShape(geoJSONStr);
+    }
+
+    @ReactProp(name = "cluster")
+    public void setCluster(RCTMGLShapeSource source, int cluster) {
+        source.setCluster(cluster == 1);
+    }
+
+    @ReactProp(name = "clusterRadius")
+    public void setClusterRadius(RCTMGLShapeSource source, int radius) {
+        source.setClusterRadius(radius);
+    }
+
+    @ReactProp(name = "clusterMaxZoomLevel")
+    public void setClusterMaxZoomLevel(RCTMGLShapeSource source, int clusterMaxZoom) {
+        source.setClusterMaxZoom(clusterMaxZoom);
+    }
+
+    @ReactProp(name = "clusterProperties")
+    public void setClusterProperties(RCTMGLShapeSource source, ReadableMap map) {
+        List<Map.Entry<String, ClusterPropertyEntry>> properties = new ArrayList<>();
+
+        ReadableMapKeySetIterator iterator = map.keySetIterator();
+        while (iterator.hasNextKey()) {
+            String name = iterator.nextKey();
+            ReadableArray expressions = map.getArray(name);
+
+            Expression operator;
+            if (expressions.getType(0) == ReadableType.Array) {
+                operator = ExpressionParser.from(expressions.getArray(0));
+            } else {
+                operator = Expression.literal(expressions.getString(0));
+            }
+
+            Expression mapping = ExpressionParser.from(expressions.getArray(1));
+
+            properties.add(new AbstractMap.SimpleEntry<>(name, new ClusterPropertyEntry(operator, mapping)));
+        }
+
+        source.setClusterProperties(properties);
+    }
+
+    @ReactProp(name = "maxZoomLevel")
+    public void setMaxZoomLevel(RCTMGLShapeSource source, int maxZoom) {
+        source.setMaxZoom(maxZoom);
+    }
+
+    @ReactProp(name = "buffer")
+    public void setBuffer(RCTMGLShapeSource source, int buffer) {
+        source.setBuffer(buffer);
+    }
+
+    @ReactProp(name = "tolerance")
+    public void setTolerance(RCTMGLShapeSource source, double tolerance) {
+        source.setTolerance(tolerance);
+    }
+
+    @ReactProp(name = "lineMetrics")
+    public void setLineMetrics(RCTMGLShapeSource source, boolean lineMetrics) {
+        source.setLineMetrics(lineMetrics);
+    }
+
+    @ReactProp(name = "hasPressListener")
+    public void setHasPressListener(RCTMGLShapeSource source, boolean hasPressListener) {
+        source.setHasPressListener(hasPressListener);
+    }
+
+    @ReactProp(name="hitbox")
+    public void setHitbox(RCTMGLShapeSource source, ReadableMap map) {
+        source.setHitbox(map);
+    }
+
+    @Override
+    public Map<String, String> customEvents() {
+        return MapBuilder.<String, String>builder()
+                .put(EventKeys.SHAPE_SOURCE_LAYER_CLICK, "onMapboxShapeSourcePress")
+                .put(EventKeys.MAP_ANDROID_CALLBACK, "onAndroidCallback")
+                .build();
+    }
+
+    //region React Methods
+    public static final int METHOD_FEATURES = 103;
+    public static final int METHOD_GET_CLUSTER_EXPANSION_ZOOM = 104;
+    public static final int METHOD_GET_CLUSTER_LEAVES = 105;
+    public static final int METHOD_GET_CLUSTER_CHILDREN = 106;
+
+    // Deprecated. Will be removed in 9+ ver.
+    public static final int METHOD_GET_CLUSTER_EXPANSION_ZOOM_BY_ID = 107;
+    public static final int METHOD_GET_CLUSTER_LEAVES_BY_ID = 108;
+    public static final int METHOD_GET_CLUSTER_CHILDREN_BY_ID = 109;
+
+    @Nullable
+    @Override
+    public Map<String, Integer> getCommandsMap() {
+        return MapBuilder.<String, Integer>builder()
+                .put("features", METHOD_FEATURES)
+                .put("getClusterExpansionZoom", METHOD_GET_CLUSTER_EXPANSION_ZOOM)
+                .put("getClusterLeaves", METHOD_GET_CLUSTER_LEAVES)
+                .put("getClusterChildren", METHOD_GET_CLUSTER_CHILDREN)
+
+                // Deprecated. Will be removed in 9+ ver.
+                .put("getClusterExpansionZoomById", METHOD_GET_CLUSTER_EXPANSION_ZOOM_BY_ID)
+                .put("getClusterLeavesById", METHOD_GET_CLUSTER_LEAVES_BY_ID)
+                .put("getClusterChildrenById", METHOD_GET_CLUSTER_CHILDREN_BY_ID)
+
+                .build();
+    }
+
+    @Override
+    public void receiveCommand(RCTMGLShapeSource source, int commandID, @Nullable ReadableArray args) {
+        switch (commandID) {
+            case METHOD_FEATURES:
+                source.querySourceFeatures(
+                        args.getString(0),
+                        ExpressionParser.from(args.getArray(1))
+                );
+                break;
+            case METHOD_GET_CLUSTER_EXPANSION_ZOOM:
+                source.getClusterExpansionZoom(args.getString(0), args.getString(1));
+                break;
+            case METHOD_GET_CLUSTER_LEAVES:
+                source.getClusterLeaves(
+                        args.getString(0),
+                        args.getString(1),
+                        args.getInt(2),
+                        args.getInt((3))
+                );
+                break;
+            case METHOD_GET_CLUSTER_CHILDREN:
+                source.getClusterChildren(
+                        args.getString(0),
+                        args.getString(1)
+                );
+                break;
+            case METHOD_GET_CLUSTER_EXPANSION_ZOOM_BY_ID:
+                source.getClusterExpansionZoomById(args.getString(0), args.getInt(1));
+                break;
+            case METHOD_GET_CLUSTER_LEAVES_BY_ID:
+                source.getClusterLeavesById(
+                        args.getString(0),
+                        args.getInt(1),
+                        args.getInt(2),
+                        args.getInt((3))
+                );
+                break;
+            case METHOD_GET_CLUSTER_CHILDREN_BY_ID:
+                source.getClusterChildrenById(
+                        args.getString(0),
+                        args.getInt(1)
+                );
+                break;
+        }
+    }
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/styles/sources/RCTMGLTileSource.java

@@ -0,0 +1,97 @@
+package com.mapbox.rctmgl.components.styles.sources;
+
+import android.content.Context;
+
+import com.mapbox.mapboxsdk.style.sources.Source;
+import com.mapbox.mapboxsdk.style.sources.TileSet;
+
+import java.util.Collection;
+
+@SuppressWarnings("unused")
+public abstract class RCTMGLTileSource<T extends Source> extends RCTSource<T> {
+    static final String TILE_SPEC_VERSION = "2.1.0";
+
+    private String mURL;
+    private Collection<String> mTileUrlTemplates;
+    private String mAttribution;
+
+    private Integer mMinZoomLevel;
+    private Integer mMaxZoomLevel;
+
+    private boolean mIsTmsSource;
+
+    public RCTMGLTileSource(Context context) {
+        super(context);
+    }
+
+    public String getURL() {
+        return mURL;
+    }
+
+    public void setURL(String mURL) {
+        this.mURL = mURL;
+    }
+
+    public String getAttribution() {
+        return mAttribution;
+    }
+
+    public void setAttribution(String mAttribution) {
+        this.mAttribution = mAttribution;
+    }
+
+    public Integer getMinZoomLevel() {
+        return mMinZoomLevel;
+    }
+
+    public void setMinZoomLevel(Integer mMinZoomLevel) {
+        this.mMinZoomLevel = mMinZoomLevel;
+    }
+
+    public Integer getMaxZoomLevel() {
+        return mMaxZoomLevel;
+    }
+
+    public void setMaxZoomLevel(Integer mMaxZoomLevel) {
+        this.mMaxZoomLevel = mMaxZoomLevel;
+    }
+
+    public boolean getTMS() {
+        return mIsTmsSource;
+    }
+
+    public void setTMS(boolean mIsTmsSource) {
+        this.mIsTmsSource = mIsTmsSource;
+    }
+
+    public Collection<String> getTileUrlTemplates() {
+        return mTileUrlTemplates;
+    }
+
+    public void setTileUrlTemplates(Collection<String> tileUrlTemplates) {
+        this.mTileUrlTemplates = tileUrlTemplates;
+    }
+
+    public TileSet buildTileset() {
+        String[] tileUrlTemplates = mTileUrlTemplates.toArray(new String[mTileUrlTemplates.size()]);
+        TileSet tileSet = new TileSet(TILE_SPEC_VERSION, tileUrlTemplates);
+
+        if (mMinZoomLevel != null) {
+            tileSet.setMinZoom(mMinZoomLevel.floatValue());
+        }
+
+        if (mMaxZoomLevel != null) {
+            tileSet.setMaxZoom(mMaxZoomLevel.floatValue());
+        }
+
+        if (mIsTmsSource) {
+            tileSet.setScheme("tms");
+        }
+
+        if (mAttribution != null) {
+            tileSet.setAttribution(mAttribution);
+        }
+
+        return tileSet;
+    }
+}