diff --git a/demo/mapboxgl-android-4.x.x-example.js b/demo/mapboxgl-android-4.x.x-example.js
new file mode 100644
index 0000000..6d0afb4
--- /dev/null
+++ b/demo/mapboxgl-android-4.x.x-example.js
@@ -0,0 +1,87 @@
+var cabo = {
+    name: "Cabo San Lucas",
+    style: "emerald",
+    minZoom: 0,
+    maxZoom: 16,
+    bounds: {
+        north: 22.891,
+        east: -109.919,
+        south: 22.879,
+        west: -109.905
+    }
+};
+
+Mapbox.listOfflineRegions(function (err, regions) {
+    if (err) return onError(err);
+    console.log('listOfflineRegions()', regions);
+
+    var region = regions[cabo.name];
+
+    // First load will download region.
+    if (!region) {
+        region = Mapbox.createOfflineRegion(cabo);
+
+        region.on("error", function (e) {
+            console.error("OfflineRegion onError", e);
+        });
+
+        region.on("progress", function (progress) {
+            console.log("OfflineRegion download onProgress", progress);
+        });
+
+        region.on("complete", function (progress) {
+            console.log("OfflineRegion download onComplete", progress);
+        });
+
+        region.download();
+    }
+    // Subsequent loads will display offline region download status.
+    else {
+        region.getStatus(function (err, status) {
+            if (err) return onError(err);
+            console.log("OfflineRegion getStatus()", status);
+        });
+    }
+});
+
+var map = new Mapbox.Map({
+        style: 'emerald',
+        zoom: 15,
+        center: [-109.912, 22.885],
+        showUserLocation: true,
+        margins: {
+            left: 0,
+            right: 0,
+            top: 0,
+            bottom: 0
+        },
+        markers: [
+            {"title": "Marker 1", "lng": -109.912, "lat": 22.885}
+        ],
+        // NOTE: the options below are broken...
+        hideAttribution: true, // default false
+        hideLogo: true, // default false
+        hideCompass: false, // default false
+        disableRotation: false, // default false
+        disableScroll: false, // default false
+        disableZoom: false, // default false
+        disablePitch: false // default false
+    });
+
+map.on('load', function (e) {
+    map.addMarkers(
+        [
+            {"title": "Marker 2", "lng": -109.910, "lat": 22.886},
+            {"title": "Marker 3", "lng": -109.913, "lat": 22.883}
+        ],
+        function () { console.log("Markers added!"); },
+        function (e) { console.error("Error adding markers:", e); }
+    );
+
+    map.addMarkerCallback(printMarker);
+
+    function printMarker(selectedMarker) {
+        alert("Marker selected: " + JSON.stringify(selectedMarker));
+        map.addMarkerCallback(printMarker);
+    }
+});
diff --git a/plugin.xml b/plugin.xml
index f2d6d31..1f6111e 100755
--- a/plugin.xml
+++ b/plugin.xml
@@ -24,8 +24,15 @@
     <engine name="cordova-plugman" version=">=4.2.0"/><!-- needed for gradleReference support -->
   </engines>
 
+  <js-module src="www/mixin.js" name="mixin" />
+  <js-module src="www/mapbox-plugin-api-mixin.js" name="mapbox-plugin-api-mixin" />
+  <js-module src="www/events-mixin.js" name="events-mixin" />
+  <js-module src="www/map-events.js" name="map-events" />
+  <js-module src="www/map-instance.js" name="map-instance" />
+  <js-module src="www/offline-region.js" name="offline-region" />
+
   <js-module src="www/Mapbox.js" name="Mapbox">
-    <clobbers target="Mapbox" />
+    <clobbers target="window.Mapbox" />
   </js-module>
 
   <!-- android -->
@@ -46,8 +53,19 @@
       <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
     </config-file>
 
+    <config-file target="AndroidManifest.xml" parent="/manifest/application">
+      <service android:name="com.mapbox.mapboxsdk.telemetry.TelemetryService" />
+    </config-file>
+
     <framework src="src/android/mapbox.gradle" custom="true" type="gradleReference"/>
+    <framework src="com.android.support:appcompat-v7:22.+" />
     <source-file src="src/android/Mapbox.java" target-dir="src/com/telerik/plugins/mapbox"/>
+    <source-file src="src/android/MapboxManager.java" target-dir="src/com/telerik/plugins/mapbox"/>
+    <source-file src="src/android/OfflineRegion.java" target-dir="src/com/telerik/plugins/mapbox"/>
+    <source-file src="src/android/Map.java" target-dir="src/com/telerik/plugins/mapbox"/>
+    <source-file src="src/android/FeatureManager.java" target-dir="src/com/telerik/plugins/mapbox"/>
+    <source-file src="src/android/GeoJSONMarker.java" target-dir="src/com/telerik/plugins/mapbox"/>
+    <source-file src="src/android/GeoJSONMarkerOptions.java" target-dir="src/com/telerik/plugins/mapbox"/>
 
     <!-- This leads to trouble in AppBuilder when compiling for Cordova-Android 4 -->
     <!--source-file src="src/android/res/values/mapboxstrings.xml" target-dir="res/values" />
diff --git a/src/android/FeatureManager.java b/src/android/FeatureManager.java
new file mode 100644
index 0000000..b333de8
--- /dev/null
+++ b/src/android/FeatureManager.java
@@ -0,0 +1,344 @@
+package com.telerik.plugins.mapbox;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.support.annotation.Nullable;
+import android.util.DisplayMetrics;
+import android.util.Log;
+
+import com.cocoahero.android.geojson.Feature;
+import com.cocoahero.android.geojson.FeatureCollection;
+import com.cocoahero.android.geojson.GeoJSON;
+import com.cocoahero.android.geojson.GeoJSONObject;
+import com.cocoahero.android.geojson.Geometry;
+import com.cocoahero.android.geojson.GeometryCollection;
+import com.cocoahero.android.geojson.LineString;
+import com.cocoahero.android.geojson.MultiLineString;
+import com.cocoahero.android.geojson.MultiPoint;
+import com.cocoahero.android.geojson.MultiPolygon;
+import com.cocoahero.android.geojson.Point;
+import com.cocoahero.android.geojson.Polygon;
+import com.cocoahero.android.geojson.Position;
+import com.cocoahero.android.geojson.Ring;
+import com.mapbox.mapboxsdk.annotations.BaseMarkerOptions;
+import com.mapbox.mapboxsdk.annotations.Icon;
+import com.mapbox.mapboxsdk.annotations.IconFactory;
+import com.mapbox.mapboxsdk.annotations.Marker;
+import com.mapbox.mapboxsdk.annotations.MarkerOptions;
+import com.mapbox.mapboxsdk.annotations.PolygonOptions;
+import com.mapbox.mapboxsdk.annotations.PolylineOptions;
+import com.mapbox.mapboxsdk.geometry.LatLng;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+interface DataSource {
+    List<Feature> getFills();
+    List<Feature> getLines();
+    List<Feature> getSymbols();
+}
+
+class FeatureManager {
+    private String TAG = "FeatureManager";
+
+    protected long ids = 0;
+
+    protected Context ctx;
+
+    protected IconFactory iconFactory;
+
+    protected MapboxMap mapboxMap;
+
+    protected HashMap<String, DataSource> sources = new HashMap<String, DataSource>();
+
+    protected HashMap<Long, GeoJSONMarker> markerIndex = new HashMap<Long, GeoJSONMarker>();
+
+    public FeatureManager(Context ctx, MapboxMap mapboxMap) {
+        this.ctx = ctx;
+        this.mapboxMap = mapboxMap;
+        this.iconFactory = IconFactory.getInstance(ctx);
+    }
+
+    public boolean hasSource(String name) {
+        return this.sources.containsKey(name);
+    }
+
+    public boolean hasMarker(Long id) {
+        return this.markerIndex.containsKey(id);
+    }
+
+    public GeoJSONMarker getMarker(Long id) {
+        if (this.hasMarker(id)) {
+            return this.markerIndex.get(id);
+        } else {
+            return null;
+        }
+    }
+
+    public void addGeoJSONSource(String name, String json) throws JSONException {
+        this.sources.put(name, new GeoJSONSource(name).addGeoJSON(json));
+    }
+
+    public void addGeoJSONSource(String name, JSONObject json) throws JSONException {
+        this.sources.put(name, new GeoJSONSource(name).addGeoJSON(json));
+    }
+
+    public void addFillLayer(String id, String source, JSONObject layer) {
+        for (Feature feature : this.sources.get(source).getFills()) {
+            ArrayList<LatLng> latLngs = new ArrayList<LatLng>();
+            for (Ring ring : ((Polygon) feature.getGeometry()).getRings()) {
+                for (Position position : ring.getPositions()) {
+                    latLngs.add(new LatLng(position.getLatitude(), position.getLongitude()));
+                }
+            }
+            LatLng[] points = latLngs.toArray(new LatLng[latLngs.size()]);
+
+            PolygonOptions polygon = new PolygonOptions()
+                    // TODO: Need to use values in layer to set options.
+                    .add(points);
+
+            this.mapboxMap.addPolygon(polygon);
+        }
+    }
+
+    public void addLineLayer(String id, String source, JSONObject layer) {
+        for (Feature feature : this.sources.get(source).getLines()) {
+            ArrayList<LatLng> latLngs = new ArrayList<LatLng>();
+            for (Position position : ((LineString) feature.getGeometry()).getPositions()) {
+                latLngs.add(new LatLng(position.getLatitude(), position.getLongitude()));
+            }
+            LatLng[] points = latLngs.toArray(new LatLng[latLngs.size()]);
+
+            PolylineOptions line = new PolylineOptions()
+                    // TODO: Need to use values in layer to set options.
+                    .add(points);
+
+            this.mapboxMap.addPolyline(line);
+        }
+    }
+
+    public void addMarkerLayer(String id, String source, JSONObject layer) {
+        List<Feature> features = this.sources.get(source).getSymbols();
+
+        for (Feature feature : features) {
+            GeoJSONMarkerOptions options = this.createMarker(feature, layer);
+            GeoJSONMarker marker = (GeoJSONMarker) this.mapboxMap.addMarker(options);
+            this.markerIndex.put(marker.getFeatureId(), marker);
+        }
+    }
+
+    public GeoJSONMarkerOptions createMarker(LatLng latLng, String title, String snippet, @Nullable Icon icon, @Nullable JSONObject properties) {
+        GeoJSONMarkerOptions marker = new GeoJSONMarkerOptions()
+                .title(title)
+                .snippet(snippet)
+                .position(latLng)
+                .featureId(this.ids++);
+
+        if (icon != null) {
+            marker.icon(icon);
+        }
+
+        if (properties != null) {
+            marker.properties(properties);
+        }
+
+        return marker;
+    }
+
+    public GeoJSONMarkerOptions createMarker(LatLng latLng, String title, String snippet) {
+        return createMarker(latLng, title, snippet, null, null);
+    }
+
+    protected GeoJSONMarkerOptions createMarker(Feature feature, JSONObject style) {
+        JSONObject properties = feature.getProperties();
+        Position p = ((Point) feature.getGeometry()).getPosition();
+        LatLng latLng = new LatLng(p.getLatitude(), p.getLongitude());
+        String title = "";
+        String snippet = "";
+        Icon icon = null;
+
+        try {
+            String textField = style.getJSONObject("layout").getString("text-field");
+            title = textField.replace("{title}", properties.getString("title"));
+        } catch (JSONException e) {
+            Log.w(TAG, "Error parsing Style JSON properties: " + e.getMessage());
+        }
+
+        try {
+            snippet = properties.getString("description");
+        } catch (JSONException e) {
+            Log.w(TAG, "Error parsing Style JSON properties: " + e.getMessage());
+        }
+
+        try {
+            String iconImage = style.getJSONObject("layout").getString("icon-image");
+            String markerSymbol = properties.getString("marker-symbol");
+            URI uri = new URI(iconImage.replace("{marker-symbol}", markerSymbol));
+            icon = this.loadIcon(uri);
+        } catch (JSONException e) {
+            Log.w(TAG, "Error parsing Style JSON properties: " + e.getMessage());
+        } catch (URISyntaxException e) {
+            Log.w(TAG, "Invalid icon-image URI: " + e.getMessage());
+        } catch (IOException e) {
+            Log.w(TAG, "Error loading file: " + e.getMessage());
+        }
+
+        return this.createMarker(latLng, title, snippet, icon, feature.getProperties());
+    }
+
+    protected Icon loadIcon(URI uri) throws IOException {
+        Icon icon;
+
+        if (uri.getScheme().equals("asset")) {
+            // Stripping leading '/'.
+            String path = uri.getPath().substring(1);
+            icon = iconFactory.fromBitmap(this.loadScaledBitmap(path));
+        }
+        else {
+            icon = iconFactory.fromPath(uri.getPath());
+        }
+
+        return icon;
+    }
+
+    protected Bitmap loadScaledBitmap(String path) throws IOException {
+        AssetManager am = ctx.getAssets();
+        InputStream image = am.open(path);
+        Bitmap bmp = BitmapFactory.decodeStream(image);
+        DisplayMetrics dm = ctx.getResources().getDisplayMetrics();
+        bmp.setDensity(dm.densityDpi);
+        return bmp;
+    }
+
+    private class GeoJSONSource implements DataSource {
+        private String TAG = "GeoJSONSource";
+
+        protected String name;
+
+        protected ArrayList<Feature> polygons = new ArrayList<Feature>();
+        protected ArrayList<Feature> polylines = new ArrayList<Feature>();
+        protected ArrayList<Feature> markers = new ArrayList<Feature>();
+
+        public GeoJSONSource(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public List<Feature> getFills() {
+            return polygons;
+        }
+
+        @Override
+        public List<Feature> getLines() {
+            return polylines;
+        }
+
+        @Override
+        public List<Feature> getSymbols() {
+            return markers;
+        }
+
+        public GeoJSONSource addGeoJSON(String json) throws JSONException {
+            return this.addGeoJSON(GeoJSON.parse(json));
+        }
+
+        public GeoJSONSource addGeoJSON(JSONObject json) throws JSONException {
+            return this.addGeoJSON(GeoJSON.parse(json));
+        }
+
+        public GeoJSONSource addGeoJSON(GeoJSONObject geojson) {
+            if (geojson instanceof FeatureCollection) {
+                FeatureCollection fc = (FeatureCollection) geojson;
+                for (Feature f : fc.getFeatures()) {
+                    this.addGeoJSON(f);
+                }
+            } else if (geojson instanceof Feature) {
+                Feature feature = (Feature) geojson;
+                this.addFeature(feature);
+            } else {
+                Log.e(TAG, "GeoJSON must be FeatureCollection or Feature.");
+            }
+
+            return this;
+        }
+
+        /**
+         * TODO: Handling of Complex geometries (GeometryCollection & Multi*) needs improvement when Mapbox SDK supports them better.
+         * TODO: Recursive processing of GeoJSON could probably be optimized.
+         *
+         * @param feature
+         */
+        public void addFeature(Feature feature) {
+            Geometry geom = feature.getGeometry();
+
+            if (geom instanceof GeometryCollection) {
+                GeometryCollection gc = (GeometryCollection) geom;
+                for (Geometry g : gc.getGeometries()) {
+                    this.addFeature(feature, g);
+                }
+            }
+            else if (geom instanceof MultiPolygon) {
+                MultiPolygon multiPoly = (MultiPolygon) geom;
+                for (Polygon poly : multiPoly.getPolygons()) {
+                    this.addFeature(feature, poly);
+                }
+            }
+            else if (geom instanceof MultiLineString) {
+                MultiLineString multiLine = (MultiLineString) geom;
+                for (LineString ls : multiLine.getLineStrings()) {
+                    this.addFeature(feature, ls);
+                }
+            }
+            else if (geom instanceof MultiPoint) {
+                MultiPoint multiPoint = (MultiPoint) geom;
+                for (Position p : multiPoint.getPositions()) {
+                    this.addFeature(feature, new Point(p));
+                }
+            }
+            else {
+                this.addFeature(feature, geom);
+            }
+        }
+
+        protected void addFeature(Feature feature, Geometry geom) {
+            if (geom instanceof MultiPolygon || geom instanceof MultiLineString || geom instanceof MultiPoint) {
+                feature.setGeometry(geom);
+                Feature f = new Feature(geom);
+                f.setProperties(feature.getProperties());
+                this.addFeature(f);
+            }
+            else if (geom instanceof Polygon) {
+                this.polygons.add(this.createFeature(feature.getProperties(), geom));
+            }
+            else if (geom instanceof LineString) {
+                this.polylines.add(this.createFeature(feature.getProperties(), geom));
+            }
+            else if (geom instanceof Point) {
+                this.markers.add(this.createFeature(feature.getProperties(), geom));
+            } else {
+                // Unsupported geometry type.
+                Log.e(TAG, String.format("Unsupported GeoJSON geometry type: %s.", geom.getType()));
+            }
+        }
+
+        protected Feature createFeature(JSONObject properties, Geometry geom) {
+            Feature f = new Feature();
+            f.setGeometry(geom);
+            f.setProperties(properties);
+            return f;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/android/GeoJSONMarker.java b/src/android/GeoJSONMarker.java
new file mode 100644
index 0000000..36c5344
--- /dev/null
+++ b/src/android/GeoJSONMarker.java
@@ -0,0 +1,25 @@
+package com.telerik.plugins.mapbox;
+
+import com.mapbox.mapboxsdk.annotations.Marker;
+
+import org.json.JSONObject;
+
+public class GeoJSONMarker extends Marker {
+    private JSONObject properties;
+
+    private long featureId;
+
+    public GeoJSONMarker(GeoJSONMarkerOptions options, JSONObject properties, long featureId) {
+        super(options);
+        this.properties = properties;
+        this.featureId = featureId;
+    }
+
+    public JSONObject getProperties() {
+        return this.properties != null ? this.properties : new JSONObject();
+    }
+
+    public long getFeatureId() {
+        return this.featureId;
+    }
+}
\ No newline at end of file
diff --git a/src/android/GeoJSONMarkerOptions.java b/src/android/GeoJSONMarkerOptions.java
new file mode 100644
index 0000000..04b6f50
--- /dev/null
+++ b/src/android/GeoJSONMarkerOptions.java
@@ -0,0 +1,75 @@
+package com.telerik.plugins.mapbox;
+
+import android.graphics.Bitmap;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import com.mapbox.mapboxsdk.annotations.BaseMarkerOptions;
+import com.mapbox.mapboxsdk.annotations.Icon;
+import com.mapbox.mapboxsdk.annotations.IconFactory;
+import com.mapbox.mapboxsdk.geometry.LatLng;
+
+import org.json.JSONObject;
+
+public class GeoJSONMarkerOptions extends BaseMarkerOptions<GeoJSONMarker, GeoJSONMarkerOptions> {
+    private long featureId;
+    private JSONObject properties;
+
+    public GeoJSONMarkerOptions properties(JSONObject properties) {
+        this.properties = properties;
+        return this.getThis();
+    }
+
+    public GeoJSONMarkerOptions featureId(long id) {
+        this.featureId = id;
+        return this.getThis();
+    }
+
+    public GeoJSONMarkerOptions() {
+
+    }
+
+    private GeoJSONMarkerOptions(Parcel in) {
+        position((LatLng) in.readParcelable(LatLng.class.getClassLoader()));
+        snippet(in.readString());
+        String iconId = in.readString();
+        Bitmap iconBitmap = in.readParcelable(Bitmap.class.getClassLoader());
+        Icon icon = IconFactory.recreate(iconId, iconBitmap);
+        icon(icon);
+        title(in.readString());
+    }
+
+    @Override
+    public GeoJSONMarkerOptions getThis() {
+        return this;
+    }
+
+    @Override
+    public GeoJSONMarker getMarker() {
+        return new GeoJSONMarker(this, this.properties, this.featureId);
+    }
+
+    public static final Parcelable.Creator<GeoJSONMarkerOptions> CREATOR = new Parcelable.Creator<GeoJSONMarkerOptions>() {
+        public GeoJSONMarkerOptions createFromParcel(Parcel in) {
+            return new GeoJSONMarkerOptions(in);
+        }
+
+        public GeoJSONMarkerOptions[] newArray(int size) {
+            return new GeoJSONMarkerOptions[size];
+        }
+    };
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel out, int flags) {
+        out.writeParcelable(position, flags);
+        out.writeString(snippet);
+        out.writeString(icon.getId());
+        out.writeParcelable(icon.getBitmap(), flags);
+        out.writeString(title);
+    }
+}
\ No newline at end of file
diff --git a/src/android/Map.java b/src/android/Map.java
new file mode 100644
index 0000000..33c2ebc
--- /dev/null
+++ b/src/android/Map.java
@@ -0,0 +1,366 @@
+package com.telerik.plugins.mapbox;
+
+import android.location.Location;
+import android.support.annotation.Nullable;
+
+import com.mapbox.mapboxsdk.annotations.Marker;
+import com.mapbox.mapboxsdk.camera.CameraPosition;
+import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
+import com.mapbox.mapboxsdk.geometry.LatLng;
+import com.mapbox.mapboxsdk.maps.MapView;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.MapboxMapOptions;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class Map {
+
+    public static final String JSON_FIELD_ID = "id";
+    public static final String JSON_FIELD_PROPERTIES = "properties";
+    public static final String JSON_FIELD_LNGLAT = "lngLat";
+
+    public static final int EVENT_CAMERACHANGE = 0;
+    public static final int EVENT_FLING = 1;
+    public static final int EVENT_INFOWINDOWCLICK = 2;
+    public static final int EVENT_INFOWINDOWCLOSE = 3;
+    public static final int EVENT_INFOWINDOWLONGCLICK = 4;
+    public static final int EVENT_MAPCLICK = 5;
+    public static final int EVENT_MAPLONGCLICK = 6;
+    public static final int EVENT_MARKERCLICK = 7;
+    public static final int EVENT_BEARINGTRACKINGMODECHANGE = 8;
+    public static final int EVENT_LOCATIONCHANGE = 9;
+    public static final int EVENT_LOCATIONTRACKINGMODECHANGE = 10;
+    public static final int EVENT_ONSCROLL = 11;
+
+    public interface MapEventListener {
+        void onEvent(int code, JSONObject event);
+        void onError(String message);
+    }
+
+    public static MapboxMapOptions createMapboxMapOptions(JSONObject options) throws JSONException {
+        MapboxMapOptions opts = new MapboxMapOptions();
+        opts.styleUrl(MapboxManager.getStyle(options.getString("style")));
+        opts.attributionEnabled(options.isNull("hideAttribution") || !options.getBoolean("hideAttribution"));
+        opts.logoEnabled(options.isNull("hideLogo") || options.getBoolean("hideLogo"));
+        opts.locationEnabled(!options.isNull("showUserLocation") && options.getBoolean("showUserLocation"));
+        opts.camera(Map.getCameraPostion(options, null));
+        opts.compassEnabled(options.isNull("hideCompass") || !options.getBoolean("hideCompass"));
+        opts.rotateGesturesEnabled(options.isNull("disableRotation") || !options.getBoolean("disableRotation"));
+        opts.scrollGesturesEnabled(options.isNull("disableScroll") || !options.getBoolean("disableScroll"));
+        opts.zoomGesturesEnabled(options.isNull("disableZoom") || !options.getBoolean("disableZoom"));
+        opts.tiltGesturesEnabled(options.isNull("disableTilt") || !options.getBoolean("disableTilt"));
+        return opts;
+    }
+
+    public static CameraPosition getCameraPostion(JSONObject options, @Nullable CameraPosition start) throws JSONException {
+        CameraPosition.Builder builder = new CameraPosition.Builder(start);
+
+        if (!options.isNull("zoom")) {
+            builder.zoom(options.getDouble("zoom"));
+        }
+
+        if (!options.isNull("center")) {
+            JSONArray center = options.getJSONArray("center");
+            double lng = center.getDouble(0);
+            double lat = center.getDouble(1);
+            builder.target(new LatLng(lat, lng));
+        }
+
+        // TODO: Bearing
+
+        // TODO: Pitch
+
+        return builder.build();
+    }
+
+    private long id;
+
+    private MapView mapView;
+
+    private MapboxMap mapboxMap;
+
+    private MapEventListener eventListener;
+
+    private FeatureManager features;
+
+    public Map(long id, MapEventListener eventListener, final MapView mapView) {
+        this.id = id;
+        this.mapView = mapView;
+        this.eventListener = eventListener;
+    }
+
+    public long getId() {
+        return this.id;
+    }
+
+    public MapView getMapView() {
+        return this.mapView;
+    }
+
+    public JSONArray latLngToJSON(LatLng latLng) throws JSONException {
+        return new JSONArray()
+                .put(latLng.getLongitude())
+                .put(latLng.getLatitude());
+    }
+
+    public JSONObject getMarkerJSON(Marker marker) throws JSONException {
+        LatLng point = marker.getPosition();
+        JSONObject data = new JSONObject()
+                .put(JSON_FIELD_LNGLAT, latLngToJSON(point));
+
+        if (marker instanceof GeoJSONMarker) {
+            long featureId = ((GeoJSONMarker) marker).getFeatureId();
+            data.put(JSON_FIELD_ID, featureId);
+            data.put(JSON_FIELD_PROPERTIES, features.getMarker(featureId).getProperties());
+        }
+
+        return data;
+    }
+
+    public void setMapboxMap(MapboxMap mMap) {
+        this.mapboxMap = mMap;
+
+        this.mapboxMap.setOnCameraChangeListener(new MapboxMap.OnCameraChangeListener() {
+            @Override
+            public void onCameraChange(CameraPosition position) {
+                eventListener.onEvent(EVENT_CAMERACHANGE, new JSONObject());
+            }
+        });
+
+        this.mapboxMap.setOnFlingListener(new MapboxMap.OnFlingListener() {
+            @Override
+            public void onFling() {
+                eventListener.onEvent(EVENT_FLING, new JSONObject());
+            }
+        });
+
+        this.mapboxMap.setOnInfoWindowClickListener(new MapboxMap.OnInfoWindowClickListener() {
+            @Override
+            public boolean onInfoWindowClick(Marker marker) {
+                try {
+                    JSONObject data = getMarkerJSON(marker);
+                    eventListener.onEvent(EVENT_INFOWINDOWCLICK, data);
+                    return true;
+                } catch (JSONException e) {
+                    eventListener.onError(e.getMessage());
+                    return false;
+                }
+            }
+        });
+
+        this.mapboxMap.setOnInfoWindowCloseListener(new MapboxMap.OnInfoWindowCloseListener() {
+            @Override
+            public void onInfoWindowClose(Marker marker) {
+                try {
+                    JSONObject data = getMarkerJSON(marker);
+                    eventListener.onEvent(EVENT_INFOWINDOWCLOSE, data);
+                } catch (JSONException e) {
+                    eventListener.onError(e.getMessage());
+                }
+            }
+        });
+
+        this.mapboxMap.setOnInfoWindowLongClickListener(new MapboxMap.OnInfoWindowLongClickListener() {
+            @Override
+            public void onInfoWindowLongClick(Marker marker) {
+                try {
+                    JSONObject data = getMarkerJSON(marker);
+                    eventListener.onEvent(EVENT_INFOWINDOWLONGCLICK, data);
+                } catch (JSONException e) {
+                    eventListener.onError(e.getMessage());
+                }
+            }
+        });
+
+        this.mapboxMap.setOnMapClickListener(new MapboxMap.OnMapClickListener() {
+            @Override
+            public void onMapClick(LatLng point) {
+                try {
+                    JSONObject data = new JSONObject()
+                            .put("lngLat", latLngToJSON(point));
+                    eventListener.onEvent(EVENT_MAPCLICK, data);
+                } catch (JSONException e) {
+                    eventListener.onError(e.getMessage());
+                }
+            }
+        });
+
+        this.mapboxMap.setOnMapLongClickListener(new MapboxMap.OnMapLongClickListener() {
+            @Override
+            public void onMapLongClick(LatLng point) {
+                try {
+                    JSONObject data = new JSONObject()
+                            .put("lngLat", latLngToJSON(point));
+                    eventListener.onEvent(EVENT_MAPLONGCLICK, data);
+                } catch (JSONException e) {
+                    eventListener.onError(e.getMessage());
+                }
+            }
+        });
+
+        this.mapboxMap.setOnMarkerClickListener(new MapboxMap.OnMarkerClickListener() {
+            @Override
+            public boolean onMarkerClick(Marker marker) {
+                try {
+                    JSONObject data = getMarkerJSON(marker);
+                    eventListener.onEvent(EVENT_MARKERCLICK, data);
+                    return true;
+                } catch (JSONException e) {
+                    eventListener.onError(e.getMessage());
+                    return false;
+                }
+            }
+        });
+
+        this.mapboxMap.setOnMyBearingTrackingModeChangeListener(new MapboxMap.OnMyBearingTrackingModeChangeListener() {
+            @Override
+            public void onMyBearingTrackingModeChange(int myBearingTrackingMode) {
+                eventListener.onEvent(EVENT_BEARINGTRACKINGMODECHANGE, new JSONObject());
+            }
+        });
+
+        this.mapboxMap.setOnMyLocationChangeListener(new MapboxMap.OnMyLocationChangeListener() {
+            @Override
+            public void onMyLocationChange(@Nullable Location location) {
+                eventListener.onEvent(EVENT_LOCATIONCHANGE, new JSONObject());
+            }
+        });
+
+        this.mapboxMap.setOnMyLocationTrackingModeChangeListener(new MapboxMap.OnMyLocationTrackingModeChangeListener() {
+            @Override
+            public void onMyLocationTrackingModeChange(int myLocationTrackingMode) {
+                eventListener.onEvent(EVENT_LOCATIONTRACKINGMODECHANGE, new JSONObject());
+            }
+        });
+
+        this.mapboxMap.setOnScrollListener(new MapboxMap.OnScrollListener() {
+            @Override
+            public void onScroll() {
+                eventListener.onEvent(EVENT_ONSCROLL, new JSONObject());
+            }
+        });
+    }
+
+    public void setFeatureManager(FeatureManager featureManager) {
+        this.features = featureManager;
+    }
+
+    public MapboxMap getMapboxMap() {
+        return this.mapboxMap;
+    }
+
+    public JSONArray getCenter() throws JSONException {
+        CameraPosition cameraPosition = mapboxMap.getCameraPosition();
+        double lat = cameraPosition.target.getLatitude();
+        double lng = cameraPosition.target.getLongitude();
+        double alt = cameraPosition.target.getAltitude();
+        return new JSONArray().put(lat).put(lng).put(alt);
+    }
+
+    public void setCenter(JSONArray coords) throws JSONException {
+        double lng = coords.getDouble(0);
+        double lat = coords.getDouble(1);
+        //double alt = coords.getDouble(2);
+
+        mapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(
+                new CameraPosition.Builder()
+                        .target(new LatLng(lat, lng))
+                        .build()
+        ));
+    }
+
+    public double getZoom() {
+        CameraPosition cameraPosition = mapboxMap.getCameraPosition();
+        return cameraPosition.zoom;
+    }
+
+    public void setZoom(double zoom) {
+        mapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(
+                new CameraPosition.Builder()
+                        .zoom(zoom)
+                        .build()
+        ));
+    }
+
+    public void jumpTo(JSONObject options) throws JSONException {
+        CameraPosition position = Map.getCameraPostion(options, mapboxMap.getCameraPosition());
+        mapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(position));
+    }
+
+    public void addMarkers(JSONArray markers) throws JSONException {
+        for (int i = 0; i < markers.length(); i++) {
+            JSONObject marker = markers.getJSONObject(i);
+            LatLng latLng = new LatLng(marker.getDouble("lat"), marker.getDouble("lng"));
+            String title = marker.isNull("title") ? null : marker.getString("title");
+            String snippet = marker.isNull("subtitle") ? null : marker.getString("subtitle");
+            mapboxMap.addMarker(features.createMarker(latLng, title, snippet));
+        }
+    }
+
+    public void addMarkerListener(MapboxMap.OnInfoWindowClickListener listener) {
+        mapboxMap.setOnInfoWindowClickListener(listener);
+    }
+
+    public void showUserLocation(boolean enabled) {
+        mapboxMap.setMyLocationEnabled(enabled);
+    }
+
+    public void addSource(String name, JSONObject source) throws UnsupportedTypeException, JSONException {
+        final String sourceType = source.getString("type");
+
+        if (sourceType.equals("geojson") && source.has("data")) {
+            final JSONObject data = source.getJSONObject("data");
+            features.addGeoJSONSource(name, data);
+        } else {
+            throw new UnsupportedTypeException("source:" + sourceType);
+        }
+    }
+
+    public void addLayer(JSONObject layer) throws UnknownSourceException, UnsupportedTypeException, JSONException {
+        final String layerType = layer.getString("type");
+        final String source = layer.getString("source");
+        final String id = layer.getString("id");
+
+        if (features.hasSource(source)) {
+            if (layerType.equals("fill")) {
+                features.addFillLayer(id, source, layer);
+            } else if (layerType.equals("line")) {
+                features.addLineLayer(id, source, layer);
+            } else if (layerType.equals("symbol")) {
+                features.addMarkerLayer(id, source, layer);
+            } else {
+                throw new UnsupportedTypeException("layer:" + layerType);
+            }
+        } else {
+            throw new UnknownSourceException(source);
+        }
+    }
+}
+
+class UnsupportedTypeException extends Exception {
+    String type;
+
+    public UnsupportedTypeException(String type) {
+        this.type = type;
+    }
+
+    @Override
+    public String getMessage() {
+        return "Unsupported type: " + this.type;
+    }
+}
+
+class UnknownSourceException extends Exception {
+    String source;
+
+    public UnknownSourceException(String source) {
+        this.source = source;
+    }
+
+    @Override
+    public String getMessage() {
+        return "Unknown source: " + this.source;
+    }
+}
\ No newline at end of file
diff --git a/src/android/Mapbox.java b/src/android/Mapbox.java
index 029fe92..cc4d449 100644
--- a/src/android/Mapbox.java
+++ b/src/android/Mapbox.java
@@ -1,58 +1,54 @@
 package com.telerik.plugins.mapbox;
 
 import android.Manifest;
+import android.app.Activity;
 import android.content.pm.PackageManager;
 import android.content.res.Resources;
 import android.os.Build;
-import android.support.annotation.NonNull;
 import android.support.v4.app.ActivityCompat;
 import android.util.DisplayMetrics;
-import android.view.ViewGroup;
-import android.widget.FrameLayout;
 
-import com.mapbox.mapboxsdk.camera.CameraPosition;
-import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
-import com.mapbox.mapboxsdk.constants.Style;
 import com.mapbox.mapboxsdk.annotations.Marker;
-import com.mapbox.mapboxsdk.annotations.MarkerOptions;
-import com.mapbox.mapboxsdk.annotations.PolygonOptions;
-import com.mapbox.mapboxsdk.geometry.LatLng;
-import com.mapbox.mapboxsdk.geometry.LatLngZoom;
-import com.mapbox.mapboxsdk.views.MapView;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
 
 import org.apache.cordova.CallbackContext;
 import org.apache.cordova.CordovaArgs;
 import org.apache.cordova.CordovaInterface;
 import org.apache.cordova.CordovaPlugin;
 import org.apache.cordova.CordovaWebView;
+
 import org.apache.cordova.PluginResult;
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
 import java.util.HashMap;
-import java.util.Map;
-
 
 // TODO for screen rotation, see https://www.mapbox.com/mapbox-android-sdk/#screen-rotation
 // TODO fox Xwalk compat, see nativepagetransitions plugin
 // TODO look at demo app: https://github.com/mapbox/mapbox-gl-native/blob/master/android/java/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxgl/testapp/MainActivity.java
 public class Mapbox extends CordovaPlugin {
-
   public static final String FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
   public static final String COARSE_LOCATION = Manifest.permission.ACCESS_COARSE_LOCATION;
-  public static final int LOCATION_REQ_CODE = 0;
 
   public static final int PERMISSION_DENIED_ERROR = 20;
 
   private static final String MAPBOX_ACCESSTOKEN_RESOURCE_KEY = "mapbox_accesstoken";
 
-  private static final String ACTION_SHOW = "show";
-  private static final String ACTION_HIDE = "hide";
+  private static final String ACTION_CREATE_MAP = "createMap";
+  private static final String ACTION_JUMP_TO = "jumpTo";
+  private static final String ACTION_SHOW_USER_LOCATION = "showUserLocation";
+  private static final String ACTION_LIST_OFFLINE_REGIONS = "listOfflineRegions";
+  private static final String ACTION_CREATE_OFFLINE_REGION = "createOfflineRegion";
+  private static final String ACTION_DOWNLOAD_OFFLINE_REGION = "downloadOfflineRegion";
+  private static final String ACTION_PAUSE_OFFLINE_REGION = "pauseOfflineRegion";
+  private static final String ACTION_OFFLINE_REGION_STATUS = "offlineRegionStatus";
   private static final String ACTION_ADD_MARKERS = "addMarkers";
   private static final String ACTION_ADD_MARKER_CALLBACK = "addMarkerCallback";
   private static final String ACTION_ADD_POLYGON = "addPolygon";
   private static final String ACTION_ADD_GEOJSON = "addGeoJSON";
+  private static final String ACTION_ADD_SOURCE = "addSource";
+  private static final String ACTION_ADD_LAYER = "addLayer";
   private static final String ACTION_GET_ZOOMLEVEL = "getZoomLevel";
   private static final String ACTION_SET_ZOOMLEVEL = "setZoomLevel";
   private static final String ACTION_GET_CENTER = "getCenter";
@@ -61,386 +57,397 @@ public class Mapbox extends CordovaPlugin {
   private static final String ACTION_SET_TILT = "setTilt";
   private static final String ACTION_ANIMATE_CAMERA = "animateCamera";
 
-  public static MapView mapView;
-  private static float retinaFactor;
-  private String accessToken;
-  private CallbackContext callback;
-  private CallbackContext markerCallbackContext;
-
-  private boolean showUserLocation;
+  private MapboxManager mapboxManager;
 
   @Override
   public void initialize(CordovaInterface cordova, CordovaWebView webView) {
     super.initialize(cordova, webView);
-
-    DisplayMetrics metrics = new DisplayMetrics();
-    cordova.getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);
-    retinaFactor = metrics.density;
-
-    try {
-      int mapboxAccesstokenResourceId = cordova.getActivity().getResources().getIdentifier(MAPBOX_ACCESSTOKEN_RESOURCE_KEY, "string", cordova.getActivity().getPackageName());
-      accessToken = cordova.getActivity().getString(mapboxAccesstokenResourceId);
-    } catch (Resources.NotFoundException e) {
-      // we'll deal with this when the accessToken property is read, but for now let's dump the error:
-      e.printStackTrace();
-    }
+    this.mapboxManager = new MapboxManager(this.getAccessToken(), this.getRetinaFactor(), webView);
   }
 
   @Override
   public boolean execute(final String action, final CordovaArgs args, final CallbackContext callbackContext) throws JSONException {
+  Command command = Command.create(action, args, callbackContext);
+    return execute(command);
+  }
 
-    this.callback = callbackContext;
-
-    try {
-      if (ACTION_SHOW.equals(action)) {
-        final JSONObject options = args.getJSONObject(0);
-        final String style = getStyle(options.optString("style"));
-
-        final JSONObject margins = options.isNull("margins") ? null : options.getJSONObject("margins");
-        final int left = applyRetinaFactor(margins == null || margins.isNull("left") ? 0 : margins.getInt("left"));
-        final int right = applyRetinaFactor(margins == null || margins.isNull("right") ? 0 : margins.getInt("right"));
-        final int top = applyRetinaFactor(margins == null || margins.isNull("top") ? 0 : margins.getInt("top"));
-        final int bottom = applyRetinaFactor(margins == null || margins.isNull("bottom") ? 0 : margins.getInt("bottom"));
-
-        final JSONObject center = options.isNull("center") ? null : options.getJSONObject("center");
-
-        this.showUserLocation = !options.isNull("showUserLocation") && options.getBoolean("showUserLocation");
+  public boolean execute(Command command) throws JSONException {
+    final String action = command.getAction();
+    final CordovaArgs args = command.getArgs();
+    final CallbackContext callbackContext = command.getCallbackContext();
+
+    if (ACTION_CREATE_MAP.equals(action)) {
+      final JSONObject options = args.getJSONObject(0);
+      boolean showUserLocation = !options.isNull("showUserLocation") && options.getBoolean("showUserLocation");
+      if (!showUserLocation || requestPermission(command, COARSE_LOCATION, FINE_LOCATION)) {
+        final CallbackContext eventCallback = new CallbackContext(args.getString(1), this.webView);
+        this.createMap(options, eventCallback, callbackContext);
+      }
+    }
 
+    else if (ACTION_SHOW_USER_LOCATION.equals(action)) {
+      final long mapId = args.getLong(0);
+      final Map map = mapboxManager.getMap(mapId);
+      final boolean enabled = args.getBoolean(1);
+      if (requestPermission(command, COARSE_LOCATION, FINE_LOCATION)) {
         cordova.getActivity().runOnUiThread(new Runnable() {
           @Override
           public void run() {
-            if (accessToken == null) {
-              callbackContext.error(MAPBOX_ACCESSTOKEN_RESOURCE_KEY + " not set in strings.xml");
-              return;
-            }
-            mapView = new MapView(webView.getContext(), accessToken);
-
-            // need to do this to register a receiver which onPause later needs
-            mapView.onResume();
-            mapView.onCreate(null);
-
-            try {
-              mapView.setCompassEnabled(options.isNull("hideCompass") || !options.getBoolean("hideCompass"));
-              mapView.setRotateEnabled(options.isNull("disableRotation") || !options.getBoolean("disableRotation"));
-              mapView.setScrollEnabled(options.isNull("disableScroll") || !options.getBoolean("disableScroll"));
-              mapView.setZoomEnabled(options.isNull("disableZoom") || !options.getBoolean("disableZoom"));
-              mapView.setTiltEnabled(options.isNull("disableTilt") || !options.getBoolean("disableTilt"));
-
-              // placing these offscreen in case the user wants to hide them
-              if (!options.isNull("hideAttribution") && options.getBoolean("hideAttribution")) {
-                mapView.setAttributionMargins(-300, 0, 0, 0);
-              }
-              if (!options.isNull("hideLogo") && options.getBoolean("hideLogo")) {
-                mapView.setLogoMargins(-300, 0, 0, 0);
-              }
-
-              if (showUserLocation) {
-                showUserLocation();
-              }
-
-              Double zoom = options.isNull("zoomLevel") ? 10 : options.getDouble("zoomLevel");
-              float zoomLevel = zoom.floatValue();
-              if (center != null) {
-                final double lat = center.getDouble("lat");
-                final double lng = center.getDouble("lng");
-                mapView.setLatLng(new LatLngZoom(lat, lng, zoomLevel));
-              } else {
-                if (zoomLevel > 18.0) {
-                  zoomLevel = 18.0f;
-                }
-                mapView.setZoom(zoomLevel);
-              }
-
-              if (options.has("markers")) {
-                addMarkers(options.getJSONArray("markers"));
-              }
-            } catch (JSONException e) {
-              callbackContext.error(e.getMessage());
-              return;
-            }
-
-            mapView.setStyleUrl(style);
-
-            // position the mapView overlay
-            int webViewWidth = webView.getView().getWidth();
-            int webViewHeight = webView.getView().getHeight();
-            final FrameLayout layout = (FrameLayout) webView.getView().getParent();
-            FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(webViewWidth - left - right, webViewHeight - top - bottom);
-            params.setMargins(left, top, right, bottom);
-            mapView.setLayoutParams(params);
-
-            layout.addView(mapView);
+            map.showUserLocation(enabled);
             callbackContext.success();
           }
         });
+      }
+    }
 
-      } else if (ACTION_HIDE.equals(action)) {
-        if (mapView != null) {
-          cordova.getActivity().runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-              ViewGroup vg = (ViewGroup) mapView.getParent();
-              if (vg != null) {
-                vg.removeView(mapView);
-              }
-              callbackContext.success();
-            }
-          });
-        }
-
-      } else if (ACTION_GET_ZOOMLEVEL.equals(action)) {
-        if (mapView != null) {
-          cordova.getActivity().runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-              final double zoomLevel = mapView.getZoom();
-              callbackContext.success("" + zoomLevel);
-            }
-          });
-        }
+    else if (ACTION_JUMP_TO.equals(action)) {
+      final long mapId = args.getLong(0);
+      final Map map = mapboxManager.getMap(mapId);
+      final JSONObject options = args.getJSONObject(1);
 
-      } else if (ACTION_SET_ZOOMLEVEL.equals(action)) {
-        if (mapView != null) {
-          cordova.getActivity().runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-              try {
-                final JSONObject options = args.getJSONObject(0);
-                final double zoom = options.getDouble("level");
-                if (zoom >= 0 && zoom <= 20) {
-                  final boolean animated = !options.isNull("animated") && options.getBoolean("animated");
-                  mapView.setZoom(zoom, animated);
-                  callbackContext.success();
-                } else {
-                  callbackContext.error("invalid zoomlevel, use any double value from 0 to 20 (like 8.3)");
-                }
-              } catch (JSONException e) {
-                callbackContext.error(e.getMessage());
-              }
-            }
-          });
+      cordova.getActivity().runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+          try {
+            map.jumpTo(options);
+            callbackContext.success();
+          } catch (JSONException e) {
+            callbackContext.error(e.getMessage());
+          }
         }
+      });
+    }
 
-      } else if (ACTION_GET_CENTER.equals(action)) {
-        if (mapView != null) {
-          cordova.getActivity().runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-              final LatLng center = mapView.getLatLng();
-              Map<String, Double> result = new HashMap<String, Double>();
-              result.put("lat", center.getLatitude());
-              result.put("lng", center.getLongitude());
-              callbackContext.success(new JSONObject(result));
-            }
-          });
-        }
+    else if (ACTION_GET_CENTER.equals(action)) {
+      final long mapId = args.getLong(0);
+      final Map map = mapboxManager.getMap(mapId);
+      try {
+        callbackContext.success(map.getCenter());
+      } catch (JSONException e) {
+        callbackContext.error(e.getMessage());
+      }
+    }
 
-      } else if (ACTION_SET_CENTER.equals(action)) {
-        if (mapView != null) {
-          cordova.getActivity().runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-              try {
-                final JSONObject options = args.getJSONObject(0);
-                final boolean animated = !options.isNull("animated") && options.getBoolean("animated");
-                final double lat = options.getDouble("lat");
-                final double lng = options.getDouble("lng");
-                mapView.setLatLng(new LatLng(lat, lng), animated);
-                callbackContext.success();
-              } catch (JSONException e) {
-                callbackContext.error(e.getMessage());
-              }
-            }
-          });
-        }
+    else if (ACTION_SET_CENTER.equals(action)) {
+      final long mapId = args.getLong(0);
+      final Map map = mapboxManager.getMap(mapId);
+      final JSONArray center = args.getJSONArray(1);
+      try {
+        map.setCenter(center);
+        callbackContext.success();
+      } catch (JSONException e) {
+        callbackContext.error(e.getMessage());
+      }
+    }
 
-      } else if (ACTION_GET_TILT.equals(action)) {
-        if (mapView != null) {
-          cordova.getActivity().runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-              final double tilt = mapView.getTilt();
-              callbackContext.success("" + tilt);
-            }
-          });
-        }
+    else if (ACTION_GET_ZOOMLEVEL.equals(action)) {
+      final long mapId = args.getLong(0);
+      final Map map = mapboxManager.getMap(mapId);
+      callbackContext.success("" + map.getZoom());
+    }
 
-      } else if (ACTION_SET_TILT.equals(action)) {
-        if (mapView != null) {
-          cordova.getActivity().runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-              try {
-                final JSONObject options = args.getJSONObject(0);
-                mapView.setTilt(
-                    options.optDouble("pitch", 20),      // default 20
-                    options.optLong("duration", 5000)); // default 5s
-                callbackContext.success();
-              } catch (JSONException e) {
-                callbackContext.error(e.getMessage());
-              }
-            }
-          });
-        }
+    else if (ACTION_SET_ZOOMLEVEL.equals(action)) {
+      final long mapId = args.getLong(0);
+      final Map map = mapboxManager.getMap(mapId);
+      final double zoom = args.getDouble(1);
+      map.setZoom(zoom);
+      callbackContext.success();
+    }
 
-      } else if (ACTION_ANIMATE_CAMERA.equals(action)) {
-        if (mapView != null) {
-          cordova.getActivity().runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-              try {
-                // TODO check mandatory elements
-                final JSONObject options = args.getJSONObject(0);
-
-                final JSONObject target = options.getJSONObject("target");
-                final double lat = target.getDouble("lat");
-                final double lng = target.getDouble("lng");
-
-                final CameraPosition.Builder builder =
-                    new CameraPosition.Builder()
-                        .target(new LatLng(lat, lng));
-
-                if (options.has("bearing")) {
-                  builder.bearing(((Double)options.getDouble("bearing")).floatValue());
-                }
-                if (options.has("tilt")) {
-                  builder.tilt(((Double)options.getDouble("tilt")).floatValue());
-                }
-                if (options.has("zoomLevel")) {
-                  builder.zoom(((Double)options.getDouble("zoomLevel")).floatValue());
-                }
-
-                mapView.animateCamera(
-                    CameraUpdateFactory.newCameraPosition(builder.build()),
-                    (options.optInt("duration", 15)) * 1000, // default 15 seconds
-                    null);
-
-                callbackContext.success();
-              } catch (JSONException e) {
-                callbackContext.error(e.getMessage());
-              }
-            }
-          });
-        }
+    else if (ACTION_ADD_MARKERS.equals(action)) {
+      final long mapId = args.getLong(0);
+      final Map map = mapboxManager.getMap(mapId);
+      try {
+        map.addMarkers(args.getJSONArray(1));
+        callbackContext.success();
+      } catch (JSONException e) {
+        callbackContext.error(e.getMessage());
+      }
+    }
 
-      } else if (ACTION_ADD_POLYGON.equals(action)) {
-        cordova.getActivity().runOnUiThread(new Runnable() {
+    else if (ACTION_ADD_MARKER_CALLBACK.equals(action)) {
+      final long mapId = args.getLong(0);
+      final CallbackContext markerCallback = new CallbackContext(args.getString(1), this.webView);
+      final Map map = mapboxManager.getMap(mapId);
+      map.addMarkerListener(
+        new MapboxMap.OnInfoWindowClickListener() {
           @Override
-          public void run() {
+          public boolean onInfoWindowClick(Marker marker) {
             try {
-              final PolygonOptions polygon = new PolygonOptions();
-              final JSONObject options = args.getJSONObject(0);
-              final JSONArray points = options.getJSONArray("points");
-              for (int i = 0; i < points.length(); i++) {
-                final JSONObject marker = points.getJSONObject(i);
-                final double lat = marker.getDouble("lat");
-                final double lng = marker.getDouble("lng");
-                polygon.add(new LatLng(lat, lng));
-              }
-              mapView.addPolygon(polygon);
-
-              callbackContext.success();
+              JSONObject markerInfo = new JSONObject()
+                      .put("title", marker.getTitle())
+                      .put("subtitle", marker.getSnippet())
+                      .put("lat", marker.getPosition().getLatitude())
+                      .put("lng", marker.getPosition().getLongitude());
+              PluginResult result = new PluginResult(PluginResult.Status.OK, markerInfo);
+              result.setKeepCallback(true);
+              markerCallback.sendPluginResult(result);
+              return true;
             } catch (JSONException e) {
-              callbackContext.error(e.getMessage());
+              String message = "Error in callback of " + ACTION_ADD_MARKER_CALLBACK + ": " + e.getMessage();
+              markerCallback.error(message);
+              return false;
             }
           }
-        });
+        }
+      );
+      callbackContext.success();
+    }
 
-      } else if (ACTION_ADD_GEOJSON.equals(action)) {
-        cordova.getActivity().runOnUiThread(new Runnable() {
-          @Override
-          public void run() {
-            // TODO implement
+    else if (ACTION_ADD_SOURCE.equals(action)) {
+      final long mapId = args.getLong(0);
+      final String name = args.getString(1);
+      final JSONObject source = args.getJSONObject(2);
+      final Map map = mapboxManager.getMap(mapId);
+      try {
+        map.addSource(name, source);
+        callbackContext.success();
+      } catch (Exception e) {
+        callbackContext.error("Unable to add data source to map: " + e.getMessage());
+      }
+    }
+
+    else if (ACTION_ADD_LAYER.equals(action)) {
+      final long mapId = args.getLong(0);
+      final JSONObject layer = args.getJSONObject(1);
+      final Map map = mapboxManager.getMap(mapId);
+      cordova.getActivity().runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+          try {
+            map.addLayer(layer);
             callbackContext.success();
+          } catch (Exception e) {
+            callbackContext.error("Unable to add layer to map: " + e.getMessage());
           }
-        });
+        }
+      });
+    }
 
-      } else if (ACTION_ADD_MARKERS.equals(action)) {
-        cordova.getActivity().runOnUiThread(new Runnable() {
-          @Override
-          public void run() {
-            try {
-              addMarkers(args.getJSONArray(0));
-              callbackContext.success();
-            } catch (JSONException e) {
-              callbackContext.error(e.getMessage());
-            }
-          }
-        });
+    else if (ACTION_LIST_OFFLINE_REGIONS.equals(action)) {
+      this.listOfflineRegions(callbackContext);
+    }
 
-      } else if (ACTION_ADD_MARKER_CALLBACK.equals(action)) {
-        this.markerCallbackContext = callbackContext;
-        mapView.setOnInfoWindowClickListener(new MarkerClickListener());
+    else if (ACTION_CREATE_OFFLINE_REGION.equals(action)) {
+      final JSONObject options = args.getJSONObject(0);
+      final CallbackContext onProgress = new CallbackContext(args.getString(1), this.webView);
+      final CallbackContext onComplete = new CallbackContext(args.getString(2), this.webView);
 
-      } else {
-        return false;
-      }
-    } catch (Throwable t) {
-      t.printStackTrace();
-      callbackContext.error(t.getMessage());
+      this.createOfflineRegion(options, onProgress, onComplete, callbackContext);
     }
-    return true;
-  }
 
-  private void addMarkers(JSONArray markers) throws JSONException {
-    for (int i=0; i<markers.length(); i++) {
-      final JSONObject marker = markers.getJSONObject(i);
-      final MarkerOptions mo = new MarkerOptions();
-      mo.title(marker.isNull("title") ? null : marker.getString("title"));
-      mo.snippet(marker.isNull("subtitle") ? null : marker.getString("subtitle"));
-      mo.position(new LatLng(marker.getDouble("lat"), marker.getDouble("lng")));
-      mapView.addMarker(mo);
+    else if (ACTION_DOWNLOAD_OFFLINE_REGION.equals(action)) {
+      final long offlineRegionId = args.getLong(0);
+      final OfflineRegion region = this.mapboxManager.getOfflineRegion(offlineRegionId);
+      region.download();
+      callbackContext.success();
+    }
+
+    else if (ACTION_PAUSE_OFFLINE_REGION.equals(action)) {
+      final long offlineRegionId = args.getLong(0);
+      final OfflineRegion region = this.mapboxManager.getOfflineRegion(offlineRegionId);
+      region.pause();
+      callbackContext.success();
+    }
+
+    else if (ACTION_OFFLINE_REGION_STATUS.equals(action)) {
+      final long offlineRegionId = args.getLong(0);
+      final OfflineRegion region = this.mapboxManager.getOfflineRegion(offlineRegionId);
+
+      region.getStatus(new MapboxManager.OfflineRegionStatusCallback() {
+        @Override
+        public void onStatus(JSONObject status) {
+          callbackContext.success(status);
+        }
+
+        @Override
+        public void onError(String error) {
+          callbackContext.error(error);
+        }
+      });
+    }
+
+    else if (ACTION_GET_TILT.equals(action)) {
+//        if (mapView != null) {
+//          cordova.getActivity().runOnUiThread(new Runnable() {
+//            @Override
+//            public void run() {
+//              final double tilt = mapView.getTilt();
+//              callbackContext.success("" + tilt);
+//            }
+//          });
+//        }
+
+    } else if (ACTION_SET_TILT.equals(action)) {
+//        if (mapView != null) {
+//          cordova.getActivity().runOnUiThread(new Runnable() {
+//            @Override
+//            public void run() {
+//              try {
+//                final JSONObject options = args.getJSONObject(0);
+//                mapView.setTilt(
+//                    options.optDouble("pitch", 20),      // default 20
+//                    options.optLong("duration", 5000)); // default 5s
+//                callbackContext.success();
+//              } catch (JSONException e) {
+//                callbackContext.error(e.getMessage());
+//              }
+//            }
+//          });
+//        }
+
+    } else if (ACTION_ANIMATE_CAMERA.equals(action)) {
+//        if (mapView != null) {
+//          cordova.getActivity().runOnUiThread(new Runnable() {
+//            @Override
+//            public void run() {
+//              try {
+//                // TODO check mandatory elements
+//                final JSONObject options = args.getJSONObject(0);
+//
+//                final JSONObject target = options.getJSONObject("target");
+//                final double lat = target.getDouble("lat");
+//                final double lng = target.getDouble("lng");
+//
+//                final CameraPosition.Builder builder =
+//                    new CameraPosition.Builder()
+//                        .target(new LatLng(lat, lng));
+//
+//                if (options.has("bearing")) {
+//                  builder.bearing(((Double)options.getDouble("bearing")).floatValue());
+//                }
+//                if (options.has("tilt")) {
+//                  builder.tilt(((Double)options.getDouble("tilt")).floatValue());
+//                }
+//                if (options.has("zoomLevel")) {
+//                  builder.zoom(((Double)options.getDouble("zoomLevel")).floatValue());
+//                }
+//
+//                mapView.animateCamera(
+//                    CameraUpdateFactory.newCameraPosition(builder.build()),
+//                    (options.optInt("duration", 15)) * 1000, // default 15 seconds
+//                    null);
+//
+//                callbackContext.success();
+//              } catch (JSONException e) {
+//                callbackContext.error(e.getMessage());
+//              }
+//            }
+//          });
+//        }
+
+    } else if (ACTION_ADD_POLYGON.equals(action)) {
+//        cordova.getActivity().runOnUiThread(new Runnable() {
+//          @Override
+//          public void run() {
+//            try {
+//              final PolygonOptions polygon = new PolygonOptions();
+//              final JSONObject options = args.getJSONObject(0);
+//              final JSONArray points = options.getJSONArray("points");
+//              for (int i = 0; i < points.length(); i++) {
+//                final JSONObject marker = points.getJSONObject(i);
+//                final double lat = marker.getDouble("lat");
+//                final double lng = marker.getDouble("lng");
+//                polygon.add(new LatLng(lat, lng));
+//              }
+//              mapView.addPolygon(polygon);
+//
+//              callbackContext.success();
+//            } catch (JSONException e) {
+//              callbackContext.error(e.getMessage());
+//            }
+//          }
+//        });
+
+    } else if (ACTION_ADD_GEOJSON.equals(action)) {
+      cordova.getActivity().runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+          // TODO implement
+          callbackContext.success();
+        }
+      });
+
+    } else {
+      return false;
     }
+    return true;
   }
 
-  private class MarkerClickListener implements MapView.OnInfoWindowClickListener {
+  private void createMap(final JSONObject options, final CallbackContext eventCallback, final CallbackContext callback) {
+    cordova.getActivity().runOnUiThread(new Runnable() {
+      @Override
+      public void run() {
+        Map.MapEventListener eventListener = createEventListener(eventCallback);
+        mapboxManager.createMap(options, eventListener, callback);
+      }
+    });
+  }
 
-    @Override
-    public boolean onMarkerClick(@NonNull Marker marker) {
-      // callback
-      if (markerCallbackContext != null) {
-        final JSONObject json = new JSONObject();
+  private Map.MapEventListener createEventListener(final CallbackContext callback) {
+    return new Map.MapEventListener() {
+      @Override
+      public void onEvent(int code, JSONObject data) {
         try {
-          json.put("title", marker.getTitle());
-          json.put("subtitle", marker.getSnippet());
-          json.put("lat", marker.getPosition().getLatitude());
-          json.put("lng", marker.getPosition().getLongitude());
+          JSONObject event = new JSONObject()
+                  .put("code", code)
+                  .put("data", data);
+          PluginResult result = new PluginResult(PluginResult.Status.OK, event);
+          result.setKeepCallback(true);
+          callback.sendPluginResult(result);
         } catch (JSONException e) {
-          PluginResult pluginResult = new PluginResult(PluginResult.Status.ERROR,
-              "Error in callback of " + ACTION_ADD_MARKER_CALLBACK + ": " + e.getMessage());
-          pluginResult.setKeepCallback(true);
-          markerCallbackContext.sendPluginResult(pluginResult);
+          this.onError(e.getMessage());
         }
-        PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, json);
-        pluginResult.setKeepCallback(true);
-        markerCallbackContext.sendPluginResult(pluginResult);
-        return true;
       }
-      return false;
-    }
+
+      @Override
+      public void onError(String error) {
+        String message = "Error during map event: " + error;
+        PluginResult result = new PluginResult(PluginResult.Status.ERROR, message);
+        result.setKeepCallback(true);
+        callback.sendPluginResult(result);
+      }
+    };
   }
 
-  private static int applyRetinaFactor(int i) {
-    return (int) (i * retinaFactor);
+  public void listOfflineRegions(final CallbackContext callback) {
+    cordova.getActivity().runOnUiThread(new Runnable() {
+      @Override
+      public void run() {
+        mapboxManager.loadOfflineRegions(new MapboxManager.LoadOfflineRegionsCallback() {
+          @Override
+          public void onList(JSONArray offlineRegions) {
+            callback.success(offlineRegions);
+          }
+
+          @Override
+          public void onError(String error) {
+            String message = "Error loading offline regions: " + error;
+            callback.error(message);
+          }
+        });
+      }
+    });
   }
 
-  private static String getStyle(final String requested) {
-    if ("light".equalsIgnoreCase(requested)) {
-      return Style.LIGHT;
-    } else if ("dark".equalsIgnoreCase(requested)) {
-      return Style.DARK;
-    } else if ("emerald".equalsIgnoreCase(requested)) {
-      return Style.EMERALD;
-    } else if ("satellite".equalsIgnoreCase(requested)) {
-      return Style.SATELLITE;
-      // TODO not currently supported on Android
-//    } else if ("hybrid".equalsIgnoreCase(requested)) {
-//      return Style.HYBRID;
-    } else if ("streets".equalsIgnoreCase(requested)) {
-      return Style.MAPBOX_STREETS;
-    } else {
-      return requested;
-    }
+  public void createOfflineRegion(final JSONObject options, final CallbackContext onProgress, final CallbackContext onComplete, final CallbackContext callback) throws JSONException {
+    cordova.getActivity().runOnUiThread(new Runnable() {
+      @Override
+      public void run() {
+        mapboxManager.getOrCreateOfflineRegion(options, new MapboxManager.OfflineRegionLoadCallback() {
+          @Override
+          public void onLoad(OfflineRegion region) {
+            region.bindStatusCallbacks(onProgress, onComplete);
+            callback.success(region.getMetadata());
+          }
+
+          @Override
+          public void onError(String error) {
+            callback.error(error);
+          }
+        });
+      }
+    });
   }
 
   private boolean permissionGranted(String... types) {
@@ -455,47 +462,150 @@ private boolean permissionGranted(String... types) {
     return true;
   }
 
-  protected void showUserLocation() {
-    if (permissionGranted(COARSE_LOCATION, FINE_LOCATION)) {
-      //noinspection MissingPermission
-      mapView.setMyLocationEnabled(showUserLocation);
+  private boolean requestPermission(Command command, String... types) {
+    if (!permissionGranted(types)) {
+      int commandId = Command.save(command);
+      cordova.requestPermissions(this, commandId, types);
+      return false;
     } else {
-      requestPermission(COARSE_LOCATION, FINE_LOCATION);
+      return true;
     }
   }
 
-
-  private void requestPermission(String... types) {
-    ActivityCompat.requestPermissions(
-        this.cordova.getActivity(),
-        types,
-        LOCATION_REQ_CODE);
-  }
-
   // TODO
-  public void onRequestPermissionResult(int requestCode, String[] permissions, int[] grantResults) throws JSONException {
+  public void onRequestPermissionResult(int commandId, String[] permissions, int[] grantResults) throws JSONException {
     for (int r : grantResults) {
       if (r == PackageManager.PERMISSION_DENIED) {
-        this.callback.sendPluginResult(new PluginResult(PluginResult.Status.ERROR, PERMISSION_DENIED_ERROR));
+        Command.error(commandId, PERMISSION_DENIED_ERROR);
         return;
       }
     }
-    switch (requestCode) {
-      case LOCATION_REQ_CODE:
-        showUserLocation();
-        break;
+
+    Command.execute(this, commandId);
+  }
+
+  public void onResume(boolean multitasking) {
+    for (Map map : mapboxManager.maps()) {
+      map.getMapView().onResume();
     }
   }
 
+  @Override
   public void onPause(boolean multitasking) {
-    mapView.onPause();
+    for (Map map : mapboxManager.maps()) {
+      map.getMapView().onPause();
+    }
   }
 
-  public void onResume(boolean multitasking) {
-    mapView.onResume();
+  @Override
+  public void onDestroy() {
+    for (Map map : mapboxManager.maps()) {
+      map.getMapView().onDestroy();
+    }
   }
 
-  public void onDestroy() {
-    mapView.onDestroy();
+  private float getRetinaFactor() {
+    Activity activity = this.cordova.getActivity();
+    Resources res = activity.getResources();
+    DisplayMetrics metrics = res.getDisplayMetrics();
+    return metrics.density;
+  }
+
+  private String getAccessToken() {
+    Activity activity = cordova.getActivity();
+    Resources res = activity.getResources();
+    String packageName = activity.getPackageName();
+    int resourceId;
+    String accessToken;
+
+    try {
+      resourceId = res.getIdentifier(MAPBOX_ACCESSTOKEN_RESOURCE_KEY, "string", packageName);
+      accessToken = activity.getString(resourceId);
+    } catch (Resources.NotFoundException e) {
+      // we'll deal with this when the accessToken property is read, but for now let's dump the error:
+      e.printStackTrace();
+      throw e;
+    }
+
+    return accessToken;
+  }
+}
+
+class Command {
+  private static int ids = 0;
+
+  private static HashMap<Integer, Command> commands = new HashMap<Integer, Command>();
+
+  public static Command create(final String action, final CordovaArgs args, final CallbackContext callbackContext) {
+    return new Command(action, args, callbackContext);
+  }
+
+  public static int save(final String action, final CordovaArgs args, final CallbackContext callbackContext) {
+    return save(create(action, args, callbackContext));
+  }
+
+  public static int save(Command command) {
+    int id = command.getId();
+    commands.put(id, command);
+    return id;
+  }
+
+  public static void execute(Mapbox plugin, int id) throws JSONException {
+    Command command = commands.remove(id);
+    plugin.execute(command);
+  }
+
+  public static void error(final int id, final int errorCode) {
+    error(id, errorCode, null);
+  }
+
+  public static void error(final int id, final int errorCode, final String errorMessage) {
+    Command command = commands.remove(id);
+    CallbackContext callback = command.getCallbackContext();
+    JSONObject error = new JSONObject();
+    String message = "Error (" + errorCode + ")";
+
+    if (errorMessage != null) {
+      message += ": "  + errorMessage;
+    }
+
+    try {
+      error.put("code", id);
+      error.put("message", message);
+      callback.error(error);
+    } catch (JSONException e) {
+      callback.error(message);
+    }
+  }
+
+  private int id;
+
+  private String action;
+
+  private CordovaArgs args;
+
+  private CallbackContext callbackContext;
+
+  private Command(final String action, final CordovaArgs args, final CallbackContext callbackContext) {
+    this.id = ids++;
+    this.action = action;
+    this.args = args;
+    this.callbackContext = callbackContext;
+  }
+
+  public int getId() {
+    return id;
+  }
+
+  public String getAction() {
+    return action;
+  }
+
+  public CordovaArgs getArgs() {
+    return args;
+  }
+
+  public CallbackContext getCallbackContext() {
+    return callbackContext;
   }
 }
diff --git a/src/android/MapboxManager.java b/src/android/MapboxManager.java
new file mode 100644
index 0000000..61170af
--- /dev/null
+++ b/src/android/MapboxManager.java
@@ -0,0 +1,272 @@
+package com.telerik.plugins.mapbox;
+
+import android.widget.FrameLayout;
+
+import com.mapbox.mapboxsdk.constants.Style;
+import com.mapbox.mapboxsdk.geometry.LatLng;
+import com.mapbox.mapboxsdk.geometry.LatLngBounds;
+import com.mapbox.mapboxsdk.maps.MapView;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.MapboxMapOptions;
+import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
+import com.mapbox.mapboxsdk.offline.OfflineManager;
+import com.mapbox.mapboxsdk.offline.OfflineRegionDefinition;
+import com.mapbox.mapboxsdk.offline.OfflineTilePyramidRegionDefinition;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaWebView;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Collection;
+import java.util.HashMap;
+
+class MapboxManager {
+    public static String getStyle(final String requested) {
+        if ("light".equalsIgnoreCase(requested)) {
+            return Style.LIGHT;
+        } else if ("dark".equalsIgnoreCase(requested)) {
+            return Style.DARK;
+        } else if ("emerald".equalsIgnoreCase(requested)) {
+            return Style.EMERALD;
+        } else if ("satellite".equalsIgnoreCase(requested)) {
+            return Style.SATELLITE;
+            // TODO not currently supported on Android
+            //} else if ("hybrid".equalsIgnoreCase(requested)) {
+            //    return Style.HYBRID;
+        } else if ("streets".equalsIgnoreCase(requested)) {
+            return Style.MAPBOX_STREETS;
+        } else {
+            return requested;
+        }
+    }
+
+    private int ids = 0;
+
+    private String accessToken;
+
+    private Float density;
+
+    private CordovaWebView webView;
+
+    private OfflineManager offlineManager;
+
+    private static HashMap<Long, Map> maps = new HashMap<Long, Map>();
+
+    private HashMap<Long, OfflineRegion> regions = new HashMap<Long, OfflineRegion>();
+
+    public interface OfflineRegionStatusCallback {
+        void onStatus(JSONObject status);
+        void onError(String error);
+    }
+
+    public interface OfflineRegionLoadCallback {
+        void onLoad(OfflineRegion region);
+        void onError(String error);
+    }
+
+    public interface LoadOfflineRegionsCallback {
+        void onList(JSONArray regions);
+        void onError(String error);
+    }
+
+    public MapboxManager(String accessToken, Float screenDensity, CordovaWebView webView) {
+        this.accessToken = accessToken;
+        this.density = screenDensity;
+        this.webView = webView;
+        this.offlineManager = OfflineManager.getInstance(webView.getContext());
+        this.offlineManager.setAccessToken(accessToken);
+    }
+
+    public void createMap(final JSONObject options, Map.MapEventListener eventListener, final CallbackContext callback) {
+        try {
+            PositionInfo position = new PositionInfo(options.isNull("margins") ? null : options.getJSONObject("margins"), density);
+            MapView mapView = createMapView(Map.createMapboxMapOptions(options), position);
+
+            long id = ids++;
+            final Map map = new Map(id, eventListener, mapView);
+            mapView.getMapAsync(new OnMapReadyCallback() {
+                @Override
+                public void onMapReady(MapboxMap mMap) {
+                    try {
+                        map.setMapboxMap(mMap);
+                        map.setFeatureManager(new FeatureManager(webView.getContext(), mMap));
+
+                        if (options.has("markers")) {
+                            map.addMarkers(options.getJSONArray("markers"));
+                        }
+
+                        maps.put(map.getId(), map);
+
+                        JSONObject resp = new JSONObject();
+                        resp.put("id", map.getId());
+                        callback.success(resp);
+                    } catch (JSONException e) {
+                        removeMap(map.getId());
+                        callback.error("Failed to create map: " + e.getMessage());
+                    }
+                }
+            });
+        } catch (JSONException e) {
+            callback.error("Failed to create map: " + e.getMessage());
+        }
+    }
+
+    private MapView createMapView(MapboxMapOptions options, PositionInfo position) throws JSONException {
+        options.accessToken(accessToken);
+        MapView mapView = new MapView(this.webView.getContext(), options);
+
+        // need to do this to register a receiver which onPause later needs
+        mapView.onResume();
+        mapView.onCreate(null);
+
+        int webViewWidth = webView.getView().getWidth();
+        int webViewHeight = webView.getView().getHeight();
+        FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
+                webViewWidth - position.left - position.right,
+                webViewHeight - position.top - position.bottom
+        );
+
+        params.setMargins(position.left, position.top, position.right, position.bottom);
+        mapView.setLayoutParams(params);
+
+        final FrameLayout layout = (FrameLayout) webView.getView().getParent();
+        layout.addView(mapView);
+
+        return mapView;
+    }
+
+    public Collection<Map> maps() {
+        return maps.values();
+    }
+
+    public Map getMap(long id) {
+        return maps.get(id);
+    }
+
+    public void removeMap(long id) {
+        maps.remove(id);
+    }
+
+    public void loadOfflineRegions(final LoadOfflineRegionsCallback callback) {
+        this.offlineManager.listOfflineRegions(new OfflineManager.ListOfflineRegionsCallback() {
+            @Override
+            public void onList(com.mapbox.mapboxsdk.offline.OfflineRegion[] offlineRegions) {
+                try {
+                    JSONArray responses = new JSONArray();
+                    JSONObject response;
+                    OfflineRegion region;
+                    for (com.mapbox.mapboxsdk.offline.OfflineRegion offlineRegion : offlineRegions) {
+                        if (regions.containsKey(offlineRegion.getID())) {
+                            region = regions.get(offlineRegion.getID());
+                        } else {
+                            region = createOfflineRegion(offlineRegion);
+                        }
+                        response = region.getMetadata();
+                        responses.put(response);
+                    }
+                    callback.onList(responses);
+                } catch (JSONException e) {
+                    this.onError(e.getMessage());
+                } catch (UnsupportedEncodingException e) {
+                    this.onError(e.getMessage());
+                }
+            }
+
+            @Override
+            public void onError(String error) {
+                callback.onError(error);
+            }
+        });
+    }
+
+    public void getOrCreateOfflineRegion(final JSONObject options, final OfflineRegionLoadCallback callback) {
+        try {
+            if (options.has("id")) {
+                OfflineRegion region = getOfflineRegion(options.getLong("id"));
+                callback.onLoad(region);
+            } else {
+                JSONObject properties = options.getJSONObject(OfflineRegion.JSON_FIELD_PROPERTIES);
+                byte[] encodedMetadata = new JSONObject()
+                        .put(OfflineRegion.JSON_FIELD_PROPERTIES, properties)
+                        .toString()
+                        .getBytes(OfflineRegion.JSON_CHARSET);
+                OfflineRegionDefinition definition = this.createOfflineRegionDefinition(density, options);
+
+                offlineManager.createOfflineRegion(definition, encodedMetadata, new OfflineManager.CreateOfflineRegionCallback() {
+                    @Override
+                    public void onCreate(com.mapbox.mapboxsdk.offline.OfflineRegion offlineRegion) {
+                        try {
+                            OfflineRegion region = createOfflineRegion(offlineRegion);
+                            callback.onLoad(region);
+                        } catch (JSONException e) {
+                            this.onError(e.getMessage());
+                            removeOfflineRegion(offlineRegion.getID());
+                        } catch (UnsupportedEncodingException e) {
+                            this.onError(e.getMessage());
+                            removeOfflineRegion(offlineRegion.getID());
+                        }
+                    }
+
+                    @Override
+                    public void onError(String error) {
+                        callback.onError(error);
+                    }
+                });
+            }
+        } catch(JSONException e) {
+            callback.onError(e.getMessage());
+        } catch (UnsupportedEncodingException e) {
+            callback.onError(e.getMessage());
+        }
+    }
+
+    private OfflineRegion createOfflineRegion(com.mapbox.mapboxsdk.offline.OfflineRegion offlineRegion) throws JSONException, UnsupportedEncodingException {
+        OfflineRegion region = new OfflineRegion(offlineRegion);
+        regions.put(offlineRegion.getID(), region);
+        return region;
+    }
+
+    public OfflineRegion getOfflineRegion(long id) {
+        return regions.get(id);
+    }
+
+    public void removeOfflineRegion(long id) {
+        regions.remove(id);
+    }
+
+    private OfflineRegionDefinition createOfflineRegionDefinition(float retinaFactor, JSONObject options) throws JSONException {
+        String styleURL = MapboxManager.getStyle(options.getString("style"));
+        double minZoom = options.getDouble("minZoom");
+        double maxZoom = options.getDouble("maxZoom");
+        JSONObject boundsOptions = options.getJSONObject("bounds");
+        double north = boundsOptions.getDouble("north");
+        double east = boundsOptions.getDouble("east");
+        double south = boundsOptions.getDouble("south");
+        double west = boundsOptions.getDouble("west");
+
+        LatLngBounds bounds = new LatLngBounds.Builder()
+                .include(new LatLng(north, west))
+                .include(new LatLng(south, east))
+                .build();
+
+        return new OfflineTilePyramidRegionDefinition(styleURL, bounds, minZoom, maxZoom, retinaFactor);
+    }
+
+    private class PositionInfo {
+        int top = 0;
+        int right = 0;
+        int bottom = 0;
+        int left = 0;
+
+        public PositionInfo(JSONObject margins, float density) throws JSONException {
+            this.top = margins == null || margins.isNull("top") ? 0 : (int) (density * margins.getInt("top"));
+            this.right = margins == null || margins.isNull("right") ? 0 : (int) (density * margins.getInt("right"));
+            this.bottom = margins == null || margins.isNull("bottom") ? 0 : (int) (density * margins.getInt("bottom"));
+            this.left = margins == null || margins.isNull("left") ? 0 : (int) (density * margins.getInt("left"));
+        }
+    }
+}
diff --git a/src/android/OfflineRegion.java b/src/android/OfflineRegion.java
new file mode 100644
index 0000000..a486d4d
--- /dev/null
+++ b/src/android/OfflineRegion.java
@@ -0,0 +1,122 @@
+package com.telerik.plugins.mapbox;
+
+import android.util.Log;
+
+import com.mapbox.mapboxsdk.offline.OfflineRegionError;
+import com.mapbox.mapboxsdk.offline.OfflineRegionStatus;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.PluginResult;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.UnsupportedEncodingException;
+
+public class OfflineRegion {
+
+    public static final String LOG_TAG = "OfflineRegion";
+
+    public static final String JSON_CHARSET = "UTF-8";
+    public static final String JSON_FIELD_ID = "id";
+    public static final String JSON_FIELD_PROPERTIES = "properties";
+
+    private JSONObject metadata;
+
+    private com.mapbox.mapboxsdk.offline.OfflineRegion region;
+
+    protected OfflineRegion(com.mapbox.mapboxsdk.offline.OfflineRegion region) throws JSONException, UnsupportedEncodingException {
+        this.region = region;
+        byte[] encodedMetadata = region.getMetadata();
+        JSONObject metadata = new JSONObject(new String(encodedMetadata, JSON_CHARSET))
+                .put(JSON_FIELD_ID, this.getId());
+        this.metadata = metadata;
+    }
+
+    public Long getId() {
+        return this.region.getID();
+    }
+
+    public JSONObject getMetadata() {
+        return this.metadata;
+    }
+
+    public void getStatus(final MapboxManager.OfflineRegionStatusCallback statusCallback) {
+        this.region.getStatus(new com.mapbox.mapboxsdk.offline.OfflineRegion.OfflineRegionStatusCallback() {
+            @Override
+            public void onStatus(OfflineRegionStatus status) {
+                try {
+                    statusCallback.onStatus(statusToJSON(status));
+                } catch (JSONException e) {
+                    this.onError(e.getMessage());
+                }
+            }
+
+            @Override
+            public void onError(String error) {
+                statusCallback.onError(error);
+            }
+        });
+    }
+
+    public void download() {
+        this.region.setDownloadState(com.mapbox.mapboxsdk.offline.OfflineRegion.STATE_ACTIVE);
+    }
+
+    public void pause() {
+        this.region.setDownloadState(com.mapbox.mapboxsdk.offline.OfflineRegion.STATE_INACTIVE);
+    }
+
+    public void bindStatusCallbacks(final CallbackContext onProgress, final CallbackContext onComplete) {
+        this.region.setObserver(new com.mapbox.mapboxsdk.offline.OfflineRegion.OfflineRegionObserver() {
+            @Override
+            public void onStatusChanged(OfflineRegionStatus status) {
+                try {
+                    JSONObject progress = statusToJSON(status);
+                    PluginResult result = new PluginResult(PluginResult.Status.OK, progress);
+                    if (status.isComplete()) {
+                        onComplete.sendPluginResult(result);
+                    } else {
+                        result.setKeepCallback(true);
+                        onProgress.sendPluginResult(result);
+                    }
+                } catch (JSONException e) {
+                    this.onError(e.getMessage());
+                }
+            }
+
+            @Override
+            public void onError(OfflineRegionError error) {
+                String message = "OfflineRegionError: [" + error.getReason() + "] " + error.getMessage();
+                this.onError(message);
+            }
+
+            @Override
+            public void mapboxTileCountLimitExceeded(long limit) {
+                this.onError("Tile limit exceeded (limit: " + limit + ")");
+            }
+
+            private void onError(String error) {
+                Log.e(LOG_TAG, error);
+                PluginResult result = new PluginResult(PluginResult.Status.ERROR, error);
+                result.setKeepCallback(true);
+                onComplete.error(error);
+                pause();
+            }
+        });
+    }
+
+    private JSONObject statusToJSON(OfflineRegionStatus status) throws JSONException {
+        long completedCount = status.getCompletedResourceCount();
+        long requiredCount = status.getRequiredResourceCount();
+        double percentage = requiredCount >= 0 ? (100.0 * completedCount / requiredCount) : 0.0;
+        JSONObject jsonStatus = new JSONObject()
+            .put("completed", status.isComplete())
+            .put("downloading", status.getDownloadState() == com.mapbox.mapboxsdk.offline.OfflineRegion.STATE_ACTIVE)
+            .put("completedCount", completedCount)
+            .put("completedSize", status.getCompletedResourceSize())
+            .put("requiredCount", requiredCount)
+            .put("percentage", percentage);
+
+        return jsonStatus;
+    }
+}
diff --git a/src/android/mapbox.gradle b/src/android/mapbox.gradle
index af6df92..d2c694b 100644
--- a/src/android/mapbox.gradle
+++ b/src/android/mapbox.gradle
@@ -2,13 +2,12 @@ ext.cdvMinSdkVersion = 15
 
 repositories {
     mavenCentral()
-    maven { url "http://oss.sonatype.org/content/repositories/snapshots/" }
 }
 
-
 dependencies {
+    compile 'com.cocoahero.android:geojson:1.0.1@jar'
     compile 'com.android.support:appcompat-v7:23.0.1'
-    compile ('com.mapbox.mapboxsdk:mapbox-android-sdk:3.2.0@aar'){
+    compile ('com.mapbox.mapboxsdk:mapbox-android-sdk:4.0.0@aar'){
         transitive=true
     }
 }
diff --git a/www/Mapbox.js b/www/Mapbox.js
index 2360cd2..fecf072 100644
--- a/www/Mapbox.js
+++ b/www/Mapbox.js
@@ -1,64 +1,9 @@
-var exec = require("cordova/exec");
+var exec = require("cordova/exec"),
+    MapInstance = require("./map-instance"),
+    offline = require("./offline-region");
 
 module.exports = {
-  show: function (options, successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "show", [options]);
-  },
-
-  hide: function (options, successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "hide", [options]);
-  },
-
-  addMarkers: function (options, successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "addMarkers", [options]);
-  },
-
-  addMarkerCallback: function (callback) {
-    cordova.exec(callback, null, "Mapbox", "addMarkerCallback", []);
-  },
-
-  animateCamera: function (options, successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "animateCamera", [options]);
-  },
-
-  addGeoJSON: function (options, successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "addGeoJSON", [options]);
-  },
-
-  setCenter: function (options, successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "setCenter", [options]);
-  },
-
-  getCenter: function (successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "getCenter", []);
-  },
-
-  setTilt: function (options, successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "setTilt", [options]);
-  },
-
-  getTilt: function (successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "getTilt", []);
-  },
-
-  getZoomLevel: function (successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "getZoomLevel", []);
-  },
-
-  setZoomLevel: function (options, successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "setZoomLevel", [options]);
-  },
-
-  addPolygon: function (options, successCallback, errorCallback) {
-    cordova.exec(successCallback, errorCallback, "Mapbox", "addPolygon", [options]);
-  },
-
-  convertCoordinate: function(options, successCallback, errorCallback){
-    cordova.exec(successCallback, errorCallback, "Mapbox", "convertCoordinate", [options]);
-  },
-
-  convertPoint: function(options, successCallback, errorCallback){
-    cordova.exec(successCallback, errorCallback, "Mapbox", "convertPoint", [options]);
-  }
-
-};
\ No newline at end of file
+    Map: MapInstance,
+    createOfflineRegion: offline.createOfflineRegion,
+    listOfflineRegions: offline.listOfflineRegions
+};
diff --git a/www/events-mixin.js b/www/events-mixin.js
new file mode 100644
index 0000000..2ee5045
--- /dev/null
+++ b/www/events-mixin.js
@@ -0,0 +1,57 @@
+var Mixin = require('./mixin'),
+    channel = require("cordova/channel"),
+    channelIds = 0;
+
+module.exports = function (prefix, target) {
+    var _channelPrefix = prefix + "." + (channelIds++);
+
+    function _prefix(type) {
+        return _channelPrefix + "." + type;
+    }
+
+    return Mixin({
+        _channel: function (type, sticky) {
+            var t = _prefix(type);
+            if (!this._channels) {
+                this._channels = {};
+            }
+            if (sticky !== undefined) {
+                this._channels[t] = sticky ?
+                    channel.createSticky(t) :
+                    channel.create(t);
+            }
+            return this._channels[t];
+        },
+
+        createChannel: function (type) {
+            this._channel(type, false);
+        },
+
+        createStickyChannel: function (type) {
+            this._channel(type, true);
+        },
+
+        once: function (type, listener) {
+            var onEvent = function (e) {
+                    listener(e);
+                    this.off(type, onEvent);
+                };
+            this.on(type, onEvent.bind(this));
+        },
+
+        on: function (type, listener) {
+            this._channel(type).subscribe(listener);
+        },
+
+        off: function (type, listener) {
+            this._channel(type).unsubscribe(listener);
+        },
+
+        fire: function (type, e) {
+            if (!this._channel(type)) {
+                this.createChannel(type);
+            }
+            this._channel(type).fire(e);
+        }
+    })(target);
+};
diff --git a/www/map-events.js b/www/map-events.js
new file mode 100644
index 0000000..92e0076
--- /dev/null
+++ b/www/map-events.js
@@ -0,0 +1,33 @@
+var codes = {
+        CAMERACHANGE: 0,
+        FLING: 1,
+        INFOWINDOWCLICK: 2,
+        INFOWINDOWCLOSE: 3,
+        INFOWINDOWLONGCLICK: 4,
+        MAPCLICK: 5,
+        MAPLONGCLICK: 6,
+        MARKERCLICK: 7,
+        BEARINGTRACKINGMODECHANGE: 8,
+        LOCATIONCHANGE: 9,
+        LOCATIONTRACKINGMODECHANGE: 10,
+        ONSCROLL: 11,
+    },
+    events = {};
+
+events[codes.CAMERACHANGE] = {name: "camerachange"};
+events[codes.FLING] = {name: "fling"};
+events[codes.INFOWINDOWCLICK] = {name: "infowindowclick"};
+events[codes.INFOWINDOWCLOSE] = {name: "infowindowclose"};
+events[codes.INFOWINDOWLONGCLICK] = {name: "infowindowlongclick"};
+events[codes.MAPCLICK] = {name: "mapclick"};
+events[codes.MAPLONGCLICK] = {name: "maplongclick"};
+events[codes.MARKERCLICK] = {name: "markerclick"};
+events[codes.BEARINGTRACKINGMODECHANGE] = {name: "bearingtrackingmodechange"};
+events[codes.LOCATIONCHANGE] = {name: "locationchange"};
+events[codes.LOCATIONTRACKINGMODECHANGE] = {name: "locationtrackingmodechange"};
+events[codes.ONSCROLL] = {name: "onscroll"};
+
+module.exports = {
+    events: events,
+    codes: codes
+};
diff --git a/www/map-instance.js b/www/map-instance.js
new file mode 100644
index 0000000..dc6139f
--- /dev/null
+++ b/www/map-instance.js
@@ -0,0 +1,106 @@
+var exec = require("cordova/exec"),
+    MapboxPluginAPI = require("./mapbox-plugin-api-mixin"),
+    EventsMixin = require("./events-mixin"),
+    E = require("./map-events");
+
+function MapInstance(options) {
+    var onLoad = this._onLoad.bind(this),
+        onEvent = _onEvent.bind(this),
+        onError = _onError.bind(this);
+
+    this.createStickyChannel("load");
+    this._onEventId = this._registerCallback('onEvent', onEvent, onError);
+
+    exec(onLoad, onError, "Mapbox", "createMap", [options, this._onEventId]);
+
+    function _onEvent(e) {
+        var event = E.events[e.code];
+        switch (e.code) {
+            case E.codes.INFOWINDOWCLICK:
+            case E.codes.INFOWINDOWCLOSE:
+            case E.codes.INFOWINDOWLONGCLICK:
+            case E.codes.MARKERCLICK:
+                var marker = new Marker(e.data.id);
+                console.debug("Event recieved: " + event.name, marker);
+                return this.fire(event.name, marker);
+            default:
+                console.debug("Event recieved: " + event.name, e.data);
+                return this.fire(event.name, e.data);
+        }
+    }
+
+    function _onError(error) {
+        try {
+            this.prototype._error.call(this, error);
+        } catch (e) {
+            this.fire("error", e);
+        }
+    }
+}
+
+MapboxPluginAPI('MapInstance', MapInstance.prototype);
+EventsMixin('MapInstance', MapInstance.prototype);
+
+MapInstance.prototype.jumpTo = function (options, callback) {
+    return this._execAfterLoad(callback, "jumpTo", [options]);
+};
+
+MapInstance.prototype.setCenter = function (options, callback) {
+    return this._execAfterLoad(callback, "setCenter", [options]);
+};
+
+MapInstance.prototype.getCenter = function (callback) {
+    return this._execAfterLoad(callback, "getCenter");
+};
+
+MapInstance.prototype.addMarkers = function (options, callback) {
+    return this._execAfterLoad(callback, "addMarkers", [options]);
+};
+
+MapInstance.prototype.addMarkerCallback = function (markerCallback, callback) {
+    return this._execAfterLoad(callback, "addMarkerCallback", [markerCallback]);
+};
+
+MapInstance.prototype.setCenter = function (center, callback) {
+    return this._execAfterLoad(callback, "setCenter", [center]);
+};
+
+MapInstance.prototype.getCenter = function (callback) {
+    return this._execAfterLoad(callback, "getCenter");
+};
+
+MapInstance.prototype.getZoomLevel = function (callback) {
+    return this._execAfterLoad(callback, "getZoomLevel");
+};
+
+MapInstance.prototype.setZoomLevel = function (zoom, callback) {
+    return this._execAfterLoad(callback, "setZoomLevel", [zoom]);
+};
+
+MapInstance.prototype.showUserLocation = function (enabled, callback) {
+    return this._execAfterLoad(callback, "showUserLocation", [enabled]);
+};
+
+MapInstance.prototype.addSource = function (name, source, callback) {
+    return this._execAfterLoad(callback, "addSource", [name, source]);
+};
+
+MapInstance.prototype.addLayer = function (layer, callback) {
+    return this._execAfterLoad(callback, "addLayer", [layer]);
+};
+
+MapInstance.prototype._onLoad = function (resp) {
+    this._id = resp.id;
+    this.loaded = true;
+
+    this.fire("load", {map: this});
+};
+
+function Marker(id) {
+    this._id = id;
+}
+
+MapboxPluginAPI('Marker', Marker.prototype);
+EventsMixin('Marker', Marker.prototype);
+
+module.exports = MapInstance;
diff --git a/www/mapbox-plugin-api-mixin.js b/www/mapbox-plugin-api-mixin.js
new file mode 100644
index 0000000..46b38fd
--- /dev/null
+++ b/www/mapbox-plugin-api-mixin.js
@@ -0,0 +1,57 @@
+var cordova = require("cordova"),
+    exec = require("cordova/exec"),
+    Mixin = require('./mixin');
+
+module.exports = function (type, target) {
+    var _mapboxType = type;
+
+    return Mixin({
+        _registerCallback: function (name, success, fail) {
+            var callbackId = ["Mapbox", type, name, cordova.callbackId++].join('.');
+
+            success = success ||  function () { console.log(callbackId + "() success!", arguments); };
+            fail = fail ||  function () { console.log(callbackId + "() fail :(", arguments); };
+
+            cordova.callbacks[callbackId] = {success: success, fail: fail};
+            return callbackId;
+        },
+
+        _error: function (err) {
+            var error = new Error("MapboxPlugin error (" + _mapboxType + ":" + this._id + "): " + err);
+            console.warn("throwing MapboxPluginError: ", error);
+            throw error;
+        },
+
+        _execAfterLoad: function () {
+            var args = Array.prototype.slice.call(arguments),
+                once = this.once.bind(this),
+                onLoad = function () {
+                    return this._exec.apply(this, args);
+                }.bind(this);
+
+            return new Promise(function (resolve, reject) {
+                once('load', function (obj) {
+                    onLoad().then(resolve, reject);
+                });
+            });
+        },
+
+        _exec: function (callback, method, args) {
+            args = [this._id].concat(args || []);
+            callback = callback || function (err, response) {};
+            return new Promise(function (resolve, reject) {
+                exec(
+                    function onSuccess(response) {
+                        callback(null, response);
+                        resolve(response);
+                    },
+                    function onError(error) {
+                        callback(error);
+                        reject(error);
+                    },
+                    "Mapbox", method, args
+                );
+            });
+        }
+    })(target);
+};
diff --git a/www/mixin.js b/www/mixin.js
new file mode 100644
index 0000000..f4178e9
--- /dev/null
+++ b/www/mixin.js
@@ -0,0 +1,26 @@
+module.exports = Mixin;
+
+function Mixin(behaviour) {
+    return function(target) {
+        return assign(target, behaviour);
+    };
+}
+
+function assign(target) {
+    if (target === undefined || target === null) {
+        throw new TypeError('Cannot convert undefined or null to object');
+    }
+
+    var output = Object(target);
+    for (var index = 1; index < arguments.length; index++) {
+        var source = arguments[index];
+        if (source !== undefined && source !== null) {
+            for (var nextKey in source) {
+                if (source.hasOwnProperty(nextKey)) {
+                    output[nextKey] = source[nextKey];
+                }
+            }
+        }
+    }
+    return output;
+}
diff --git a/www/offline-region.js b/www/offline-region.js
new file mode 100644
index 0000000..10871f3
--- /dev/null
+++ b/www/offline-region.js
@@ -0,0 +1,137 @@
+var exec = require("cordova/exec"),
+    MapboxPluginAPI = require("./mapbox-plugin-api-mixin"),
+    EventsMixin = require("./events-mixin");
+
+var OFFLINE_REGIONS = {};
+
+function OfflineRegion(options) {
+    this._init();
+    this._properties = options.properties || {};
+
+    var args = [options, this._onProgressId, this._onCompleteId];
+    exec(this._onCreate, this._error, "Mapbox", "createOfflineRegion", args);
+}
+
+MapboxPluginAPI('OfflineRegion', OfflineRegion.prototype);
+EventsMixin('OfflineRegion', OfflineRegion.prototype);
+
+Object.defineProperty(OfflineRegion.prototype, "downloading", {
+    get: function () {
+        return this._downloading;
+    }
+});
+
+Object.defineProperty(OfflineRegion.prototype, "loaded", {
+    get: function () {
+        return this._loaded;
+    }
+});
+
+Object.defineProperty(OfflineRegion.prototype, "properties", {
+    get: function () {
+        return this._properties;
+    }
+});
+
+OfflineRegion.prototype._init = function () {
+    var onProgress = _onProgress.bind(this),
+        onComplete = _onComplete.bind(this),
+        onError = _onError.bind(this);
+
+    this._onProgressId = this._registerCallback('onProgress', onProgress);
+    this._onCompleteId = this._registerCallback('onComplete', onComplete, onError);
+    this._error = onError;
+    this._onCreate = this._onCreate.bind(this);
+
+    this._downloading = false;
+
+    this.createStickyChannel("load");
+    this.createChannel("progress");
+    this.createStickyChannel("complete");
+    this.createStickyChannel("error");
+
+    function _onProgress(progress) {
+        this.fire("progress", progress);
+    }
+
+    function _onComplete(resp) {
+        this._downloading = false;
+        this.fire("complete", resp);
+    }
+
+    function _onError(error) {
+        try {
+            this.prototype._error.call(this, error);
+        } catch (e) {
+            this.fire("error", e);
+        }
+    }
+};
+
+OfflineRegion.prototype._onCreate = function onCreate(response) {
+    this._id = response.id;
+    this._properties = response.properties;
+    this._loaded = true;
+    this.fire("load", this);
+
+    OFFLINE_REGIONS[this._id] = this;
+};
+
+OfflineRegion.prototype.download = function (callback) {
+    this._downloading = true;
+    return this._execAfterLoad(onSuccess, "downloadOfflineRegion");
+    function onSuccess(err) {
+        if (err) return (callback || this._error)(err);
+        console.debug("Mapbox OfflineRegion download started.");
+    }
+};
+
+OfflineRegion.prototype.pause = function (callback) {
+    this._downloading = false;
+    return this._execAfterLoad(onSuccess, "pauseOfflineRegion");
+    function onSuccess(err) {
+        if (err) return (callback || this._error)(err);
+        console.debug("Mapbox OfflineRegion download paused.");
+    }
+};
+
+OfflineRegion.prototype.getStatus = function (callback) {
+    return this._execAfterLoad(callback, "offlineRegionStatus");
+};
+
+function listOfflineRegions() {
+    return new Promise(function (resolve, reject) {
+        exec(resolve, reject, "Mapbox", "listOfflineRegions", []);
+    });
+}
+
+function createRegionFromResponse(response) {
+    return new Promise(function (resolve, reject) {
+        var region = OFFLINE_REGIONS[response.id] || new OfflineRegion(response);
+        region.once('load', resolve);
+    });
+}
+
+module.exports = {
+    createOfflineRegion: function (options) {
+        return new OfflineRegion(options);
+    },
+
+    listOfflineRegions: function (callback) {
+        callback = callback || function (err, response) {};
+
+        return listOfflineRegions()
+            .then(function (responses) {
+                return Promise.all(responses.map(createRegionFromResponse));
+            })
+            .then(function (regions) {
+                callback(null, regions);
+                return regions;
+            })
+            .catch(function (errorMessage) {
+                var error = "Error getting offline regions: " + errorMessage;
+                console.error(error);
+                callback(error);
+            });
+    }
+};