+
+ 
Map |
+
+var options = {
+ camera: {
+ target: {lat: ..., lng: ...},
+ zoom: 19
+ }
+};
+var map = plugin.google.maps.Map.getMap(mapDiv, options) |
+
+
+ 
Marker |
+
+var marker = map.addMarker({
+ position: {lat: ..., lng: ...},
+ title: "Hello Cordova Google Maps for iOS and Android",
+ snippet: "This plugin is awesome!"
+}) |
+
+
+ 
MarkerCluster |
+
+var markerCluster = map.addMarkerCluster({
+ //maxZoomLevel: 5,
+ boundsDraw: true,
+ markers: dummyData(),
+ icons: [
+ {min: 2, max: 100, url: "./img/blue.png", anchor: {x: 16, y: 16}},
+ {min: 100, max: 1000, url: "./img/yellow.png", anchor: {x: 16, y: 16}},
+ {min: 1000, max: 2000, url: "./img/purple.png", anchor: {x: 24, y: 24}},
+ {min: 2000, url: "./img/red.png",anchor: {x: 32,y: 32}}
+ ]
+}); |
+
+
+ 
HtmlInfoWindow |
+
+var html = "<img src='./House-icon.png' width='64' height='64' >" +
+ "<br>" +
+ "This is an example";
+htmlInfoWindow.setContent(html);
+htmlInfoWindow.open(marker);
+ |
+
+
+ 
Circle |
+
+var circle = map.addCircle({
+ 'center': {lat: ..., lng: ...},
+ 'radius': 300,
+ 'strokeColor' : '#AA00FF',
+ 'strokeWidth': 5,
+ 'fillColor' : '#880000'
+}); |
+
+
+ 
Polyline |
+
+var polyline = map.addPolyline({
+ points: AIR_PORTS,
+ 'color' : '#AA00FF',
+ 'width': 10,
+ 'geodesic': true
+}); |
+
+
+ 
Polygon |
+
+var polygon = map.addPolygon({
+ 'points': GORYOKAKU_POINTS,
+ 'strokeColor' : '#AA00FF',
+ 'strokeWidth': 5,
+ 'fillColor' : '#880000'
+}); |
+
+
+ 
GroundOverlay |
+
+var groundOverlay = map.addGroundOverlay({
+ 'url': "./newark_nj_1922.jpg",
+ 'bounds': [
+ {"lat": 40.712216, "lng": -74.22655},
+ {"lat": 40.773941, "lng": -74.12544}
+ ],
+ 'opacity': 0.5
+});
+ |
+
+
+ 
TileOverlay |
+
+var tileOverlay = map.addTileOverlay({
+ debug: true,
+ opacity: 0.75,
+ getTile: function(x, y, zoom) {
+ return "../images/map-for-free/" + zoom + "_" + x + "-" + y + ".gif"
+ }
+}); |
+
+
+ 
KmlOverlay |
+
+map.addKmlOverlay({
+ 'url': 'polygon.kml'
+}, function(kmlOverlay) { ... }); |
+
+
+ 
Geocoder |
+
+plugin.google.maps.Geocoder.geocode({
+ // US Capital cities
+ "address": [
+ "Montgomery, AL, USA", ... "Cheyenne, Wyoming, USA"
+ ]
+}, function(mvcArray) { ... }); |
+
+
+ 
poly utility |
+
+var GORYOKAKU_POINTS = [
+ {lat: 41.79883, lng: 140.75675},
+ ...
+ {lat: 41.79883, lng: 140.75673}
+]
+var contain = plugin.google.maps.geometry.poly.containsLocation(
+ position, GORYOKAKU_POINTS);
+marker.setIcon(contain ? "blue" : "red");
+ |
+
+
+ 
encode utility |
+
+var GORYOKAKU_POINTS = [
+ {lat: 41.79883, lng: 140.75675},
+ ...
+ {lat: 41.79883, lng: 140.75673}
+]
+var encodedPath = plugin.google.maps.geometry.
+ encoding.encodePath(GORYOKAKU_POINTS);
+ |
+
+
+ 
spherical utility |
+
+var heading = plugin.google.maps.geometry.spherical.computeHeading(
+ markerA.getPosition(), markerB.getPosition());
+label.innerText = "heading : " + heading.toFixed(0) + "°";
+ |
+
+
+ 
Location service |
+
+plugin.google.maps.LocationService.getMyLocation(function(result) {
+ alert(["Your current location:\n",
+ "latitude:" + location.latLng.lat.toFixed(3),
+ "longitude:" + location.latLng.lng.toFixed(3),
+ "speed:" + location.speed,
+ "time:" + location.time,
+ "bearing:" + location.bearing].join("\n"));
+});
+ |
+
+
+
+ 
StreetView |
+
+var div = document.getElementById("pano_canvas1");
+var panorama = plugin.google.maps.StreetView.getPanorama(div, {
+ camera: {
+ target: {lat: 42.345573, lng: -71.098326}
+ }
+}); |
+
+
+
+
+---------------------------------------------------------------------------------------------------------
+
+### What is the difference between this plugin and Google Maps JavaScript API v3?
+
+Google Maps JavaScript API v3 works on any platforms,
+but it does not work if device is **offline**.
+
+This plugin uses three different APIs:
+- Android : [Google Maps Android API](https://developers.google.com/maps/documentation/android/)
+- iOS : [Google Maps SDK for iOS](https://developers.google.com/maps/documentation/ios/)
+- Browser : [Google Maps JavaScript API v3](https://developers.google.com/maps/documentation/javascript/)
+
+In Android and iOS applications, this plugin displays native Google Maps views, which is **faster** than Google Maps JavaScript API v3.
+And it even works if the device is **offline**.
+
+In Browser platform, this plugin displays JS map views (Google Maps JavaScript API v3).
+It should work as PWA (progressive web application), but the device has to be **online**.
+
+In order to work for all platforms, this plugin provides **own API** instead of each original APIs.
+You can write your code `similar to` the Google Maps JavaScript API v3.
+
+**Feature comparison table**
+
+| | Google Maps JavaScript API v3 | Cordova-Plugin-GoogleMaps(Android,iOS)| Cordova-Plugin-GoogleMaps(Browser) |
+|----------------|-----------------------------------|---------------------------------------|---------------------------------------|
+|Rendering system| JavaScript + HTML | JavaScript + Native API's | JavaScript |
+|Offline map | Not possible | Possible (only your displayed area) | Not possible |
+|3D View | Not possible | Possible | Not possible |
+|Platform | All browsers | Android and iOS applications only | All browsers |
+|Tile image | Bitmap | Vector | Bitmap |
+
+**Class comparison table**
+
+| Google Maps JavaScript API v3 | Cordova-Plugin-GoogleMaps |
+|-----------------------------------|---------------------------------------|
+| google.maps.Map | Map |
+| google.maps.Marker | Marker |
+| google.maps.InfoWindow | Default InfoWindow, and HtmlInfoWindow|
+| google.maps.Circle | Circle |
+| google.maps.Rectangle | Polygon |
+| google.maps.Polyline | Polyline |
+| google.maps.Polygon | Polygon |
+| google.maps.GroundOverlay | GroundOverlay |
+| google.maps.ImageMapType | TileOverlay |
+| google.maps.MVCObject | BaseClass |
+| google.maps.MVCArray | BaseArrayClass |
+| google.maps.Geocoder | plugin.google.maps.geocoder |
+| google.maps.geometry.spherical | plugin.google.maps.geometry.spherical |
+| google.maps.geometry.encoding | plugin.google.maps.geometry.encoding |
+| google.maps.geometry.poly | plugin.google.maps.geometry.poly |
+| (not available) | MarkerCluster |
+| google.maps.KmlLayer | KmlOverlay |
+| (not available) | LocationService |
+| google.maps.StreetView | StreetView :sparkles: |
+| google.maps.Data | (not available) |
+| google.maps.DirectionsService | (not available) |
+| google.maps.DistanceMatrixService | (not available) |
+| google.maps.TransitLayer | (not available) |
+| google.maps.places.* | (not available) |
+| google.maps.visualization.* | (not available) |
+
+### How does this plugin work (Android, iOS)?
+
+This plugin generates native map views, and puts them **under the browser**.
+
+The map views are not HTML elements. This means that they are not a `` or anything HTML related.
+But you can specify the size and position of the map view using its containing `
`.
+
+This plugin changes the background to `transparent` in your application.
+Then the plugin detects your touch position, which is either meant for the `native map` or an `html element`
+(which can be on top of your map, or anywhere else on the screen).
+
+
+
+The benefit of this plugin is the ability to automatically detect which HTML elements are over the map or not.
+
+For instance, in the image below, say you tap on the header div (which is over the map view).
+The plugin will detect whether your tap is for the header div or for the map view and then pass the touch event appropriately.
+
+This means **you can use the native Google Maps views similar to HTML elements**.
+
+
+
+
+---------------------------------------------------------------------------------------------------------
+## Official Communities
+
+- Gitter : (managed by @Hirbod)
+
+ https://gitter.im/nightstomp/cordova-plugin-googlemaps
diff --git a/node_modules/cordova-plugin-googlemaps/build_test.sh b/node_modules/cordova-plugin-googlemaps/build_test.sh
new file mode 100644
index 0000000..cb36f67
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/build_test.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+DO_BUILD=0
+
+# If pull request, do it.
+echo "TRAVIS_EVENT_TYPE = ${TRAVIS_EVENT_TYPE}"
+if [[ ${TRAVIS_EVENT_TYPE} == "pull_request" ]]; then
+ DO_BUILD=1
+fi
+
+
+# If commit branch is master, do the build test
+echo "TRAVIS_BRANCH = ${TRAVIS_BRANCH}"
+if [[ ${TRAVIS_BRANCH} == "master" ]]; then
+ DO_BUILD=1
+fi
+
+if [ ${DO_BUILD} -eq 1 ]; then
+ cordova-paramedic --verbose --platform ${CORDOVA_PLATFORM} --justBuild --plugin ./tests;
+fi
+
+if [[ ${CORDOVA_PLATFORM} == "browser" ]]; then
+ npm run test
+fi
diff --git a/node_modules/cordova-plugin-googlemaps/images/api_key_restrictions.png b/node_modules/cordova-plugin-googlemaps/images/api_key_restrictions.png
new file mode 100644
index 0000000..bbdb4ed
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/api_key_restrictions.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/browser_demo.gif b/node_modules/cordova-plugin-googlemaps/images/browser_demo.gif
new file mode 100644
index 0000000..613f1ff
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/browser_demo.gif differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/circle.png b/node_modules/cordova-plugin-googlemaps/images/circle.png
new file mode 100644
index 0000000..1139967
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/circle.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/development_mode.png b/node_modules/cordova-plugin-googlemaps/images/development_mode.png
new file mode 100644
index 0000000..27502b1
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/development_mode.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/documentations.png b/node_modules/cordova-plugin-googlemaps/images/documentations.png
new file mode 100644
index 0000000..47a64ae
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/documentations.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/encode.png b/node_modules/cordova-plugin-googlemaps/images/encode.png
new file mode 100644
index 0000000..4c195bf
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/encode.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/geocoder.png b/node_modules/cordova-plugin-googlemaps/images/geocoder.png
new file mode 100644
index 0000000..56af079
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/geocoder.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/groundoverlay.png b/node_modules/cordova-plugin-googlemaps/images/groundoverlay.png
new file mode 100644
index 0000000..65b6a1f
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/groundoverlay.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/htmlInfoWindow.png b/node_modules/cordova-plugin-googlemaps/images/htmlInfoWindow.png
new file mode 100644
index 0000000..946548c
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/htmlInfoWindow.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/icon-android.png b/node_modules/cordova-plugin-googlemaps/images/icon-android.png
new file mode 100644
index 0000000..895e823
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/icon-android.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/icon-ios.png b/node_modules/cordova-plugin-googlemaps/images/icon-ios.png
new file mode 100644
index 0000000..c9d7a79
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/icon-ios.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/kmloverlay.png b/node_modules/cordova-plugin-googlemaps/images/kmloverlay.png
new file mode 100644
index 0000000..78abfb1
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/kmloverlay.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/locationService.png b/node_modules/cordova-plugin-googlemaps/images/locationService.png
new file mode 100644
index 0000000..1506b10
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/locationService.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/map.png b/node_modules/cordova-plugin-googlemaps/images/map.png
new file mode 100644
index 0000000..189f9cd
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/map.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/marker.png b/node_modules/cordova-plugin-googlemaps/images/marker.png
new file mode 100644
index 0000000..69038b7
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/marker.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/markercluster.png b/node_modules/cordova-plugin-googlemaps/images/markercluster.png
new file mode 100644
index 0000000..3bc9bb8
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/markercluster.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/modern_browsers.png b/node_modules/cordova-plugin-googlemaps/images/modern_browsers.png
new file mode 100644
index 0000000..cca0f7b
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/modern_browsers.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/poly.png b/node_modules/cordova-plugin-googlemaps/images/poly.png
new file mode 100644
index 0000000..8d004d5
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/poly.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/polygon.png b/node_modules/cordova-plugin-googlemaps/images/polygon.png
new file mode 100644
index 0000000..ca5106d
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/polygon.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/polyline.png b/node_modules/cordova-plugin-googlemaps/images/polyline.png
new file mode 100644
index 0000000..c5d586a
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/polyline.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/spherical.png b/node_modules/cordova-plugin-googlemaps/images/spherical.png
new file mode 100644
index 0000000..ad22cab
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/spherical.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/streetview.png b/node_modules/cordova-plugin-googlemaps/images/streetview.png
new file mode 100644
index 0000000..55ca48f
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/streetview.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/tileoverlay.png b/node_modules/cordova-plugin-googlemaps/images/tileoverlay.png
new file mode 100644
index 0000000..3ea80b3
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/tileoverlay.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/images/touch.png b/node_modules/cordova-plugin-googlemaps/images/touch.png
new file mode 100644
index 0000000..7ad9414
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/images/touch.png differ
diff --git a/node_modules/cordova-plugin-googlemaps/jest-cordova-resolver.js b/node_modules/cordova-plugin-googlemaps/jest-cordova-resolver.js
new file mode 100644
index 0000000..ed7abe6
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/jest-cordova-resolver.js
@@ -0,0 +1,22 @@
+var Resolver = require('jest-resolve');
+var path = require('path');
+var fs = require('fs');
+
+var pluginModuleRegex = /^cordova-plugin-googlemaps\.(.*)/;
+var pathBrowser = './src/browser';
+var pathWww = './www';
+
+module.exports = function(moduleId, options) {
+ if (pluginModuleRegex.test(moduleId)) {
+ var fileName = moduleId.match(pluginModuleRegex)[1] + '.js';
+ if (fs.existsSync(path.resolve(pathBrowser, fileName))) {
+ return path.resolve(pathBrowser, fileName);
+ }
+ if (fs.existsSync(path.resolve(pathWww, fileName))) {
+ return path.resolve(pathWww, fileName);
+ }
+
+ throw new Error(moduleId + 'could not be located');
+ }
+ return Resolver.findNodeModule(moduleId, options);
+};
diff --git a/node_modules/cordova-plugin-googlemaps/jest.config.js b/node_modules/cordova-plugin-googlemaps/jest.config.js
new file mode 100644
index 0000000..2b73ad9
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/jest.config.js
@@ -0,0 +1,9 @@
+module.exports = {
+ moduleNameMapper: {
+ '^cordova/(.*)$': '
/node_modules/cordova-js/src/common/$1',
+ },
+ resolver: './jest-cordova-resolver.js',
+ globals: {
+ cordova: {},
+ },
+};
diff --git a/node_modules/cordova-plugin-googlemaps/jsdoc.json b/node_modules/cordova-plugin-googlemaps/jsdoc.json
new file mode 100644
index 0000000..2e33718
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/jsdoc.json
@@ -0,0 +1,21 @@
+{
+ "tags": {
+ "allowUnknownTags": false
+ },
+ "source": {
+ "include": "www",
+ "includePattern": ".js$",
+ "excludePattern": "(node_modules/|docs|__test__)"
+ },
+ "opts": {
+ "template": "node_modules/docdash/",
+ "encoding": "utf8",
+ "destination": "docs/",
+ "recurse": true,
+ "verbose": true
+ },
+ "templates": {
+ "cleverLinks": false,
+ "monospaceLinks": false
+ }
+}
diff --git a/node_modules/cordova-plugin-googlemaps/package.json b/node_modules/cordova-plugin-googlemaps/package.json
new file mode 100644
index 0000000..bc6c54e
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/package.json
@@ -0,0 +1,65 @@
+{
+ "name": "cordova-plugin-googlemaps",
+ "version": "2.7.1",
+ "description": "Google Maps native SDK for Android and iOS, and Google Maps JavaScript API v3 for browser.",
+ "cordova": {
+ "id": "cordova-plugin-googlemaps",
+ "platforms": [
+ "android",
+ "ios",
+ "browser"
+ ]
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/mapsplugin/cordova-plugin-googlemaps.git"
+ },
+ "keywords": [
+ "google",
+ "maps",
+ "geo",
+ "google maps",
+ "ecosystem:cordova",
+ "cordova-android",
+ "cordova-ios",
+ "cordova-browser"
+ ],
+ "engines": [
+ {
+ "name": "cordova-android",
+ "version": ">=5.1.0"
+ },
+ {
+ "name": "cordova-ios",
+ "version": ">=5.1.1"
+ },
+ {
+ "name": "apple-xcode",
+ "version": ">=10.0.0"
+ },
+ {
+ "name": "apple-ios",
+ "version": ">=10.0.0"
+ }
+ ],
+ "scripts": {
+ "test": "jest && npm run eslint",
+ "jest": "jest",
+ "test:watch": "jest --watch",
+ "eslint": "node node_modules/eslint/bin/eslint www src"
+ },
+ "author": "Masashi Katsumata, Hirbod Mirjavadi",
+ "license": "Apache-2.0",
+ "bugs": {
+ "url": "https://github.com/mapsplugin/cordova-plugin-googlemaps/issues"
+ },
+ "homepage": "https://github.com/mapsplugin/cordova-plugin-googlemaps",
+ "devDependencies": {
+ "cordova-js": "^4.2.4",
+ "eslint": "^5.7.0",
+ "jest": "^23.6.0"
+ },
+ "dependencies": {
+ "cordova-common": "^3.1.0"
+ }
+}
diff --git a/node_modules/cordova-plugin-googlemaps/plugin.xml b/node_modules/cordova-plugin-googlemaps/plugin.xml
new file mode 100644
index 0000000..1a2c801
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/plugin.xml
@@ -0,0 +1,527 @@
+
+
+ cordova-plugin-googlemaps
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ You can display native Google Maps views in cordova application. Native Google Maps view is faster, powerful, and more friendly for mobile applications. You can control the native Google Maps view through this plugin API.
+
+ This plugin works in browser application as well. One code for Android, iOS, and browsers!
+
+ https://github.com/mapsplugin/cordova-plugin-googlemaps.git
+ https://github.com/mapsplugin/cordova-plugin-googlemaps/issues
+ Masashi Katsumata, Hirbod
+
+ Apache-2.0
+
+ google,maps,geo
+
+
+
+
+
+
+
+
+
+
+
+ Official document https://github.com/mapsplugin/cordova-plugin-googlemaps-doc/blob/master/v2.6.0/README.md Please consider to buy a beer for us 🍺 https://github.com/mapsplugin/cordova-plugin-googlemaps#buy-us-a-beer
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Official document https://github.com/mapsplugin/cordova-plugin-googlemaps-doc/blob/master/v2.6.0/README.md Please consider to buy a beer for us 🍺 https://github.com/mapsplugin/cordova-plugin-googlemaps#buy-us-a-beer
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ $LOCATION_WHEN_IN_USE_DESCRIPTION
+
+
+
+ $LOCATION_ALWAYS_USAGE_DESCRIPTION
+
+
+
+
+ googlechromes
+ comgooglemaps
+
+
+
+
+
+
+ CFBundleTypeRole
+ Editor
+ CFBundleURLName
+ $PACKAGE_NAME
+ CFBundleURLSchemes
+
+ $PACKAGE_NAME
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Official document https://github.com/mapsplugin/cordova-plugin-googlemaps-doc/blob/master/v2.6.0/README.md Please consider to buy a beer for us 🍺 https://github.com/mapsplugin/cordova-plugin-googlemaps#buy-us-a-beer
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/node_modules/cordova-plugin-googlemaps/pull_request_template.md b/node_modules/cordova-plugin-googlemaps/pull_request_template.md
new file mode 100644
index 0000000..7361202
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/pull_request_template.md
@@ -0,0 +1,9 @@
+# Pull request guide
+
+Thank you for considering to improve this cordova-plugin-googlemaps.
+
+When you create a pull request, please make it to **multiple_maps** branch instead of master branch.
+
+Because **the multiple_maps branch is edge version**.
+
+Thank you for your understanding.
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/frameworks/pgm-custom.gradle b/node_modules/cordova-plugin-googlemaps/src/android/frameworks/pgm-custom.gradle
new file mode 100644
index 0000000..0144d22
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/frameworks/pgm-custom.gradle
@@ -0,0 +1,106 @@
+def searchFileInParents(target) {
+ def searchPath = target
+ for (int i = 0; i < 8; i++) {
+ println(searchPath)
+ def targetFile = file(searchPath)
+ if(!targetFile.canRead()) {
+ searchPath = '../' + searchPath;
+ } else {
+ return targetFile;
+ }
+ }
+ return null;
+}
+
+android {
+ // #1. Find (project)/config.xml file,
+ // because ionic capacitor does not copy nodes
+ def configXmlFile = searchFileInParents("config.xml")
+
+ if (configXmlFile == null) {
+ // #2. Find (project)/app/src/main/res/xml/config.xml file,
+ // cordova should copy to this file
+ configXmlFile = searchFileInParents("app/src/main/res/xml/config.xml")
+ }
+
+ if (configXmlFile == null) {
+ throw new GradleException("Can not find config.xml file.")
+ }
+
+ // parse xml file
+ def widget = new XmlParser().parse(configXmlFile)
+ if (widget.preference == null) {
+ throw new GradleException("widget is null.")
+ }
+ if (widget.preference.size() == 0) {
+ throw new GradleException("Please add '' to the config.xml file.")
+ }
+ println("preference = " + widget.preference.size())
+ Properties props = new Properties()
+ def isKeyFound = 0
+ def useBetaSdk = 0
+ props.setProperty("GOOGLE_MAPS_PLAY_SERVICES_VERSION", "16.0.0");
+ props.setProperty("ANDROID_SUPPORT_V4_VERSION", "27.1.1");
+ props.setProperty("GOOGLE_MAPS_ANDROID_SDK", "");
+
+ widget.preference.each { pref ->
+ def name = pref.attributes().name
+ def value = pref.attributes().value
+ println("name = " + name);
+ if (name == "GOOGLE_MAPS_ANDROID_API_KEY") {
+ isKeyFound = 1
+ props.setProperty(name, value)
+ }
+ if (name == "GOOGLE_MAPS_PLAY_SERVICES_VERSION" ||
+ name == "ANDROID_SUPPORT_V4_VERSION") {
+ props.setProperty(name, value)
+ }
+ if (name == "GOOGLE_MAPS_ANDROID_SDK") {
+ useBetaSdk = 1
+ props.setProperty("GOOGLE_MAPS_ANDROID_SDK", value)
+ }
+ }
+
+
+ if (isKeyFound == 0) {
+ throw new GradleException("Please add '' to the config.xml file.")
+ }
+
+ if (useBetaSdk == 1) {
+ def libsDirPath = System.getProperty("user.dir")
+ def libsDir = new File("${libsDirPath}/libs/")
+ if (!libsDir.exists()) {
+ libsDir.mkdirs()
+ }
+
+ def mapsSDK = props.getProperty("GOOGLE_MAPS_ANDROID_SDK")
+ def f = new File("${libsDir.absolutePath}/${mapsSDK}.aar")
+ println("---->lib = " + f.absolutePath);
+ if (!f.exists()) {
+ new URL("https://dl.google.com/dl/geosdk/${mapsSDK}.aar").withInputStream{ i -> f.withOutputStream{ it << i }}
+ }
+ dependencies {
+ implementation name: mapsSDK, ext:'aar'
+ }
+ }
+
+ def PLAY_SERVICES_VERSION = props.get("GOOGLE_MAPS_PLAY_SERVICES_VERSION")
+ def ANDROID_SUPPORT_V4_VERSION = props.get("ANDROID_SUPPORT_V4_VERSION")
+ println("---->PLAY_SERVICES_VERSION = ${PLAY_SERVICES_VERSION}")
+ println("---->ANDROID_SUPPORT_V4_VERSION = ${ANDROID_SUPPORT_V4_VERSION}")
+ dependencies {
+ implementation "com.google.android.gms:play-services-maps:${PLAY_SERVICES_VERSION}"
+ implementation "com.google.android.gms:play-services-location:${PLAY_SERVICES_VERSION}"
+ implementation "com.android.support:support-core-utils:${ANDROID_SUPPORT_V4_VERSION}"
+ }
+
+
+ buildTypes {
+ debug {
+ manifestPlaceholders.GOOGLE_MAPS_ANDROID_API_KEY = props.getProperty("GOOGLE_MAPS_ANDROID_API_KEY")
+ }
+ release {
+ manifestPlaceholders.GOOGLE_MAPS_ANDROID_API_KEY = props.getProperty("GOOGLE_MAPS_ANDROID_API_KEY")
+ }
+ }
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/frameworks/tbxml-android.aar b/node_modules/cordova-plugin-googlemaps/src/android/frameworks/tbxml-android.aar
new file mode 100644
index 0000000..121a869
Binary files /dev/null and b/node_modules/cordova-plugin-googlemaps/src/android/frameworks/tbxml-android.aar differ
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/frameworks/tbxml-android.gradle b/node_modules/cordova-plugin-googlemaps/src/android/frameworks/tbxml-android.gradle
new file mode 100644
index 0000000..d329088
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/frameworks/tbxml-android.gradle
@@ -0,0 +1,22 @@
+repositories {
+ maven { url 'https://maven.google.com' }
+ mavenCentral()
+ jcenter()
+ def libsDirPath = System.getProperty("user.dir")
+ flatDir{
+ dirs 'src/main/libs', 'libs', "${libsDirPath}/libs"
+ }
+}
+
+dependencies {
+ implementation(name:'tbxml-android', ext:'aar')
+}
+
+android {
+ compileSdkVersion 26
+
+ packagingOptions {
+ exclude 'README'
+ exclude 'LICENSE'
+ }
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/AsyncLoadImage.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/AsyncLoadImage.java
new file mode 100644
index 0000000..16e0bb0
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/AsyncLoadImage.java
@@ -0,0 +1,576 @@
+package plugin.google.maps;
+
+import android.content.res.AssetManager;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.Bitmap.Config;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.os.AsyncTask;
+import android.util.Log;
+
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaResourceApi;
+import org.apache.cordova.CordovaWebView;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+public class AsyncLoadImage extends AsyncTask {
+ private AsyncLoadImageInterface callback;
+ private float density = Resources.getSystem().getDisplayMetrics().density;
+ private AsyncLoadImageOptions mOptions;
+ private String userAgent;
+ private String currentPageUrl;
+
+ // Get max available VM memory, exceeding this amount will throw an
+ // OutOfMemory exception.
+ static int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
+ // Use 1/8th of the available memory for this memory cache.
+ public static BitmapCache mIconCache = new BitmapCache(maxMemory / 8);
+
+ private final String TAG = "AsyncLoadImage";
+ private CordovaWebView webView;
+ private CordovaInterface cordova;
+
+ public static class AsyncLoadImageOptions {
+ String url;
+ int width;
+ int height;
+ boolean noCaching;
+ }
+
+ public static class AsyncLoadImageResult {
+ Bitmap image;
+ boolean cacheHit;
+ String cacheKey;
+ }
+
+ public AsyncLoadImage(CordovaInterface cordova, CordovaWebView webView, AsyncLoadImageOptions options, AsyncLoadImageInterface callback) {
+ this.callback = callback;
+ this.mOptions = options;
+ this.webView = webView;
+ this.cordova = cordova;
+ }
+
+ public static String getCacheKey(String url, int width, int height) {
+ if (url == null) {
+ return null;
+ }
+ try {
+ return getCacheKey(new URL(url), width, height);
+ } catch (MalformedURLException e) {
+ return url.hashCode() + "/" + width + "x" + height;
+ }
+ }
+ public static String getCacheKey(URL url, int width, int height) {
+ return url.hashCode() + "/" + width + "x" + height;
+ }
+
+ public static void addBitmapToMemoryCache(String key, Bitmap image) {
+ if (getBitmapFromMemCache(key) == null) {
+ mIconCache.put(key, image.copy(image.getConfig(), true));
+ }
+ }
+
+ public static void removeBitmapFromMemCahce(String key) {
+ Bitmap image = mIconCache.remove(key);
+ if (image == null || image.isRecycled()) {
+ return;
+ }
+ image.recycle();
+ }
+
+ public static Bitmap getBitmapFromMemCache(String key) {
+ Bitmap image = mIconCache.get(key);
+ if (image == null || image.isRecycled()) {
+ return null;
+ }
+
+ return image.copy(image.getConfig(), true);
+ }
+
+
+ @Override
+ protected void onCancelled(AsyncLoadImageResult result) {
+ super.onCancelled(result);
+ if (result == null) {
+ return;
+ }
+
+ if (!result.image.isRecycled()) {
+ result.image.recycle();
+ }
+ result.image = null;
+ }
+
+ @Override
+ protected void onPreExecute() {
+ super.onPreExecute();
+
+ //----------------------------------------------------------------
+ // If icon url contains "cdvfile://", convert to physical path.
+ //----------------------------------------------------------------
+ if (mOptions.url.indexOf("cdvfile://") == 0) {
+ CordovaResourceApi resourceApi = webView.getResourceApi();
+ mOptions.url = PluginUtil.getAbsolutePathFromCDVFilePath(resourceApi, mOptions.url);
+ }
+
+ String currentPage = webView.getUrl();
+ if (currentPage == null) {
+ // Maybe someone close the map page.
+ this.cancel(true);
+ return;
+ }
+ currentPage = currentPage.replaceAll("#.*$", "");
+ currentPage = currentPage.replaceAll("\\?.*$", "");
+ currentPage = currentPage.replaceAll("[^\\/]*$", "");
+ this.currentPageUrl = currentPage;
+
+ //Log.d(TAG, "-->currentPageUrl = " + this.currentPageUrl);
+
+ //View browserView = webView.getView();
+ //String browserViewName = browserView.getClass().getName();
+ this.userAgent = "Mozilla";
+
+ /*
+ if("org.xwalk.core.XWalkView".equals(browserViewName) ||
+ "org.crosswalk.engine.XWalkCordovaView".equals(browserViewName)) {
+
+ CordovaPreferences preferences = webView.getPreferences();
+ // Set xwalk webview settings by Cordova preferences.
+ String xwalkUserAgent = preferences == null ? "" : preferences.getString("xwalkUserAgent", "");
+ if (!xwalkUserAgent.isEmpty()) {
+ this.userAgent = xwalkUserAgent;
+ }
+
+ String appendUserAgent = preferences.getString("AppendUserAgent", "");
+ if (!appendUserAgent.isEmpty()) {
+ this.userAgent = this.userAgent + " " + appendUserAgent;
+ }
+ if ("".equals(this.userAgent)) {
+ this.userAgent = "Mozilla";
+ }
+ } else {
+ this.userAgent = ((WebView) webView.getEngine().getView()).getSettings().getUserAgentString();
+ }
+ */
+
+ }
+
+ protected AsyncLoadImageResult doInBackground(Void... params) {
+
+ int mWidth = mOptions.width;
+ int mHeight = mOptions.height;
+ String iconUrl = mOptions.url;
+ String orgIconUrl = iconUrl;
+ Bitmap image = null;
+
+ if (iconUrl == null) {
+ return null;
+ }
+
+ String cacheKey = null;
+ cacheKey = getCacheKey(orgIconUrl, mWidth, mHeight);
+
+ image = getBitmapFromMemCache(cacheKey);
+ if (image != null) {
+ AsyncLoadImageResult result = new AsyncLoadImageResult();
+ result.image = image;
+ result.cacheHit = true;
+ result.cacheKey = cacheKey;
+ return result;
+ }
+
+// Log.d(TAG, String.format("---->iconURL = %s", iconUrl));
+ //--------------------------------
+ // Load image from local path
+ //--------------------------------
+ if (!iconUrl.startsWith("data:image")) {
+
+ if (iconUrl.startsWith("http://localhost") ||
+ iconUrl.startsWith("http://127.0.0.1")) {
+// Log.d(TAG, String.format("---->(201)iconURL = %s", iconUrl));
+ if (iconUrl.contains("://")) {
+ iconUrl = iconUrl.replaceAll("http://.+?/", "file:///android_asset/www/");
+ } else {
+ // Avoid WebViewLocalServer (because can not make a connection for some reason)
+ iconUrl = "file:///android_asset/www/".concat(iconUrl);
+ }
+ }
+
+ if (!iconUrl.contains("://") &&
+ !iconUrl.startsWith("/") &&
+ !iconUrl.startsWith("www/") &&
+ !iconUrl.startsWith("data:image") &&
+ !iconUrl.startsWith("./") &&
+ !iconUrl.startsWith("../")) {
+ iconUrl = "./" + iconUrl;
+ //Log.d(TAG, "--> iconUrl = " + iconUrl);
+ }
+
+ if (iconUrl.startsWith("./") || iconUrl.startsWith("../")) {
+ iconUrl = iconUrl.replace("(\\.\\/)+", "./");
+ String currentPage = this.currentPageUrl;
+ currentPage = currentPage.replaceAll("[^\\/]*$", "");
+ currentPage = currentPage.replaceAll("#.*$", "");
+ currentPage = currentPage.replaceAll("\\/[^\\/]+\\.[^\\/]+$", "");
+ if (!currentPage.endsWith("/")) {
+ currentPage = currentPage + "/";
+ }
+ iconUrl = currentPage + iconUrl;
+ iconUrl = iconUrl.replaceAll("(\\/\\.\\/+)+", "/");
+ //Log.d(TAG, "--> iconUrl = " + iconUrl);
+ }
+
+ if (iconUrl.indexOf("file://") == 0 &&
+ !iconUrl.contains("file:///android_asset/")) {
+ iconUrl = iconUrl.replace("file://", "");
+ } else {
+ //Log.d(TAG, "--> iconUrl = " + iconUrl);
+
+// if (iconUrl.indexOf("file:///android_asset/") == 0) {
+// iconUrl = iconUrl.replace("file:///android_asset/", "");
+// }
+
+ //Log.d(TAG, "iconUrl(222) = " + iconUrl);
+ if (iconUrl.contains("./")) {
+ try {
+ boolean isAbsolutePath = iconUrl.startsWith("/");
+ File relativePath = new File(iconUrl);
+ iconUrl = relativePath.getCanonicalPath();
+ //Log.d(TAG, "iconUrl = " + iconUrl);
+ if (!isAbsolutePath) {
+ iconUrl = iconUrl.substring(1);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ }
+
+ cacheKey = getCacheKey(iconUrl, mWidth, mHeight);
+
+ image = getBitmapFromMemCache(cacheKey);
+ if (image != null) {
+ AsyncLoadImageResult result = new AsyncLoadImageResult();
+ result.image = image;
+ result.cacheHit = true;
+ result.cacheKey = cacheKey;
+ return result;
+ }
+
+ cacheKey = getCacheKey(orgIconUrl, mWidth, mHeight);
+
+ if (iconUrl.indexOf("http") == 0) {
+ //--------------------------------
+ // Load image from the Internet
+ //--------------------------------
+ try {
+ URL url = new URL(iconUrl);
+
+ boolean redirect = true;
+ HttpURLConnection http = null;
+ String cookies = null;
+ int redirectCnt = 0;
+ while(redirect && redirectCnt < 10) {
+ redirect = false;
+ http = (HttpURLConnection)url.openConnection();
+ http.setRequestMethod("GET");
+ if (cookies != null) {
+ http.setRequestProperty("Cookie", cookies);
+ }
+ http.addRequestProperty("Accept-Language", "en-US,en;q=0.8");
+ http.addRequestProperty("User-Agent", this.userAgent);
+ http.setInstanceFollowRedirects(true);
+ HttpURLConnection.setFollowRedirects(true);
+
+ // normally, 3xx is redirect
+ try {
+ int status = http.getResponseCode();
+ if (status != HttpURLConnection.HTTP_OK) {
+ if (status == HttpURLConnection.HTTP_MOVED_TEMP
+ || status == HttpURLConnection.HTTP_MOVED_PERM
+ || status == HttpURLConnection.HTTP_SEE_OTHER)
+ redirect = true;
+ }
+ if (redirect) {
+ // get redirect url from "location" header field
+ url = new URL(http.getHeaderField("Location"));
+
+ // get the cookie if need, for login
+ cookies = http.getHeaderField("Set-Cookie");
+
+ // Disconnect the current connection
+ http.disconnect();
+ redirectCnt++;
+ continue;
+ }
+ if (status == HttpURLConnection.HTTP_OK) {
+ break;
+ } else {
+ return null;
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "can not connect to " + iconUrl, e);
+ }
+ }
+
+
+ Bitmap myBitmap = null;
+ InputStream inputStream = http.getInputStream();
+
+ ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+ int nRead;
+ byte[] data = new byte[16384];
+ while ((nRead = inputStream.read(data, 0, data.length)) != -1) {
+ buffer.write(data, 0, nRead);
+ }
+ buffer.flush();
+ inputStream.close();
+ byte[] imageBytes = buffer.toByteArray();
+
+ BitmapFactory.Options options = new BitmapFactory.Options();
+ options.inJustDecodeBounds = true;
+ options.inPreferredConfig = Config.ARGB_8888;
+
+ // The below line just checking the bitmap size (width,height).
+ // Returned value is always null.
+ BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length, options);
+
+ if (mWidth < 1 && mHeight < 1) {
+ mWidth = options.outWidth;
+ mHeight = options.outHeight;
+ }
+
+ // Resize
+ int newWidth = (int)(mWidth * density);
+ int newHeight = (int)(mHeight * density);
+ if (newWidth > 2000 || newHeight > 2000) {
+ float rationResize;
+ if (newWidth >= newHeight) {
+ rationResize = 2000.0f / ((float) newWidth);
+ } else {
+ rationResize = 2000.0f / ((float) newHeight);
+ }
+ newWidth = (int)(((float)newWidth) * rationResize);
+ newHeight = (int)(((float)newHeight) * rationResize);
+ Log.w(TAG, "Since the image size is too large, the image size resizes down mandatory");
+ }
+
+
+ /**
+ * http://stackoverflow.com/questions/4821488/bad-image-quality-after-resizing-scaling-bitmap#7468636
+ */
+ Bitmap scaledBitmap = Bitmap.createBitmap(newWidth, newHeight, Config.ARGB_8888);
+
+ float ratioX = newWidth / (float) options.outWidth;
+ float ratioY = newHeight / (float) options.outHeight;
+ float middleX = newWidth / 2.0f;
+ float middleY = newHeight / 2.0f;
+
+ options.inJustDecodeBounds = false;
+ //options.inSampleSize = (int) Math.max(ratioX, ratioY);
+ options.outWidth = newWidth;
+ options.outHeight = newHeight;
+
+ Matrix scaleMatrix = new Matrix();
+ scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);
+
+ Canvas canvas = new Canvas(scaledBitmap);
+ canvas.setMatrix(scaleMatrix);
+
+ myBitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length, options);
+ canvas.drawBitmap(myBitmap, middleX - options.outWidth / 2, middleY - options.outHeight / 2, new Paint(Paint.FILTER_BITMAP_FLAG));
+ myBitmap.recycle();
+ myBitmap = null;
+ canvas = null;
+ imageBytes = null;
+
+ AsyncLoadImageResult result = new AsyncLoadImageResult();
+ result.image = scaledBitmap;
+ result.cacheHit = false;
+ if (!mOptions.noCaching) {
+ result.cacheKey = cacheKey;
+ addBitmapToMemoryCache(cacheKey, scaledBitmap);
+ }
+
+ return result;
+ } catch (Exception e) {
+ e.printStackTrace();
+ return null;
+ }
+
+
+ } else {
+ //Log.d(TAG, "--> iconUrl = " + iconUrl);
+ if (iconUrl.indexOf("data:image/") == 0 && iconUrl.contains(";base64,")) {
+ String[] tmp = iconUrl.split(",");
+ image = PluginUtil.getBitmapFromBase64encodedImage(tmp[1]);
+ } else {
+ try {
+ InputStream inputStream = null;
+ if (iconUrl.startsWith("file:/android_asset/")) {
+ AssetManager assetManager = cordova.getActivity().getAssets();
+ iconUrl = iconUrl.replace("file:/android_asset/", "");
+ inputStream = assetManager.open(iconUrl);
+ //Log.d(TAG, "--> iconUrl = " + iconUrl);
+ } else if (iconUrl.startsWith("file:///android_asset/")) {
+ AssetManager assetManager = cordova.getActivity().getAssets();
+ iconUrl = iconUrl.replace("file:///android_asset/", "");
+ inputStream = assetManager.open(iconUrl);
+ //Log.d(TAG, "--> iconUrl = " + iconUrl);
+ } else if (iconUrl.startsWith("/")) {
+ File file = new File(iconUrl);
+ inputStream = new FileInputStream(file);
+ }
+ if (inputStream != null) {
+ image = BitmapFactory.decodeStream(inputStream);
+ inputStream.close();
+ } else {
+ Log.e(TAG, "Can not load the file from '" + iconUrl + "'");
+ return null;
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+ /*
+ //--------------------------------
+ // Load image from local path
+ //--------------------------------
+ if (!iconUrl.contains("://") &&
+ !iconUrl.startsWith("/") &&
+ !iconUrl.startsWith("www/") &&
+ !iconUrl.startsWith("data:image") &&
+ !iconUrl.startsWith("./") &&
+ !iconUrl.startsWith("../")) {
+ iconUrl = "./" + iconUrl;
+ Log.d(TAG, "--> iconUrl = " + iconUrl);
+ }
+
+ if (iconUrl.startsWith("./") || iconUrl.startsWith("../")) {
+ iconUrl = iconUrl.replace("(\\.\\/)+", "./");
+ String currentPage = this.currentPageUrl;
+ currentPage = currentPage.replaceAll("[^\\/]*$", "");
+ currentPage = currentPage.replaceAll("#.*$", "");
+ currentPage = currentPage.replaceAll("\\/[^\\/]+\\.[^\\/]+$", "");
+ if (!currentPage.endsWith("/")) {
+ currentPage = currentPage + "/";
+ }
+ iconUrl = currentPage + iconUrl;
+ iconUrl = iconUrl.replaceAll("(\\/\\.\\/+)+", "/");
+ Log.d(TAG, "--> iconUrl = " + iconUrl);
+ }
+
+ if (iconUrl.indexOf("data:image/") == 0 && iconUrl.contains(";base64,")) {
+ cacheKey = getCacheKey(iconUrl, mWidth, mHeight);
+
+ image = getBitmapFromMemCache(cacheKey);
+ if (image != null) {
+ AsyncLoadImageResult result = new AsyncLoadImageResult();
+ result.image = image;
+ result.cacheHit = true;
+ result.cacheKey = cacheKey;
+ return result;
+ }
+
+ String[] tmp = iconUrl.split(",");
+ image = PluginUtil.getBitmapFromBase64encodedImage(tmp[1]);
+ } else if (iconUrl.indexOf("file://") == 0 &&
+ !iconUrl.contains("file:///android_asset/")) {
+ iconUrl = iconUrl.replace("file://", "");
+ File tmp = new File(iconUrl);
+ if (tmp.exists()) {
+ cacheKey = getCacheKey(iconUrl, mWidth, mHeight);
+
+ image = getBitmapFromMemCache(cacheKey);
+ if (image != null) {
+ AsyncLoadImageResult result = new AsyncLoadImageResult();
+ result.image = image;
+ result.cacheHit = true;
+ result.cacheKey = cacheKey;
+ return result;
+ }
+
+ image = BitmapFactory.decodeFile(iconUrl);
+ } else {
+ //if (PluginMarker.this.mapCtrl.mPluginLayout.isDebug) {
+ Log.w(TAG, "icon is not found (" + iconUrl + ")");
+ //}
+ return null;
+ }
+ } else {
+ Log.d(TAG, "--> iconUrl = " + iconUrl);
+ cacheKey = getCacheKey(iconUrl, mWidth, mHeight);
+ image = getBitmapFromMemCache(cacheKey);
+
+ if (image != null) {
+ AsyncLoadImageResult result = new AsyncLoadImageResult();
+ result.image = image;
+ result.cacheHit = true;
+ result.cacheKey = cacheKey;
+ return result;
+ }
+
+ Log.d(TAG, "iconUrl = " + iconUrl);
+ if (iconUrl.indexOf("file:///android_asset/") == 0) {
+ iconUrl = iconUrl.replace("file:///android_asset/", "");
+ }
+
+ Log.d(TAG, "iconUrl = " + iconUrl);
+ if (iconUrl.contains("./")) {
+ try {
+ boolean isAbsolutePath = iconUrl.startsWith("/");
+ File relativePath = new File(iconUrl);
+ iconUrl = relativePath.getCanonicalPath();
+ Log.d(TAG, "iconUrl = " + iconUrl);
+ if (!isAbsolutePath) {
+ iconUrl = iconUrl.substring(1);
+ }
+ Log.d(TAG, "iconUrl = " + iconUrl);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ */
+
+ //}
+
+ if (mWidth > 0 && mHeight > 0) {
+ mWidth = Math.round(mWidth * density);
+ mHeight = Math.round(mHeight * density);
+ image = PluginUtil.resizeBitmap(image, mWidth, mHeight);
+ } else {
+ image = PluginUtil.scaleBitmapForDevice(image);
+ }
+
+ AsyncLoadImageResult result = new AsyncLoadImageResult();
+ result.image = image;
+ result.cacheHit = false;
+ if (!mOptions.noCaching) {
+ result.cacheKey = cacheKey;
+ addBitmapToMemoryCache(cacheKey, image);
+ }
+
+ return result;
+ }
+ }
+
+
+ @Override
+ protected void onPostExecute(AsyncLoadImageResult result) {
+ this.callback.onPostExecute(result);
+ }
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/AsyncLoadImageInterface.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/AsyncLoadImageInterface.java
new file mode 100644
index 0000000..62c58c0
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/AsyncLoadImageInterface.java
@@ -0,0 +1,5 @@
+package plugin.google.maps;
+
+public interface AsyncLoadImageInterface {
+ public void onPostExecute(AsyncLoadImage.AsyncLoadImageResult result) ;
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/BitmapCache.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/BitmapCache.java
new file mode 100644
index 0000000..fe3a7f4
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/BitmapCache.java
@@ -0,0 +1,26 @@
+package plugin.google.maps;
+
+import android.graphics.Bitmap;
+import android.util.LruCache;
+
+public class BitmapCache extends LruCache {
+
+ public BitmapCache(int maxSize) {
+ super(maxSize);
+ }
+
+ @Override
+ protected int sizeOf(String key, Bitmap bitmap) {
+ // The cache size will be measured in kilobytes rather than
+ // number of items.
+ return bitmap.getByteCount() / 1024;
+ }
+
+ @Override
+ protected void entryRemoved(boolean evicted, String key, Bitmap oldBitmap, Bitmap newBitmap) {
+ if (!oldBitmap.isRecycled()) {
+ oldBitmap.recycle();
+ oldBitmap = null;
+ }
+ }
+}
\ No newline at end of file
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/CordovaGoogleMaps.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/CordovaGoogleMaps.java
new file mode 100644
index 0000000..7e965dc
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/CordovaGoogleMaps.java
@@ -0,0 +1,584 @@
+package plugin.google.maps;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.graphics.Color;
+import android.graphics.RectF;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GooglePlayServicesUtil;
+import com.google.android.gms.maps.MapsInitializer;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.LOG;
+import org.apache.cordova.PluginEntry;
+import org.apache.cordova.PluginManager;
+import org.apache.cordova.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.lang.reflect.Field;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Set;
+
+@SuppressWarnings("deprecation")
+public class CordovaGoogleMaps extends CordovaPlugin implements ViewTreeObserver.OnScrollChangedListener{
+ private final String TAG = "GoogleMapsPlugin";
+ private Activity activity;
+ public ViewGroup root;
+ public MyPluginLayout mPluginLayout = null;
+ public boolean initialized = false;
+ public PluginManager pluginManager;
+ private static final Object timerLock = new Object();
+
+ @SuppressLint("NewApi") @Override
+ public void initialize(final CordovaInterface cordova, final CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ if (root != null) {
+ return;
+ }
+ LOG.setLogLevel(LOG.ERROR);
+
+ activity = cordova.getActivity();
+ final View view = webView.getView();
+ view.getViewTreeObserver().addOnScrollChangedListener(CordovaGoogleMaps.this);
+ root = (ViewGroup) view.getParent();
+
+ pluginManager = webView.getPluginManager();
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @SuppressLint("NewApi")
+ public void run() {
+
+ // Enable this, webView makes draw cache on the Android action bar issue.
+ //View view = webView.getView();
+ //if (Build.VERSION.SDK_INT >= 21 || "org.xwalk.core.XWalkView".equals(view.getClass().getName())){
+ // view.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+ // Log.d("Layout", "--> view =" + view.isHardwareAccelerated()); //always false
+ //}
+
+
+ // ------------------------------
+ // Check of Google Play Services
+ // ------------------------------
+ int checkGooglePlayServices = GooglePlayServicesUtil.isGooglePlayServicesAvailable(activity);
+
+ Log.d(TAG, "----> checkGooglePlayServices = " + (ConnectionResult.SUCCESS == checkGooglePlayServices));
+
+ if (checkGooglePlayServices != ConnectionResult.SUCCESS) {
+ // google play services is missing!!!!
+ /*
+ * Returns status code indicating whether there was an error. Can be one
+ * of following in ConnectionResult: SUCCESS, SERVICE_MISSING,
+ * SERVICE_VERSION_UPDATE_REQUIRED, SERVICE_DISABLED, SERVICE_INVALID.
+ */
+ Log.e(TAG, "---Google Play Services is not available: " + GooglePlayServicesUtil.getErrorString(checkGooglePlayServices));
+
+ boolean isNeedToUpdate = false;
+
+ String errorMsg = PluginUtil.getPgmStrings(activity, "pgm_google_play_error");
+ switch (checkGooglePlayServices) {
+ case ConnectionResult.DEVELOPER_ERROR:
+ errorMsg = PluginUtil.getPgmStrings(activity,"pgm_google_play_developer_error");
+ break;
+ case ConnectionResult.INTERNAL_ERROR:
+ errorMsg = PluginUtil.getPgmStrings(activity,"pgm_google_play_internal_error");
+ break;
+ case ConnectionResult.INVALID_ACCOUNT:
+ errorMsg = PluginUtil.getPgmStrings(activity,"pgm_google_play_invalid_account");
+ break;
+ case ConnectionResult.LICENSE_CHECK_FAILED:
+ errorMsg = PluginUtil.getPgmStrings(activity,"pgm_google_play_license_check_failed");
+ break;
+ case ConnectionResult.NETWORK_ERROR:
+ errorMsg = PluginUtil.getPgmStrings(activity,"pgm_google_play_network_error");
+ break;
+ case ConnectionResult.SERVICE_DISABLED:
+ errorMsg = PluginUtil.getPgmStrings(activity,"pgm_google_play_service_disabled");
+ break;
+ case ConnectionResult.SERVICE_INVALID:
+ errorMsg = PluginUtil.getPgmStrings(activity,"pgm_google_play_service_invalid");
+ isNeedToUpdate = true;
+ break;
+ case ConnectionResult.SERVICE_MISSING:
+ errorMsg = PluginUtil.getPgmStrings(activity,"pgm_google_play_service_missing");
+ isNeedToUpdate = true;
+ break;
+ case ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED:
+ errorMsg = PluginUtil.getPgmStrings(activity,"pgm_google_play_service_update_required");
+ isNeedToUpdate = true;
+ break;
+ case ConnectionResult.SIGN_IN_REQUIRED:
+ errorMsg = PluginUtil.getPgmStrings(activity,"pgm_google_play_sign_in_required");
+ break;
+ default:
+ isNeedToUpdate = true;
+ break;
+ }
+
+ final boolean finalIsNeedToUpdate = isNeedToUpdate;
+ AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(activity);
+ alertDialogBuilder
+ .setMessage(errorMsg)
+ .setCancelable(false)
+ .setPositiveButton(PluginUtil.getPgmStrings(activity,"pgm_google_close_button"), new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog,int id) {
+ dialog.dismiss();
+ if (finalIsNeedToUpdate) {
+ try {
+ activity.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=com.google.android.gms")));
+ } catch (android.content.ActivityNotFoundException anfe) {
+ activity.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("http://play.google.com/store/apps/details?id=com.google.android.gms")));
+ }
+ }
+ }
+ });
+ AlertDialog alertDialog = alertDialogBuilder.create();
+
+ // show it
+ alertDialog.show();
+
+ Log.e(TAG, "Google Play Services is not available.");
+ return;
+ }
+
+ webView.getView().setBackgroundColor(Color.TRANSPARENT);
+ webView.getView().setOverScrollMode(View.OVER_SCROLL_NEVER);
+ mPluginLayout = new MyPluginLayout(webView, activity);
+ mPluginLayout.stopTimer();
+
+
+ // Check the API key
+ ApplicationInfo appliInfo = null;
+ try {
+ appliInfo = activity.getPackageManager().getApplicationInfo(activity.getPackageName(), PackageManager.GET_META_DATA);
+ } catch (NameNotFoundException e) {}
+
+ String API_KEY = appliInfo.metaData.getString("com.google.android.maps.v2.API_KEY");
+ if ("API_KEY_FOR_ANDROID".equals(API_KEY)) {
+
+ AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(activity);
+
+ alertDialogBuilder
+ .setMessage(PluginUtil.getPgmStrings(activity,"pgm_api_key_error"))
+ .setCancelable(false)
+ .setPositiveButton(PluginUtil.getPgmStrings(activity,"pgm_google_close_button"), new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog,int id) {
+ dialog.dismiss();
+ }
+ });
+ AlertDialog alertDialog = alertDialogBuilder.create();
+
+ // show it
+ alertDialog.show();
+ }
+
+
+ //------------------------------
+ // Initialize Google Maps SDK
+ //------------------------------
+ if (!initialized) {
+ try {
+ MapsInitializer.initialize(cordova.getActivity());
+ initialized = true;
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ }
+ });
+
+
+ }
+
+ @Override
+ public boolean onOverrideUrlLoading(String url) {
+ mPluginLayout.stopTimer();
+ /*
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ webView.loadUrl("javascript:if(window.cordova){cordova.fireDocumentEvent('plugin_url_changed', {});}");
+ }
+ });
+ */
+ return false;
+ }
+
+
+ @Override
+ public void onScrollChanged() {
+ if (mPluginLayout == null) {
+ return;
+ }
+ View view = webView.getView();
+ int scrollX = view.getScrollX();
+ int scrollY = view.getScrollY();
+ mPluginLayout.scrollTo(scrollX, scrollY);
+
+ }
+
+ @Override
+ public boolean execute(final String action, final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ cordova.getThreadPool().submit(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ if (action.equals("putHtmlElements")) {
+ CordovaGoogleMaps.this.putHtmlElements(args, callbackContext);
+ } else if ("clearHtmlElements".equals(action)) {
+ CordovaGoogleMaps.this.clearHtmlElements(args, callbackContext);
+ } else if ("pause".equals(action)) {
+ CordovaGoogleMaps.this.pause(args, callbackContext);
+ } else if ("resume".equals(action)) {
+ CordovaGoogleMaps.this.resume(args, callbackContext);
+ } else if ("getMap".equals(action)) {
+ CordovaGoogleMaps.this.getMap(args, callbackContext);
+ } else if ("getPanorama".equals(action)) {
+ CordovaGoogleMaps.this.getPanorama(args, callbackContext);
+ } else if ("removeMap".equals(action)) {
+ CordovaGoogleMaps.this.removeMap(args, callbackContext);
+ } else if ("backHistory".equals(action)) {
+ CordovaGoogleMaps.this.backHistory(args, callbackContext);
+ } else if ("updateMapPositionOnly".equals(action)) {
+ CordovaGoogleMaps.this.updateMapPositionOnly(args, callbackContext);
+ }
+
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+ });
+ return true;
+
+ }
+
+ public void updateMapPositionOnly(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final JSONObject elements = args.getJSONObject(0);
+
+ Bundle elementsBundle = PluginUtil.Json2Bundle(elements);
+ float zoomScale = Resources.getSystem().getDisplayMetrics().density;
+
+ Iterator domIDs = elementsBundle.keySet().iterator();
+ String domId;
+ Bundle domInfo, size, currentDomInfo;
+ while (domIDs.hasNext()) {
+ domId = domIDs.next();
+ domInfo = elementsBundle.getBundle(domId);
+
+ size = domInfo.getBundle("size");
+ RectF rectF = new RectF();
+ rectF.left = (float)(Double.parseDouble(size.get("left") + "") * zoomScale);
+ rectF.top = (float)(Double.parseDouble(size.get("top") + "") * zoomScale);
+ rectF.right = rectF.left + (float)(Double.parseDouble(size.get("width") + "") * zoomScale);
+ rectF.bottom = rectF.top + (float)(Double.parseDouble(size.get("height") + "") * zoomScale);
+
+ mPluginLayout.HTMLNodeRectFs.put(domId, rectF);
+ }
+
+ if (mPluginLayout.isSuspended) {
+ mPluginLayout.updateMapPositions();
+ }
+ callbackContext.success();
+ }
+ public void backHistory(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ if (!webView.backHistory()) {
+ // If no more history back, exit the app
+ cordova.getActivity().finish();
+ }
+ }
+ });
+ }
+
+
+
+ public synchronized void pause(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ synchronized (timerLock) {
+ if (mPluginLayout == null) {
+ callbackContext.success();
+ return;
+ }
+ mPluginLayout.stopTimer();
+ callbackContext.success();
+ }
+ }
+ public synchronized void resume(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ synchronized (timerLock) {
+ if (mPluginLayout == null) {
+ callbackContext.success();
+ return;
+ }
+ if (mPluginLayout.isSuspended) {
+ mPluginLayout.startTimer();
+ }
+ callbackContext.success();
+
+ //On resume reapply background because it might have been changed by some other plugin
+ webView.getView().setBackgroundColor(Color.TRANSPARENT);
+ }
+ }
+ public void clearHtmlElements(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ if (mPluginLayout == null) {
+ callbackContext.success();
+ return;
+ }
+ mPluginLayout.clearHtmlElements();
+ callbackContext.success();
+ }
+ public void putHtmlElements(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ final JSONObject elements = args.getJSONObject(0);
+ if (mPluginLayout == null) {
+ callbackContext.success();
+ return;
+ }
+
+ //Log.d(TAG, "--->stopFlag = " + mPluginLayout.stopFlag + ", mPluginLayout.needUpdatePosition = " + mPluginLayout.needUpdatePosition);
+ if (!mPluginLayout.stopFlag || mPluginLayout.needUpdatePosition) {
+ mPluginLayout.putHTMLElements(elements);
+ }
+
+ //mPluginLayout.updateMapPositions();
+ //mPluginLayout.startTimer();
+ callbackContext.success();
+ }
+
+ @Override
+ public void onReset() {
+ super.onReset();
+ if (mPluginLayout == null || mPluginLayout.pluginOverlays == null) {
+ return;
+ }
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ mPluginLayout.setBackgroundColor(Color.WHITE);
+
+ Set mapIds = mPluginLayout.pluginOverlays.keySet();
+ IPluginView pluginOverlay;
+
+ // prevent the ConcurrentModificationException error.
+ String[] mapIdArray= mapIds.toArray(new String[mapIds.size()]);
+ for (String mapId : mapIdArray) {
+ if (mPluginLayout.pluginOverlays.containsKey(mapId)) {
+ pluginOverlay = mPluginLayout.removePluginOverlay(mapId);
+ pluginOverlay.remove(null, null);
+ pluginOverlay.onDestroy();
+ mPluginLayout.HTMLNodes.remove(mapId);
+ }
+ }
+ mPluginLayout.HTMLNodes.clear();
+ mPluginLayout.pluginOverlays.clear();
+
+ System.gc();
+ Runtime.getRuntime().gc();
+ }
+ });
+
+ }
+
+ public void removeMap(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String mapId = args.getString(0);
+ if (mPluginLayout.pluginOverlays.containsKey(mapId)) {
+ IPluginView pluginOverlay = mPluginLayout.removePluginOverlay(mapId);
+ if (pluginOverlay != null) {
+ pluginOverlay.remove(null, null);
+ pluginOverlay.onDestroy();
+ mPluginLayout.HTMLNodes.remove(mapId);
+ pluginOverlay = null;
+ }
+
+ try {
+ Field pluginMapField = pluginManager.getClass().getDeclaredField("pluginMap");
+ pluginMapField.setAccessible(true);
+ LinkedHashMap pluginMapInstance = (LinkedHashMap) pluginMapField.get(pluginManager);
+ pluginMapInstance.remove(mapId);
+ Field entryMapField = pluginManager.getClass().getDeclaredField("entryMap");
+ entryMapField.setAccessible(true);
+ LinkedHashMap entryMapInstance = (LinkedHashMap) entryMapField.get(pluginManager);
+ entryMapInstance.remove(mapId);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+
+ }
+
+
+
+ System.gc();
+ Runtime.getRuntime().gc();
+ callbackContext.success();
+ }
+
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ public void getMap(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ //------------------------------------------
+ // Create an instance of PluginMap class.
+ //------------------------------------------
+ JSONObject meta = args.getJSONObject(0);
+ String mapId = meta.getString("__pgmId");
+ PluginMap pluginMap = new PluginMap();
+ pluginMap.privateInitialize(mapId, cordova, webView, null);
+ pluginMap.initialize(cordova, webView);
+ pluginMap.mapCtrl = CordovaGoogleMaps.this;
+ pluginMap.self = pluginMap;
+
+ PluginEntry pluginEntry = new PluginEntry(mapId, pluginMap);
+ pluginManager.addService(pluginEntry);
+
+ pluginMap.getMap(args, callbackContext);
+ }
+
+
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ public void getPanorama(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ //------------------------------------------
+ // Create an instance of PluginStreetView class.
+ //------------------------------------------
+ JSONObject meta = args.getJSONObject(0);
+ String mapId = meta.getString("__pgmId");
+ Log.d(TAG, "---> mapId = " + mapId);
+ PluginStreetViewPanorama pluginStreetView = new PluginStreetViewPanorama();
+ pluginStreetView.privateInitialize(mapId, cordova, webView, null);
+ pluginStreetView.initialize(cordova, webView);
+ pluginStreetView.mapCtrl = CordovaGoogleMaps.this;
+ pluginStreetView.self = pluginStreetView;
+
+ PluginEntry pluginEntry = new PluginEntry(mapId, pluginStreetView);
+ pluginManager.addService(pluginEntry);
+
+ pluginStreetView.getPanorama(args, callbackContext);
+ }
+
+ @Override
+ public void onStart() {
+ super.onStart();
+
+ CollectionpluginEntries = pluginManager.getPluginEntries();
+ for (PluginEntry pluginEntry: pluginEntries) {
+ if (pluginEntry.service.startsWith("map_")) {
+ pluginEntry.plugin.onStart();
+ }
+ }
+
+ }
+ @Override
+ public void onStop() {
+ super.onStop();
+
+ CollectionpluginEntries = pluginManager.getPluginEntries();
+ for (PluginEntry pluginEntry: pluginEntries) {
+ if (pluginEntry.service.startsWith("map_")) {
+ pluginEntry.plugin.onStop();
+ }
+ }
+
+ }
+ @Override
+ public void onPause(boolean multitasking) {
+ super.onPause(multitasking);
+ if (mPluginLayout != null) {
+ mPluginLayout.stopTimer();
+ }
+
+ CollectionpluginEntries = pluginManager.getPluginEntries();
+ for (PluginEntry pluginEntry: pluginEntries) {
+ if (pluginEntry.service.startsWith("map_")) {
+ pluginEntry.plugin.onPause(multitasking);
+ }
+ }
+
+ }
+
+ @Override
+ public void onResume(boolean multitasking) {
+ CollectionpluginEntries = pluginManager.getPluginEntries();
+ for (Iterator iterator = pluginEntries.iterator(); iterator.hasNext();) {
+ PluginEntry pluginEntry = iterator.next();
+ if (pluginEntry.service.startsWith("map_")) {
+ pluginEntry.plugin.onResume(multitasking);
+ }
+ }
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+
+ CollectionpluginEntries = pluginManager.getPluginEntries();
+ for (PluginEntry pluginEntry: pluginEntries) {
+ if (pluginEntry.service.startsWith("map_")) {
+ pluginEntry.plugin.onDestroy();
+ }
+ }
+
+ }
+
+ /**
+ * Called by the system when the device configuration changes while your activity is running.
+ *
+ * @param newConfig The new device configuration
+ */
+ public void onConfigurationChanged(Configuration newConfig) {
+ super.onConfigurationChanged(newConfig);
+
+ Handler handler = new Handler();
+ handler.postDelayed(new Runnable() {
+ @Override
+ public void run() {
+ PluginMap pluginMap;
+ Collection collection = pluginManager.getPluginEntries();
+ for (PluginEntry entry: collection) {
+ if ("plugin.google.maps.PluginMap".equals(entry.pluginClass) && entry.plugin != null) {
+ pluginMap = (PluginMap)entry.plugin;
+ if (pluginMap.map != null) {
+
+ // Trigger the CAMERA_MOVE_END mandatory
+ pluginMap.onCameraIdle();
+ }
+ }
+ }
+ }
+ }, 500);
+ /*
+ // Checks the orientation of the screen
+ if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
+ Toast.makeText(activity, "landscape", Toast.LENGTH_SHORT).show();
+ } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT){
+ Toast.makeText(activity, "portrait", Toast.LENGTH_SHORT).show();
+ }
+ */
+ }
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/IPluginView.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/IPluginView.java
new file mode 100644
index 0000000..9ec0a79
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/IPluginView.java
@@ -0,0 +1,24 @@
+package plugin.google.maps;
+
+import android.view.View;
+import android.view.ViewGroup;
+
+import org.apache.cordova.CallbackContext;
+import org.json.JSONArray;
+
+public interface IPluginView {
+ boolean getVisible();
+ boolean getClickable();
+ String getDivId();
+ String getOverlayId();
+ ViewGroup getView();
+ int getViewDepth();
+ void onDestroy();
+ void onStart();
+ void onStop();
+ void onPause(boolean multitasking);
+ void onResume(boolean multitasking);
+ void remove(JSONArray args, final CallbackContext callbackContext);
+ void attachToWebView(JSONArray args, final CallbackContext callbackContext);
+ void detachFromWebView(JSONArray args, final CallbackContext callbackContext);
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/MyPlugin.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/MyPlugin.java
new file mode 100644
index 0000000..9af3faa
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/MyPlugin.java
@@ -0,0 +1,244 @@
+package plugin.google.maps;
+
+import android.annotation.SuppressLint;
+import android.content.res.Resources;
+import android.util.Log;
+
+import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.model.Circle;
+import com.google.android.gms.maps.model.GroundOverlay;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.Marker;
+import com.google.android.gms.maps.model.Polygon;
+import com.google.android.gms.maps.model.Polyline;
+import com.google.android.gms.maps.model.TileOverlay;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.PluginEntry;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class MyPlugin extends CordovaPlugin implements MyPluginInterface {
+ public MyPlugin self = null;
+ public final Map methods = new ConcurrentHashMap();
+ protected static ExecutorService executorService = null;
+
+ public CordovaGoogleMaps mapCtrl = null;
+ public GoogleMap map = null;
+ public PluginMap pluginMap = null;
+ protected boolean isRemoved = false;
+ protected static float density = Resources.getSystem().getDisplayMetrics().density;
+
+ public void setPluginMap(PluginMap pluginMap) {
+ this.pluginMap = pluginMap;
+ this.mapCtrl = pluginMap.mapCtrl;
+ this.map = pluginMap.map;
+ }
+ protected String TAG = "";
+
+ @SuppressLint("UseSparseArrays")
+ @Override
+ public void initialize(CordovaInterface cordova, final CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ TAG = this.getServiceName();
+ if (executorService == null) {
+ cordova.getThreadPool().execute(new Runnable() {
+ @Override
+ public void run() {
+ executorService = Executors.newCachedThreadPool();
+ }
+ });
+ }
+ }
+ @Override
+ public boolean execute(final String action, final JSONArray args, final CallbackContext callbackContext) {
+ self = this;
+ executorService.submit(new Runnable() {
+ @Override
+ public void run() {
+
+ if (isRemoved) {
+ // Ignore every execute calls.
+ return;
+ }
+
+ synchronized (methods) {
+ if (methods.size() == 0) {
+ TAG = MyPlugin.this.getServiceName();
+ if (!TAG.contains("-")) {
+ if (TAG.startsWith("map")) {
+ mapCtrl.mPluginLayout.pluginOverlays.put(TAG, (PluginMap) MyPlugin.this);
+ } else if (TAG.startsWith("streetview")) {
+ mapCtrl.mPluginLayout.pluginOverlays.put(TAG, (PluginStreetViewPanorama) MyPlugin.this);
+ }
+ } else {
+ PluginEntry pluginEntry = new PluginEntry(TAG, MyPlugin.this);
+ pluginMap.plugins.put(TAG, pluginEntry);
+ }
+
+
+ //CordovaPlugin plugin = mapCtrl.webView.getPluginManager().getPlugin(this.getServiceName());
+ // Log.d("MyPlugin", "---> this = " + this);
+ // Log.d("MyPlugin", "---> plugin = " + plugin);
+
+ Method[] classMethods = self.getClass().getMethods();
+ for (Method classMethod : classMethods) {
+ methods.put(classMethod.getName(), classMethod);
+ }
+ }
+
+
+ // this.create(args, callbackContext);
+ // return true;
+ if (methods.containsKey(action)) {
+ if (self.mapCtrl.mPluginLayout.isDebug) {
+ try {
+ if (args != null && args.length() > 0) {
+ Log.d(TAG, "(debug)action=" + action + " args[0]=" + args.getString(0));
+ } else {
+ Log.d(TAG, "(debug)action=" + action);
+ }
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+ Method method = methods.get(action);
+ try {
+ if (isRemoved) {
+ // Ignore every execute calls.
+ return;
+ }
+ method.invoke(self, args, callbackContext);
+ } catch (IllegalAccessException e) {
+ e.printStackTrace();
+ callbackContext.error("Cannot access to the '" + action + "' method.");
+ } catch (InvocationTargetException e) {
+ e.printStackTrace();
+ callbackContext.error("Cannot access to the '" + action + "' method.");
+ }
+ }
+ }
+ }
+ });
+ return true;
+
+ }
+
+
+ protected void create(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ // dummy
+ }
+
+ protected synchronized Circle getCircle(String id) {
+ if (!pluginMap.objects.containsKey(id)) {
+ //Log.e(TAG, "---> can not find the circle : " + id);
+ return null;
+ }
+ return (Circle)pluginMap.objects.get(id);
+ }
+ protected synchronized GroundOverlay getGroundOverlay(String id) {
+ if (!pluginMap.objects.containsKey(id)) {
+ //Log.e(TAG, "---> can not find the ground overlay : " + id);
+ return null;
+ }
+ return (GroundOverlay)pluginMap.objects.get(id);
+ }
+ protected synchronized Marker getMarker(String id) {
+ if (!pluginMap.objects.containsKey(id)) {
+ //Log.e(TAG, "---> can not find the maker : " + id);
+ return null;
+ }
+ return (Marker)pluginMap.objects.get(id);
+ }
+ protected synchronized Polyline getPolyline(String id) {
+ if (!pluginMap.objects.containsKey(id)) {
+ //Log.e(TAG, "---> can not find the polyline : " + id);
+ return null;
+ }
+ return (Polyline)pluginMap.objects.get(id);
+ }
+ protected synchronized Polygon getPolygon(String id) {
+ if (!pluginMap.objects.containsKey(id)) {
+ //Log.e(TAG, "---> can not find the polygon : " + id);
+ return null;
+ }
+ return (Polygon)pluginMap.objects.get(id);
+ }
+ protected synchronized TileOverlay getTileOverlay(String id) {
+ if (!pluginMap.objects.containsKey(id)) {
+ //Log.e(TAG, "---> can not find the tileoverlay : " + id);
+ return null;
+ }
+ return (TileOverlay)pluginMap.objects.get(id);
+ }
+
+ protected void setInt(String methodName, String id, int value, final CallbackContext callbackContext) throws JSONException {
+ this.setValue(methodName, int.class, id, value, callbackContext);
+ }
+ protected void setFloat(String methodName, String id, float value, final CallbackContext callbackContext) throws JSONException {
+ this.setValue(methodName, float.class, id, value, callbackContext);
+ }
+ protected void setDouble(String methodName, String id, float value, final CallbackContext callbackContext) throws JSONException {
+ this.setValue(methodName, double.class, id, value, callbackContext);
+ }
+ protected void setString(String methodName, String id, String value, final CallbackContext callbackContext) throws JSONException {
+ this.setValue(methodName, String.class, id, value, callbackContext);
+ }
+
+ protected void setBoolean(String methodName, String id, Boolean value, final CallbackContext callbackContext) throws JSONException {
+ this.setValue(methodName, boolean.class, id, value, callbackContext);
+ }
+
+ private void setValue(String methodName, Class methodClass, String id, final Object value, final CallbackContext callbackContext) throws JSONException {
+ if (!pluginMap.objects.containsKey(id)) {
+ return;
+ }
+ final Object object = pluginMap.objects.get(id);
+ try {
+ final Method method = object.getClass().getDeclaredMethod(methodName, methodClass);
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ method.invoke(object, value);
+ callbackContext.success();
+ } catch (Exception e) {
+ e.printStackTrace();
+ callbackContext.error(e.getMessage());
+ }
+ }
+ });
+ } catch (Exception e) {
+ e.printStackTrace();
+ callbackContext.error(e.getMessage());
+ }
+ }
+ protected void clear() {
+ String[] keys = pluginMap.objects.keys.toArray(new String[pluginMap.objects.size()]);
+ Object object;
+ for (String key : keys) {
+ object = pluginMap.objects.remove(key);
+ object = null;
+ }
+ pluginMap.objects.clear();
+ }
+
+
+ protected void onOverlayEvent(String eventName, String overlayId, LatLng point) {
+ webView.loadUrl("javascript:plugin.google.maps.Map." +
+ "_onOverlayEvent(" +
+ "'" + eventName + "','" + overlayId + "', " +
+ "new window.plugin.google.maps.LatLng(" + point.latitude + "," + point.longitude + ")" +
+ ")");
+ }
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/MyPluginInterface.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/MyPluginInterface.java
new file mode 100644
index 0000000..1900164
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/MyPluginInterface.java
@@ -0,0 +1,16 @@
+package plugin.google.maps;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaArgs;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+public interface MyPluginInterface {
+ public void initialize(CordovaInterface cordova, CordovaWebView webView);
+ public void setPluginMap(PluginMap pluginMap);
+ public boolean execute(String action, String rawArgs, CallbackContext callbackContext) throws JSONException;
+ public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException;
+ public boolean execute(String action, CordovaArgs args, CallbackContext callbackContext) throws JSONException;
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/MyPluginLayout.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/MyPluginLayout.java
new file mode 100644
index 0000000..044f84d
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/MyPluginLayout.java
@@ -0,0 +1,716 @@
+package plugin.google.maps;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.PointF;
+import android.graphics.RectF;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+import android.widget.AbsoluteLayout;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.ScrollView;
+
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.ConcurrentHashMap;
+
+@SuppressWarnings("deprecation")
+public class MyPluginLayout extends FrameLayout implements ViewTreeObserver.OnScrollChangedListener, ViewTreeObserver.OnGlobalLayoutListener {
+ private static final String TAG = "MyPluginLayout";
+ private View browserView;
+ private Context context;
+ private FrontLayerLayout frontLayer;
+ private ScrollView scrollView;
+ public FrameLayout scrollFrameLayout;
+ public Map pluginOverlays = new ConcurrentHashMap();
+ private Map touchableWrappers = new ConcurrentHashMap();
+ private boolean isScrolling = false;
+ public boolean isDebug = false;
+ public final Object _lockHtmlNodes = new Object();
+ public Map CACHE_FIND_DOM = new ConcurrentHashMap();
+ public Map HTMLNodes = new ConcurrentHashMap();
+ public Map HTMLNodeRectFs = new ConcurrentHashMap();
+ private Activity mActivity = null;
+ private Paint debugPaint = new Paint();
+ public boolean stopFlag = false;
+ public boolean needUpdatePosition = false;
+ public boolean isSuspended = false;
+ private float zoomScale;
+ private static final Object timerLock = new Object();
+
+ private static Timer redrawTimer;
+
+ @Override
+ public void onGlobalLayout() {
+ ViewTreeObserver observer = browserView.getViewTreeObserver();
+ observer.removeGlobalOnLayoutListener(this);
+ observer.addOnScrollChangedListener(this);
+ }
+
+ private Runnable resizeWorker = new Runnable() {
+ @Override
+ public void run() {
+ final int scrollY = browserView.getScrollY();
+ final int scrollX = browserView.getScrollX();
+ final int webviewWidth = browserView.getWidth();
+ final int webviewHeight = browserView.getHeight();
+
+ Set keySet = pluginOverlays.keySet();
+ String[] toArrayBuf = new String[pluginOverlays.size()];
+ String[] mapIds = keySet.toArray(toArrayBuf);
+ String mapId;
+ IPluginView pluginOverlay;
+ RectF drawRect;
+ for (int i = 0; i < mapIds.length; i++) {
+ mapId = mapIds[i];
+ if (mapId == null) {
+ continue;
+ }
+ pluginOverlay = pluginOverlays.get(mapId);
+ if (pluginOverlay == null || pluginOverlay.getDivId() == null) {
+ continue;
+ }
+ drawRect = HTMLNodeRectFs.get(pluginOverlay.getDivId());
+ if (drawRect == null || drawRect.left == 0 && drawRect.top == 0 && drawRect.width() == 0 && drawRect.height() == 0) {
+
+ continue;
+ }
+
+ int width = (int)drawRect.width();
+ int height = (int)drawRect.height();
+ int x = (int) drawRect.left;
+ int y = (int) drawRect.top + scrollY;
+
+
+
+ if (pluginOverlay.getVisible()) {
+ if (pluginOverlay.getOverlayId().startsWith("streetview_")) {
+ if (y + height >= scrollY &&
+ x + width >= scrollX &&
+ y < scrollY + webviewHeight &&
+ x < scrollX + webviewWidth) {
+ MyPluginLayout.this.addPluginOverlay(pluginOverlay);
+ } else {
+
+ scrollFrameLayout.removeView(pluginOverlay.getView());
+ pluginOverlay.getView().removeView(touchableWrappers.remove(pluginOverlay.getOverlayId()));
+ }
+ }
+ }
+
+ ViewGroup.LayoutParams lParams = pluginOverlay.getView().getLayoutParams();
+ FrameLayout.LayoutParams params = (FrameLayout.LayoutParams) lParams;
+ //Log.d("MyPluginLayout", "-->FrameLayout x = " + x + ", y = " + y + ", w = " + width + ", h = " + height);
+ if (params.leftMargin == x && params.topMargin == y &&
+ params.width == width && params.height == height) {
+ continue;
+ }
+ params.width = width;
+ params.height = height;
+ params.leftMargin = x;
+ params.topMargin = y;
+ pluginOverlay.getView().setLayoutParams(params);
+
+
+ }
+ }
+ };
+
+ public void updateMapPositions() {
+ mActivity.runOnUiThread(resizeWorker);
+ }
+
+ private class ResizeTask extends TimerTask {
+ @Override
+ public void run() {
+ mActivity.runOnUiThread(resizeWorker);
+ }
+ }
+
+ @SuppressLint("NewApi")
+ public MyPluginLayout(CordovaWebView webView, Activity activity) {
+ super(webView.getView().getContext());
+ this.browserView = webView.getView();
+ browserView.getViewTreeObserver().addOnGlobalLayoutListener(this);
+ mActivity = activity;
+ ViewGroup root = (ViewGroup) browserView.getParent();
+ this.context = browserView.getContext();
+ //if (Build.VERSION.SDK_INT >= 21 || "org.xwalk.core.XWalkView".equals(browserView.getClass().getName())) {
+ // browserView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+ //}
+
+ zoomScale = Resources.getSystem().getDisplayMetrics().density;
+ Log.e(TAG, "--> zoomScale = " + zoomScale);
+ frontLayer = new FrontLayerLayout(this.context);
+
+ scrollView = new ScrollView(this.context);
+ scrollView.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+
+ root.removeView(browserView);
+ frontLayer.addView(browserView);
+
+ scrollFrameLayout = new FrameLayout(this.context);
+ scrollFrameLayout.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT));
+
+
+ View dummyView = new View(this.context);
+ dummyView.setLayoutParams(new LayoutParams(1, 99999));
+ scrollFrameLayout.addView(dummyView);
+
+ scrollView.setHorizontalScrollBarEnabled(true);
+ scrollView.setVerticalScrollBarEnabled(true);
+ scrollView.addView(scrollFrameLayout);
+
+ browserView.setDrawingCacheEnabled(false);
+
+
+ this.addView(scrollView);
+ this.addView(frontLayer);
+ root.addView(this);
+ browserView.setBackgroundColor(Color.TRANSPARENT);
+ /*
+ if("org.xwalk.core.XWalkView".equals(browserView.getClass().getName())
+ || "org.crosswalk.engine.XWalkCordovaView".equals(browserView.getClass().getName())) {
+ try {
+ // view.setZOrderOnTop(true)
+ // Called just in time as with root.setBackground(...) the color
+ // come in front and take the whole screen
+ browserView.getClass().getMethod("setZOrderOnTop", boolean.class)
+ .invoke(browserView, true);
+ }
+ catch(Exception e) {
+ e.printStackTrace();
+ }
+ }
+ */
+ scrollView.setHorizontalScrollBarEnabled(false);
+ scrollView.setVerticalScrollBarEnabled(false);
+ startTimer();
+ }
+
+ public synchronized void stopTimer() {
+ synchronized (timerLock) {
+ try {
+ if (redrawTimer != null) {
+ redrawTimer.cancel();
+ redrawTimer.purge();
+ ResizeTask task = new ResizeTask();
+ task.run();
+ isSuspended = true;
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ redrawTimer = null;
+ }
+ }
+
+ public synchronized void startTimer() {
+ synchronized (timerLock) {
+ if (redrawTimer != null) {
+ return;
+ }
+
+ redrawTimer = new Timer();
+ redrawTimer.scheduleAtFixedRate(new ResizeTask(), 0, 25);
+ //mActivity.getWindow().getDecorView().requestFocus(); <--- This changes thread number sometimes. Do not use this!
+ isSuspended = false;
+ }
+ }
+
+
+
+ public void clearHtmlElements() {
+ synchronized (_lockHtmlNodes) {
+ String[] keys = HTMLNodes.keySet().toArray(new String[HTMLNodes.size()]);
+ for (int i = 0; i < HTMLNodes.size(); i++) {
+ HTMLNodes.remove(keys[i]);
+ HTMLNodeRectFs.remove(keys[i]);
+ }
+ }
+ }
+
+ public void putHTMLElements(JSONObject elements) {
+
+
+ Map newBuffer = new ConcurrentHashMap();
+ Map newBufferRectFs = new ConcurrentHashMap();
+
+ Bundle elementsBundle = PluginUtil.Json2Bundle(elements);
+
+ Iterator domIDs = elementsBundle.keySet().iterator();
+ String domId;
+ Bundle domInfo, size;
+ while (domIDs.hasNext()) {
+ domId = domIDs.next();
+ domInfo = elementsBundle.getBundle(domId);
+ if (domInfo == null) {
+ continue;
+ }
+
+ size = domInfo.getBundle("size");
+ if (size == null) {
+ continue;
+ }
+
+ RectF rectF = new RectF();
+ rectF.left = (float)(Double.parseDouble(size.get("left") + "") * zoomScale);
+ rectF.top = (float)(Double.parseDouble(size.get("top") + "") * zoomScale);
+ rectF.right = (float)(Double.parseDouble(size.get("right") + "") * zoomScale);
+ rectF.bottom = (float)(Double.parseDouble(size.get("bottom") + "") * zoomScale);
+
+
+ newBufferRectFs.put(domId, rectF);
+
+ domInfo.remove("size");
+ newBuffer.put(domId, domInfo);
+ }
+
+ Map oldBuffer = HTMLNodes;
+ Map oldBufferRectFs = HTMLNodeRectFs;
+
+ synchronized (_lockHtmlNodes) {
+ HTMLNodes = newBuffer;
+ HTMLNodeRectFs = newBufferRectFs;
+ }
+
+ String[] keys = oldBuffer.keySet().toArray(new String[oldBuffer.size()]);
+ for (int i = 0; i < oldBuffer.size(); i++) {
+ oldBuffer.remove(keys[i]);
+ oldBufferRectFs.remove(keys[i]);
+ }
+ }
+
+ public void setDebug(final boolean debug) {
+ this.isDebug = debug;
+ mActivity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ if (debug) {
+ inValidate();
+ }
+ }
+ });
+ }
+
+ public IPluginView removePluginOverlay(final String overlayId) {
+ if (pluginOverlays == null || !pluginOverlays.containsKey(overlayId)) {
+ return null;
+ }
+ final IPluginView pluginOverlay = pluginOverlays.remove(overlayId);
+
+ mActivity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ scrollFrameLayout.removeView(pluginOverlay.getView());
+ pluginOverlay.getView().removeView(touchableWrappers.remove(overlayId));
+
+ //Log.d("MyPluginLayout", "--> removePluginMap / overlayId = " + overlayId);
+
+
+ //mActivity.getWindow().getDecorView().requestFocus();
+ } catch (Exception e) {
+ // ignore
+ //e.printStackTrace();
+ }
+ }
+ });
+ return pluginOverlay;
+ }
+
+ public void addPluginOverlay(final IPluginView pluginOverlay) {
+ if (pluginOverlay.getDivId() == null) {
+ return;
+ }
+
+ if (!HTMLNodes.containsKey(pluginOverlay.getDivId())) {
+ Log.e(TAG, "----> 200x200");
+ Bundle dummyInfo = new Bundle();
+ dummyInfo.putDouble("offsetX", 0);
+ dummyInfo.putDouble("offsetY", 3000);
+ dummyInfo.putBoolean("isDummy", true);
+ HTMLNodes.put(pluginOverlay.getDivId(), dummyInfo);
+ HTMLNodeRectFs.put(pluginOverlay.getDivId(), new RectF(0, 3000, 200, 200));
+ }
+ pluginOverlays.put(pluginOverlay.getOverlayId(), pluginOverlay);
+
+ mActivity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ if (pluginOverlay.getView().getParent() == null) {
+ TouchableWrapper wrapper = new TouchableWrapper(context);
+ touchableWrappers.put(pluginOverlay.getOverlayId(), wrapper);
+ pluginOverlay.getView().addView(wrapper);
+ int depth = pluginOverlay.getViewDepth();
+ int childCnt = scrollFrameLayout.getChildCount();
+ View view;
+ int index = childCnt;
+ for (int i = childCnt - 1; i >= 0; i--) {
+ view = scrollFrameLayout.getChildAt(i);
+ if (view.getTag() == null) {
+ continue;
+ }
+ if (Integer.parseInt(view.getTag() + "") < depth) {
+ index = i;
+ break;
+ }
+ }
+
+ scrollFrameLayout.addView(pluginOverlay.getView(), (childCnt - index));
+ }
+
+ //mActivity.getWindow().getDecorView().requestFocus();
+
+ //updateViewPosition(pluginMap.mapId);
+
+ }
+ });
+ }
+
+ public void scrollTo(int x, int y) {
+ this.scrollView.scrollTo(x, y);
+ }
+
+ public void inValidate() {
+ this.frontLayer.invalidate();
+ }
+
+ @Override
+ public void onScrollChanged() {
+//Log.d("Layout", "---> onScrollChanged");
+ scrollView.scrollTo(browserView.getScrollX(), browserView.getScrollY());
+ }
+
+ private class Overflow {
+ boolean cropX;
+ boolean cropY;
+ RectF rect;
+ }
+
+ private class FrontLayerLayout extends FrameLayout {
+
+ public FrontLayerLayout(Context context) {
+ super(context);
+ this.setWillNotDraw(false);
+ }
+
+ private String findClickedDom(String domId, PointF clickPoint, boolean isMapChild, Overflow overflow) {
+ if (CACHE_FIND_DOM.containsKey(domId)) {
+ String cacheResult = CACHE_FIND_DOM.get(domId);
+ if ("(null)".equals(cacheResult)) {
+ cacheResult = null;
+ }
+ return cacheResult;
+ }
+
+ Overflow overflow1 = null;
+ if (overflow != null) {
+ overflow1 = new Overflow();
+ overflow1.cropX = overflow.cropX;
+ overflow1.cropY = overflow.cropY;
+ overflow1.rect = new RectF(overflow.rect.left, overflow.rect.top, overflow.rect.right, overflow.rect.bottom);
+ }
+ //Log.d(TAG, "-(findClickedDom)domId = " + domId + ", clickPoint = " + clickPoint.x + ", " + clickPoint.y);
+
+ String maxDomId = null;
+ RectF rect, rect2, rect3;
+ Bundle domInfo = HTMLNodes.get(domId);
+ Bundle zIndexProp;
+ int containMapCnt = 0;
+ if (domInfo.containsKey("containMapIDs")) {
+ Set keys = domInfo.getBundle("containMapIDs").keySet();
+ if (keys != null) {
+ containMapCnt = keys.size();
+ }
+ }
+ isMapChild = isMapChild || domInfo.getBoolean("isMap", false);
+
+ String pointerEvents = domInfo.getString("pointerEvents");
+ String overflowX = domInfo.getString("overflowX");
+ String overflowY = domInfo.getString("overflowY");
+ if ("hidden".equals(overflowX) || "scroll".equals(overflowX) ||
+ "hidden".equals(overflowY) || "scroll".equals(overflowY)) {
+ overflow1 = new Overflow();
+ overflow1.cropX = "hidden".equals(overflowX) || "scroll".equals(overflowX);
+ overflow1.cropY = "hidden".equals(overflowY) || "scroll".equals(overflowY);
+ rect3 = HTMLNodeRectFs.get(domId);
+ overflow1.rect = new RectF(rect3.left, rect3.top, rect3.right, rect3.bottom);
+ } else if ("visible".equals(overflowX) || "visible".equals(overflowY)) {
+ if (overflow1 != null) {
+ overflow1.cropX = !"visible".equals(overflowX);
+ overflow1.cropY = !"visible".equals(overflowY);
+ }
+ }
+
+ //if (overflow1 != null) {
+ // Log.d(TAG, "--domId = " + domId + ", domInfo = " + domInfo + "\n" +
+ // " overflow1 cropX= " + overflow1.cropX + ", cropY = " + overflow1.cropY + ",\n" +
+ // " rect = " + overflow1.rect.toShortString());
+ //} else {
+ // Log.d(TAG, "--domId = " + domId + ", domInfo = " + domInfo);
+ //}
+
+ zIndexProp = domInfo.getBundle("zIndex");
+ ArrayList children = domInfo.getStringArrayList("children");
+ if ((containMapCnt > 0 || isMapChild || "none".equals(pointerEvents) || zIndexProp.getBoolean("isInherit")) && children != null && children.size() > 0) {
+ int maxZindex = (int) Double.NEGATIVE_INFINITY;
+ int zIndexValue;
+ String childId, grandChildId;
+ ArrayList grandChildren;
+ for (int i = children.size() - 1; i >= 0; i--) {
+ childId = children.get(i);
+ domInfo = HTMLNodes.get(childId);
+ if (domInfo == null) {
+ continue;
+ }
+
+ zIndexProp = domInfo.getBundle("zIndex");
+ zIndexValue = zIndexProp.getInt("z");
+ if (maxZindex < zIndexValue || zIndexProp.getBoolean("isInherit")) {
+ grandChildren = domInfo.getStringArrayList("children");
+ if (grandChildren == null || grandChildren.size() == 0) {
+ rect = HTMLNodeRectFs.get(childId);
+ rect2 = new RectF(rect.left, rect.top, rect.right, rect.bottom);
+ if (overflow1 != null && !"root".equals(domId) ) {
+ overflow1.rect = new RectF(HTMLNodeRectFs.get(domId));
+ if (overflow1.cropX) {
+ rect2.left = Math.max(rect2.left, overflow1.rect.left);
+ rect2.right = Math.min(rect2.right, overflow1.rect.right);
+ }
+ if (overflow1.cropY) {
+ rect2.top = Math.max(rect2.top, overflow1.rect.top);
+ rect2.bottom = Math.min(rect2.bottom, overflow1.rect.bottom);
+ }
+ }
+ if (!rect2.contains(clickPoint.x, clickPoint.y)) {
+ continue;
+ }
+
+ //Log.d(TAG, "---childId = " + childId + ", domInfo = " + domInfo);
+ if ("none".equals(domInfo.getString("pointerEvents"))) {
+ continue;
+ }
+ //Log.d(TAG, "----childId = " + childId + ", maxZindex = " + maxZindex + ", zIndexValue = " + zIndexValue);
+ if (maxZindex < zIndexValue) {
+ maxZindex = zIndexValue;
+ maxDomId = childId;
+ //Log.i(TAG, "-----current = " + childId);
+ }
+ } else {
+ if (zIndexValue < maxZindex) {
+ //Log.i(TAG, "-----skip because " + childId + " is " + zIndexValue + " < " + maxZindex);
+ continue;
+ }
+ grandChildId = findClickedDom(childId, clickPoint, isMapChild, overflow1);
+ if (grandChildId == null) {
+ grandChildId = childId;
+ } else {
+ zIndexValue = HTMLNodes.get(grandChildId).getBundle("zIndex").getInt("z");
+ }
+ rect = HTMLNodeRectFs.get(grandChildId);
+ //rect2 = new RectF(rect);
+ //Log.d(TAG, "---findClickedDom("+ childId + ") -> " + grandChildId + ",rect = " + rect2.toShortString());
+ /*
+ if (overflow1 != null && !"root".equals(domId) ) {
+ overflow1.rect = new RectF(HTMLNodeRectFs.get(domId));
+ if (overflow1.cropX) {
+ rect2.left = Math.max(rect2.left, overflow1.rect.left);
+ rect2.right = Math.min(rect2.right, overflow1.rect.right);
+ }
+ if (overflow1.cropY) {
+ rect2.top = Math.max(rect2.top, overflow1.rect.top);
+ rect2.bottom = Math.min(rect2.bottom, overflow1.rect.bottom);
+ }
+ //Log.d(TAG, "---overflow(" + domId + ") -> " + overflow1.rect.toShortString() + ", \n"+
+ // " str=" + HTMLNodeRectFs.get(domId) + ",\n" +
+ // " overflowX = " + overflowX + ", overflowY = " + overflowY +
+ // " cropX = " + overflow1.cropX + ", cropY = " + overflow1.cropY);
+ }
+ */
+ if (!rect.contains(clickPoint.x, clickPoint.y)) {
+ //Log.e(TAG, "----the click point is not in this element(" +grandChildId + "), rect = " + rect2.toShortString() + ", click = " + clickPoint.x + "," + clickPoint.y );
+ continue;
+ }
+
+ domInfo = HTMLNodes.get(grandChildId);
+ //Log.d(TAG, "----grandChildId = " + grandChildId + ", domInfo = " + domInfo);
+ if ("none".equals(domInfo.getString("pointerEvents"))) {
+ //Log.e(TAG, "-----grandChildId(" + grandChildId + ") is " + domInfo.getString("pointerEvents"));
+ continue;
+ }
+ //Log.d(TAG, "----grandChildId = " + grandChildId + ", maxZindex = " + maxZindex + ", zIndexValue = " + zIndexValue);
+ if (maxZindex < zIndexValue) {
+ maxZindex = zIndexValue;
+ maxDomId = grandChildId;
+ //Log.i(TAG, "-----current = " + grandChildId);
+ }
+ }
+ }
+ }
+ }
+ if (maxDomId == null && !"root".equals(domId)) {
+ if ("none".equals(pointerEvents)) {
+ CACHE_FIND_DOM.put(domId, "(null)");
+ return null;
+ }
+ rect = HTMLNodeRectFs.get(domId);
+ rect2 = new RectF(rect.left, rect.top, rect.right, rect.bottom);
+// if (overflow1 != null ) {
+// overflow1.rect = new RectF(HTMLNodeRectFs.get(domId));
+// if (overflow1.cropX) {
+// rect2.left = Math.max(rect2.left, overflow1.rect.left);
+// rect2.right = Math.min(rect2.right, overflow1.rect.right);
+// }
+// if (overflow1.cropY) {
+// rect2.top = Math.max(rect2.top, overflow1.rect.top);
+// rect2.bottom = Math.min(rect2.bottom, overflow1.rect.bottom);
+// }
+// }
+ if (!rect2.contains(clickPoint.x, clickPoint.y)) {
+ //Log.e(TAG, "--the click point is not in this element(" +domId + "), rect = " + rect2.toShortString() + ", click = " + clickPoint.x + "," + clickPoint.y );
+ CACHE_FIND_DOM.put(domId, "(null)");
+ return null;
+ }
+ maxDomId = domId;
+ }
+ if (maxDomId == null) {
+ CACHE_FIND_DOM.put(domId, "(null)");
+ } else {
+ CACHE_FIND_DOM.put(domId, maxDomId);
+ }
+ //Log.i(TAG, "-maxDomId = " + maxDomId + ", domId = " + domId);
+
+ return maxDomId;
+ }
+
+ @Override
+ public boolean onInterceptTouchEvent(MotionEvent event) {
+ if (pluginOverlays == null || pluginOverlays.size() == 0) {
+ return false;
+ }
+ MyPluginLayout.this.stopFlag = true;
+
+ int action = event.getAction();
+ //Log.d("FrontLayerLayout", "----> action = " + action + ", isScrolling = " + isScrolling);
+
+ // The scroll action that started in the browser region is end.
+ isScrolling = action != MotionEvent.ACTION_UP && isScrolling;
+ if (isScrolling) {
+ MyPluginLayout.this.stopFlag = false;
+ return false;
+ }
+
+
+ IPluginView pluginOverlay;
+ Iterator> iterator = pluginOverlays.entrySet().iterator();
+ Entry entry;
+
+ PointF clickPoint = new PointF(event.getX(), event.getY());
+
+ RectF drawRect;
+
+ synchronized (_lockHtmlNodes) {
+ CACHE_FIND_DOM.clear();
+
+ String clickedDomId = findClickedDom("root", clickPoint, false, null);
+ //Log.d(TAG, "----clickedDomId = " + clickedDomId);
+ while (iterator.hasNext()) {
+ entry = iterator.next();
+ pluginOverlay = entry.getValue();
+
+ //-----------------------
+ // Is the map clickable?
+ //-----------------------
+ if (!pluginOverlay.getVisible() || !pluginOverlay.getClickable()) {
+ continue;
+ }
+
+ if (pluginOverlay.getDivId() == null) {
+ continue;
+ }
+
+ //------------------------------------------------
+ // Is the clicked point is in the map rectangle?
+ //------------------------------------------------
+ drawRect = HTMLNodeRectFs.get(pluginOverlay.getDivId());
+ if (drawRect == null || !drawRect.contains(clickPoint.x, clickPoint.y)) {
+ continue;
+ }
+
+ if (pluginOverlay.getDivId().equals(clickedDomId)) {
+ return true;
+ }
+
+ }
+ }
+ isScrolling = (action == MotionEvent.ACTION_DOWN) || isScrolling;
+
+ //browserView.requestFocus(View.FOCUS_DOWN);
+ return false;
+ }
+
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ if (isSuspended || HTMLNodes.isEmpty() || !isDebug) {
+ return;
+ }
+
+ IPluginView pluginOverlay;
+ Iterator> iterator = pluginOverlays.entrySet().iterator();
+ Entry entry;
+ RectF mapRect;
+ synchronized (_lockHtmlNodes) {
+ while (iterator.hasNext()) {
+ entry = iterator.next();
+ pluginOverlay = entry.getValue();
+ if (pluginOverlay.getDivId() == null) {
+ continue;
+ }
+ mapRect = HTMLNodeRectFs.get(pluginOverlay.getDivId());
+
+ debugPaint.setColor(Color.argb(100, 0, 255, 0));
+ canvas.drawRect(mapRect, debugPaint);
+ }
+ }
+
+
+ }
+ }
+
+ private class TouchableWrapper extends FrameLayout {
+
+ public TouchableWrapper(Context context) {
+ super(context);
+ }
+
+ @Override
+ public boolean dispatchTouchEvent(MotionEvent event) {
+ int action = event.getAction();
+ if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_UP) {
+ scrollView.requestDisallowInterceptTouchEvent(true);
+ }
+ return super.dispatchTouchEvent(event);
+ }
+ }
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/ObjectCache.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/ObjectCache.java
new file mode 100644
index 0000000..12df5d2
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/ObjectCache.java
@@ -0,0 +1,46 @@
+package plugin.google.maps;
+
+import android.util.LruCache;
+
+import java.util.HashSet;
+
+public class ObjectCache {
+ public final HashSet keys = new HashSet();
+ private LruCache objects = new LruCache(1024 * 1024 * 10);
+
+ public boolean containsKey(String key) {
+ return keys.contains(key);
+ }
+
+ public void put(String key, Object object) {
+ keys.add(key);
+ objects.put(key, object);
+ }
+
+ public Object remove(String key) {
+ keys.remove(key);
+ return objects.remove(key);
+ }
+
+ public Object get(String key) {
+ return objects.get(key);
+ }
+
+ public int size() {
+ return objects.size();
+ }
+
+
+ public void clear() {
+ for (String key : keys) {
+ objects.remove(key);
+ }
+ keys.clear();
+ }
+
+ public void destroy() {
+ objects.evictAll();
+ }
+
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginAsyncInterface.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginAsyncInterface.java
new file mode 100644
index 0000000..322eeb6
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginAsyncInterface.java
@@ -0,0 +1,6 @@
+package plugin.google.maps;
+
+public interface PluginAsyncInterface {
+ public void onPostExecute(Object object);
+ public void onError(String errorMsg);
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginCircle.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginCircle.java
new file mode 100644
index 0000000..8b53685
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginCircle.java
@@ -0,0 +1,267 @@
+package plugin.google.maps;
+
+import com.google.android.gms.maps.model.Circle;
+import com.google.android.gms.maps.model.CircleOptions;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.LatLngBounds;
+
+import org.apache.cordova.CallbackContext;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class PluginCircle extends MyPlugin implements MyPluginInterface {
+
+ private String circleHashCode;
+
+ /**
+ * Create circle
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void create(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final CircleOptions circleOptions = new CircleOptions();
+ int color;
+ final JSONObject properties = new JSONObject();
+
+ JSONObject opts = args.getJSONObject(1);
+ final String hashCode = args.getString(2);
+ circleHashCode = hashCode;
+
+ if (opts.has("center")) {
+ JSONObject center = opts.getJSONObject("center");
+ circleOptions.center(new LatLng(center.getDouble("lat"), center.getDouble("lng")));
+ }
+ if (opts.has("radius")) {
+ circleOptions.radius(opts.getDouble("radius"));
+ }
+ if (opts.has("strokeColor")) {
+ color = PluginUtil.parsePluginColor(opts.getJSONArray("strokeColor"));
+ circleOptions.strokeColor(color);
+ }
+ if (opts.has("fillColor")) {
+ color = PluginUtil.parsePluginColor(opts.getJSONArray("fillColor"));
+ circleOptions.fillColor(color);
+ }
+ if (opts.has("strokeWidth")) {
+ circleOptions.strokeWidth((int)(opts.getDouble("strokeWidth") * density));
+ }
+ if (opts.has("visible")) {
+ circleOptions.visible(opts.getBoolean("visible"));
+ }
+ if (opts.has("zIndex")) {
+ circleOptions.zIndex(opts.getInt("zIndex"));
+ }
+ if (opts.has("clickable")) {
+ properties.put("isClickable", opts.getBoolean("clickable"));
+ } else {
+ properties.put("isClickable", true);
+ }
+ properties.put("isVisible", circleOptions.isVisible());
+
+ // Since this plugin provide own click detection,
+ // disable default clickable feature.
+ circleOptions.clickable(false);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ Circle circle = map.addCircle(circleOptions);
+ circle.setTag(hashCode);
+ pluginMap.objects.put("circle_" + hashCode, circle);
+
+ pluginMap.objects.put("circle_property_" + hashCode, properties);
+
+ // Recalculate the circle bounds
+ LatLngBounds bounds = PluginUtil.getBoundsFromCircle(circleOptions.getCenter(), circleOptions.getRadius());
+ pluginMap.objects.put("circle_bounds_" + hashCode, bounds);
+
+ JSONObject result = new JSONObject();
+ try {
+ result.put("hashCode", hashCode);
+ result.put("__pgmId", "circle_" + hashCode);
+ callbackContext.success(result);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ callbackContext.error(e.getMessage() + "");
+ }
+ }
+ });
+
+ }
+
+
+ /**
+ * set center
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void setCenter(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final LatLng center = new LatLng(args.getDouble(1), args.getDouble(2));
+ final Circle circle = this.getCircle(id);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Recalculate the circle bounds
+ String propertyId = "circle_bounds_" + circleHashCode;
+ LatLngBounds bounds = PluginUtil.getBoundsFromCircle(circle.getCenter(), circle.getRadius());
+ pluginMap.objects.put(propertyId, bounds);
+
+ circle.setCenter(center);
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * set fill color
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void setFillColor(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ int color = PluginUtil.parsePluginColor(args.getJSONArray(1));
+ this.setInt("setFillColor", id, color, callbackContext);
+ }
+
+ /**
+ * set stroke color
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void setStrokeColor(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ int color = PluginUtil.parsePluginColor(args.getJSONArray(1));
+ this.setInt("setStrokeColor", id, color, callbackContext);
+ }
+
+ /**
+ * set stroke width
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void setStrokeWidth(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ float width = (float)(args.getDouble(1) * density);
+ this.setFloat("setStrokeWidth", id, width, callbackContext);
+ }
+
+ /**
+ * set radius
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void setRadius(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final float radius = (float) args.getDouble(1);
+ final Circle circle = this.getCircle(id);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ // Recalculate the circle bounds
+ String propertyId = "circle_bounds_" + circleHashCode;
+ LatLngBounds bounds = PluginUtil.getBoundsFromCircle(circle.getCenter(), circle.getRadius());
+ pluginMap.objects.put(propertyId, bounds);
+
+ // Update the overlay
+ circle.setRadius(radius);
+ callbackContext.success();
+ }
+ });
+
+ }
+
+ /**
+ * set z-index
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void setZIndex(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ float zIndex = (float) args.getDouble(1);
+ this.setFloat("setZIndex", id, zIndex, callbackContext);
+ }
+
+
+ /**
+ * Set visibility for the object
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setVisible(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final boolean isVisible = args.getBoolean(1);
+
+ final Circle circle = this.getCircle(id);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ circle.setVisible(isVisible);
+ }
+ });
+ String propertyId = "circle_property_" + circleHashCode;
+ JSONObject properties = (JSONObject)pluginMap.objects.get(propertyId);
+ properties.put("isVisible", isVisible);
+ pluginMap.objects.put(propertyId, properties);
+ callbackContext.success();
+ }
+
+ /**
+ * Set clickable for the object
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setClickable(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final boolean clickable = args.getBoolean(1);
+ String propertyId = id.replace("circle_", "circle_property_");
+ JSONObject properties = (JSONObject)pluginMap.objects.get(propertyId);
+ properties.put("isClickable", clickable);
+ pluginMap.objects.put(propertyId, properties);
+ callbackContext.success();
+ }
+ /**
+ * Remove the circle
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void remove(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final String id = args.getString(0);
+ final Circle circle = this.getCircle(id);
+ if (circle == null) {
+ callbackContext.success();
+ return;
+ }
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ circle.remove();
+ if (pluginMap.objects != null) {
+ pluginMap.objects.remove(id);
+ }
+ callbackContext.success();
+ }
+ });
+ }
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginEnvironment.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginEnvironment.java
new file mode 100644
index 0000000..df8eb98
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginEnvironment.java
@@ -0,0 +1,133 @@
+package plugin.google.maps;
+
+import android.content.Intent;
+import android.graphics.Color;
+import android.net.Uri;
+import android.os.Handler;
+import android.util.Log;
+
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.PluginManager;
+import org.apache.cordova.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+import java.lang.reflect.Method;
+
+public class PluginEnvironment extends CordovaPlugin {
+ public PluginManager pluginManager;
+
+ @Override
+ public void initialize(final CordovaInterface cordova, final CordovaWebView webView) {
+ pluginManager = webView.getPluginManager();
+ }
+
+ @Override
+ public boolean execute(final String action, final JSONArray args, final CallbackContext callbackContext) {
+ cordova.getThreadPool().submit(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ Method method = PluginEnvironment.this.getClass().getDeclaredMethod(action, JSONArray.class, CallbackContext.class);
+ if (!method.isAccessible()) {
+ method.setAccessible(true);
+ }
+ method.invoke(PluginEnvironment.this, args, callbackContext);
+ } catch (Exception e) {
+ Log.e("CordovaLog", "An error occurred", e);
+ callbackContext.error(e.toString());
+ }
+ }
+ });
+
+ return true;
+ }
+
+ @SuppressWarnings("unused")
+ public void isAvailable(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ // ------------------------------
+ // Check of Google Play Services
+ // ------------------------------
+ int checkGooglePlayServices =
+ GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(cordova.getActivity());
+ if (checkGooglePlayServices != ConnectionResult.SUCCESS) {
+ String errorMsg = GoogleApiAvailability.getInstance().getErrorString(checkGooglePlayServices);
+ callbackContext.error(errorMsg);
+
+ try {
+ cordova.getActivity().startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=com.google.android.gms")));
+ } catch (android.content.ActivityNotFoundException anfe) {
+ cordova.getActivity().startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("http://play.google.com/store/apps/details?id=com.google.android.gms")));
+ }
+
+ // End the app (in order to prevent lots of crashes)
+ cordova.getActivity().finish();
+
+ return;
+ }
+
+ // ------------------------------
+ // Check of Google Maps Android API v2
+ // ------------------------------
+ try {
+ @SuppressWarnings({ "rawtypes" })
+ Class GoogleMapsClass = Class.forName("com.google.android.gms.maps.GoogleMap");
+ } catch (Exception e) {
+ Log.e("GoogleMaps", "Error", e);
+ callbackContext.error(e.getMessage());
+ return;
+ }
+ callbackContext.success();
+ }
+
+
+
+ /**
+ * Set the app background
+ * @param args Parameters given from JavaScript side
+ * @param callbackContext Callback contect for sending back the result.
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void setBackGroundColor(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ JSONArray rgba = args.getJSONArray(0);
+ int backgroundColor = Color.WHITE;
+
+ if (rgba != null && rgba.length() == 4) {
+ backgroundColor = PluginUtil.parsePluginColor(rgba);
+ }
+ final int finalBackgroundColor = backgroundColor;
+
+
+ final CordovaGoogleMaps googleMaps = (CordovaGoogleMaps) pluginManager.getPlugin("CordovaGoogleMaps");
+
+ Handler handler = new Handler(cordova.getActivity().getMainLooper());
+ handler.postDelayed(new Runnable() {
+ public void run() {
+ googleMaps.mPluginLayout.setBackgroundColor(finalBackgroundColor);
+ callbackContext.success();
+ }
+ }, googleMaps.initialized ? 0 : 250);
+ }
+
+ @SuppressWarnings("unused")
+ public Boolean getLicenseInfo(JSONArray args, final CallbackContext callbackContext) {
+ callbackContext.success("Google Maps Android API v2 does not need this method anymore. But for iOS, you still need to display the lincense.");
+ return true;
+ }
+
+ @SuppressWarnings("unused")
+ public Boolean setEnv(JSONArray args, final CallbackContext callbackContext) {
+ // stub
+ callbackContext.success();
+ return true;
+ }
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginGeocoder.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginGeocoder.java
new file mode 100644
index 0000000..c2cda46
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginGeocoder.java
@@ -0,0 +1,252 @@
+package plugin.google.maps;
+
+import android.location.Address;
+import android.location.Geocoder;
+import android.os.Bundle;
+
+import com.google.android.gms.maps.model.LatLngBounds;
+
+import org.apache.cordova.CallbackContext;
+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.io.IOException;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class PluginGeocoder extends CordovaPlugin {
+
+ // In order to prevent the TOO_MANY_REQUEST_ERROR (block by Google because too many request in short period),
+ // restricts the number of parallel threads.
+ //
+ // According from my tests, 5 threads are the best setting.
+ private static ExecutorService executorService = Executors.newFixedThreadPool(5);
+ private static Geocoder geocoder = null;
+
+
+ public void initialize(CordovaInterface cordova, final CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ if (geocoder == null) {
+ geocoder = new Geocoder(cordova.getActivity());
+ }
+ }
+
+
+ @Override
+ public boolean execute(final String action, final JSONArray args, final CallbackContext callbackContext) {
+ executorService.submit(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ if ("geocode".equals(action)) {
+ PluginGeocoder.this.geocode(args, callbackContext);
+ } else {
+ callbackContext.error("Method: Geocoder." + action + "() is not found.");
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ callbackContext.error(e.getMessage() + "");
+ }
+ }
+ });
+ return true;
+ }
+
+ @SuppressWarnings("unused")
+ private void geocode(final JSONArray args,
+ final CallbackContext callbackContext) throws JSONException, IOException {
+
+ JSONObject opts = args.getJSONObject(0);
+ List geoResults = null;
+ JSONArray results = new JSONArray();
+ Iterator iterator = null;
+ int retryLimit = 10;
+
+ // Geocoding
+ if (!opts.has("position") && opts.has("address")) {
+ String address = opts.getString("address");
+ if (opts.has("bounds")) {
+ if (opts.has("bounds")) {
+ JSONArray points = opts.getJSONArray("bounds");
+ LatLngBounds bounds = PluginUtil.JSONArray2LatLngBounds(points);
+
+ boolean retry = true;
+ while (retry && retryLimit > 0) {
+ retry = false;
+ try {
+ geoResults = geocoder.getFromLocationName(address, 5,
+ bounds.southwest.latitude, bounds.southwest.longitude,
+ bounds.northeast.latitude, bounds.northeast.longitude);
+ } catch (IOException e) {
+ if ("Timed out waiting for response from server".equals(e.getMessage())) {
+ retry = true;
+ retryLimit--;
+ try {
+ Thread.sleep((int)(150 + Math.random() * 100)); // wait (150 + random)ms before retry
+ } catch (InterruptedException e1) {
+ //e1.printStackTrace();
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ if (geoResults.size() == 0) {
+ JSONObject methodResult = new JSONObject();
+ methodResult.put("idx", opts.getInt("idx"));
+ methodResult.put("results", new JSONArray());
+
+ PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, methodResult);
+ callbackContext.sendPluginResult(pluginResult);
+
+ return;
+ }
+ iterator = geoResults.iterator();
+ }
+ } else {
+
+ boolean retry = true;
+ while (retry) {
+ retry = false;
+ try {
+ geoResults = geocoder.getFromLocationName(address, 5);
+ } catch (IOException e) {
+ if ("Timed out waiting for response from server".equals(e.getMessage())) {
+ retry = true;
+ try {
+ Thread.sleep((int)(150 + Math.random() * 100)); // wait (150 + random)ms before retry
+ } catch (InterruptedException e1) {
+ //e1.printStackTrace();
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ if (geoResults == null || geoResults.size() == 0) {
+ JSONObject methodResult = new JSONObject();
+ methodResult.put("idx", opts.getInt("idx"));
+ methodResult.put("results", new JSONArray());
+
+ PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, methodResult);
+ callbackContext.sendPluginResult(pluginResult);
+
+ return;
+ }
+ iterator = geoResults.iterator();
+ }
+ }
+
+ // Reverse geocoding
+ if (opts.has("position") && !opts.has("address")) {
+ JSONObject position = opts.getJSONObject("position");
+
+ boolean retry = true;
+ while (retry && retryLimit > 0) {
+ retry = false;
+ try {
+ geoResults = geocoder.getFromLocation(
+ position.getDouble("lat"),
+ position.getDouble("lng"), 5);
+ } catch (IOException e) {
+ if ("Timed out waiting for response from server".equals(e.getMessage())) {
+ retry = true;
+ retryLimit--;
+ try {
+ Thread.sleep((int)(150 + Math.random() * 100)); // wait (150 + random)ms before retry
+ } catch (InterruptedException e1) {
+ //e1.printStackTrace();
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ if (geoResults == null || geoResults.size() == 0) {
+ //-------------
+ // No results
+ //-------------
+ JSONObject methodResult = new JSONObject();
+ methodResult.put("idx", opts.getInt("idx"));
+ methodResult.put("results", new JSONArray());
+
+ PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, methodResult);
+ callbackContext.sendPluginResult(pluginResult);
+
+ return;
+ }
+ iterator = geoResults.iterator();
+ }
+
+ if (iterator == null) {
+ callbackContext.error( "Invalid request for geocoder");
+ return;
+ }
+
+ while(iterator.hasNext()) {
+ JSONObject result = new JSONObject();
+ Address addr = iterator.next();
+
+ JSONObject position = new JSONObject();
+ position.put("lat", addr.getLatitude());
+ position.put("lng", addr.getLongitude());
+ result.put("position", position);
+
+ result.put("locality", addr.getLocality());
+ result.put("adminArea", addr.getAdminArea());
+ result.put("country", addr.getCountryName());
+ result.put("countryCode", addr.getCountryCode());
+ result.put("locale", addr.getLocale());
+ result.put("postalCode", addr.getPostalCode());
+ result.put("subAdminArea", addr.getSubAdminArea());
+ result.put("subLocality", addr.getSubLocality());
+ result.put("subThoroughfare", addr.getSubThoroughfare());
+ result.put("thoroughfare", addr.getThoroughfare());
+
+
+ JSONObject extra = new JSONObject();
+ extra.put("featureName", addr.getFeatureName());
+ extra.put("phone", addr.getPhone());
+ extra.put("permises", addr.getPremises());
+ extra.put("url", addr.getUrl());
+
+ JSONArray lines = new JSONArray();
+ // Handled cases where we have only one line address.
+ for (int i = 0; i <= addr.getMaxAddressLineIndex(); i++) {
+ lines.put(addr.getAddressLine(i));
+ }
+ extra.put("lines", lines);
+
+
+ Bundle extraInfo = addr.getExtras();
+ if (extraInfo != null) {
+ Set keys = extraInfo.keySet();
+ Iterator keyIterator = keys.iterator();
+ String key;
+ while(keyIterator.hasNext()) {
+ key = keyIterator.next();
+ extra.put(key, extraInfo.get(key));
+ }
+ }
+ result.put("extra", extra);
+ results.put(result);
+ }
+
+ JSONObject methodResult = new JSONObject();
+ methodResult.put("idx", opts.getInt("idx"));
+ methodResult.put("results", results);
+
+ PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, methodResult);
+ callbackContext.sendPluginResult(pluginResult);
+ }
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginGroundOverlay.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginGroundOverlay.java
new file mode 100644
index 0000000..e5ba35e
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginGroundOverlay.java
@@ -0,0 +1,661 @@
+package plugin.google.maps;
+
+import android.graphics.Bitmap;
+import android.os.AsyncTask;
+
+import com.google.android.gms.maps.model.BitmapDescriptor;
+import com.google.android.gms.maps.model.BitmapDescriptorFactory;
+import com.google.android.gms.maps.model.GroundOverlay;
+import com.google.android.gms.maps.model.GroundOverlayOptions;
+import com.google.android.gms.maps.model.LatLngBounds;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.Set;
+
+public class PluginGroundOverlay extends MyPlugin implements MyPluginInterface {
+
+ private HashMap imageLoadingTasks = new HashMap();
+ private final Object semaphore = new Object();
+ private HashMap overlayImage = new HashMap();
+ private boolean _clearDone = false;
+
+ @Override
+ public void initialize(final CordovaInterface cordova, final CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ }
+
+ /**
+ * Create ground overlay
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void create(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ JSONObject opts = args.getJSONObject(1);
+ String hashCode = args.getString(2);
+ _createGroundOverlay(hashCode, opts, callbackContext);
+ }
+
+ public void _createGroundOverlay(final String idBase, final JSONObject opts, final CallbackContext callbackContext) throws JSONException {
+ final GroundOverlayOptions options = new GroundOverlayOptions();
+ final JSONObject properties = new JSONObject();
+ options.anchor(0.5f, 0.5f);
+
+ if (opts.has("anchor")) {
+ JSONArray anchor = opts.getJSONArray("anchor");
+ options.anchor((float)anchor.getDouble(0), (float)anchor.getDouble(1));
+ }
+ if (opts.has("bearing")) {
+ options.bearing((float)opts.getDouble("bearing"));
+ }
+ if (opts.has("opacity")) {
+ options.transparency(1 - (float)opts.getDouble("opacity"));
+ }
+ if (opts.has("zIndex")) {
+ options.zIndex((float)opts.getDouble("zIndex"));
+ }
+ if (opts.has("visible")) {
+ options.visible(opts.getBoolean("visible"));
+ }
+ if (opts.has("bounds")) {
+ JSONArray points = opts.getJSONArray("bounds");
+ LatLngBounds bounds = PluginUtil.JSONArray2LatLngBounds(points);
+ options.positionFromBounds(bounds);
+ }
+ if (opts.has("clickable")) {
+ properties.put("isClickable", opts.getBoolean("clickable"));
+ } else {
+ properties.put("isClickable", true);
+ }
+ properties.put("isVisible", options.isVisible());
+
+ // Since this plugin provide own click detection,
+ // disable default clickable feature.
+ options.clickable(false);
+
+ // Load image
+ final String imageUrl = opts.getString("url");
+
+ setImage_(imageUrl, new PluginAsyncInterface() {
+
+ @Override
+ public void onPostExecute(Object object) {
+ if (object == null) {
+ callbackContext.error("Cannot create a ground overlay");
+ return;
+ }
+
+ AsyncLoadImage.AsyncLoadImageResult result = (AsyncLoadImage.AsyncLoadImageResult)object;
+ BitmapDescriptor bitmapDescriptor = BitmapDescriptorFactory.fromBitmap(result.image);
+ options.image(bitmapDescriptor);
+ //options.zIndex(Calendar.getInstance().getTimeInMillis());
+ GroundOverlay groundOverlay = self.map.addGroundOverlay(options);
+ overlayImage.put("groundoverlay_" + idBase, result.image);
+
+ groundOverlay.setTag(idBase);
+
+ pluginMap.objects.put("groundoverlay_" + idBase, groundOverlay);
+
+ pluginMap.objects.put("groundoverlay_bounds_" + idBase, groundOverlay.getBounds());
+
+ pluginMap.objects.put("groundoverlay_property_" + idBase, properties);
+
+ pluginMap.objects.put("groundoverlay_initOpts_" + idBase, opts);
+
+
+ JSONObject resultJSON = new JSONObject();
+ try {
+ resultJSON.put("hashCode", idBase);
+ resultJSON.put("__pgmId", "groundoverlay_" + idBase);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ callbackContext.success(resultJSON);
+ }
+
+ @Override
+ public void onError(String errorMsg) {
+ callbackContext.error(errorMsg);
+ }
+
+ });
+ }
+
+
+ @Override
+ protected void clear() {
+ _clearDone = false;
+ synchronized (semaphore) {
+
+ //--------------------------------------
+ // clean up properties as much as possible
+ //--------------------------------------
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ Set keySet = pluginMap.objects.keys;
+ if (keySet.size() > 0) {
+ String[] objectIdArray = keySet.toArray(new String[keySet.size()]);
+
+ synchronized (pluginMap.objects) {
+ Bitmap image;
+ for (String objectId : objectIdArray) {
+ if (pluginMap.objects.containsKey(objectId)) {
+ if (objectId.startsWith("groundoverlay_") &&
+ !objectId.startsWith("groundoverlay_property_") &&
+ !objectId.startsWith("groundoverlay_initOpts_") &&
+ !objectId.startsWith("groundoverlay_bounds_")) {
+ GroundOverlay groundOverlay = (GroundOverlay) pluginMap.objects.remove(objectId);
+ image = overlayImage.remove(objectId);
+ if (image != null && !image.isRecycled()) {
+ image.recycle();
+ }
+ groundOverlay.setTag(null);
+ groundOverlay.remove();
+ groundOverlay = null;
+ } else {
+ Object object = pluginMap.objects.remove(objectId);
+ object = null;
+ }
+ }
+ }
+ }
+
+ synchronized (semaphore) {
+ _clearDone = true;
+ semaphore.notify();
+ }
+ }
+
+ }
+ });
+
+ Set keySet = pluginMap.objects.keys;
+ if (keySet.size() > 0) {
+ try {
+ if (!_clearDone) {
+ semaphore.wait(1000);
+ }
+ } catch (InterruptedException e) {
+ // ignore
+ //e.printStackTrace();
+ }
+ }
+ }
+ }
+
+ /**
+ * Remove this tile layer
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void remove(JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final String id = args.getString(0);
+ final GroundOverlay groundOverlay = (GroundOverlay)pluginMap.objects.get(id);
+ if (groundOverlay == null) {
+ callbackContext.success();
+ return;
+ }
+
+ synchronized (pluginMap.objects) {
+ pluginMap.objects.remove(id.replace("groundoverlay_", "groundoverlay_property_"));
+ pluginMap.objects.remove(id.replace("groundoverlay_", "groundoverlay_initOpts_"));
+ pluginMap.objects.remove(id.replace("groundoverlay_", "groundoverlay_bounds_"));
+ }
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ synchronized (pluginMap.objects) {
+ GroundOverlay groundOverlay = (GroundOverlay) pluginMap.objects.remove(id);
+ if (groundOverlay != null) {
+ Bitmap image = overlayImage.remove(id);
+ if (image != null && !image.isRecycled()) {
+ image.recycle();
+ }
+ groundOverlay.remove();
+ }
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+
+ /**
+ * Set image of the ground-overlay
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setImage(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final String id = args.getString(0);
+ final String url = args.getString(1);
+ final String idBase = id.replace("groundoverlay_", "");
+
+ String propertyId = "groundoverlay_initOpts_" + idBase;
+ final JSONObject opts = (JSONObject) pluginMap.objects.get(propertyId);
+ opts.put("url", url);
+ pluginMap.objects.put(propertyId, opts);
+
+ setImage_(url, new PluginAsyncInterface() {
+ @Override
+ public void onPostExecute(Object object) {
+ if (object == null) {
+ callbackContext.error("[error]groundoverlay.setImage(" + url + ")");
+ return;
+ }
+ AsyncLoadImage.AsyncLoadImageResult result = (AsyncLoadImage.AsyncLoadImageResult) object;
+ GroundOverlay groundOverlay = getGroundOverlay(id);
+ if (groundOverlay != null) {
+ Bitmap currentBmp = overlayImage.remove(id);
+ if (currentBmp != null) {
+ currentBmp.recycle();
+ }
+ }
+ if (result.image != null) {
+ overlayImage.put(id, result.image);
+ groundOverlay.setImage(BitmapDescriptorFactory.fromBitmap(result.image));
+ callbackContext.success();
+ } else {
+ callbackContext.error("[error]groundoverlay.setImage(" + url + ")");
+ }
+ }
+
+ @Override
+ public void onError(String errorMsg) {
+
+ }
+ });
+ }
+
+
+ /**
+ * Set bounds
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setBounds(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final GroundOverlay groundOverlay = (GroundOverlay)pluginMap.objects.get(id);
+
+ String propertyId = id.replace("groundoverlay_", "groundoverlay_initOpts_");
+ JSONObject opts = (JSONObject) pluginMap.objects.get(propertyId);
+
+ JSONArray points = args.getJSONArray(1);
+ opts.put("bounds", points);
+ pluginMap.objects.put(propertyId, opts);
+
+ final LatLngBounds bounds = PluginUtil.JSONArray2LatLngBounds(points);
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ groundOverlay.setPositionFromBounds(bounds);
+ }
+ });
+
+ String boundsId = id.replace("groundoverlay_", "groundoverlay_bounds_");
+ pluginMap.objects.put(boundsId, bounds);
+
+ callbackContext.success();
+ }
+
+ /**
+ * Set opacity
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setOpacity(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ float opacity = (float)args.getDouble(1);
+ String id = args.getString(0);
+
+ String propertyId = id.replace("groundoverlay_", "groundoverlay_initOpts_");
+ JSONObject opts = (JSONObject) pluginMap.objects.get(propertyId);
+ opts.put("opacity", opacity);
+ pluginMap.objects.put(propertyId, opts);
+
+ this.setFloat("setTransparency", id, 1 - opacity, callbackContext);
+ }
+ /**
+ * Set bearing
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setBearing(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ float bearing = (float)args.getDouble(1);
+ String id = args.getString(0);
+
+ String propertyId = id.replace("groundoverlay_", "groundoverlay_initOpts_");
+ JSONObject opts = (JSONObject) pluginMap.objects.get(propertyId);
+ opts.put("bearing", bearing);
+ pluginMap.objects.put(propertyId, opts);
+
+ this.setFloat("setBearing", id, bearing, callbackContext);
+ }
+ /**
+ * set z-index
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setZIndex(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ float zIndex = (float) args.getDouble(1);
+
+ String propertyId = id.replace("groundoverlay_", "groundoverlay_initOpts_");
+ JSONObject opts = (JSONObject) pluginMap.objects.get(propertyId);
+ opts.put("zIndex", zIndex);
+ pluginMap.objects.put(propertyId, opts);
+
+ this.setFloat("setZIndex", id, zIndex, callbackContext);
+ }
+
+
+ /**
+ * Set visibility for the object
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setVisible(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final boolean isVisible = args.getBoolean(1);
+
+ final GroundOverlay groundOverlay = this.getGroundOverlay(id);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ groundOverlay.setVisible(isVisible);
+ }
+ });
+ String propertyId = id.replace("groundoverlay_", "groundoverlay_property_");
+ JSONObject properties = (JSONObject)pluginMap.objects.get(propertyId);
+ properties.put("isVisible", isVisible);
+ pluginMap.objects.put(propertyId, properties);
+
+ propertyId = id.replace("groundoverlay_", "groundoverlay_initOpts_");
+ JSONObject opts = (JSONObject) pluginMap.objects.get(propertyId);
+ opts.put("visible", isVisible);
+ pluginMap.objects.put(propertyId, opts);
+
+ callbackContext.success();
+ }
+
+ /**
+ * Set clickable for the object
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setClickable(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final boolean clickable = args.getBoolean(1);
+ String propertyId = id.replace("groundoverlay_", "groundoverlay_property_");
+ JSONObject properties = (JSONObject)pluginMap.objects.get(propertyId);
+ properties.put("isClickable", clickable);
+ pluginMap.objects.put(propertyId, properties);
+ callbackContext.success();
+ }
+
+
+ private void setImage_(final String imgUrl, final PluginAsyncInterface callback) {
+ if (imgUrl == null) {
+ callback.onPostExecute(null);
+ return;
+ }
+
+ final AsyncLoadImage.AsyncLoadImageOptions imageOptions = new AsyncLoadImage.AsyncLoadImageOptions();
+ imageOptions.height = -1;
+ imageOptions.width = -1;
+ imageOptions.noCaching = true;
+ imageOptions.url = imgUrl;
+ final int taskId = imageOptions.hashCode();
+
+ final AsyncLoadImageInterface onComplete = new AsyncLoadImageInterface() {
+
+ @Override
+ public void onPostExecute(AsyncLoadImage.AsyncLoadImageResult result) {
+ if (result == null || result.image == null) {
+ callback.onError("Can not read image from " + imgUrl);
+ imageLoadingTasks.remove(taskId).cancel(true);
+ return;
+ }
+
+ callback.onPostExecute(result);
+
+ imageLoadingTasks.remove(taskId).cancel(true);
+ }
+ };
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ AsyncLoadImage task = new AsyncLoadImage(cordova, webView, imageOptions, onComplete);
+ //cordova.getActivity().runOnUiThread(new Runnable() {
+ // @Override
+ // public void run() {
+ // task.execute();
+ // }
+ //});
+ task.execute();
+ imageLoadingTasks.put(taskId, task);
+ }
+ });
+
+
+/*
+ if (imgUrl == null) {
+ callback.onPostExecute(null);
+ return;
+ }
+
+ if (!imgUrl.contains("://") &&
+ !imgUrl.startsWith("/") &&
+ !imgUrl.startsWith("www/") &&
+ !imgUrl.startsWith("data:image") &&
+ !imgUrl.startsWith("./") &&
+ !imgUrl.startsWith("../")) {
+ imgUrl = "./" + imgUrl;
+ }
+ if (imgUrl.startsWith("./") || imgUrl.startsWith("../")) {
+ imgUrl = imgUrl.replace("././", "./");
+ String currentPage = CURRENT_PAGE_URL;
+ currentPage = currentPage.replaceAll("[^\\/]*$", "");
+ imgUrl = currentPage + "/" + imgUrl;
+ }
+
+ if (imgUrl == null) {
+ callback.onPostExecute(null);
+ return;
+ }
+
+ final String imageUrl = imgUrl;
+ if (imageUrl.indexOf("http") != 0) {
+ //----------------------------------
+ // Load img from local file
+ //----------------------------------
+ AsyncTask task = new AsyncTask() {
+
+ @Override
+ protected Bitmap doInBackground(Void... params) {
+ String imgUrl = imageUrl;
+ if (imgUrl == null) {
+ return null;
+ }
+
+ Bitmap image = null;
+ if (imgUrl.indexOf("cdvfile://") == 0) {
+ CordovaResourceApi resourceApi = webView.getResourceApi();
+ imgUrl = PluginUtil.getAbsolutePathFromCDVFilePath(resourceApi, imgUrl);
+ }
+ if (imgUrl == null) {
+ return null;
+ }
+
+ if (imgUrl.indexOf("data:image/") == 0 && imgUrl.contains(";base64,")) {
+ String[] tmp = imgUrl.split(",");
+ image = PluginUtil.getBitmapFromBase64encodedImage(tmp[1]);
+ } else if (imgUrl.indexOf("file://") == 0 &&
+ !imgUrl.contains("file:///android_asset/")) {
+ imgUrl = imgUrl.replace("file://", "");
+ File tmp = new File(imgUrl);
+ if (tmp.exists()) {
+ image = BitmapFactory.decodeFile(imgUrl);
+ } else {
+ Log.w(TAG, "image is not found (" + imgUrl + ")");
+ }
+ } else {
+ //Log.d(TAG, "imgUrl = " + imgUrl);
+ if (imgUrl.indexOf("file:///android_asset/") == 0) {
+ imgUrl = imgUrl.replace("file:///android_asset/", "");
+ }
+ //Log.d(TAG, "imgUrl = " + imgUrl);
+ if (imgUrl.contains("./")) {
+ try {
+ boolean isAbsolutePath = imgUrl.startsWith("/");
+ File relativePath = new File(imgUrl);
+ imgUrl = relativePath.getCanonicalPath();
+ //Log.d(TAG, "imgUrl = " + imgUrl);
+ if (!isAbsolutePath) {
+ imgUrl = imgUrl.substring(1);
+ }
+ //Log.d(TAG, "imgUrl = " + imgUrl);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ AssetManager assetManager = PluginGroundOverlay.this.cordova.getActivity().getAssets();
+ InputStream inputStream;
+ try {
+ inputStream = assetManager.open(imgUrl);
+ image = BitmapFactory.decodeStream(inputStream);
+ } catch (IOException e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+ if (image == null) {
+ return null;
+ }
+
+ return image;
+ }
+
+ @Override
+ protected void onPostExecute(Bitmap image) {
+ if (image == null) {
+ callback.onPostExecute(null);
+ return;
+ }
+
+ GroundOverlay groundOverlay = null;
+ try {
+ BitmapDescriptor bitmapDescriptor = BitmapDescriptorFactory.fromBitmap(image);
+ options.image(bitmapDescriptor);
+ groundOverlay = self.map.addGroundOverlay(options);
+
+ callback.onPostExecute(groundOverlay);
+
+ } catch (Exception e) {
+ Log.e(TAG,"PluginGroundOverlay: Warning - ground overlay method is called when ground overlay method has been disposed, wait for addGroundOverlay callback before calling more methods on the groundOverlay.");
+ //e.printStackTrace();
+ try {
+ if (groundOverlay != null) {
+ groundOverlay.remove();
+ }
+ } catch (Exception ignore) {
+ ignore = null;
+ }
+ callback.onError(e.getMessage() + "");
+ }
+ }
+ };
+ task.execute();
+ imageLoadingTasks.add(task);
+
+
+ return;
+ }
+
+ if (imageUrl.indexOf("http") == 0) {
+ //----------------------------------
+ // Load img from on the internet
+ //----------------------------------
+ int width = -1;
+ int height = -1;
+ AsyncLoadImage task = new AsyncLoadImage(userAgent, width, height, true, new AsyncLoadImageInterface() {
+
+ @Override
+ public void onPostExecute(Bitmap image) {
+
+ if (image == null) {
+ callback.onPostExecute(null);
+ return;
+ }
+ GroundOverlay groundOverlay = null;
+ try {
+ BitmapDescriptor bitmapDescriptor = BitmapDescriptorFactory.fromBitmap(image);
+ options.image(bitmapDescriptor);
+ groundOverlay = self.map.addGroundOverlay(options);
+
+ image.recycle();
+ callback.onPostExecute(groundOverlay);
+ } catch (Exception e) {
+ //e.printStackTrace();
+ try {
+ if (groundOverlay != null) {
+ groundOverlay.remove();
+ }
+ } catch (Exception ignore) {
+ ignore = null;
+ }
+ callback.onError(e.getMessage() + "");
+ }
+
+ }
+
+ });
+ task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, imageUrl);
+ imageLoadingTasks.add(task);
+ }
+*/
+ }
+
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+
+ //--------------------------------------
+ // Cancel tasks
+ //--------------------------------------
+ cordova.getThreadPool().submit(new Runnable() {
+ @Override
+ public void run() {
+ AsyncTask task;
+ int i, ilen = imageLoadingTasks.size();
+ for (i = 0; i < ilen; i++) {
+ task = imageLoadingTasks.remove(i);
+ task.cancel(true);
+ task = null;
+ }
+ imageLoadingTasks = null;
+ }
+ });
+
+ this.clear();
+
+ }
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginKmlOverlay.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginKmlOverlay.java
new file mode 100644
index 0000000..b12d67f
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginKmlOverlay.java
@@ -0,0 +1,434 @@
+package plugin.google.maps;
+
+import android.os.Bundle;
+
+import org.apache.cordova.CallbackContext;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import za.co.twyst.tbxml.TBXML;
+
+
+public class PluginKmlOverlay extends MyPlugin implements MyPluginInterface {
+ private HashMap styles = new HashMap();
+
+ private enum KML_TAG {
+ NOT_SUPPORTED,
+
+ kml,
+ style,
+ styleurl,
+ stylemap,
+ schema,
+ coordinates
+ }
+
+ /**
+ * Create kml overlay
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void create(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ final JSONObject opts = args.getJSONObject(1);
+ self = this;
+ if (!opts.has("url")) {
+ callbackContext.error("No kml file is specified");
+ return;
+ }
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ String urlStr = null;
+
+ try {
+ urlStr = opts.getString("url");
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ if (urlStr == null || urlStr.length() == 0) {
+ callbackContext.error("No kml file is specified");
+ return;
+ }
+
+ String currentPageUrl = webView.getUrl();
+ if (!urlStr.contains("://") &&
+ !urlStr.startsWith("/") &&
+ !urlStr.startsWith("www/") &&
+ !urlStr.startsWith("data:image") &&
+ !urlStr.startsWith("./") &&
+ !urlStr.startsWith("../")) {
+ urlStr = "./" + urlStr;
+ }
+
+ if (currentPageUrl.startsWith("http://localhost") ||
+ currentPageUrl.startsWith("http://127.0.0.1")) {
+ if (urlStr.contains("://")) {
+ urlStr = urlStr.replaceAll("http://.+?/", "file:///android_asset/www/");
+ } else {
+ // Avoid WebViewLocalServer (because can not make a connection for some reason)
+ urlStr = "file:///android_asset/www/".concat(urlStr);
+ }
+ }
+
+
+ if (urlStr.startsWith("./") || urlStr.startsWith("../")) {
+ urlStr = urlStr.replace("././", "./");
+ currentPageUrl = currentPageUrl.replaceAll("[^\\/]*$", "");
+ urlStr = currentPageUrl + "/" + urlStr;
+ }
+ if (urlStr.startsWith("cdvfile://")) {
+ urlStr = PluginUtil.getAbsolutePathFromCDVFilePath(webView.getResourceApi(), urlStr);
+ }
+
+ // Avoid WebViewLocalServer (because can not make a connection for some reason)
+ if (urlStr.contains("http://localhost") || urlStr.contains("http://127.0.0.1")) {
+ urlStr = urlStr.replaceAll("^http://[^\\/]+\\//", "file:///android_asset/www/");
+ }
+
+
+ final String finalUrl = urlStr;
+ executorService.submit(new Runnable() {
+ @Override
+ public void run() {
+ Bundle result = loadKml(finalUrl);
+ callbackContext.success(PluginUtil.Bundle2Json(result));
+ }
+ });
+ }
+ });
+ }
+
+ private Bundle loadKml(String urlStr) {
+
+ InputStream inputStream = getKmlContents(urlStr);
+ if (inputStream == null) {
+ return null;
+ }
+ try {
+ // KMZ is not ready yet.... sorry
+
+// if (urlStr.contains(".kmz")) {
+// String cacheDirPath = cordova.getActivity().getCacheDir() + "/" + Integer.toString(urlStr.hashCode(), 16);
+// File cacheDir = new File(cacheDirPath);
+// if (!cacheDir.exists()) {
+// cacheDir.mkdirs();
+// }
+// ArrayList files = (PluginUtil.unpackZipFromBytes(inputStream, cacheDirPath));
+// inputStream.close();
+// for (File file : files) {
+// if (file.getName().contains(".kml")) {
+// inputStream = new FileInputStream(file);
+// break;
+// }
+// }
+// }
+
+
+ String line;
+ StringBuilder stringBuilder = new StringBuilder();
+ InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
+ BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
+ while ((line = bufferedReader.readLine()) != null) {
+ stringBuilder.append(line);
+ stringBuilder.append("\n");
+ }
+ bufferedReader.close();
+
+
+ TBXML tbxml = new TBXML();
+ tbxml.parse(stringBuilder.toString());
+
+ KmlParserClass parser = new KmlParserClass();
+ Bundle root = parser.parseXml(tbxml, tbxml.rootXMLElement());
+ Bundle result = new Bundle();
+ result.putBundle("schemas", parser.schemaHolder);
+ result.putBundle("styles", parser.styleHolder);
+ result.putBundle("root", root);
+
+
+ tbxml.release();
+ inputStreamReader.close();
+ inputStream.close();
+ inputStream = null;
+ return result;
+ } catch (Exception e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ class KmlParserClass {
+ public Bundle styleHolder = new Bundle();
+ public Bundle schemaHolder = new Bundle();
+
+
+ private Bundle parseXml(TBXML tbxml, long rootElement) {
+ Bundle result = new Bundle();
+ String styleId, schemaId, txt, attrName;
+ int i;
+ String tagName = tbxml.elementName(rootElement).toLowerCase();
+ long childNode;
+ Bundle styles, schema, extendedData;
+ ArrayList children;
+ ArrayList styleIDs;
+
+ //Log.d(TAG, "--->tagName = " + tagName + "(" + rootElement + ")");
+ result.putString("tagName", tagName);
+
+ KML_TAG kmlTag = null;
+ try {
+ kmlTag = KML_TAG.valueOf(tagName);
+ } catch(Exception e) {
+ kmlTag = KML_TAG.NOT_SUPPORTED;
+ }
+
+ long[] attributes = tbxml.listAttributesOfElement(rootElement);
+ for (i = 0; i < attributes.length; i++) {
+ attrName = tbxml.attributeName(attributes[i]);
+ result.putString(attrName, tbxml.attributeValue(attributes[i]));
+ }
+
+
+ switch (kmlTag) {
+
+ case styleurl:
+ styleId = tbxml.textForElement(rootElement);
+ result.putString("styleId", styleId);
+ break;
+
+ case stylemap:
+ case style:
+
+ // Generate a style id for the tag
+ styleId = tbxml.valueOfAttributeNamed("id", rootElement);
+ if (styleId == null || styleId.isEmpty()) {
+ styleId = "__" + rootElement + "__";
+ }
+ result.putString("styleId", styleId);
+
+ // Store style information into the styleHolder.
+ styles = new Bundle();
+ children = new ArrayList();
+ childNode = tbxml.firstChild(rootElement);
+ while (childNode > 0) {
+ Bundle node = this.parseXml(tbxml, childNode);
+ if (node != null) {
+ if (node.containsKey("value")) {
+ styles.putString(node.getString("tagName"), node.getString("value"));
+ } else {
+ children.add(node);
+ }
+ }
+ childNode = tbxml.nextSibling(childNode);
+ }
+ if (children.size() > 0) {
+ styles.putParcelableArrayList("children", children);
+ }
+ styleHolder.putBundle(styleId, styles);
+
+
+ break;
+
+ case schema:
+
+ // Generate a schema id for the tag
+ schemaId = tbxml.valueOfAttributeNamed("id", rootElement);
+ if (schemaId == null || schemaId.isEmpty()) {
+ schemaId = "__" + rootElement + "__";
+ }
+
+ // Store schema information into the schemaHolder.
+ schema = new Bundle();
+ schema.putString("name", tbxml.valueOfAttributeNamed("name", rootElement));
+ children = new ArrayList();
+ childNode = tbxml.firstChild(rootElement);
+ while (childNode > 0) {
+ Bundle node = this.parseXml(tbxml, childNode);
+ if (node != null) {
+ children.add(node);
+ }
+ childNode = tbxml.nextSibling(childNode);
+ }
+ if (children.size() > 0) {
+ schema.putParcelableArrayList("children", children);
+ }
+ schemaHolder.putBundle(schemaId, schema);
+
+
+ break;
+ case coordinates:
+
+
+ ArrayList latLngList = new ArrayList();
+
+ txt = tbxml.textForElement(rootElement);
+ txt = txt.replaceAll("\\s+", "\n");
+ txt = txt.replaceAll("\\n+", "\n");
+ String lines[] = txt.split("\n");
+ String tmpArry[];
+ Bundle latLng;
+ for (i = 0; i < lines.length; i++) {
+ lines[i] = lines[i].replaceAll("[^0-9,.\\-Ee]", "");
+ if (!"".equals(lines[i])) {
+ tmpArry = lines[i].split(",");
+ latLng = new Bundle();
+ latLng.putDouble("lat", Double.parseDouble(tmpArry[1]));
+ latLng.putDouble("lng", Double.parseDouble(tmpArry[0]));
+ latLngList.add(latLng);
+ }
+ }
+
+ result.putParcelableArrayList(tagName, latLngList);
+ break;
+
+
+
+ default:
+
+ childNode = tbxml.firstChild(rootElement);
+ if (childNode != 0) {
+ children = new ArrayList();
+ while (childNode != 0) {
+ Bundle node = this.parseXml(tbxml, childNode);
+ if (node != null) {
+ if (node.containsKey("styleId")) {
+ //--------------------------------------------
+ // writtin in JavaScript
+ // result.styleIDs = result.styleIDs || [];
+ // result.styleIDs.push(node.styleId);
+ //--------------------------------------------
+ styleIDs = result.getStringArrayList("styleIDs");
+ if (styleIDs == null) {
+ styleIDs = new ArrayList();
+ }
+ styleIDs.add(node.getString("styleId"));
+ result.putStringArrayList("styleIDs", styleIDs);
+ } else if (!("schema".equals(node.getString("tagName")))) {
+ children.add(node);
+ }
+ }
+ childNode = tbxml.nextSibling(childNode);
+ }
+
+ result.putParcelableArrayList("children", children);
+ } else {
+ result.putString("value", tbxml.textForElement(rootElement));
+ }
+ break;
+ }
+
+ return result;
+ }
+ }
+
+
+ private InputStream getKmlContents(String urlStr) {
+
+ InputStream inputStream;
+ try {
+ //Log.d("PluginKmlOverlay", "---> url = " + urlStr);
+ if (urlStr.startsWith("http://") || urlStr.startsWith("https://")) {
+ URL url = new URL(urlStr);
+ boolean redirect = true;
+ HttpURLConnection http = null;
+ String cookies = null;
+ int redirectCnt = 0;
+ while(redirect && redirectCnt < 10) {
+ redirect = false;
+ http = (HttpURLConnection)url.openConnection();
+ http.setRequestMethod("GET");
+ if (cookies != null) {
+ http.setRequestProperty("Cookie", cookies);
+ }
+ http.addRequestProperty("Accept-Language", "en-US,en;q=0.8");
+ http.addRequestProperty("User-Agent", "Mozilla");
+ http.setInstanceFollowRedirects(true);
+ HttpURLConnection.setFollowRedirects(true);
+
+ // normally, 3xx is redirect
+ int status = http.getResponseCode();
+ if (status != HttpURLConnection.HTTP_OK) {
+ if (status == HttpURLConnection.HTTP_MOVED_TEMP
+ || status == HttpURLConnection.HTTP_MOVED_PERM
+ || status == HttpURLConnection.HTTP_SEE_OTHER)
+ redirect = true;
+ }
+ if (redirect) {
+ // get redirect url from "location" header field
+ url = new URL(http.getHeaderField("Location"));
+
+ // get the cookie if need, for login
+ cookies = http.getHeaderField("Set-Cookie");
+
+ // Disconnect the current connection
+ http.disconnect();
+ redirectCnt++;
+ }
+ }
+
+ inputStream = http.getInputStream();
+ } else if (urlStr.indexOf("file://") == 0 && !urlStr.contains("file:///android_asset/") ||
+ urlStr.indexOf("/") == 0) {
+ urlStr = urlStr.replace("file://", "");
+ try {
+ boolean isAbsolutePath = urlStr.startsWith("/");
+ File relativePath = new File(urlStr);
+ urlStr = relativePath.getCanonicalPath();
+ //Log.d(TAG, "imgUrl = " + imgUrl);
+ if (!isAbsolutePath) {
+ urlStr = urlStr.substring(1);
+ }
+ //Log.d(TAG, "imgUrl = " + imgUrl);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ //Log.d("PluginKmlOverlay", "---> url = " + urlStr);
+ inputStream = new FileInputStream(urlStr);
+ } else {
+ if (urlStr.indexOf("file:///android_asset/") == 0) {
+ urlStr = urlStr.replace("file:///android_asset/", "");
+ }
+
+
+ try {
+ boolean isAbsolutePath = urlStr.startsWith("/");
+ File relativePath = new File(urlStr);
+ urlStr = relativePath.getCanonicalPath();
+ //Log.d(TAG, "imgUrl = " + imgUrl);
+ if (!isAbsolutePath) {
+ urlStr = urlStr.substring(1);
+ }
+ //Log.d(TAG, "imgUrl = " + imgUrl);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ //Log.d("PluginKmlOverlay", "---> url = " + urlStr);
+ inputStream = cordova.getActivity().getResources().getAssets().open(urlStr);
+ }
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ return inputStream;
+
+ }
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginLocationService.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginLocationService.java
new file mode 100644
index 0000000..b385cc2
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginLocationService.java
@@ -0,0 +1,665 @@
+package plugin.google.maps;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.location.Location;
+import android.location.LocationManager;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Looper;
+import android.support.annotation.NonNull;
+import android.support.v4.content.PermissionChecker;
+import android.util.Log;
+
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.location.LocationCallback;
+import com.google.android.gms.location.LocationRequest;
+import com.google.android.gms.location.LocationResult;
+import com.google.android.gms.location.LocationServices;
+import com.google.android.gms.tasks.OnFailureListener;
+import com.google.android.gms.tasks.OnSuccessListener;
+
+import org.apache.cordova.CallbackContext;
+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.ArrayList;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+
+public class PluginLocationService extends CordovaPlugin {
+ private Activity activity;
+ private final String TAG = "PluginLocationService";
+ private HashMap bufferForLocationDialog = new HashMap();
+
+ private final int ACTIVITY_LOCATION_DIALOG = 0x7f999900; // Invite the location dialog using Google Play Services
+ private final int ACTIVITY_LOCATION_PAGE = 0x7f999901; // Open the location settings page
+
+ private GoogleApiClient googleApiClient = null;
+
+ public void initialize(final CordovaInterface cordova, final CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ activity = cordova.getActivity();
+ }
+ private static Location lastLocation = null;
+ private ArrayList regularAccuracyRequestList = new ArrayList();
+ private ArrayList highAccuracyRequestList = new ArrayList();
+ public static final Object semaphore = new Object();
+
+ public static void setLastLocation(Location location) {
+ // Sets the last location if the end user click on the mylocation (blue dot)
+ lastLocation = location;
+ }
+
+
+ @Override
+ public boolean execute(final String action, final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ cordova.getThreadPool().submit(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ if ("getMyLocation".equals(action)) {
+ PluginLocationService.this.getMyLocation(args, callbackContext);
+ } else if ("hasPermission".equals(action)) {
+ PluginLocationService.this.hasPermission(args, callbackContext);
+ }
+
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+ });
+ return true;
+
+ }
+
+
+
+ @SuppressWarnings("unused")
+ public void hasPermission(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ synchronized (semaphore) {
+ // Check geolocation permission.
+ boolean locationPermission = PermissionChecker.checkSelfPermission(cordova.getActivity().getApplicationContext(), Manifest.permission.ACCESS_COARSE_LOCATION) == PermissionChecker.PERMISSION_GRANTED;
+ callbackContext.success(locationPermission ? 1 : 0);
+ }
+ }
+
+
+ @SuppressWarnings("unused")
+ public void getMyLocation(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ synchronized (semaphore) {
+
+
+
+ LocationManager locationManager = (LocationManager) this.activity.getSystemService(Context.LOCATION_SERVICE);
+ List providers = locationManager.getAllProviders();
+ int availableProviders = 0;
+ //if (mPluginLayout != null && mPluginLayout.isDebug) {
+ Log.d(TAG, "---debug at getMyLocation(available providers)--");
+ //}
+ Iterator iterator = providers.iterator();
+ String provider;
+ boolean isAvailable;
+ while(iterator.hasNext()) {
+ provider = iterator.next();
+ if ("passive".equals(provider)) {
+ continue;
+ }
+ isAvailable = locationManager.isProviderEnabled(provider);
+ if (isAvailable) {
+ availableProviders++;
+ }
+ //if (mPluginLayout != null && mPluginLayout.isDebug) {
+ Log.d(TAG, " " + provider + " = " + (isAvailable ? "" : "not ") + "available");
+ //}
+ }
+ if (availableProviders == 0) {
+ JSONObject result = new JSONObject();
+ try {
+ result.put("status", false);
+ result.put("error_code", "not_available");
+ result.put("error_message", PluginUtil.getPgmStrings(activity,"pgm_no_location_providers"));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ callbackContext.error(result);
+ return;
+ }
+
+
+
+
+
+ JSONObject params = args.getJSONObject(0);
+ boolean requestHighAccuracy = false;
+ if (params.has("enableHighAccuracy")) {
+ requestHighAccuracy = params.getBoolean("enableHighAccuracy");
+ }
+ if (requestHighAccuracy && !locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
+ JSONObject result = new JSONObject();
+ try {
+ result.put("status", false);
+ result.put("error_code", "not_available");
+ result.put("error_message", PluginUtil.getPgmStrings(activity,"pgm_no_location_service_is_disabled"));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ callbackContext.error(result);
+ return;
+ }
+
+ // enableHighAccuracy = true -> PRIORITY_HIGH_ACCURACY
+ // enableHighAccuracy = false -> PRIORITY_BALANCED_POWER_ACCURACY
+ if (requestHighAccuracy) {
+ highAccuracyRequestList.add(callbackContext);
+ } else {
+ regularAccuracyRequestList.add(callbackContext);
+ }
+
+ if (googleApiClient != null && googleApiClient.isConnecting()) {
+ return;
+ }
+ }
+
+ // Request geolocation permission.
+ boolean locationPermission = PermissionChecker.checkSelfPermission(cordova.getActivity().getApplicationContext(), Manifest.permission.ACCESS_COARSE_LOCATION) == PermissionChecker.PERMISSION_GRANTED;
+
+ if (!locationPermission) {
+ //_saveArgs = args;
+ //_saveCallbackContext = callbackContext;
+ synchronized (semaphore) {
+ cordova.requestPermissions(this, callbackContext.hashCode(), new String[]{
+ Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION
+ });
+ try {
+ semaphore.wait();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ locationPermission = PermissionChecker.checkSelfPermission(cordova.getActivity().getApplicationContext(), Manifest.permission.ACCESS_COARSE_LOCATION) == PermissionChecker.PERMISSION_GRANTED;
+
+ if (!locationPermission) {
+
+ PluginResult errorResult = new PluginResult(PluginResult.Status.ERROR, PluginUtil.getPgmStrings(activity,"pgm_location_rejected_by_user"));
+
+ synchronized (semaphore) {
+ for (CallbackContext callback: regularAccuracyRequestList) {
+ callback.sendPluginResult(errorResult);
+ }
+ for (CallbackContext callback: highAccuracyRequestList) {
+ callback.sendPluginResult(errorResult);
+ }
+ regularAccuracyRequestList.clear();
+ highAccuracyRequestList.clear();
+ }
+ return;
+ }
+ }
+ if (lastLocation != null && Calendar.getInstance().getTimeInMillis() - lastLocation.getTime() <= 2000) {
+ //---------------------------------------------------------------------
+ // If the user requests the location in two seconds from the last time,
+ // return the last result in order to save battery usage.
+ // (Don't request the device location too much! Save battery usage!)
+ //---------------------------------------------------------------------
+ JSONObject result;
+ try {
+ result = PluginUtil.location2Json(lastLocation);
+ result.put("status", true);
+
+ PluginResult successResult = new PluginResult(PluginResult.Status.OK, result);
+ synchronized (semaphore) {
+ for (CallbackContext callback: regularAccuracyRequestList) {
+ callback.sendPluginResult(successResult);
+ }
+ for (CallbackContext callback: highAccuracyRequestList) {
+ callback.sendPluginResult(successResult);
+ }
+ regularAccuracyRequestList.clear();
+ highAccuracyRequestList.clear();
+ }
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+
+ return;
+ }
+
+ if (googleApiClient == null) {
+
+ googleApiClient = new GoogleApiClient.Builder(activity)
+ .addApi(LocationServices.API)
+ .addConnectionCallbacks(new com.google.android.gms.common.api.GoogleApiClient.ConnectionCallbacks() {
+
+ @Override
+ public void onConnected(Bundle connectionHint) {
+ Log.d(TAG, "===> onConnected " + callbackContext.getCallbackId());
+ requestLocation();
+ }
+
+ @Override
+ public void onConnectionSuspended(int cause) {
+ Log.e(TAG, "===> onConnectionSuspended");
+ }
+
+ })
+ .addOnConnectionFailedListener(new com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener() {
+
+ @Override
+ public void onConnectionFailed(@NonNull ConnectionResult result) {
+ Log.e(TAG, "===> onConnectionFailed");
+
+ PluginResult errorResult = new PluginResult(PluginResult.Status.ERROR, result.toString());
+
+ synchronized (semaphore) {
+ for (CallbackContext callback: regularAccuracyRequestList) {
+ callback.sendPluginResult(errorResult);
+ }
+ for (CallbackContext callback: highAccuracyRequestList) {
+ callback.sendPluginResult(errorResult);
+ }
+ regularAccuracyRequestList.clear();
+ highAccuracyRequestList.clear();
+ }
+
+ googleApiClient.disconnect();
+ }
+
+ })
+ .build();
+ googleApiClient.connect();
+ } else if (googleApiClient.isConnected()) {
+ requestLocation();
+ } else {
+ Log.e(TAG, "===> googleApiClient.isConnected() is not connected");
+ googleApiClient.connect();
+ }
+ }
+
+ private void requestLocation() {
+ Log.d(TAG, "--->regularAccuracyRequestList.size = " + regularAccuracyRequestList.size());
+
+ if (regularAccuracyRequestList.size() > 0) {
+ PluginLocationService.this._requestLocationUpdate(false, false, new CallbackContext("regular-callback", webView) {
+ @Override
+ public void sendPluginResult(PluginResult pluginResult) {
+
+ synchronized (semaphore) {
+ for (CallbackContext callback: regularAccuracyRequestList) {
+ callback.sendPluginResult(pluginResult);
+ }
+ regularAccuracyRequestList.clear();
+
+ if (regularAccuracyRequestList.size() == 0 && highAccuracyRequestList.size() == 0) {
+ googleApiClient.disconnect();
+ }
+ }
+
+ }
+ });
+ }
+ Log.d(TAG, "--->highAccuracyRequestList.size = " + highAccuracyRequestList.size());
+ if (highAccuracyRequestList.size() > 0) {
+ PluginLocationService.this._requestLocationUpdate(false, true, new CallbackContext("regular-callback", webView) {
+ @Override
+ public void sendPluginResult(PluginResult pluginResult) {
+
+ synchronized (semaphore) {
+ for (CallbackContext callback: highAccuracyRequestList) {
+ callback.sendPluginResult(pluginResult);
+ }
+ highAccuracyRequestList.clear();
+ if (regularAccuracyRequestList.size() == 0 && highAccuracyRequestList.size() == 0) {
+ googleApiClient.disconnect();
+ }
+ }
+
+ }
+ });
+ }
+ }
+
+// private void _checkLocationSettings() {
+//
+// LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder().setAlwaysShow(true);
+//
+// LocationRequest locationRequest;
+// locationRequest = LocationRequest.create()
+// .setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);
+// builder.addLocationRequest(locationRequest);
+//
+// if (enableHighAccuracy) {
+// locationRequest = LocationRequest.create()
+// .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
+// builder.addLocationRequest(locationRequest);
+// }
+//
+// PendingResult locationSettingsResult =
+// LocationServices.SettingsApi.checkLocationSettings(googleApiClient, builder.build());
+//
+// locationSettingsResult.setResultCallback(new ResultCallback() {
+//
+// @Override
+// public void onResult(@NonNull LocationSettingsResult result) {
+// final Status status = result.getStatus();
+// switch (status.getStatusCode()) {
+// case LocationSettingsStatusCodes.SUCCESS:
+// _requestLocationUpdate(false, enableHighAccuracy, callbackContext);
+// break;
+//
+// case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
+// // Location settings are not satisfied. But could be fixed by showing the user
+// // a dialog.
+// try {
+// //Keep the callback id
+// Bundle bundle = new Bundle();
+// bundle.putInt("type", ACTIVITY_LOCATION_DIALOG);
+// bundle.putString("callbackId", callbackContext.getCallbackId());
+// bundle.putBoolean("enableHighAccuracy", enableHighAccuracy);
+// int hashCode = bundle.hashCode();
+//
+// bufferForLocationDialog.put("bundle_" + hashCode, bundle);
+// //PluginLocationService.this.sendNoResult(callbackContext);
+//
+// // Show the dialog by calling startResolutionForResult(),
+// // and check the result in onActivityResult().
+// cordova.setActivityResultCallback(PluginLocationService.this);
+// status.startResolutionForResult(cordova.getActivity(), hashCode);
+// } catch (IntentSender.SendIntentException e) {
+// // Show the dialog that is original version of this plugin.
+// _showLocationSettingsPage(enableHighAccuracy, callbackContext);
+// }
+// break;
+//
+// case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
+// // Location settings are not satisfied. However, we have no way to fix the
+// // settings so we won't show the dialog.
+//
+// JSONObject jsResult = new JSONObject();
+// try {
+// jsResult.put("status", false);
+// jsResult.put("error_code", "service_not_available");
+// jsResult.put("error_message", "This app has been rejected to use Location Services.");
+// } catch (JSONException e) {
+// e.printStackTrace();
+// }
+// callbackContext.error(jsResult);
+// break;
+// }
+// }
+//
+// });
+// }
+//
+// private void _showLocationSettingsPage(final boolean enableHighAccuracy, final CallbackContext callbackContext) {
+// //Ask the user to turn on the location services.
+// AlertDialog.Builder builder = new AlertDialog.Builder(this.activity);
+// builder.setTitle("Improve location accuracy");
+// builder.setMessage("To enhance your Maps experience:\n\n" +
+// " - Enable Google apps location access\n\n" +
+// " - Turn on GPS and mobile network location");
+// builder.setPositiveButton("Settings", new DialogInterface.OnClickListener() {
+// @Override
+// public void onClick(DialogInterface dialog, int which) {
+// //Keep the callback id
+// Bundle bundle = new Bundle();
+// bundle.putInt("type", ACTIVITY_LOCATION_PAGE);
+// bundle.putString("callbackId", callbackContext.getCallbackId());
+// bundle.putBoolean("enableHighAccuracy", enableHighAccuracy);
+// int hashCode = bundle.hashCode();
+//
+// bufferForLocationDialog.put("bundle_" + hashCode, bundle);
+// //PluginLocationService.this.sendNoResult(callbackContext);
+//
+// //Launch settings, allowing user to make a change
+// cordova.setActivityResultCallback(PluginLocationService.this);
+// Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
+// activity.startActivityForResult(intent, hashCode);
+// }
+// });
+// builder.setNegativeButton("Skip", new DialogInterface.OnClickListener() {
+// @Override
+// public void onClick(DialogInterface dialog, int which) {
+// //No location service, no Activity
+// dialog.dismiss();
+//
+// JSONObject result = new JSONObject();
+// try {
+// result.put("status", false);
+// result.put("error_code", "service_denied");
+// result.put("error_message", "This app has been rejected to use Location Services.");
+// } catch (JSONException e) {
+// e.printStackTrace();
+// }
+// callbackContext.error(result);
+// }
+// });
+// builder.create().show();
+// }
+
+ @SuppressWarnings("MissingPermission")
+ private void _requestLocationUpdate(final boolean isRetry, final boolean enableHighAccuracy, final CallbackContext callbackContext) {
+
+ Log.d(TAG, "---->_requestLocationUpdate (isRetry = " + isRetry + ")");
+ int priority = LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY;
+ if (enableHighAccuracy || "Genymotion".equals(Build.MANUFACTURER)) {
+ priority = LocationRequest.PRIORITY_HIGH_ACCURACY;
+ }
+
+ if (!isRetry) {
+ LocationServices.getFusedLocationProviderClient(cordova.getActivity())
+ .getLastLocation()
+ .addOnSuccessListener(new OnSuccessListener() {
+ @Override
+ public void onSuccess(Location location) {
+ lastLocation = location;
+ if (lastLocation != null && Calendar.getInstance().getTimeInMillis() - lastLocation.getTime() <= 2000) {
+ Log.d(TAG, "---->The last location is obtained in 2 sec.");
+ //---------------------------------------------------------------------
+ // If the user requests the location in two seconds from the last time,
+ // return the last result in order to save battery usage.
+ // (Don't request the device location too much! Save battery usage!)
+ //---------------------------------------------------------------------
+ JSONObject result;
+ try {
+ result = PluginUtil.location2Json(lastLocation);
+ result.put("status", true);
+
+ PluginResult successResult = new PluginResult(PluginResult.Status.OK, result);
+ synchronized (semaphore) {
+ for (CallbackContext callback : regularAccuracyRequestList) {
+ callback.sendPluginResult(successResult);
+ }
+ for (CallbackContext callback: highAccuracyRequestList) {
+ callback.sendPluginResult(successResult);
+ }
+ regularAccuracyRequestList.clear();
+ highAccuracyRequestList.clear();
+ }
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+
+ googleApiClient.disconnect();
+ } else {
+ Log.d(TAG, "---->The last location is expired. Let's get the latest location...");
+ _requestLocationUpdate(true, enableHighAccuracy, callbackContext);
+ }
+ }
+ })
+ .addOnFailureListener(new OnFailureListener() {
+ @Override
+ public void onFailure(@NonNull Exception e) {
+ _requestLocationUpdate(true, enableHighAccuracy, callbackContext);
+ }
+ });
+ return;
+ }
+
+ // It seems setting the values to both setFastestInterval() and setInterval() is important.
+ // https://akira-watson.com/android/fusedlocationproviderapi.html
+ LocationRequest locationRequest= LocationRequest.create()
+ //.setNumUpdates(2)
+ .setFastestInterval(5000)
+ .setInterval(10000)
+ //.setSmallestDisplacement(0)
+ .setPriority(priority)
+ .setExpirationDuration(12000)
+ .setMaxWaitTime(5000);
+
+ LocationServices.getFusedLocationProviderClient(cordova.getActivity()).requestLocationUpdates(locationRequest, new LocationCallback() {
+ @Override
+ public void onLocationResult(LocationResult locationResult) {
+ Log.d(TAG, "---->onLocationResult");
+ Location location = null;
+ if (locationResult.getLocations().size() > 0) {
+ location = locationResult.getLocations().get(0);
+ lastLocation = location;
+ } else if (locationResult.getLastLocation() != null) {
+ location = locationResult.getLastLocation();
+ }
+
+ Log.d(TAG, "===> location =" + location);
+ if (location != null) {
+ JSONObject result;
+ Log.d(TAG, "===> location =" + callbackContext.getCallbackId());
+ try {
+ result = PluginUtil.location2Json(location);
+ result.put("status", true);
+ callbackContext.success(result);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ } else {
+ // Send back the error result
+ JSONObject result = new JSONObject();
+ try {
+ result.put("status", false);
+ result.put("error_code", "cannot_detect");
+ result.put("error_message", PluginUtil.getPgmStrings(activity,"pgm_can_not_get_location"));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ callbackContext.error(result);
+ }
+
+ googleApiClient.disconnect();
+ }
+ }, Looper.myLooper());
+
+ }
+
+ private void _onActivityResultLocationPage(Bundle bundle) {
+ String callbackId = bundle.getString("callbackId");
+ CallbackContext callbackContext = new CallbackContext(callbackId, this.webView);
+
+ LocationManager locationManager = (LocationManager) this.activity.getSystemService(Context.LOCATION_SERVICE);
+ List providers = locationManager.getAllProviders();
+ int availableProviders = 0;
+ //if (mPluginLayout != null && mPluginLayout.isDebug) {
+ Log.d(TAG, "---debug at getMyLocation(available providers)--");
+ //}
+ Iterator iterator = providers.iterator();
+ String provider;
+ boolean isAvailable;
+ while(iterator.hasNext()) {
+ provider = iterator.next();
+ if ("passive".equals(provider)) {
+ continue;
+ }
+ isAvailable = locationManager.isProviderEnabled(provider);
+ if (isAvailable) {
+ availableProviders++;
+ }
+ //if (mPluginLayout != null && mPluginLayout.isDebug) {
+ Log.d(TAG, " " + provider + " = " + (isAvailable ? "" : "not ") + "available");
+ //}
+ }
+ if (availableProviders == 0) {
+ JSONObject result = new JSONObject();
+ try {
+ result.put("status", false);
+ result.put("error_code", "not_available");
+ result.put("error_message", PluginUtil.getPgmStrings(activity,"pgm_no_location_providers"));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ callbackContext.error(result);
+ return;
+ }
+
+ _inviteLocationUpdateAfterActivityResult(bundle);
+ }
+
+ private void _inviteLocationUpdateAfterActivityResult(Bundle bundle) {
+ boolean enableHighAccuracy = bundle.getBoolean("enableHighAccuracy");
+ String callbackId = bundle.getString("callbackId");
+ CallbackContext callbackContext = new CallbackContext(callbackId, this.webView);
+ this._requestLocationUpdate(false, enableHighAccuracy, callbackContext);
+ }
+
+ @Override
+ public void onActivityResult(int requestCode, int resultCode, Intent data) {
+ super.onActivityResult(requestCode, resultCode, data);
+
+ if (!bufferForLocationDialog.containsKey("bundle_" + requestCode)) {
+ Log.e(TAG, "no key");
+ return;
+ }
+ Bundle query = bufferForLocationDialog.get("bundle_" + requestCode);
+ Log.d(TAG, "====> onActivityResult (" + resultCode + ")");
+
+ switch (query.getInt("type")) {
+ case ACTIVITY_LOCATION_DIALOG:
+ // User was asked to enable the location setting.
+ switch (resultCode) {
+ case Activity.RESULT_OK:
+ // All required changes were successfully made
+ _inviteLocationUpdateAfterActivityResult(query);
+ break;
+ case Activity.RESULT_CANCELED:
+ // The user was asked to change settings, but chose not to
+ _userRefusedToUseLocationAfterActivityResult(query);
+ break;
+ default:
+ break;
+ }
+ break;
+ case ACTIVITY_LOCATION_PAGE:
+ _onActivityResultLocationPage(query);
+ break;
+ }
+ }
+ private void _userRefusedToUseLocationAfterActivityResult(Bundle bundle) {
+ String callbackId = bundle.getString("callbackId");
+ CallbackContext callbackContext = new CallbackContext(callbackId, this.webView);
+ JSONObject result = new JSONObject();
+ try {
+ result.put("status", false);
+ result.put("error_code", "service_denied");
+ result.put("error_message", PluginUtil.getPgmStrings(activity,"pgm_location_rejected_by_user"));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ callbackContext.error(result);
+ }
+
+ public void onRequestPermissionResult(int requestCode, String[] permissions,
+ int[] grantResults) throws JSONException {
+ synchronized (semaphore) {
+ semaphore.notify();
+ }
+ }
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginMap.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginMap.java
new file mode 100644
index 0000000..a3d379f
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginMap.java
@@ -0,0 +1,3183 @@
+package plugin.google.maps;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Color;
+import android.graphics.Point;
+import android.graphics.RectF;
+import android.graphics.Typeface;
+import android.location.Location;
+import android.os.AsyncTask;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.support.annotation.NonNull;
+import android.support.v4.content.PermissionChecker;
+import android.util.Base64;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.google.android.gms.maps.CameraUpdate;
+import com.google.android.gms.maps.CameraUpdateFactory;
+import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.GoogleMap.InfoWindowAdapter;
+import com.google.android.gms.maps.GoogleMap.OnIndoorStateChangeListener;
+import com.google.android.gms.maps.GoogleMap.OnInfoWindowClickListener;
+import com.google.android.gms.maps.GoogleMap.OnMapClickListener;
+import com.google.android.gms.maps.GoogleMap.OnMapLongClickListener;
+import com.google.android.gms.maps.GoogleMap.OnMarkerClickListener;
+import com.google.android.gms.maps.GoogleMap.OnMarkerDragListener;
+import com.google.android.gms.maps.GoogleMap.OnMyLocationButtonClickListener;
+import com.google.android.gms.maps.GoogleMapOptions;
+import com.google.android.gms.maps.MapView;
+import com.google.android.gms.maps.OnMapReadyCallback;
+import com.google.android.gms.maps.Projection;
+import com.google.android.gms.maps.UiSettings;
+import com.google.android.gms.maps.model.CameraPosition;
+import com.google.android.gms.maps.model.CameraPosition.Builder;
+import com.google.android.gms.maps.model.Circle;
+import com.google.android.gms.maps.model.GroundOverlay;
+import com.google.android.gms.maps.model.IndoorBuilding;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.LatLngBounds;
+import com.google.android.gms.maps.model.MapStyleOptions;
+import com.google.android.gms.maps.model.Marker;
+import com.google.android.gms.maps.model.MarkerOptions;
+import com.google.android.gms.maps.model.PointOfInterest;
+import com.google.android.gms.maps.model.Polygon;
+import com.google.android.gms.maps.model.Polyline;
+import com.google.android.gms.maps.model.PolylineOptions;
+import com.google.android.gms.maps.model.VisibleRegion;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.PluginEntry;
+import org.apache.cordova.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.ByteArrayOutputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+
+public class PluginMap extends MyPlugin implements OnMarkerClickListener,
+ OnInfoWindowClickListener, OnMapClickListener, OnMapLongClickListener,
+ OnMarkerDragListener, GoogleMap.OnMapLoadedCallback,
+ OnMyLocationButtonClickListener, OnIndoorStateChangeListener, InfoWindowAdapter,
+ GoogleMap.OnCameraIdleListener, GoogleMap.OnCameraMoveCanceledListener,
+ GoogleMap.OnCameraMoveListener, GoogleMap.OnCameraMoveStartedListener,
+ GoogleMap.OnInfoWindowLongClickListener, GoogleMap.OnInfoWindowCloseListener,
+ GoogleMap.OnMyLocationClickListener, GoogleMap.OnPoiClickListener,
+ IPluginView{
+
+ private LatLngBounds initCameraBounds;
+ private Activity activity;
+ public GoogleMap map;
+ private MapView mapView;
+ private String mapId;
+ private boolean isVisible = true;
+ private boolean isClickable = true;
+ private final String TAG = mapId;
+ private String mapDivId;
+ public Map plugins = new ConcurrentHashMap();
+ private final float DEFAULT_CAMERA_PADDING = 20;
+ private Projection projection = null;
+ public Marker activeMarker = null;
+ private boolean isDragging = false;
+ public final ObjectCache objects = new ObjectCache();
+ private ImageView dummyMyLocationButton;
+ public static final Object semaphore = new Object();
+ private int viewDepth = 0;
+
+ private enum TEXT_STYLE_ALIGNMENTS {
+ left, center, right
+ }
+
+ private final String ANIMATE_CAMERA_DONE = "animate_camera_done";
+ private final String ANIMATE_CAMERA_CANCELED = "animate_camera_canceled";
+
+ private Handler mainHandler;
+
+ private class AsyncUpdateCameraPositionResult {
+ CameraUpdate cameraUpdate;
+ int durationMS;
+ LatLngBounds cameraBounds;
+ double cameraPadding;
+ }
+
+ private class AsyncSetOptionsResult {
+ int MAP_TYPE_ID;
+ CameraPosition cameraPosition;
+ LatLngBounds cameraBounds;
+ double cameraPadding;
+ String styles;
+ }
+
+ public int getViewDepth() {
+ return viewDepth;
+ }
+ public String getDivId() {
+ return this.mapDivId;
+ }
+ public String getOverlayId() {
+ return this.mapId;
+ }
+ public ViewGroup getView() {
+ return this.mapView;
+ }
+ public boolean getVisible() {
+ return isVisible;
+ }
+ public boolean getClickable() {
+ return isClickable;
+ }
+
+
+ @Override
+ public void initialize(CordovaInterface cordova, final CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ activity = cordova.getActivity();
+ mainHandler = new Handler(Looper.getMainLooper());
+ }
+
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ public void getMap(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ GoogleMapOptions options = new GoogleMapOptions();
+ JSONObject meta = args.getJSONObject(0);
+ mapId = meta.getString("__pgmId");
+ viewDepth = meta.getInt("depth");
+ final JSONObject params = args.getJSONObject(1);
+
+ //controls
+ if (params.has("controls")) {
+ JSONObject controls = params.getJSONObject("controls");
+
+ if (controls.has("compass")) {
+ options.compassEnabled(controls.getBoolean("compass"));
+ }
+ if (controls.has("zoom")) {
+ options.zoomControlsEnabled(controls.getBoolean("zoom"));
+ }
+ if (controls.has("mapToolbar")) {
+ options.mapToolbarEnabled(controls.getBoolean("mapToolbar"));
+ }
+
+
+ if (controls.has("myLocationButton") || controls.has("myLocation")) {
+
+ // Request geolocation permission.
+ boolean locationPermission = PermissionChecker.checkSelfPermission(cordova.getActivity(), Manifest.permission.ACCESS_COARSE_LOCATION) == PermissionChecker.PERMISSION_GRANTED;
+ //Log.d(TAG, "---> (235) hasPermission = " + locationPermission);
+
+ if (!locationPermission) {
+ //_saveArgs = args;
+ //_saveCallbackContext = callbackContext;
+ synchronized (semaphore) {
+ cordova.requestPermissions(PluginMap.this, callbackContext.hashCode(), new String[]{
+ Manifest.permission.ACCESS_FINE_LOCATION
+ });
+ try {
+ semaphore.wait();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ locationPermission = PermissionChecker.checkSelfPermission(cordova.getActivity(), Manifest.permission.ACCESS_FINE_LOCATION) == PermissionChecker.PERMISSION_GRANTED;
+
+ //Log.d(TAG, "---> (252)setMyLocationEnabled, hasPermission = " + locationPermission);
+
+ }
+ }
+ }
+
+ //gestures
+ if (params.has("gestures")) {
+ JSONObject gestures = params.getJSONObject("gestures");
+
+ if (gestures.has("tilt")) {
+ options.tiltGesturesEnabled(gestures.getBoolean("tilt"));
+ }
+ if (gestures.has("scroll")) {
+ options.scrollGesturesEnabled(gestures.getBoolean("scroll"));
+ }
+ if (gestures.has("rotate")) {
+ options.rotateGesturesEnabled(gestures.getBoolean("rotate"));
+ }
+ if (gestures.has("zoom")) {
+ options.zoomGesturesEnabled(gestures.getBoolean("zoom"));
+ }
+ }
+
+ // map type
+ if (!params.has("styles") && params.has("mapType")) {
+ String typeStr = params.getString("mapType");
+ int mapTypeId = -1;
+ mapTypeId = typeStr.equals("MAP_TYPE_NORMAL") ? GoogleMap.MAP_TYPE_NORMAL : mapTypeId;
+ mapTypeId = typeStr.equals("MAP_TYPE_HYBRID") ? GoogleMap.MAP_TYPE_HYBRID : mapTypeId;
+ mapTypeId = typeStr.equals("MAP_TYPE_SATELLITE") ? GoogleMap.MAP_TYPE_SATELLITE : mapTypeId;
+ mapTypeId = typeStr.equals("MAP_TYPE_TERRAIN") ? GoogleMap.MAP_TYPE_TERRAIN : mapTypeId;
+ mapTypeId = typeStr.equals("MAP_TYPE_NONE") ? GoogleMap.MAP_TYPE_NONE : mapTypeId;
+ if (mapTypeId != -1) {
+ options.mapType(mapTypeId);
+ }
+ }
+
+ // initial camera position
+ if (params.has("camera")) {
+ JSONObject camera = params.getJSONObject("camera");
+ Builder builder = CameraPosition.builder();
+ if (camera.has("bearing")) {
+ builder.bearing((float) camera.getDouble("bearing"));
+ }
+ if (camera.has("target")) {
+ Object target = camera.get("target");
+ @SuppressWarnings("rawtypes")
+ Class targetClass = target.getClass();
+ if ("org.json.JSONArray".equals(targetClass.getName())) {
+ JSONArray points = camera.getJSONArray("target");
+ initCameraBounds = PluginUtil.JSONArray2LatLngBounds(points);
+ builder.target(initCameraBounds.getCenter());
+
+ } else {
+ JSONObject latLng = camera.getJSONObject("target");
+ builder.target(new LatLng(latLng.getDouble("lat"), latLng.getDouble("lng")));
+ if (camera.has("zoom")) {
+ builder.zoom((float) camera.getDouble("zoom"));
+ }
+ }
+ } else {
+ builder.target(new LatLng(0, 0));
+ }
+ if (camera.has("tilt")) {
+ builder.tilt((float) camera.getDouble("tilt"));
+ }
+ options.camera(builder.build());
+ }
+
+ mapView = new MapView(activity, options);
+
+ activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ mapView.onCreate(null);
+ mapView.setTag(getViewDepth());
+
+ mapView.getMapAsync(new OnMapReadyCallback() {
+ @Override
+ public void onMapReady(GoogleMap googleMap) {
+
+ dummyMyLocationButton = new ImageView(activity);
+ FrameLayout.LayoutParams lParams = new FrameLayout.LayoutParams((int)(48 * density), (int)(48 * density));
+ lParams.gravity = Gravity.RIGHT;
+ lParams.rightMargin = (int)(6 * density);
+ lParams.topMargin = (int)(6 * density);
+ lParams.leftMargin = 0;
+ dummyMyLocationButton.setClickable(true);
+ dummyMyLocationButton.setAlpha(0.75f);
+ dummyMyLocationButton.setVisibility(View.GONE);
+ dummyMyLocationButton.setLayoutParams(lParams);
+
+ int buttonImgId = PluginUtil.getAppResource(cordova.getActivity(), "dummy_my_location_button", "drawable");
+ dummyMyLocationButton.setImageBitmap(BitmapFactory.decodeResource(activity.getResources(), buttonImgId));
+
+ int shadowXmlId = PluginUtil.getAppResource(cordova.getActivity(), "dummy_mylocation_button_shadow", "drawable");
+ dummyMyLocationButton.setBackground(activity.getResources().getDrawable(shadowXmlId));
+
+ dummyMyLocationButton.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ PluginMap.this.onMyLocationButtonClick();
+ }
+ });
+ mapView.addView(dummyMyLocationButton);
+
+ map = googleMap;
+ projection = map.getProjection();
+
+ try {
+ //styles
+ if (params.has("styles")) {
+ String styles = params.getString("styles");
+ MapStyleOptions styleOptions = new MapStyleOptions(styles);
+ map.setMapStyle(styleOptions);
+ map.setMapType(GoogleMap.MAP_TYPE_NORMAL);
+ }
+
+ //controls
+ if (params.has("controls")) {
+ JSONObject controls = params.getJSONObject("controls");
+
+ if (controls.has("indoorPicker")) {
+ Boolean isEnabled = controls.getBoolean("indoorPicker");
+ map.setIndoorEnabled(isEnabled);
+ }
+
+ if (controls.has("myLocationButton") || controls.has("myLocation")) {
+ boolean locationPermission = PermissionChecker.checkSelfPermission(cordova.getActivity(), Manifest.permission.ACCESS_COARSE_LOCATION) == PermissionChecker.PERMISSION_GRANTED;
+ //Log.d(TAG, "---> (314) hasPermission = " + locationPermission);
+
+ if (locationPermission) {
+ Boolean isMyLocationEnabled = false;
+ if (controls.has("myLocation")) {
+ isMyLocationEnabled = controls.getBoolean("myLocation");
+ map.setMyLocationEnabled(isMyLocationEnabled);
+ }
+
+ Boolean isMyLocationButtonEnabled = false;
+ if (controls.has("myLocationButton")) {
+ isMyLocationButtonEnabled = controls.getBoolean("myLocationButton");
+ map.getUiSettings().setMyLocationButtonEnabled(isMyLocationButtonEnabled);
+ }
+ //Log.d(TAG, "--->isMyLocationButtonEnabled = " + isMyLocationButtonEnabled + ", isMyLocationEnabled = " + isMyLocationEnabled);
+ if (!isMyLocationEnabled && isMyLocationButtonEnabled) {
+ dummyMyLocationButton.setVisibility(View.VISIBLE);
+ } else {
+ dummyMyLocationButton.setVisibility(View.GONE);
+ }
+ }
+ }
+ }
+ //preferences
+ if (params.has("preferences")) {
+ JSONObject preferences = params.getJSONObject("preferences");
+
+ if (preferences.has("padding")) {
+ JSONObject padding = preferences.getJSONObject("padding");
+ int left = 0, top = 0, bottom = 0, right = 0;
+ if (padding.has("left")) {
+ left = (int) (padding.getInt("left") * density);
+ }
+ if (padding.has("top")) {
+ top = (int) (padding.getInt("top") * density);
+ }
+ if (padding.has("bottom")) {
+ bottom = (int) (padding.getInt("bottom") * density);
+ }
+ if (padding.has("right")) {
+ right = (int) (padding.getInt("right") * density);
+ }
+ map.setPadding(left, top, right, bottom);
+
+ FrameLayout.LayoutParams lParams2 = (FrameLayout.LayoutParams) dummyMyLocationButton.getLayoutParams();
+ lParams2.rightMargin = right + (int)(5 * density);
+ lParams2.topMargin = top + (int)(5 * density);
+ dummyMyLocationButton.setLayoutParams(lParams2);
+
+ }
+
+ if (preferences.has("zoom")) {
+ JSONObject zoom = preferences.getJSONObject("zoom");
+ if (zoom.has("minZoom")) {
+ map.setMinZoomPreference((float)zoom.getDouble("minZoom"));
+ }
+ if (zoom.has("maxZoom")) {
+ map.setMaxZoomPreference((float)zoom.getDouble("maxZoom"));
+ }
+ }
+
+
+ if (preferences.has("gestureBounds")) {
+ Object target = preferences.get("gestureBounds");
+ @SuppressWarnings("rawtypes")
+ Class targetClass = target.getClass();
+ if ("org.json.JSONArray".equals(targetClass.getName())) {
+ JSONArray points = preferences.getJSONArray("gestureBounds");
+ LatLngBounds bounds = PluginUtil.JSONArray2LatLngBounds(points);
+ map.setLatLngBoundsForCameraTarget(bounds);
+ }
+ }
+ }
+
+ // Set event listener
+ map.setOnCameraIdleListener(PluginMap.this);
+ map.setOnCameraMoveCanceledListener(PluginMap.this);
+ map.setOnCameraMoveListener(PluginMap.this);
+ map.setOnCameraMoveStartedListener(PluginMap.this);
+ map.setOnMapClickListener(PluginMap.this);
+ map.setOnMapLongClickListener(PluginMap.this);
+ map.setOnMarkerClickListener(PluginMap.this);
+ map.setOnMarkerDragListener(PluginMap.this);
+ map.setOnMyLocationButtonClickListener(PluginMap.this);
+ map.setOnMapLoadedCallback(PluginMap.this);
+ map.setOnIndoorStateChangeListener(PluginMap.this);
+ map.setOnInfoWindowClickListener(PluginMap.this);
+ map.setOnInfoWindowLongClickListener(PluginMap.this);
+ map.setOnInfoWindowCloseListener(PluginMap.this);
+ map.setOnMyLocationClickListener(PluginMap.this);
+ map.setOnPoiClickListener(PluginMap.this);
+
+ //Custom info window
+ map.setInfoWindowAdapter(PluginMap.this);
+
+
+ mapView.onResume();
+
+
+ // ------------------------------
+ // Embed the map if a container is specified.
+ // ------------------------------
+ if (args.length() == 3) {
+ mapDivId = args.getString(2);
+
+ mapCtrl.mPluginLayout.addPluginOverlay(PluginMap.this);
+ PluginMap.this.resizeMap(args, new PluginUtil.MyCallbackContext("dummy-" + map.hashCode(), webView) {
+ @Override
+ public void onResult(PluginResult pluginResult) {
+
+ if (initCameraBounds != null) {
+ map.setOnCameraIdleListener(new GoogleMap.OnCameraIdleListener() {
+ @Override
+ public void onCameraIdle() {
+ mapView.setVisibility(View.INVISIBLE);
+ PluginMap.this.onCameraIdle();
+ map.setOnCameraIdleListener(PluginMap.this);
+ Handler handler = new Handler();
+ handler.postDelayed(new AdjustInitCamera(params, callbackContext), 750);
+ }
+ });
+ } else {
+ mapView.setVisibility(View.VISIBLE);
+ PluginMap.this.onCameraEvent("camera_move_end");
+ callbackContext.success();
+ }
+ }
+ });
+ } else {
+ if (initCameraBounds != null) {
+ map.setOnCameraIdleListener(new GoogleMap.OnCameraIdleListener() {
+ @Override
+ public void onCameraIdle() {
+ PluginMap.this.onCameraIdle();
+ map.setOnCameraIdleListener(PluginMap.this);
+ mapView.setVisibility(View.INVISIBLE);
+ Handler handler = new Handler();
+ handler.postDelayed(new AdjustInitCamera(params, callbackContext), 750);
+ }
+ });
+ } else {
+ mapView.setVisibility(View.VISIBLE);
+ PluginMap.this.onCameraEvent("camera_move_end");
+ callbackContext.success();
+ //if (map.getMapType() == GoogleMap.MAP_TYPE_NONE) {
+ PluginMap.this.onMapLoaded();
+ //}
+ }
+ }
+ } catch (Exception e) {
+ callbackContext.error(e.getMessage());
+ }
+ }
+ });
+
+
+ }
+ });
+ }
+
+ @Override
+ public void onStart() {
+ super.onStart();
+ if (mapView != null) {
+ mapView.onStart();
+ }
+ }
+
+ @Override
+ public void onStop() {
+ super.onStop();
+ if (mapView != null) {
+ mapView.onStop();
+ }
+ }
+
+ @Override
+ public void onPause(boolean multitasking) {
+ super.onPause(multitasking);
+ if (mapView != null && mapView.isActivated()) {
+ mapView.onPause();
+ }
+
+ //mapCtrl.mPluginLayout.removePluginOverlay(this.mapId);
+
+ }
+ @Override
+ public void onResume(boolean multitasking) {
+ super.onResume(multitasking);
+ if (mapView != null && mapView.isActivated()) {
+ mapView.onResume();
+ }
+ //mapCtrl.mPluginLayout.addPluginOverlay(PluginMap.this);
+ }
+
+ private class AdjustInitCamera implements Runnable {
+ private JSONObject mParams;
+ private CallbackContext mCallback;
+ public AdjustInitCamera(JSONObject params, CallbackContext callbackContext) {
+ mParams = params;
+ mCallback = callbackContext;
+ }
+ @Override
+ public void run() {
+
+ double CAMERA_PADDING = DEFAULT_CAMERA_PADDING;
+ try {
+ if (mParams.has("camera")) {
+ JSONObject camera = mParams.getJSONObject("camera");
+ if (camera.has("padding")) {
+ CAMERA_PADDING = camera.getDouble("padding");
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ map.moveCamera(CameraUpdateFactory.newLatLngBounds(initCameraBounds, (int) (CAMERA_PADDING * density)));
+
+ CameraPosition.Builder builder = CameraPosition.builder(map.getCameraPosition());
+
+ try {
+ if (mParams.has("camera")) {
+ Boolean additionalParams = false;
+ JSONObject camera = mParams.getJSONObject("camera");
+ if (camera.has("bearing")) {
+ builder.bearing((float) camera.getDouble("bearing"));
+ additionalParams = true;
+ }
+ if (camera.has("tilt")) {
+ builder.tilt((float) camera.getDouble("tilt"));
+ additionalParams = true;
+ }
+ if (additionalParams) {
+ map.moveCamera(CameraUpdateFactory.newCameraPosition(builder.build()));
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ mapView.setVisibility(View.VISIBLE);
+ mCallback.success();
+
+ //if (map.getMapType() == GoogleMap.MAP_TYPE_NONE) {
+ PluginMap.this.onMapLoaded();
+ //}
+
+ //fitBounds(initCameraBounds, CAMERA_PADDING);
+ }
+ }
+
+ //-----------------------------------
+ // Create the instance of class
+ //-----------------------------------
+ public synchronized void loadPlugin(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final String serviceName = args.getString(0);
+ final String pluginName = mapId + "-" + serviceName.toLowerCase();
+ //Log.d("PluginMap", "serviceName = " + serviceName + ", pluginName = " + pluginName);
+
+ try {
+
+ if (plugins.containsKey(pluginName)) {
+ //Log.d("PluginMap", "--> useCache");
+ MyPlugin myPlugin = (MyPlugin) plugins.get(pluginName).plugin;
+ myPlugin.create(args, callbackContext);
+ return;
+ }
+
+ //Log.d("PluginMap", "--> create new instance");
+ String className = "plugin.google.maps.Plugin" + serviceName;
+ Class pluginCls = Class.forName(className);
+
+ CordovaPlugin plugin = (CordovaPlugin) pluginCls.newInstance();
+ PluginEntry pluginEntry = new PluginEntry(pluginName, plugin);
+ plugins.put(pluginName, pluginEntry);
+ mapCtrl.pluginManager.addService(pluginEntry);
+
+ plugin.privateInitialize(pluginName, cordova, webView, null);
+
+ plugin.initialize(cordova, webView);
+ ((MyPluginInterface)plugin).setPluginMap(PluginMap.this);
+ MyPlugin myPlugin = (MyPlugin) plugin;
+ myPlugin.self = (MyPlugin)plugin;
+ myPlugin.create(args, callbackContext);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ private void fitBounds(final LatLngBounds cameraBounds, int padding) {
+ Builder builder = CameraPosition.builder();
+ builder.tilt(map.getCameraPosition().tilt);
+ builder.bearing(map.getCameraPosition().bearing);
+ Log.d(TAG, mapView.getWidth() + "x" + mapView.getHeight());
+
+ // Fit the camera to the cameraBounds with 20px padding.
+ CameraUpdate cameraUpdate = CameraUpdateFactory.newLatLngBounds(cameraBounds, padding / (int)density);
+ try {
+ map.moveCamera(cameraUpdate);
+ builder.zoom(map.getCameraPosition().zoom);
+ builder.target(map.getCameraPosition().target);
+ map.moveCamera(CameraUpdateFactory.newCameraPosition(builder.build()));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+
+ //-----------------------------------
+ // Create the instance of class
+ //-----------------------------------
+ @SuppressWarnings("rawtypes")
+ public void create(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final String className = args.getString(0);
+
+
+ try {
+ if (plugins.containsKey(className)) {
+ PluginEntry pluginEntry = plugins.get(className);
+ pluginEntry.plugin.execute("create", args, callbackContext);
+ return;
+ }
+
+ Class pluginCls = Class.forName("plugin.google.maps.Plugin" + className);
+
+ CordovaPlugin plugin = (CordovaPlugin) pluginCls.newInstance();
+ PluginEntry pluginEntry = new PluginEntry(mapId + "-" + className, plugin);
+ plugins.put(className, pluginEntry);
+ pluginMap = PluginMap.this;
+ pluginMap.mapCtrl.pluginManager.addService(pluginEntry);
+
+ plugin.privateInitialize(className, cordova, webView, null);
+ plugin.initialize(cordova, webView);
+ ((MyPluginInterface)plugin).setPluginMap(PluginMap.this);
+ pluginEntry.plugin.execute("create", args, callbackContext);
+
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+
+ public void attachToWebView(JSONArray args, final CallbackContext callbackContext) {
+ mapCtrl.mPluginLayout.addPluginOverlay(this);
+ callbackContext.success();
+ }
+ public void detachFromWebView(JSONArray args, final CallbackContext callbackContext) {
+ mapCtrl.mPluginLayout.removePluginOverlay(this.mapId);
+ callbackContext.success();
+ }
+
+ public void resizeMap(JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ if (mapCtrl.mPluginLayout == null || mapDivId == null) {
+ //Log.d("PluginMap", "---> resizeMap / mPluginLayout = null");
+ callbackContext.success();
+ if (initCameraBounds != null) {
+ mainHandler.postDelayed(new Runnable() {
+ @Override
+ public void run() {
+ }
+ }, 100);
+ }
+ return;
+ }
+
+ mapCtrl.mPluginLayout.needUpdatePosition = true;
+
+ if (!mapCtrl.mPluginLayout.HTMLNodes.containsKey(mapDivId)) {
+ Bundle dummyInfo = new Bundle();
+ dummyInfo.putBoolean("isDummy", true);
+ dummyInfo.putDouble("offsetX", 0);
+ dummyInfo.putDouble("offsetY", 3000);
+
+ Bundle dummySize = new Bundle();
+ dummySize.putDouble("left", 0);
+ dummySize.putDouble("top", 3000);
+ dummySize.putDouble("width", 200);
+ dummySize.putDouble("height", 200);
+ dummyInfo.putBundle("size", dummySize);
+ dummySize.putDouble("depth", -999);
+ mapCtrl.mPluginLayout.HTMLNodes.put(mapDivId, dummyInfo);
+ }
+
+
+
+ activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ if(mapCtrl.mPluginLayout == null || mapDivId == null) {
+ callbackContext.success();
+ return;
+ }
+
+ RectF drawRect = mapCtrl.mPluginLayout.HTMLNodeRectFs.get(mapDivId);
+
+ //Log.d(TAG, "--->mapDivId = " + mapDivId + ", drawRect = " + drawRect);
+ if (drawRect != null) {
+ final int scrollY = webView.getView().getScrollY();
+
+ int width = (int) drawRect.width();
+ int height = (int) drawRect.height();
+ int x = (int) drawRect.left;
+ int y = (int) drawRect.top + scrollY;
+ ViewGroup.LayoutParams lParams = mapView.getLayoutParams();
+ FrameLayout.LayoutParams params = (FrameLayout.LayoutParams) lParams;
+
+ params.width = width;
+ params.height = height;
+ params.leftMargin = x;
+ params.topMargin = y;
+ mapView.setLayoutParams(params);
+
+ callbackContext.success();
+ }
+ }
+ });
+ }
+
+ public void setDiv(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ if (args.length() == 0) {
+ PluginMap.this.mapDivId = null;
+ mapCtrl.mPluginLayout.removePluginOverlay(mapId);
+ callbackContext.success();
+ return;
+ }
+ PluginMap.this.mapDivId = args.getString(0);
+ mapCtrl.mPluginLayout.addPluginOverlay(PluginMap.this);
+ this.resizeMap(args, callbackContext);
+ }
+
+ /**
+ * Set clickable of the map
+ * @param args Parameters given from JavaScript side
+ * @param callbackContext Callback contect for sending back the result.
+ * @throws JSONException
+ */
+ public void setClickable(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ boolean clickable = args.getBoolean(0);
+ this.isClickable = clickable;
+ //mapCtrl.mPluginLayout.setClickable(mapId, clickable);
+ callbackContext.success();
+ }
+
+ /**
+ * Set visibility of the map
+ * @param args Parameters given from JavaScript side
+ * @param callbackContext Callback contect for sending back the result.
+ * @throws JSONException
+ */
+ public void setVisible(JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final boolean visible = args.getBoolean(0);
+ this.isVisible = visible;
+ activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ if (visible) {
+ mapView.setVisibility(View.VISIBLE);
+ } else {
+ mapView.setVisibility(View.INVISIBLE);
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ this.objects.clear();
+ this.objects.destroy();
+ }
+
+ /**
+ * Destroy the map completely
+ * @param args Parameters given from JavaScript side
+ * @param callbackContext Callback contect for sending back the result.
+ */
+ public void remove(JSONArray args, final CallbackContext callbackContext) {
+ this.isClickable = false;
+ this.isRemoved = true;
+
+ try {
+ PluginMap.this.clear(null, new PluginUtil.MyCallbackContext(mapId + "_remove", webView) {
+
+ @Override
+ public void onResult(PluginResult pluginResult) {
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ mapCtrl.mPluginLayout.removePluginOverlay(mapId);
+
+ //Log.d("pluginMap", "--> map = " + map);
+ if (map != null) {
+ try {
+ map.setIndoorEnabled(false);
+ map.setMyLocationEnabled(false);
+ map.setOnPolylineClickListener(null);
+ map.setOnPolygonClickListener(null);
+ map.setOnIndoorStateChangeListener(null);
+ map.setOnCircleClickListener(null);
+ map.setOnGroundOverlayClickListener(null);
+ map.setOnCameraIdleListener(null);
+ map.setOnCameraMoveCanceledListener(null);
+ map.setOnCameraMoveListener(null);
+ map.setOnInfoWindowClickListener(null);
+ map.setOnInfoWindowCloseListener(null);
+ map.setOnMapClickListener(null);
+ map.setOnMapLongClickListener(null);
+ map.setOnMarkerClickListener(null);
+ map.setOnMyLocationButtonClickListener(null);
+ map.setOnMapLoadedCallback(null);
+ map.setOnMarkerDragListener(null);
+ map.setOnMyLocationClickListener(null);
+ map.setOnPoiClickListener(null);
+ } catch (SecurityException e) {
+ e.printStackTrace();
+ }
+ }
+ if (mapView != null) {
+ try {
+ mapView.clearAnimation();
+ //mapView.onCancelPendingInputEvents(); // Android 4.2 crashes
+ mapView.onPause();
+ mapView.onDestroy();
+ //Log.d("pluginMap", "--> mapView.onDestroy()");
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ if (plugins.size() > 0) {
+ String[] pluginNames = plugins.keySet().toArray(new String[plugins.size()]);
+ PluginEntry pluginEntry;
+ for (int i = 0; i < pluginNames.length; i++) {
+ pluginEntry = plugins.remove(pluginNames[i]);
+ if (pluginEntry == null) {
+ continue;
+ }
+ pluginEntry.plugin.onDestroy();
+ ((MyPlugin)pluginEntry.plugin).map = null;
+ ((MyPlugin)pluginEntry.plugin).mapCtrl = null;
+ //((MyPlugin)pluginEntry.plugin).pluginMap = null; // Do not clear at here.
+ pluginEntry = null;
+ }
+ }
+ //Log.d("pluginMap", "--> mapView = " + mapView);
+ projection = null;
+ plugins = null;
+ map = null;
+ mapView = null;
+ initCameraBounds = null;
+ activity = null;
+ mapId = null;
+ mapDivId = null;
+ activeMarker = null;
+
+ System.gc();
+ Runtime.getRuntime().gc();
+ if (callbackContext != null) {
+ callbackContext.success();
+ }
+ PluginMap.this.onDestroy();
+ }
+ });
+ }
+ });
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+
+
+ @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
+ @Override
+ public View getInfoContents(Marker marker) {
+ //Log.d(TAG, "--->getInfoContents");
+ activeMarker = marker;
+ String title = marker.getTitle();
+ String snippet = marker.getSnippet();
+ if ((title == null) && (snippet == null)) {
+ return null;
+ }
+
+ String markerTag = (String) marker.getTag();
+ String tmp[] = markerTag.split("_");
+ String className = tmp[0];
+ tmp = markerTag.split("-");
+ String markerId = tmp[tmp.length - 1];
+
+ PluginEntry pluginEntry = plugins.get(mapId + "-" + className);
+ if (pluginEntry == null) {
+ //Log.d(TAG, "---> getInfoContents / marker.title = " + marker.getTitle());
+ return null;
+ }
+ MyPlugin myPlugin = (MyPlugin)pluginEntry.plugin;
+
+ JSONObject properties = null;
+ JSONObject styles = null;
+ String propertyId = "marker_property_" + markerTag;
+ //Log.d(TAG, "---> getInfoContents / propertyId = " + propertyId);
+
+ if (objects.containsKey(propertyId)) {
+ properties = (JSONObject) objects.get(propertyId);
+
+ try {
+ if (properties.has("styles")) {
+ styles = (JSONObject) properties.getJSONObject("styles");
+ }
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+
+ if ((marker.getTag() + "").startsWith("markercluster_")){
+ this.onClusterEvent("info_open", marker);
+ } else {
+ this.onMarkerEvent("info_open", marker);
+ }
+
+ // Linear layout
+ LinearLayout windowLayer = new LinearLayout(activity);
+ windowLayer.setPadding(3, 3, 3, 3);
+ windowLayer.setOrientation(LinearLayout.VERTICAL);
+ FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT);
+ layoutParams.gravity = Gravity.BOTTOM | Gravity.CENTER;
+
+ int maxWidth = 0;
+
+ if (styles != null) {
+ if (styles.has("width")) {
+ try {
+ int width = 0;
+ String widthString = styles.getString("width");
+
+ if (widthString.endsWith("%")) {
+ double widthDouble = Double.parseDouble(widthString.replace("%", ""));
+
+ width = (int) ((double) mapView.getWidth() * (widthDouble / 100));
+ } else if (PluginUtil.isNumeric(widthString)) {
+ double widthDouble = Double.parseDouble(widthString);
+
+ if (widthDouble <= 1.0) { // for percentage values (e.g. 0.5 = 50%).
+ width = (int) ((double) mapView.getWidth() * (widthDouble));
+ } else {
+ width = (int) widthDouble;
+ }
+ }
+
+ if (width > 0) {
+ layoutParams.width = width;
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ if (styles.has("maxWidth")) {
+ try {
+ String widthString = styles.getString("maxWidth");
+
+ if (widthString.endsWith("%")) {
+ double widthDouble = Double.parseDouble(widthString.replace("%", ""));
+
+ maxWidth = (int) ((double) mapView.getWidth() * (widthDouble / 100));
+
+ // make sure to take padding into account.
+ maxWidth -= (windowLayer.getPaddingLeft() + windowLayer.getPaddingRight());
+ } else if (PluginUtil.isNumeric(widthString)) {
+ double widthDouble = Double.parseDouble(widthString);
+
+ if (widthDouble <= 1.0) { // for percentage values (e.g. 0.5 = 50%).
+ maxWidth = (int) ((double) mapView.getWidth() * (widthDouble));
+ } else {
+ maxWidth = (int) widthDouble;
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ windowLayer.setLayoutParams(layoutParams);
+
+ //----------------------------------------
+ // text-align = left | center | right
+ //----------------------------------------
+ int gravity = Gravity.LEFT;
+ int textAlignment = View.TEXT_ALIGNMENT_GRAVITY;
+
+ if (styles != null) {
+ if (styles.has("text-align")) {
+ try {
+ String textAlignValue = styles.getString("text-align");
+
+ switch (TEXT_STYLE_ALIGNMENTS.valueOf(textAlignValue)) {
+ case left:
+ gravity = Gravity.LEFT;
+ textAlignment = View.TEXT_ALIGNMENT_GRAVITY;
+ break;
+ case center:
+ gravity = Gravity.CENTER;
+ textAlignment = View.TEXT_ALIGNMENT_CENTER;
+ break;
+ case right:
+ gravity = Gravity.RIGHT;
+ textAlignment = View.TEXT_ALIGNMENT_VIEW_END;
+ break;
+ }
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ if (title != null) {
+ if (title.contains("data:image/") && title.contains(";base64,")) {
+ tmp = title.split(",");
+ Bitmap image = PluginUtil.getBitmapFromBase64encodedImage(tmp[1]);
+ image = PluginUtil.scaleBitmapForDevice(image);
+ ImageView imageView = new ImageView(this.activity);
+ imageView.setImageBitmap(image);
+
+ if (maxWidth > 0) {
+ imageView.setMaxWidth(maxWidth);
+ imageView.setAdjustViewBounds(true);
+ }
+
+ windowLayer.addView(imageView);
+ } else {
+ TextView textView = new TextView(this.activity);
+ textView.setText(title);
+ textView.setSingleLine(false);
+
+ int titleColor = Color.BLACK;
+ if (styles != null && styles.has("color")) {
+ try {
+ titleColor = PluginUtil.parsePluginColor(styles.getJSONArray("color"));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+ textView.setTextColor(titleColor);
+ textView.setGravity(gravity);
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+ textView.setTextAlignment(textAlignment);
+ }
+
+ //----------------------------------------
+ // font-style = normal | italic
+ // font-weight = normal | bold
+ //----------------------------------------
+ int fontStyle = Typeface.NORMAL;
+ if (styles != null) {
+ if (styles.has("font-style")) {
+ try {
+ if ("italic".equals(styles.getString("font-style"))) {
+ fontStyle = Typeface.ITALIC;
+ }
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+ if (styles.has("font-weight")) {
+ try {
+ if ("bold".equals(styles.getString("font-weight"))) {
+ fontStyle = fontStyle | Typeface.BOLD;
+ }
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ textView.setTypeface(Typeface.DEFAULT, fontStyle);
+
+ if (maxWidth > 0) {
+ textView.setMaxWidth(maxWidth);
+ }
+
+ windowLayer.addView(textView);
+ }
+ }
+ if (snippet != null) {
+ //snippet = snippet.replaceAll("\n", "");
+ TextView textView2 = new TextView(this.activity);
+ textView2.setText(snippet);
+ textView2.setTextColor(Color.GRAY);
+ textView2.setTextSize((textView2.getTextSize() / 6 * 5) / density);
+ textView2.setGravity(gravity);
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+ textView2.setTextAlignment(textAlignment);
+ }
+
+ if (maxWidth > 0) {
+ textView2.setMaxWidth(maxWidth);
+ }
+
+ windowLayer.addView(textView2);
+ }
+
+ return windowLayer;
+ }
+
+ @Override
+ public View getInfoWindow(Marker marker) {
+ //Log.d(TAG, "--->getInfoWindow");
+ activeMarker = marker;
+
+ JSONObject properties = null;
+
+ String markerTag = (String) marker.getTag();
+ String tmp[] = markerTag.split("_");
+ String className = tmp[0];
+ tmp = markerTag.split("-");
+ String markerId = tmp[tmp.length - 1];
+
+ String propertyId = "marker_property_" + markerTag;
+
+ //Log.e(TAG, "---> getInfoWindow / propertyId = " + propertyId);
+ //Log.e(TAG, "---> getInfoWindow / pluginEntryId = " + mapId + "-" + className);
+ PluginEntry pluginEntry = plugins.get(mapId + "-" + className);
+ if (pluginEntry == null) {
+ Log.e(TAG, "---> getInfoWindow / pluginEntry is null");
+ return null;
+ }
+ MyPlugin myPlugin = (MyPlugin)pluginEntry.plugin;
+
+ if (objects.containsKey(propertyId)) {
+ properties = (JSONObject) objects.get(propertyId);
+ try {
+ if (marker.getTitle() == null && marker.getSnippet() == null) {
+
+ syncInfoWndPosition();
+
+ if ((marker.getTag() + "").startsWith("markercluster_")){
+ this.onClusterEvent("info_open", marker);
+ } else {
+ this.onMarkerEvent("info_open", marker);
+ }
+
+ int resId = PluginUtil.getAppResource(cordova.getActivity(), "dummy_infowindow", "layout");
+ return cordova.getActivity().getLayoutInflater().inflate(resId, null);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ } else {
+ Log.e(TAG, "---> getInfoWindow / can not find the property");
+ }
+ return null;
+ }
+
+
+ /**
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setOptions(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+
+ final AsyncSetOptionsResult results = new AsyncSetOptionsResult();
+ results.cameraPadding = DEFAULT_CAMERA_PADDING;
+
+ try {
+ JSONObject params = args.getJSONObject(0);
+
+ if (params.has("styles")) {
+ results.styles = params.getString("styles");
+ } else {
+ // map type
+ results.MAP_TYPE_ID = -1;
+ if (!params.has("styles") && params.has("mapType")) {
+ String typeStr = params.getString("mapType");
+ results.MAP_TYPE_ID = typeStr.equals("MAP_TYPE_NORMAL") ? GoogleMap.MAP_TYPE_NORMAL : results.MAP_TYPE_ID;
+ results.MAP_TYPE_ID = typeStr.equals("MAP_TYPE_HYBRID") ? GoogleMap.MAP_TYPE_HYBRID : results.MAP_TYPE_ID;
+ results.MAP_TYPE_ID = typeStr.equals("MAP_TYPE_SATELLITE") ? GoogleMap.MAP_TYPE_SATELLITE : results.MAP_TYPE_ID;
+ results.MAP_TYPE_ID = typeStr.equals("MAP_TYPE_TERRAIN") ? GoogleMap.MAP_TYPE_TERRAIN : results.MAP_TYPE_ID;
+ results.MAP_TYPE_ID = typeStr.equals("MAP_TYPE_NONE") ? GoogleMap.MAP_TYPE_NONE : results.MAP_TYPE_ID;
+ }
+ }
+
+
+ // move the camera position
+ if (params.has("camera")) {
+ LatLngBounds cameraBounds = null;
+ JSONObject camera = params.getJSONObject("camera");
+ Builder builder = CameraPosition.builder();
+ if (camera.has("bearing")) {
+ builder.bearing((float) camera.getDouble("bearing"));
+ }
+ if (camera.has("latLng")) {
+ JSONObject latLng = camera.getJSONObject("latLng");
+ builder.target(new LatLng(latLng.getDouble("lat"), latLng.getDouble("lng")));
+ }
+
+ if (camera.has("padding")) {
+ results.cameraPadding = camera.getDouble("padding");
+ }
+
+ if (camera.has("target")) {
+ Object target = camera.get("target");
+ @SuppressWarnings("rawtypes")
+ Class targetClass = target.getClass();
+ if ("org.json.JSONArray".equals(targetClass.getName())) {
+ JSONArray points = camera.getJSONArray("target");
+ cameraBounds = PluginUtil.JSONArray2LatLngBounds(points);
+ builder.target(cameraBounds.getCenter());
+
+ } else {
+ JSONObject latLng = camera.getJSONObject("target");
+ builder.target(new LatLng(latLng.getDouble("lat"), latLng.getDouble("lng")));
+ }
+ }
+ if (camera.has("tilt")) {
+ builder.tilt((float) camera.getDouble("tilt"));
+ }
+ if (camera.has("zoom")) {
+ builder.zoom((float) camera.getDouble("zoom"));
+ }
+ results.cameraPosition = builder.build();
+ results.cameraBounds = cameraBounds;
+
+ }
+
+
+
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ try {
+
+ if (results.cameraPosition != null) {
+ try {
+ map.moveCamera(CameraUpdateFactory.newCameraPosition(results.cameraPosition));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ if (results.cameraBounds != null) {
+ fitBounds(results.cameraBounds, (int)(results.cameraPadding / density));
+ }
+ }
+
+ //styles
+ if (results.styles != null) {
+ MapStyleOptions styleOptions = new MapStyleOptions(results.styles);
+ map.setMapStyle(styleOptions);
+ map.setMapType(GoogleMap.MAP_TYPE_NORMAL);
+ } else if (results.MAP_TYPE_ID != -1) {
+ map.setMapType(results.MAP_TYPE_ID);
+ }
+
+ JSONObject params = null;
+ params = args.getJSONObject(0);
+ UiSettings settings = map.getUiSettings();
+
+ //preferences
+ if (params.has("preferences")) {
+ JSONObject preferences = params.getJSONObject("preferences");
+
+ if (preferences.has("padding")) {
+ JSONObject padding = preferences.getJSONObject("padding");
+ int left = 0, top = 0, bottom = 0, right = 0;
+ if (padding.has("left")) {
+ left = (int) (padding.getInt("left") * density);
+ }
+ if (padding.has("top")) {
+ top = (int) (padding.getInt("top") * density);
+ }
+ if (padding.has("bottom")) {
+ bottom = (int) (padding.getInt("bottom") * density);
+ }
+ if (padding.has("right")) {
+ right = (int) (padding.getInt("right") * density);
+ }
+ map.setPadding(left, top, right, bottom);
+
+ FrameLayout.LayoutParams lParams2 = (FrameLayout.LayoutParams) dummyMyLocationButton.getLayoutParams();
+ lParams2.rightMargin = right + (int)(5 * density);
+ lParams2.topMargin = top + (int)(5 * density);
+ dummyMyLocationButton.setLayoutParams(lParams2);
+ }
+
+ if (preferences.has("zoom")) {
+ JSONObject zoom = preferences.getJSONObject("zoom");
+ if (zoom.has("minZoom")) {
+ map.setMinZoomPreference((float)zoom.getDouble("minZoom"));
+ }
+ if (zoom.has("maxZoom")) {
+ map.setMaxZoomPreference((float)zoom.getDouble("maxZoom"));
+ }
+ }
+
+
+ if (preferences.has("gestureBounds")) {
+ Object target = preferences.get("gestureBounds");
+ @SuppressWarnings("rawtypes")
+ Class targetClass = target.getClass();
+ if ("org.json.JSONArray".equals(targetClass.getName())) {
+ JSONArray points = preferences.getJSONArray("gestureBounds");
+ if (points.length() > 0) {
+ LatLngBounds bounds = PluginUtil.JSONArray2LatLngBounds(points);
+ map.setLatLngBoundsForCameraTarget(bounds);
+ } else {
+ map.setLatLngBoundsForCameraTarget(null);
+ }
+ }
+ }
+
+ }
+
+ //gestures
+ if (params.has("gestures")) {
+ JSONObject gestures = params.getJSONObject("gestures");
+
+ if (gestures.has("tilt")) {
+ settings.setTiltGesturesEnabled(gestures.getBoolean("tilt"));
+ }
+ if (gestures.has("scroll")) {
+ settings.setScrollGesturesEnabled(gestures.getBoolean("scroll"));
+ }
+ if (gestures.has("rotate")) {
+ settings.setRotateGesturesEnabled(gestures.getBoolean("rotate"));
+ }
+ if (gestures.has("zoom")) {
+ settings.setZoomGesturesEnabled(gestures.getBoolean("zoom"));
+ }
+ }
+
+ //controls
+ if (params.has("controls")) {
+ final JSONObject controls = params.getJSONObject("controls");
+
+ if (controls.has("compass")) {
+ settings.setCompassEnabled(controls.getBoolean("compass"));
+ }
+ if (controls.has("zoom")) {
+ settings.setZoomControlsEnabled(controls.getBoolean("zoom"));
+ }
+ if (controls.has("indoorPicker")) {
+ settings.setIndoorLevelPickerEnabled(controls.getBoolean("indoorPicker"));
+ }
+ if (controls.has("mapToolbar")) {
+ settings.setMapToolbarEnabled(controls.getBoolean("mapToolbar"));
+ }
+ if (controls.has("myLocation") || controls.has("myLocationButton")) {
+ cordova.getThreadPool().submit(new Runnable() {
+ @Override
+ public void run() {
+ JSONArray args = new JSONArray();
+ args.put(controls);
+ try {
+ PluginMap.this.setMyLocationEnabled(args, callbackContext);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ callbackContext.error("error at map.setOptions()");
+ }
+ }
+ });
+ } else {
+ callbackContext.success();
+ }
+ } else {
+ callbackContext.success();
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ callbackContext.error("error at map.setOptions()");
+
+ }
+ }
+ });
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ callbackContext.error("error at map.setOptions()");
+ }
+
+
+
+ }
+
+ public void getFocusedBuilding(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ IndoorBuilding focusedBuilding = map.getFocusedBuilding();
+ if (focusedBuilding != null) {
+ JSONObject result = PluginUtil.convertIndoorBuildingToJson(focusedBuilding);
+ callbackContext.success(result);
+ } else {
+ callbackContext.success(-1);
+ }
+ }
+ });
+ }
+
+ /**
+ * Set center location of the marker
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setCameraTarget(JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ double lat = args.getDouble(0);
+ double lng = args.getDouble(1);
+
+ LatLng latLng = new LatLng(lat, lng);
+ final CameraUpdate cameraUpdate = CameraUpdateFactory.newLatLng(latLng);
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ myMoveCamera(cameraUpdate, callbackContext);
+ }
+ });
+ }
+
+ /**
+ * Set angle of the map view
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setCameraTilt(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ float tilt = (float) args.getDouble(0);
+
+ if (tilt > 0 && tilt <= 90) {
+ final float finalTilt = tilt;
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ CameraPosition currentPos = map.getCameraPosition();
+ CameraPosition newPosition = new CameraPosition.Builder()
+ .target(currentPos.target).bearing(currentPos.bearing)
+ .zoom(currentPos.zoom).tilt(finalTilt).build();
+ myMoveCamera(newPosition, callbackContext);
+ }
+ });
+ } else {
+ callbackContext.error("Invalid tilt angle(" + tilt + ")");
+ }
+ }
+
+ public void setCameraBearing(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final float bearing = (float) args.getDouble(0);
+
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ CameraPosition currentPos = map.getCameraPosition();
+ CameraPosition newPosition = new CameraPosition.Builder()
+ .target(currentPos.target).bearing(bearing)
+ .zoom(currentPos.zoom).tilt(currentPos.tilt).build();
+ myMoveCamera(newPosition, callbackContext);
+ }
+ });
+ }
+
+ /**
+ * Move the camera with animation
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void animateCamera(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ this.updateCameraPosition("animateCamera", args, callbackContext);
+ }
+
+ /**
+ * Move the camera without animation
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void moveCamera(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ this.updateCameraPosition("moveCamera", args, callbackContext);
+ }
+
+
+ /**
+ * move the camera
+ * @param action
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void updateCameraPosition(final String action, final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ if (this.isRemoved) {
+ return;
+ }
+ final JSONObject cameraPos = args.getJSONObject(0);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ final CameraPosition.Builder builder = CameraPosition.builder(map.getCameraPosition());
+ UpdateCameraAction cameraAction = new UpdateCameraAction(callbackContext, cameraPos, builder, action);
+ cameraAction.execute();
+
+ }
+ });
+
+ }
+
+ private class UpdateCameraAction extends AsyncTask {
+ private Exception mException = null;
+ private CallbackContext mCallbackContext;
+ private JSONObject mCameraPos;
+ private CameraPosition.Builder mBuilder;
+ private String mAction;
+
+ UpdateCameraAction(CallbackContext callbackContext, JSONObject cameraPos, CameraPosition.Builder builder, String action) {
+ super();
+ this.mCallbackContext = callbackContext;
+ this.mCameraPos = cameraPos;
+ this.mBuilder = builder;
+ this.mAction = action;
+ }
+
+ @Override
+ protected AsyncUpdateCameraPositionResult doInBackground(Void... voids) {
+ AsyncUpdateCameraPositionResult result = new AsyncUpdateCameraPositionResult();
+ if (isRemoved) {
+ this.cancel(true);
+ return null;
+ }
+
+ try {
+
+ result.durationMS = 4000;
+ result.cameraPadding = DEFAULT_CAMERA_PADDING;
+ if (mCameraPos.has("tilt")) {
+ mBuilder.tilt((float) mCameraPos.getDouble("tilt"));
+ }
+ if (mCameraPos.has("bearing")) {
+ mBuilder.bearing((float) mCameraPos.getDouble("bearing"));
+ }
+ if (mCameraPos.has("zoom")) {
+ mBuilder.zoom((float) mCameraPos.getDouble("zoom"));
+ }
+ if (mCameraPos.has("duration")) {
+ result.durationMS = mCameraPos.getInt("duration");
+ }
+ if (mCameraPos.has("padding")) {
+ result.cameraPadding = mCameraPos.getDouble("padding");
+ }
+
+ if (!mCameraPos.has("target")) {
+ return result;
+ }
+
+ //------------------------
+ // Create a cameraUpdate
+ //------------------------
+ result.cameraUpdate = null;
+ result.cameraBounds = null;
+ CameraPosition newPosition;
+ Object target = mCameraPos.get("target");
+ @SuppressWarnings("rawtypes")
+ Class targetClass = target.getClass();
+ JSONObject latLng;
+ if ("org.json.JSONArray".equals(targetClass.getName())) {
+ JSONArray points = mCameraPos.getJSONArray("target");
+ result.cameraBounds = PluginUtil.JSONArray2LatLngBounds(points);
+ result.cameraUpdate = CameraUpdateFactory.newLatLngBounds(result.cameraBounds, (int)(result.cameraPadding * density));
+ } else {
+ latLng = mCameraPos.getJSONObject("target");
+ mBuilder.target(new LatLng(latLng.getDouble("lat"), latLng.getDouble("lng")));
+ newPosition = mBuilder.build();
+ result.cameraUpdate = CameraUpdateFactory.newCameraPosition(newPosition);
+ }
+ } catch (Exception e) {
+ mException = e;
+ e.printStackTrace();
+ this.cancel(true);
+ return null;
+ }
+
+ return result;
+ }
+
+ @Override
+ public void onCancelled() {
+ if (mException != null) {
+ mException.printStackTrace();
+ }
+ mCallbackContext.error(mException != null ? mException.getMessage() + "" : "");
+ }
+ @Override
+ public void onCancelled(AsyncUpdateCameraPositionResult AsyncUpdateCameraPositionResult) {
+ if (mException != null) {
+ mException.printStackTrace();
+ }
+ mCallbackContext.error(mException != null ? mException.getMessage() + "" : "");
+ }
+
+ @Override
+ public void onPostExecute(AsyncUpdateCameraPositionResult AsyncUpdateCameraPositionResult) {
+ if (isRemoved) {
+ return;
+ }
+
+
+ if (AsyncUpdateCameraPositionResult.cameraUpdate == null) {
+ CameraPosition.Builder builder = CameraPosition.builder(map.getCameraPosition());
+ builder.target(map.getCameraPosition().target);
+ AsyncUpdateCameraPositionResult.cameraUpdate = CameraUpdateFactory.newCameraPosition(builder.build());
+ }
+
+ final AsyncUpdateCameraPositionResult finalCameraPosition = AsyncUpdateCameraPositionResult;
+ PluginUtil.MyCallbackContext myCallback = new PluginUtil.MyCallbackContext("moveCamera", webView) {
+ @Override
+ public void onResult(final PluginResult pluginResult) {
+ if (finalCameraPosition.cameraBounds != null && ANIMATE_CAMERA_DONE.equals(pluginResult.getStrMessage())) {
+
+
+ final Builder builder = CameraPosition.builder(map.getCameraPosition());
+ if (mCameraPos.has("tilt")) {
+ try {
+ builder.tilt((float) mCameraPos.getDouble("tilt"));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+ if (mCameraPos.has("bearing")) {
+ try {
+ builder.bearing((float) mCameraPos.getDouble("bearing"));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+
+ CameraUpdate cameraUpdate = CameraUpdateFactory.newLatLngBounds(finalCameraPosition.cameraBounds, (int)(finalCameraPosition.cameraPadding * density));
+ try {
+ map.moveCamera(cameraUpdate);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ map.setOnCameraIdleListener(new GoogleMap.OnCameraIdleListener() {
+ @Override
+ public void onCameraIdle() {
+ PluginMap.this.onCameraIdle();
+ map.setOnCameraIdleListener(PluginMap.this);
+ builder.zoom(map.getCameraPosition().zoom);
+ builder.target(map.getCameraPosition().target);
+ map.moveCamera(CameraUpdateFactory.newCameraPosition(builder.build()));
+ }
+ });
+ } else {
+ final Builder builder = CameraPosition.builder(map.getCameraPosition());
+ if (mCameraPos.has("tilt")) {
+ try {
+ builder.tilt((float) mCameraPos.getDouble("tilt"));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+ if (mCameraPos.has("bearing")) {
+ try {
+ builder.bearing((float) mCameraPos.getDouble("bearing"));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+
+ try {
+ map.moveCamera(finalCameraPosition.cameraUpdate);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ builder.zoom(map.getCameraPosition().zoom);
+ builder.target(map.getCameraPosition().target);
+
+ map.setOnCameraIdleListener(new GoogleMap.OnCameraIdleListener() {
+ @Override
+ public void onCameraIdle() {
+ PluginMap.this.onCameraIdle();
+ map.setOnCameraIdleListener(PluginMap.this);
+ builder.zoom(map.getCameraPosition().zoom);
+ builder.target(map.getCameraPosition().target);
+ map.moveCamera(CameraUpdateFactory.newCameraPosition(builder.build()));
+ }
+ });
+ }
+ mCallbackContext.sendPluginResult(new PluginResult(PluginResult.Status.OK));
+ }
+ };
+ if (mAction.equals("moveCamera")) {
+ myMoveCamera(AsyncUpdateCameraPositionResult.cameraUpdate, myCallback);
+ } else {
+ myAnimateCamera(mapId, AsyncUpdateCameraPositionResult.cameraUpdate, AsyncUpdateCameraPositionResult.durationMS, myCallback);
+ }
+
+ }
+ }
+
+ /**
+ * Set zoom of the map
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setCameraZoom(JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final Long zoom = args.getLong(0);
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ myMoveCamera(CameraUpdateFactory.zoomTo(zoom), callbackContext);
+ }
+ });
+ }
+
+
+ /**
+ * Stop camera animation
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void stopAnimation(JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ if(map != null) {
+ map.stopAnimation();
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Pan by the specified pixel
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void panBy(JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ int x = args.getInt(0);
+ int y = args.getInt(1);
+ float xPixel = -x * density;
+ float yPixel = -y * density;
+ final CameraUpdate cameraUpdate = CameraUpdateFactory.scrollBy(xPixel, yPixel);
+
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ map.animateCamera(cameraUpdate);
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Move the camera of the map
+ * @param cameraPosition
+ * @param callbackContext
+ */
+ public void myMoveCamera(CameraPosition cameraPosition, final CallbackContext callbackContext) {
+ final CameraUpdate cameraUpdate = CameraUpdateFactory.newCameraPosition(cameraPosition);
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ myMoveCamera(cameraUpdate, callbackContext);
+ }
+ });
+ }
+
+ /**
+ * Move the camera of the map
+ * @param cameraUpdate
+ * @param callbackContext
+ */
+ public void myMoveCamera(CameraUpdate cameraUpdate, CallbackContext callbackContext) {
+ try {
+ map.moveCamera(cameraUpdate);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ callbackContext.success();
+ }
+
+
+ /**
+ * Enable MyLocation feature if set true
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setMyLocationEnabled(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ final JSONObject params = args.getJSONObject(0);
+
+ boolean locationPermission = PermissionChecker.checkSelfPermission(cordova.getActivity(), Manifest.permission.ACCESS_COARSE_LOCATION) == PermissionChecker.PERMISSION_GRANTED;
+ //Log.d(TAG, "---> setMyLocationEnabled, hasPermission = " + locationPermission);
+
+ if (!locationPermission) {
+ //_saveArgs = args;
+ //_saveCallbackContext = callbackContext;
+ synchronized (semaphore) {
+ cordova.requestPermissions(this, callbackContext.hashCode(), new String[]{
+ Manifest.permission.ACCESS_FINE_LOCATION
+ });
+ try {
+ semaphore.wait();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ locationPermission = PermissionChecker.checkSelfPermission(cordova.getActivity(), Manifest.permission.ACCESS_FINE_LOCATION) == PermissionChecker.PERMISSION_GRANTED;
+
+ //Log.d(TAG, "---> (1720)setMyLocationEnabled, hasPermission = " + locationPermission);
+
+ if (!locationPermission) {
+ callbackContext.error(PluginUtil.getPgmStrings(activity,"pgm_location_rejected_by_user"));
+ return;
+ }
+
+ }
+
+ this.activity.runOnUiThread(new Runnable() {
+ @SuppressLint("MissingPermission")
+ @Override
+ public void run() {
+ try {
+
+ Boolean isMyLocationEnabled = false;
+ if (params.has("myLocation")) {
+ //Log.d(TAG, "--->myLocation = " + params.getBoolean("myLocation"));
+ isMyLocationEnabled = params.getBoolean("myLocation");
+ map.setMyLocationEnabled(isMyLocationEnabled);
+ }
+
+ Boolean isMyLocationButtonEnabled = false;
+ if (params.has("myLocationButton")) {
+ //Log.d(TAG, "--->myLocationButton = " + params.getBoolean("myLocationButton"));
+ isMyLocationButtonEnabled = params.getBoolean("myLocationButton");
+ map.getUiSettings().setMyLocationButtonEnabled(isMyLocationButtonEnabled);
+ }
+ //Log.d(TAG, "--->isMyLocationButtonEnabled = " + isMyLocationButtonEnabled + ", isMyLocationEnabled = " + isMyLocationEnabled);
+ if (!isMyLocationEnabled && isMyLocationButtonEnabled) {
+ dummyMyLocationButton.setVisibility(View.VISIBLE);
+ } else {
+ dummyMyLocationButton.setVisibility(View.GONE);
+ }
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Clear all markups
+ * @param args Parameters given from JavaScript side
+ * @param callbackContext Callback contect for sending back the result.
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void clear(JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ Set pluginNames = plugins.keySet();
+ Iterator iterator = pluginNames.iterator();
+ String pluginName;
+ PluginEntry pluginEntry;
+ while(iterator.hasNext()) {
+ pluginName = iterator.next();
+ if (!"Map".equals(pluginName)) {
+ pluginEntry = plugins.get(pluginName);
+ ((MyPlugin) pluginEntry.plugin).clear();
+ }
+ }
+
+ activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ boolean isSuccess = false;
+ while (!isSuccess) {
+ try {
+ map.clear();
+ isSuccess = true;
+ } catch (Exception e) {
+ e.printStackTrace();
+ isSuccess = false;
+ }
+ }
+ if (callbackContext != null) {
+ callbackContext.success();
+ }
+ }
+ });
+
+ }
+
+ /**
+ * Enable Indoor map feature if set true
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setIndoorEnabled(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final Boolean isEnabled = args.getBoolean(0);
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ map.setIndoorEnabled(isEnabled);
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Enable the traffic layer if set true
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setTrafficEnabled(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final Boolean isEnabled = args.getBoolean(0);
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ map.setTrafficEnabled(isEnabled);
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Enable the compass if set true
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setCompassEnabled(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final Boolean isEnabled = args.getBoolean(0);
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ UiSettings uiSettings = map.getUiSettings();
+ uiSettings.setCompassEnabled(isEnabled);
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Change the map type id of the map
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setMapTypeId(JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ int mapTypeId = -1;
+ String typeStr = args.getString(0);
+ mapTypeId = typeStr.equals("MAP_TYPE_NORMAL") ? GoogleMap.MAP_TYPE_NORMAL : mapTypeId;
+ mapTypeId = typeStr.equals("MAP_TYPE_HYBRID") ? GoogleMap.MAP_TYPE_HYBRID : mapTypeId;
+ mapTypeId = typeStr.equals("MAP_TYPE_SATELLITE") ? GoogleMap.MAP_TYPE_SATELLITE : mapTypeId;
+ mapTypeId = typeStr.equals("MAP_TYPE_TERRAIN") ? GoogleMap.MAP_TYPE_TERRAIN : mapTypeId;
+ mapTypeId = typeStr.equals("MAP_TYPE_NONE") ? GoogleMap.MAP_TYPE_NONE : mapTypeId;
+
+ if (mapTypeId == -1) {
+ callbackContext.error("Unknown MapTypeID is specified:" + typeStr);
+ return;
+ }
+
+ final int myMapTypeId = mapTypeId;
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ map.setMapType(myMapTypeId);
+ callbackContext.success();
+ }
+ });
+ }
+
+
+ /**
+ * Move the camera of the map
+ * @param cameraUpdate
+ * @param durationMS
+ * @param callbackContext
+ */
+ public void myAnimateCamera(final String mapId, final CameraUpdate cameraUpdate, final int durationMS, final CallbackContext callbackContext) {
+ final GoogleMap.CancelableCallback callback = new GoogleMap.CancelableCallback() {
+ @Override
+ public void onFinish() {
+ callbackContext.success(ANIMATE_CAMERA_DONE);
+ }
+
+ @Override
+ public void onCancel() {
+ callbackContext.success(ANIMATE_CAMERA_CANCELED);
+ }
+ };
+
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ if (durationMS > 0) {
+ map.animateCamera(cameraUpdate, durationMS, callback);
+ } else {
+ map.animateCamera(cameraUpdate, callback);
+ }
+ }
+ });
+ }
+
+
+ /**
+ * Return the current position of the camera
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void getCameraPosition(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ CameraPosition camera = map.getCameraPosition();
+ JSONObject json = new JSONObject();
+ JSONObject latlng = new JSONObject();
+ try {
+ latlng.put("lat", camera.target.latitude);
+ latlng.put("lng", camera.target.longitude);
+ json.put("target", latlng);
+ json.put("zoom", camera.zoom);
+ json.put("tilt", camera.tilt);
+ json.put("bearing", camera.bearing);
+ json.put("hashCode", camera.hashCode());
+
+ callbackContext.success(json);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ callbackContext.error(e.getMessage() + "");
+ }
+ }
+ });
+ }
+
+ /**
+ * Return the image data encoded with base64
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void toDataURL(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ JSONObject params = args.getJSONObject(0);
+ boolean uncompress = false;
+ if (params.has("uncompress")) {
+ uncompress = params.getBoolean("uncompress");
+ }
+ final boolean finalUncompress = uncompress;
+
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ map.snapshot(new GoogleMap.SnapshotReadyCallback() {
+
+ @Override
+ public void onSnapshotReady(final Bitmap image) {
+ AsyncTask.execute(new Runnable() {
+ @Override
+ public void run() {
+ Bitmap image2 = image;
+ if (!finalUncompress) {
+ image2 = PluginUtil.resizeBitmap(image,
+ (int) (image2.getWidth() * density),
+ (int) (image2.getHeight() * density));
+ }
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+ image2.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
+ byte[] byteArray = outputStream.toByteArray();
+
+ callbackContext.success("data:image/png;base64," +
+ Base64.encodeToString(byteArray, Base64.NO_WRAP));
+ }
+ });
+ }
+ });
+ }
+ });
+
+ }
+ public void fromLatLngToPoint(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ double lat, lng;
+ lat = args.getDouble(0);
+ lng = args.getDouble(1);
+ final LatLng latLng = new LatLng(lat, lng);
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ projection = map.getProjection();
+ Point point = projection.toScreenLocation(latLng);
+ try {
+ JSONArray pointJSON = new JSONArray();
+ pointJSON.put((int)((double)point.x / (double)density));
+ pointJSON.put((int)((double)point.y / (double)density));
+ callbackContext.success(pointJSON);
+ } catch (Exception e) {
+ e.printStackTrace();
+ callbackContext.error(e.getMessage() + "");
+ }
+ }
+ });
+ }
+
+ public void fromPointToLatLng(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ double pointX, pointY;
+ pointX = args.getDouble(0);
+ pointY = args.getDouble(1);
+ final Point point = new Point();
+ point.x = (int)(pointX * density);
+ point.y = (int)(pointY * density);
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ projection = map.getProjection();
+ LatLng latlng = projection.fromScreenLocation(point);
+ try {
+ JSONArray pointJSON = new JSONArray();
+ pointJSON.put(latlng.latitude);
+ pointJSON.put(latlng.longitude);
+ callbackContext.success(pointJSON);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ callbackContext.error(e.getMessage() + "");
+ }
+ }
+ });
+ }
+
+
+
+ /**
+ * Sets the preference for whether all gestures should be enabled or disabled.
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setAllGesturesEnabled(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final Boolean isEnabled = args.getBoolean(0);
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ UiSettings uiSettings = map.getUiSettings();
+ uiSettings.setAllGesturesEnabled(isEnabled);
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Sets padding of the map
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setPadding(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ JSONObject padding = args.getJSONObject(0);
+ final int left = (int)(padding.getInt("left") * density);
+ final int top = (int)(padding.getInt("top") * density);
+ final int bottom = (int)(padding.getInt("bottom") * density);
+ final int right = (int)(padding.getInt("right") * density);
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ map.setPadding(left, top, right, bottom);
+
+ FrameLayout.LayoutParams lParams2 = (FrameLayout.LayoutParams) dummyMyLocationButton.getLayoutParams();
+ lParams2.rightMargin = right + (int)(5 * density);
+ lParams2.topMargin = top + (int)(5 * density);
+ dummyMyLocationButton.setLayoutParams(lParams2);
+
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * update the active marker (for internal use)
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setActiveMarkerId(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final String id = args.getString(0);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ Marker marker = (Marker) objects.get(id);
+ if (marker != null) {
+ activeMarker = marker;
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+
+ @Override
+ public boolean onMarkerClick(Marker marker) {
+ //Log.d(TAG, "---> onMarkerClick / marker.tag = " + marker.getTag());
+
+ JSONObject properties = null;
+ String clusterId_markerId = marker.getTag() + "";
+ if (clusterId_markerId.contains("markercluster_")) {
+ if (clusterId_markerId.contains("-marker_")) {
+ activeMarker = marker;
+ this.onClusterEvent("marker_click", activeMarker);
+ } else {
+ if (activeMarker != null) {
+ this.onMarkerEvent("info_close", activeMarker);
+ }
+ }
+ this.onClusterEvent("cluster_click", marker);
+ } else {
+ webView.loadUrl("javascript:if(window.cordova){cordova.fireDocumentEvent('plugin_touch', {});}");
+ this.onMarkerEvent("marker_click", marker);
+ activeMarker = marker;
+ }
+
+ String tmp[] = clusterId_markerId.split("_");
+ String className = tmp[0];
+
+ PluginEntry pluginEntry = plugins.get(mapId + "-" + className);
+ if (pluginEntry == null) {
+ return true;
+ }
+ MyPlugin myPlugin = (MyPlugin)pluginEntry.plugin;
+ String propertyId = "marker_property_" + clusterId_markerId;
+ //Log.d(TAG, "---> onMarkerClick / propertyId = " + propertyId);
+ if (objects.containsKey(propertyId)) {
+ properties = (JSONObject) objects.get(propertyId);
+ if (properties.has("disableAutoPan")) {
+ boolean disableAutoPan = false;
+ try {
+ disableAutoPan = properties.getBoolean("disableAutoPan");
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ if (disableAutoPan) {
+ marker.showInfoWindow();
+ return true;
+ } else {
+ marker.showInfoWindow();
+ return false;
+ }
+ }
+ }
+
+ marker.showInfoWindow();
+ return true;
+ //return false;
+ }
+
+ @Override
+ public void onInfoWindowClick(Marker marker) {
+ activeMarker = marker;
+ syncInfoWndPosition();
+ String markerTag = marker.getTag() + "";
+ if (markerTag.startsWith("markercluster_")){
+ this.onClusterEvent("info_click", marker);
+ } else {
+ this.onMarkerEvent("info_click", marker);
+ }
+ }
+
+ @Override
+ public void onMarkerDrag(Marker marker) {
+ if (marker.equals(activeMarker)) {
+ syncInfoWndPosition();
+ }
+ if ((marker.getTag() + "").startsWith("markercluster_")){
+ this.onClusterEvent("marker_drag", marker);
+ } else {
+ this.onMarkerEvent("marker_drag", marker);
+ }
+ }
+
+ @Override
+ public void onMarkerDragEnd(Marker marker) {
+ if (marker.equals(activeMarker)) {
+ syncInfoWndPosition();
+ }
+ if ((marker.getTag() + "").startsWith("markercluster_")){
+ this.onClusterEvent("marker_drag_end", marker);
+ } else {
+ this.onMarkerEvent("marker_drag_end", marker);
+ }
+ }
+
+ @Override
+ public void onMarkerDragStart(Marker marker) {
+ if (marker.equals(activeMarker)) {
+ syncInfoWndPosition();
+ }
+ if ((marker.getTag() + "").startsWith("markercluster_")){
+ this.onClusterEvent("marker_drag_start", marker);
+ } else {
+ this.onMarkerEvent("marker_drag_start", marker);
+ }
+ }
+
+ @Override
+ public void onInfoWindowLongClick(Marker marker) {
+ activeMarker = marker;
+ syncInfoWndPosition();
+ if ((marker.getTag() + "").startsWith("markercluster_")){
+ this.onClusterEvent("info_long_click", marker);
+ } else {
+ this.onMarkerEvent("info_long_click", marker);
+ }
+ }
+
+ @Override
+ public void onInfoWindowClose(Marker marker) {
+ //Log.d(TAG, "--->onInfoWindowClose");
+ boolean useHtmlInfoWnd = marker.getTitle() == null &&
+ marker.getSnippet() == null;
+ if (useHtmlInfoWnd) {
+ String markerTag = marker.getTag() + "";
+ if (markerTag.startsWith("markercluster_")){
+ if (markerTag.contains("-marker_")) {
+ this.onClusterEvent("info_close", marker);
+ }
+ } else {
+ this.onMarkerEvent("info_close", marker);
+ }
+ } else {
+ this.onMarkerEvent("info_close", marker);
+ }
+ //activeMarker = null; // <-- This causes HTMLinfoWindow is not able to close when you tap on the map.
+ }
+
+ @Override
+ public void onMapLoaded() {
+ this.onCameraEvent("camera_move_end");
+ }
+
+
+
+ /********************************************************
+ * Callbacks
+ ********************************************************/
+
+ /**
+ * Notify marker event to JS
+ * @param eventName
+ * @param marker
+ */
+ public void onMarkerEvent(String eventName, Marker marker) {
+ if (marker.getTag() == null) {
+ return;
+ }
+ LatLng latLng = marker.getPosition();
+
+ String markerTag = (String) marker.getTag();
+ String tmp[] = markerTag.split("_");
+ tmp = markerTag.split("-");
+ String markerId = tmp[tmp.length - 1];
+ String js = String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName: '%s', callback:'_onMarkerEvent', args:['%s', new plugin.google.maps.LatLng(%f, %f)]});}",
+ mapId, mapId, eventName, markerId, latLng.latitude, latLng.longitude);
+ jsCallback(js);
+ }
+ public void onClusterEvent(String eventName, Marker marker) {
+ if (marker.getTag() == null) {
+ return;
+ }
+ LatLng latLng = marker.getPosition();
+
+ String markerTag = (String) marker.getTag();
+ String tmp[] = markerTag.split("-");
+ String clusterId = tmp[0];
+ String markerId = tmp[1];
+ String js = String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName: '%s', callback:'_onClusterEvent', args:['%s', '%s', new plugin.google.maps.LatLng(%f, %f)]});}",
+ mapId, mapId, eventName, clusterId, markerId, latLng.latitude, latLng.longitude);
+ jsCallback(js);
+ }
+ public void syncInfoWndPosition() {
+ if (activeMarker == null) {
+ Log.d(TAG, "--->no active marker");
+ return;
+ }
+ LatLng latLng = activeMarker.getPosition();
+ Point point = projection.toScreenLocation(latLng);
+
+ String js = String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName: 'syncPosition', callback:'_onSyncInfoWndPosition', args:[{'x': %d, 'y': %d}]});}",
+ mapId, mapId, (int)(point.x / density), (int)(point.y / density));
+ jsCallback(js);
+ }
+
+ public void onOverlayEvent(String eventName, String overlayId, LatLng point) {
+ String js = String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName: '%s', callback:'_onOverlayEvent', args:['%s', new plugin.google.maps.LatLng(%f, %f)]});}",
+ mapId, mapId, eventName, overlayId, point.latitude, point.longitude);
+ jsCallback(js);
+ }
+ public void onPolylineClick(Polyline polyline, LatLng point) {
+ String overlayId = "polyline_" + polyline.getTag();
+ this.onOverlayEvent("polyline_click", overlayId, point);
+ }
+ public void onPolygonClick(Polygon polygon, LatLng point) {
+ String overlayId = "polygon_" + polygon.getTag();
+ this.onOverlayEvent("polygon_click", overlayId, point);
+ }
+ public void onCircleClick(Circle circle, LatLng point) {
+ String overlayId = "circle_" + circle.getTag();
+ this.onOverlayEvent("circle_click", overlayId, point);
+ }
+ public void onGroundOverlayClick(GroundOverlay groundOverlay, LatLng point) {
+ String overlayId = "groundoverlay_" + groundOverlay.getTag();
+ this.onOverlayEvent("groundoverlay_click", overlayId, point);
+ }
+
+ /**
+ * Notify map event to JS
+ * @param eventName
+ */
+ public void onMapEvent(final String eventName) {
+ String js = String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName: '%s', callback:'_onMapEvent', args:[]});}",
+ mapId, mapId, eventName);
+ jsCallback(js);
+ }
+
+ /**
+ * Notify map event to JS
+ * @param eventName
+ * @param point
+ */
+ public void onMapEvent(final String eventName, final LatLng point) {
+ String js = String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName: '%s', callback:'_onMapEvent', args:[new plugin.google.maps.LatLng(%f, %f)]});}",
+ mapId, mapId, eventName, point.latitude, point.longitude);
+ jsCallback(js);
+ }
+
+ @Override
+ public void onMapLongClick(LatLng point) {
+ this.onMapEvent("map_long_click", point);
+ }
+
+ private double calculateDistance(LatLng pt1, LatLng pt2){
+ float[] results = new float[1];
+ Location.distanceBetween(pt1.latitude, pt1.longitude,
+ pt2.latitude, pt2.longitude, results);
+ return results[0];
+ }
+
+ /**
+ * Intersection for non-geodesic line
+ * @ref http://movingahead.seesaa.net/article/299962216.html
+ * @ref http://www.softsurfer.com/Archive/algorithm_0104/algorithm_0104B.htm#Line-Plane
+ *
+ * @param points
+ * @param point
+ * @return LatLng on the line
+ */
+ private LatLng isPointOnTheLine(List points, LatLng point) {
+ double Sx, Sy;
+ Point p0, p1, touchPoint;
+ touchPoint = projection.toScreenLocation(point);
+
+ p0 = projection.toScreenLocation(points.get(0));
+ for (int i = 1; i < points.size(); i++) {
+ p1 = projection.toScreenLocation(points.get(i));
+ Sx = ((double)touchPoint.x - (double)p0.x) / ((double)p1.x - (double)p0.x);
+ Sy = ((double)touchPoint.y - (double)p0.y) / ((double)p1.y - (double)p0.y);
+ if (Math.abs(Sx - Sy) < 0.05 && Sx < 1 && Sx > 0) {
+ return points.get(i);
+ }
+ p0 = p1;
+ }
+ return null;
+ }
+
+ /**
+ * Intersection for geodesic line
+ * @ref http://my-clip-devdiary.blogspot.com/2014/01/html5canvas.html
+ *
+ * @param points
+ * @param point
+ * @param threshold
+ * @return LatLng on the line
+ */
+ private LatLng isPointOnTheGeodesicLine(List points, final LatLng point, double threshold) {
+
+ double trueDistance, testDistance1, testDistance2;
+ Point p0, p1;
+ int fingerSize = (int)(20 * density); // assume finger size is 20px
+
+ // clicked point(latlng) -> pixels
+ Point touchPoint = projection.toScreenLocation(point);
+ LatLngBounds possibleBounds = new LatLngBounds(point, point);
+ Point nePoint = new Point(touchPoint.x - fingerSize, touchPoint.y - fingerSize);
+ Point swPoint = new Point(touchPoint.x + fingerSize, touchPoint.y + fingerSize);
+
+ possibleBounds = possibleBounds.including(projection.fromScreenLocation(nePoint));
+ possibleBounds = possibleBounds.including(projection.fromScreenLocation(swPoint));
+
+ //--------------------------
+ // debug: draw rectangle
+ //--------------------------
+// PolylineOptions polylineOptions = new PolylineOptions();
+// polylineOptions.add(possibleBounds.northeast);
+// polylineOptions.add(new LatLng(possibleBounds.northeast.latitude, possibleBounds.southwest.longitude));
+// polylineOptions.add(possibleBounds.southwest);
+// polylineOptions.add(new LatLng(possibleBounds.southwest.latitude, possibleBounds.northeast.longitude));
+// polylineOptions.add(possibleBounds.northeast);
+// map.addPolyline(polylineOptions);
+
+ //----------------------------------------------------------------
+ // Detect the clicked-point is closer to the line or not
+ //----------------------------------------------------------------
+ LatLng start = null, finish = null;
+ for (int i = 0; i < points.size() - 1; i++) {
+ p0 = new Point();
+ p0.x = (int) (points.get(i).latitude * 100000);
+ p0.y = (int) (points.get(i).longitude * 100000);
+ p1 = new Point();
+ p1.x = (int) (points.get(i + 1).latitude * 100000);
+ p1.y = (int) (points.get(i + 1).longitude * 100000);
+ trueDistance = this.calculateDistance(points.get(i), points.get(i + 1));
+ testDistance1 = this.calculateDistance(points.get(i), point);
+ testDistance2 = this.calculateDistance(point, points.get(i + 1));
+ // the distance is exactly same if the point is on the straight line
+ if (Math.abs(trueDistance - (testDistance1 + testDistance2)) < threshold) {
+ if (i == 0) {
+ start = points.get(0);
+ finish = points.get(1);
+ } else if (i == points.size() - 1) {
+ start = points.get(i - 1);
+ finish = points.get(i);
+ } else {
+ start = points.get(i);
+ finish = points.get(i + 1);
+ }
+ break;
+ }
+ }
+
+ if (start == null) {
+ return null;
+ }
+
+ if (start.longitude > finish.longitude) {
+ LatLng tmp = start;
+ start = finish;
+ finish = tmp;
+ }
+
+ //--------------------------
+ // debug: draw rectangle
+ //--------------------------
+// LatLngBounds _targetBounds = new LatLngBounds(start, finish);
+// PolylineOptions polylineOptions2 = new PolylineOptions();
+// polylineOptions2.add(_targetBounds.northeast);
+// polylineOptions2.add(new LatLng(_targetBounds.northeast.latitude, _targetBounds.southwest.longitude));
+// polylineOptions2.add(_targetBounds.southwest);
+// polylineOptions2.add(new LatLng(_targetBounds.southwest.latitude, _targetBounds.northeast.longitude));
+// polylineOptions2.add(_targetBounds.northeast);
+// map.addPolyline(polylineOptions2);
+
+
+ //----------------------------------------------------------------
+ // Calculate waypoints from start to finish on geodesic line
+ // @ref http://jamesmccaffrey.wordpress.com/2011/04/17/drawing-a-geodesic-line-for-bing-maps-ajax/
+ //----------------------------------------------------------------
+
+ // convert to radians
+ double lat1 = start.latitude * (Math.PI / 180.0);
+ double lng1 = start.longitude * (Math.PI / 180.0);
+ double lat2 = finish.latitude * (Math.PI / 180.0);
+ double lng2 = finish.longitude * (Math.PI / 180.0);
+
+ double d = 2 * Math.asin(Math.sqrt(Math.pow((Math.sin((lat1 - lat2) / 2)), 2) +
+ Math.cos(lat1) * Math.cos(lat2) * Math.pow((Math.sin((lng1 - lng2) / 2)), 2)));
+ List wayPoints = new ArrayList();
+ double f = 0.00000000f; // fraction of the curve
+ double finc = 0.01000000f; // fraction increment
+
+ while (f <= 1.00000000f) {
+ double A = Math.sin((1.0 - f) * d) / Math.sin(d);
+ double B = Math.sin(f * d) / Math.sin(d);
+
+ double x = A * Math.cos(lat1) * Math.cos(lng1) + B * Math.cos(lat2) * Math.cos(lng2);
+ double y = A * Math.cos(lat1) * Math.sin(lng1) + B * Math.cos(lat2) * Math.sin(lng2);
+ double z = A * Math.sin(lat1) + B * Math.sin(lat2);
+ double lat = Math.atan2(z, Math.sqrt((x*x) + (y*y)));
+ double lng = Math.atan2(y, x);
+
+ LatLng wp = new LatLng(lat / (Math.PI / 180.0), lng / ( Math.PI / 180.0));
+ if (possibleBounds.contains(wp)) {
+ wayPoints.add(wp);
+ //map.addMarker(new MarkerOptions().position(wp));
+ }
+
+ f += finc;
+ } // while
+
+ // break into waypoints with negative longitudes and those with positive longitudes
+ List negLons = new ArrayList(); // lat-lons where the lon part is negative
+ List posLons = new ArrayList();
+ List connect = new ArrayList();
+
+ for (int i = 0; i < wayPoints.size(); ++i) {
+ if (wayPoints.get(i).longitude <= 0.0f)
+ negLons.add(wayPoints.get(i));
+ else
+ posLons.add(wayPoints.get(i));
+ }
+
+ // we may have to connect over 0.0 longitude
+ for (int i = 0; i < wayPoints.size() - 1; ++i) {
+ if (wayPoints.get(i).longitude <= 0.0f && wayPoints.get(i+1).longitude >= 0.0f ||
+ wayPoints.get(i).longitude >= 0.0f && wayPoints.get(i+1).longitude <= 0.0f) {
+ if (Math.abs(wayPoints.get(i).longitude) + Math.abs(wayPoints.get(i+1).longitude) < 100.0f) {
+ connect.add(wayPoints.get(i));
+ connect.add(wayPoints.get(i+1));
+ }
+ }
+ }
+
+ ArrayList inspectPoints = new ArrayList();
+ if (negLons.size() >= 2) {
+ inspectPoints.addAll(negLons);
+ }
+ if (posLons.size() >= 2) {
+ inspectPoints.addAll(posLons);
+ }
+ if (connect.size() >= 2) {
+ inspectPoints.addAll(connect);
+ }
+
+ if (inspectPoints.size() == 0) {
+ return null;
+ }
+
+
+ double minDistance = 999999999;
+ double distance;
+ LatLng mostClosePoint = null;
+
+ for (int i = 0; i < inspectPoints.size(); i++) {
+ distance = this.calculateDistance(point, inspectPoints.get(i));
+ if (distance < minDistance) {
+ minDistance = distance;
+ mostClosePoint = inspectPoints.get(i);
+ }
+ }
+ return mostClosePoint;
+ }
+
+ /**
+ * Intersects using the Winding Number Algorithm
+ * @ref http://www.nttpc.co.jp/company/r_and_d/technology/number_algorithm.html
+ * @param path
+ * @param point
+ * @return
+ */
+ private boolean isPolygonContains(List path, LatLng point) {
+ int wn = 0;
+ VisibleRegion visibleRegion = projection.getVisibleRegion();
+ LatLngBounds bounds = visibleRegion.latLngBounds;
+ Point sw = projection.toScreenLocation(bounds.southwest);
+
+ Point touchPoint = projection.toScreenLocation(point);
+ touchPoint.y = sw.y - touchPoint.y;
+ double vt;
+
+ for (int i = 0; i < path.size() - 1; i++) {
+ Point a = projection.toScreenLocation(path.get(i));
+ a.y = sw.y - a.y;
+ Point b = projection.toScreenLocation(path.get(i + 1));
+ b.y = sw.y - b.y;
+
+ if ((a.y <= touchPoint.y) && (b.y > touchPoint.y)) {
+ vt = ((double)touchPoint.y - (double)a.y) / ((double)b.y - (double)a.y);
+ if (touchPoint.x < ((double)a.x + (vt * ((double)b.x - (double)a.x)))) {
+ wn++;
+ }
+ } else if ((a.y > touchPoint.y) && (b.y <= touchPoint.y)) {
+ vt = ((double)touchPoint.y - (double)a.y) / ((double)b.y - (double)a.y);
+ if (touchPoint.x < ((double)a.x + (vt * ((double)b.x - (double)a.x)))) {
+ wn--;
+ }
+ }
+ }
+
+ return (wn != 0);
+ }
+
+ /**
+ * Check if a circle contains a point
+ * @param circle Instance of Circle class
+ * @param point LatLng
+ */
+ private boolean isCircleContains(Circle circle, LatLng point) {
+ double r = circle.getRadius();
+ LatLng center = circle.getCenter();
+ double cX = center.latitude;
+ double cY = center.longitude;
+ double pX = point.latitude;
+ double pY = point.longitude;
+
+ float[] results = new float[1];
+
+ Location.distanceBetween(cX, cY, pX, pY, results);
+
+ if(results[0] < r) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Check if a ground overlay contains a point
+ * @param groundOverlay
+ * @param point
+ */
+ private boolean isGroundOverlayContains(GroundOverlay groundOverlay, LatLng point) {
+ LatLngBounds groundOverlayBounds = groundOverlay.getBounds();
+
+ return groundOverlayBounds.contains(point);
+ }
+
+ @Override
+ public boolean onMyLocationButtonClick() {
+ jsCallback(String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName: 'my_location_button_click', callback:'_onMapEvent'});}",mapId, mapId));
+ return false;
+ }
+
+ @Override
+ public void onMyLocationClick(@NonNull Location location) {
+ PluginLocationService.setLastLocation(location);
+ try {
+ JSONObject result = PluginUtil.location2Json(location);
+ jsCallback(String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName: 'my_location_click', callback:'_onMapEvent', args: [%s]});}", mapId, mapId, result.toString(0)));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * Notify the myLocationChange event to JS
+ */
+ private void onCameraEvent(final String eventName) {
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ CameraPosition position = map.getCameraPosition();
+ JSONObject params = new JSONObject();
+ String jsonStr = "";
+ try {
+ params.put("bearing", position.bearing);
+ params.put("tilt", position.tilt);
+ params.put("zoom", position.zoom);
+
+ JSONObject target = new JSONObject();
+ target.put("lat", position.target.latitude);
+ target.put("lng", position.target.longitude);
+ params.put("target", target);
+
+ VisibleRegion visibleRegion = projection.getVisibleRegion();
+ LatLngBounds latLngBounds = visibleRegion.latLngBounds;
+
+ JSONObject northeast = new JSONObject();
+ northeast.put("lat", latLngBounds.northeast.latitude);
+ northeast.put("lng", latLngBounds.northeast.longitude);
+ params.put("northeast", northeast);
+
+ JSONObject southwest = new JSONObject();
+ southwest.put("lat", latLngBounds.southwest.latitude);
+ southwest.put("lng", latLngBounds.southwest.longitude);
+ params.put("southwest", southwest);
+
+ JSONObject nearLeft = new JSONObject();
+ nearLeft.put("lat", visibleRegion.nearLeft.latitude);
+ nearLeft.put("lng", visibleRegion.nearLeft.longitude);
+ params.put("nearLeft", nearLeft);
+
+ JSONObject nearRight = new JSONObject();
+ nearRight.put("lat", visibleRegion.nearRight.latitude);
+ nearRight.put("lng", visibleRegion.nearRight.longitude);
+ params.put("nearRight", nearRight);
+
+ JSONObject farLeft = new JSONObject();
+ farLeft.put("lat", visibleRegion.farLeft.latitude);
+ farLeft.put("lng", visibleRegion.farLeft.longitude);
+ params.put("farLeft", farLeft);
+
+ JSONObject farRight = new JSONObject();
+ farRight.put("lat", visibleRegion.farRight.latitude);
+ farRight.put("lng", visibleRegion.farRight.longitude);
+ params.put("farRight", farRight);
+
+ jsonStr = params.toString();
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+
+ jsCallback(
+ String.format(
+ Locale.ENGLISH,
+ "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName:'%s', callback:'_onCameraEvent', args: [%s]});}",
+ mapId, mapId, eventName, jsonStr));
+ }
+ });
+
+ if (activeMarker != null) {
+ syncInfoWndPosition();
+ }
+ }
+
+ @Override
+ public void onCameraIdle() {
+ projection = map.getProjection();
+ if (this.isDragging) {
+ onMapEvent("map_drag_end");
+ }
+ this.isDragging = false;
+ onCameraEvent("camera_move_end");
+ }
+
+ @Override
+ public void onCameraMoveCanceled() {
+ projection = map.getProjection();
+ if (this.isDragging) {
+ onMapEvent("map_drag_end");
+ }
+ this.isDragging = false;
+ onCameraEvent("camera_move_end");
+ }
+
+ @Override
+ public void onCameraMove() {
+ projection = map.getProjection();
+ if (this.isDragging) {
+ onMapEvent("map_drag");
+ }
+ onCameraEvent("camera_move");
+ }
+
+ @Override
+ public void onCameraMoveStarted(final int reason) {
+ projection = map.getProjection();
+
+ // In order to pass the gesture parameter to the callbacks,
+ // use the _onMapEvent callback instead of the _onCameraEvent callback.
+ this.isDragging = reason == REASON_GESTURE;
+
+ if (this.isDragging) {
+ onMapEvent("map_drag_start");
+ }
+ onCameraEvent("camera_move_start");
+
+
+ }
+
+ @Override
+ public void onIndoorBuildingFocused() {
+ IndoorBuilding building = map.getFocusedBuilding();
+ String jsonStr = "undefined";
+ if (building != null) {
+ JSONObject result = PluginUtil.convertIndoorBuildingToJson(building);
+ if (result != null) {
+ jsonStr = result.toString();
+ }
+ }
+ jsCallback(String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName:'indoor_building_focused', callback:'_onMapEvent', args: [%s]});}", mapId, mapId, jsonStr));
+ }
+
+ @Override
+ public void onIndoorLevelActivated(IndoorBuilding building) {
+ String jsonStr = "null";
+ if (building != null) {
+ JSONObject result = PluginUtil.convertIndoorBuildingToJson(building);
+ if (result != null) {
+ jsonStr = result.toString();
+ }
+ }
+ jsCallback(String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName:'indoor_level_activated', callback:'_onMapEvent', args: [%s]});}", mapId, mapId, jsonStr));
+ }
+ @Override
+ public void onPoiClick(PointOfInterest pointOfInterest) {
+ String js = String.format(Locale.ENGLISH, "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName: '%s', callback:'_onMapEvent', args:['%s', \"%s\", new plugin.google.maps.LatLng(%f, %f)]});}",
+ mapId, mapId, "poi_click", pointOfInterest.placeId, pointOfInterest.name, pointOfInterest.latLng.latitude, pointOfInterest.latLng.longitude);
+ jsCallback(js);
+ }
+
+ private void jsCallback(final String js) {
+ this.activity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ webView.loadUrl(js);
+ }
+ });
+ }
+
+ /**
+ * Notify map click event to JS, also checks for click on a polygon and triggers onPolygonEvent
+ * @param point
+ */
+ public void onMapClick(final LatLng point) {
+
+ cordova.getThreadPool().execute(new Runnable() {
+ @Override
+ public void run() {
+
+ //----------------------------------------------------------------------
+ // Pick up overlays that contains the touchpoint in the hit area bounds
+ //----------------------------------------------------------------------
+ LatLngBounds bounds;
+ final HashMap boundsHitList = new HashMap();
+
+ PluginEntry pluginEntry;
+ MyPlugin myPlugin;
+ String[] keys;
+ JSONObject properties;
+ String pluginName, key;
+ //String pluginNames[] = plugins.keySet().toArray(new String[plugins.size()]);
+ int i, j;
+ try {
+ //for (i = 0; i < pluginNames.length; i++) {
+ //pluginName = pluginNames[i];
+
+ //if (pluginName.contains("marker")) {
+ // continue;
+ //}
+ //pluginEntry = plugins.get(pluginName);
+ //myPlugin = (MyPlugin) pluginEntry.plugin;
+ if (objects.size() > 0) {
+ keys = objects.keys.toArray(new String[objects.size()]);
+ for (j = 0; j < keys.length; j++) {
+ key = keys[j];
+ if (key.contains("marker")) {
+ continue;
+ }
+ if (key.contains("property")) {
+ properties = (JSONObject) objects.get(key);
+ try {
+ //Log.d("PluginMap", "-----> key = " + key + ", " + properties.toString(2));
+ //Log.d("PluginMap", "-----> key = " + key + ", isVisible = " + properties.getBoolean("isVisible") + ", isClickable = " + properties.getBoolean("isClickable"));
+ // skip invisible overlay
+ if (!properties.getBoolean("isVisible") ||
+ !properties.getBoolean("isClickable")) {
+ continue;
+ }
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ bounds = (LatLngBounds) objects.get(key.replace("property", "bounds"));
+ if (bounds.contains(point)) {
+ //Log.d("PluginMap", "-----> add key = " + key.replace("property_", ""));
+ boundsHitList.put(key, objects.get(key.replace("property_", "")));
+ }
+
+ }
+ }
+ }
+
+ //}
+ } catch (Exception e) {
+ //e.printStackTrace();
+ }
+
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ //Log.d(TAG, "---> onMapClick : " + activeMarker);
+ if (activeMarker != null) {
+ //Log.d(TAG, "---> activeMarker.getTag() : " + activeMarker.getTag());
+ String markerTag = activeMarker.getTag() + "";
+ if (markerTag.contains("markercluster")) {
+ if (markerTag.contains("-marker_")) {
+ onClusterEvent("info_close", activeMarker);
+ }
+ // } else {
+ // boolean useHtmlInfoWnd = activeMarker.getTitle() == null &&
+ // activeMarker.getSnippet() == null;
+ // if (useHtmlInfoWnd || activeMarker.isInfoWindowShown()) {
+ // onInfoWindowClose(activeMarker);
+ // }
+ }
+ activeMarker = null;
+ }
+ Map.Entry entry;
+
+ Set> entrySet = boundsHitList.entrySet();
+ Iterator> iterator = entrySet.iterator();
+
+ List points ;
+ Point origin = new Point();
+ Point hitArea = new Point();
+ hitArea.x = 1;
+ hitArea.y = 1;
+ LatLng touchPoint = null;
+ //double threshold = calculateDistance(
+ // projection.fromScreenLocation(origin),
+ // projection.fromScreenLocation(hitArea));
+
+ float zIndex = -1;
+ float maxZIndex = -1;
+ Object hitOverlay = null;
+ Object overlay;
+ String key;
+
+ while(iterator.hasNext()) {
+ entry = iterator.next();
+ key = entry.getKey();
+ overlay = entry.getValue();
+ if (key.startsWith("polyline")) {
+
+ Polyline polyline = (Polyline)overlay;
+ if (polyline == null) {
+ continue;
+ }
+ zIndex = polyline.getZIndex();
+ if (zIndex < maxZIndex) {
+ continue;
+ }
+
+ points = polyline.getPoints();
+
+ if (polyline.isGeodesic()) {
+ hitArea.x = (int)(polyline.getWidth() * density);
+ hitArea.y = hitArea.x;
+ double threshold = calculateDistance(
+ projection.fromScreenLocation(origin),
+ projection.fromScreenLocation(hitArea));
+ touchPoint = isPointOnTheGeodesicLine(points, point, threshold);
+ if (touchPoint != null) {
+ hitOverlay = polyline;
+ maxZIndex = zIndex;
+ continue;
+ }
+ } else {
+ touchPoint = isPointOnTheLine(points, point);
+ if (touchPoint != null) {
+ hitOverlay = polyline;
+ maxZIndex = zIndex;
+ continue;
+ }
+ }
+ }
+
+ if (key.startsWith("polygon")) {
+ Polygon polygon = (Polygon)overlay;
+ if (polygon == null) {
+ continue;
+ }
+ zIndex = polygon.getZIndex();
+ if (zIndex < maxZIndex) {
+ continue;
+ }
+ if (isPolygonContains(polygon.getPoints(), point)) {
+ touchPoint = point;
+ hitOverlay = polygon;
+ maxZIndex = zIndex;
+ continue;
+ }
+ }
+
+
+ if (key.startsWith("circle")) {
+ Circle circle = (Circle)overlay;
+ if (circle == null) {
+ continue;
+ }
+ zIndex = circle.getZIndex();
+ if (zIndex < maxZIndex) {
+ continue;
+ }
+ if (isCircleContains(circle, point)) {
+ touchPoint = point;
+ hitOverlay = circle;
+ maxZIndex = zIndex;
+ continue;
+ }
+ }
+ if (key.startsWith("groundoverlay")) {
+ GroundOverlay groundOverlay = (GroundOverlay)overlay;
+ if (groundOverlay == null) {
+ continue;
+ }
+ zIndex = groundOverlay.getZIndex();
+ if (zIndex < maxZIndex) {
+ continue;
+ }
+ if (isGroundOverlayContains(groundOverlay, point)) {
+ touchPoint = point;
+ hitOverlay = groundOverlay;
+ maxZIndex = zIndex;
+ //continue;
+ }
+ }
+ }
+
+
+ final Object finalHitOverlay = hitOverlay;
+ final LatLng finalTouchPoint = touchPoint;
+
+ //Log.d("PluginMap", "---> hitOverlay = " + finalHitOverlay);
+ if (finalHitOverlay instanceof Polygon) {
+ onPolygonClick((Polygon)finalHitOverlay, finalTouchPoint);
+ } else if (finalHitOverlay instanceof Polyline) {
+ onPolylineClick((Polyline)finalHitOverlay, finalTouchPoint);
+ } else if (finalHitOverlay instanceof Circle) {
+ onCircleClick((Circle)finalHitOverlay, finalTouchPoint);
+ } else if (finalHitOverlay != null) {
+ onGroundOverlayClick((GroundOverlay)finalHitOverlay, finalTouchPoint);
+ } else {
+ // Only emit click event if no overlays are hit
+ onMapEvent("map_click", point);
+ }
+ }
+ });
+ }
+ });
+ }
+
+ public void onRequestPermissionResult(int requestCode, String[] permissions,
+ int[] grantResults) throws JSONException {
+ //Log.d(TAG, "---> onRequestPermissionResult");
+
+ synchronized (semaphore) {
+ semaphore.notify();
+ }
+ }
+
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginMarker.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginMarker.java
new file mode 100644
index 0000000..0c9f6f7
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginMarker.java
@@ -0,0 +1,1267 @@
+package plugin.google.maps;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.graphics.Typeface;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.SystemClock;
+import android.util.Log;
+import android.view.animation.BounceInterpolator;
+import android.view.animation.Interpolator;
+import android.view.animation.LinearInterpolator;
+
+import com.google.android.gms.maps.Projection;
+import com.google.android.gms.maps.model.BitmapDescriptor;
+import com.google.android.gms.maps.model.BitmapDescriptorFactory;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.Marker;
+import com.google.android.gms.maps.model.MarkerOptions;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.Semaphore;
+
+public class PluginMarker extends MyPlugin implements MyPluginInterface {
+
+ private enum Animation {
+ DROP,
+ BOUNCE
+ }
+
+ protected HashMap iconLoadingTasks = new HashMap();
+ protected HashMap icons = new HashMap();
+ protected final HashMap iconCacheKeys = new HashMap();
+ private static final Paint paint = new Paint();
+ private boolean _clearDone = false;
+
+ protected interface ICreateMarkerCallback {
+ void onSuccess(Marker marker);
+
+ void onError(String message);
+ }
+
+ @Override
+ public void initialize(CordovaInterface cordova, final CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ this.clear();
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ Set keySet = pluginMap.objects.keys;
+ if (keySet.size() > 0) {
+ String[] objectIdArray = keySet.toArray(new String[keySet.size()]);
+
+ for (String objectId : objectIdArray) {
+ if (pluginMap.objects.containsKey(objectId)) {
+ if (objectId.startsWith("marker_") &&
+ !objectId.startsWith("marker_property_") &&
+ !objectId.startsWith("marker_imageSize_") &&
+ !objectId.startsWith("marker_icon_")) {
+ Marker marker = (Marker) pluginMap.objects.remove(objectId);
+ _removeMarker(marker);
+ marker = null;
+ } else {
+ Object object = pluginMap.objects.remove(objectId);
+ object = null;
+ }
+ }
+ }
+ }
+
+ pluginMap.objects.clear();
+ }
+ });
+
+ }
+
+ @Override
+ protected void clear() {
+
+ Semaphore semaphore = new Semaphore(1);
+
+ _clearDone = false;
+
+ cordova.getThreadPool().submit(new Runnable() {
+ @Override
+ public void run() {
+ //--------------------------------------
+ // Cancel tasks
+ //--------------------------------------
+ AsyncTask task;
+ if (iconLoadingTasks != null && iconLoadingTasks.size() > 0) {
+ int i, ilen = iconLoadingTasks.size();
+ for (i = 0; i < ilen; i++) {
+ task = iconLoadingTasks.get(i);
+ task.cancel(true);
+ }
+ }
+ }
+ });
+
+
+ //--------------------------------------
+ // Recycle bitmaps as much as possible
+ //--------------------------------------
+ if (iconCacheKeys != null) {
+ if (iconCacheKeys.size() > 0) {
+ String[] cacheKeys = iconCacheKeys.keySet().toArray(new String[iconCacheKeys.size()]);
+ for (int i = 0; i < cacheKeys.length; i++) {
+ AsyncLoadImage.removeBitmapFromMemCahce(cacheKeys[i]);
+ iconCacheKeys.remove(cacheKeys[i]);
+ }
+ cacheKeys = null;
+ }
+ }
+ if (icons != null && icons.size() > 0) {
+ String[] keys = icons.keySet().toArray(new String[icons.size()]);
+ //Bitmap[] cachedBitmaps = icons.toArray(new Bitmap[icons.size()]);
+ Bitmap image;
+ for (int i = 0; i < keys.length; i++) {
+ image = icons.remove(keys[i]);
+ if (image != null && !image.isRecycled()) {
+ image.recycle();
+ }
+ image = null;
+ }
+ icons.clear();
+ }
+
+ try {
+
+ semaphore.acquire();
+ //--------------------------------------
+ // clean up properties as much as possible
+ //--------------------------------------
+ cordova.getActivity().runOnUiThread(() -> {
+ Set keySet = pluginMap.objects.keys;
+ if (keySet.size() > 0) {
+ String[] objectIdArray = keySet.toArray(new String[keySet.size()]);
+
+ for (String objectId : objectIdArray) {
+ if (pluginMap.objects.containsKey(objectId)) {
+ if (objectId.startsWith("marker_") &&
+ !objectId.startsWith("marker_property_") &&
+ !objectId.startsWith("marker_imageSize") &&
+ !objectId.startsWith("marker_icon_")) {
+ Marker marker = (Marker) pluginMap.objects.remove(objectId);
+ marker.setTag(null);
+ marker.remove();
+ marker = null;
+ } else {
+ Object object = pluginMap.objects.remove(objectId);
+ object = null;
+ }
+ }
+ }
+ }
+
+ _clearDone = true;
+ semaphore.release();
+ });
+
+ if (!_clearDone) {
+ semaphore.acquire();
+ }
+ } catch (InterruptedException ignore) {
+
+ }
+ }
+
+ /**
+ * Create a marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void create(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ // Create an instance of Marker class
+
+ JSONObject opts = args.getJSONObject(1);
+ final String markerId = "marker_" + args.getString(2);
+ final JSONObject result = new JSONObject();
+ result.put("__pgmId", markerId);
+
+ _create(markerId, opts, new ICreateMarkerCallback() {
+ @Override
+ public void onSuccess(Marker marker) {
+ if (icons.containsKey(markerId)) {
+ Bitmap icon = icons.get(markerId);
+ try {
+ result.put("width", icon.getWidth() / density);
+ result.put("height", icon.getHeight() / density);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ } else {
+ try {
+ result.put("width", 24);
+ result.put("height", 42);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ callbackContext.success(result);
+ }
+
+ @Override
+ public void onError(String message) {
+ callbackContext.error(message);
+ }
+ });
+ }
+
+ protected void _create(final String markerId, final JSONObject opts, final ICreateMarkerCallback callback) throws JSONException {
+ final JSONObject properties = new JSONObject();
+ final MarkerOptions markerOptions = new MarkerOptions();
+ if (opts.has("position")) {
+ JSONObject position = opts.getJSONObject("position");
+ markerOptions.position(new LatLng(position.getDouble("lat"), position.getDouble("lng")));
+ }
+ if (opts.has("title")) {
+ markerOptions.title(opts.getString("title"));
+ }
+ if (opts.has("snippet")) {
+ markerOptions.snippet(opts.getString("snippet"));
+ }
+ if (opts.has("visible")) {
+ if (opts.has("icon") && !"".equals(opts.getString("icon"))) {
+ markerOptions.visible(false);
+ properties.put("isVisible", false);
+ } else {
+ markerOptions.visible(opts.getBoolean("visible"));
+ properties.put("isVisible", markerOptions.isVisible());
+ }
+ } else {
+ markerOptions.visible(true);
+ }
+ if (opts.has("draggable")) {
+ markerOptions.draggable(opts.getBoolean("draggable"));
+ }
+ if (opts.has("rotation")) {
+ markerOptions.rotation((float) opts.getDouble("rotation"));
+ }
+ if (opts.has("flat")) {
+ markerOptions.flat(opts.getBoolean("flat"));
+ }
+ if (opts.has("opacity")) {
+ markerOptions.alpha((float) opts.getDouble("opacity"));
+ }
+ if (opts.has("zIndex")) {
+ markerOptions.zIndex((float) opts.getDouble("zIndex"));
+ }
+
+ if (opts.has("styles")) {
+ properties.put("styles", opts.getJSONObject("styles"));
+ }
+ if (opts.has("disableAutoPan")) {
+ properties.put("disableAutoPan", opts.getBoolean("disableAutoPan"));
+ } else {
+ properties.put("disableAutoPan", false);
+ }
+ if (opts.has("noCache")) {
+ properties.put("noCache", opts.getBoolean("noCache"));
+ } else {
+ properties.put("noCache", false);
+ }
+ if (opts.has("useHtmlInfoWnd")) {
+ properties.put("useHtmlInfoWnd", opts.getBoolean("useHtmlInfoWnd"));
+ } else {
+ properties.put("useHtmlInfoWnd", false);
+ }
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ final Marker marker = map.addMarker(markerOptions);
+ marker.setTag(markerId);
+ marker.hideInfoWindow();
+
+ cordova.getThreadPool().execute(new Runnable() {
+ @Override
+ public void run() {
+
+ try {
+ // Store the marker
+ synchronized (pluginMap.objects) {
+ pluginMap.objects.put(markerId, marker);
+
+ pluginMap.objects.put("marker_property_" + markerId, properties);
+ }
+
+ // Prepare the result
+ final JSONObject result = new JSONObject();
+ result.put("__pgmId", markerId);
+
+ // Load icon
+ if (opts.has("icon")) {
+ //------------------------------
+ // Case: have the icon property
+ //------------------------------
+ Bundle bundle = null;
+ Object value = opts.get("icon");
+ if (JSONObject.class.isInstance(value)) {
+ JSONObject iconProperty = (JSONObject) value;
+ if (iconProperty.has("url") && JSONArray.class.isInstance(iconProperty.get("url"))) {
+
+ float[] hsv = new float[3];
+ JSONArray arrayRGBA = iconProperty.getJSONArray("url");
+ Color.RGBToHSV(arrayRGBA.getInt(0), arrayRGBA.getInt(1), arrayRGBA.getInt(2), hsv);
+ bundle = new Bundle();
+ bundle.putFloat("iconHue", hsv[0]);
+
+ } else {
+ if (iconProperty.has("label")) {
+ JSONObject label = iconProperty.getJSONObject("label");
+ if (label != null && label.get("color") instanceof JSONArray) {
+ label.put("color", PluginUtil.parsePluginColor(label.getJSONArray("color")));
+ iconProperty.put("label", label);
+ }
+ }
+ bundle = PluginUtil.Json2Bundle(iconProperty);
+
+ // The `anchor` of the `icon` property
+ if (iconProperty.has("anchor")) {
+ value = iconProperty.get("anchor");
+ if (JSONArray.class.isInstance(value)) {
+ JSONArray points = (JSONArray) value;
+ double[] anchorPoints = new double[points.length()];
+ for (int i = 0; i < points.length(); i++) {
+ anchorPoints[i] = points.getDouble(i);
+ }
+ bundle.putDoubleArray("anchor", anchorPoints);
+ } else if (value instanceof JSONObject && ((JSONObject) value).has("x") && ((JSONObject) value).has("y")) {
+ double[] anchorPoints = new double[2];
+ anchorPoints[0] = ((JSONObject) value).getDouble("x");
+ anchorPoints[1] = ((JSONObject) value).getDouble("y");
+ bundle.putDoubleArray("anchor", anchorPoints);
+ }
+ }
+
+ // The `infoWindowAnchor` property for infowindow
+ if (opts.has("infoWindowAnchor")) {
+ value = opts.get("infoWindowAnchor");
+ if (JSONArray.class.isInstance(value)) {
+ JSONArray points = (JSONArray) value;
+ double[] anchorPoints = new double[points.length()];
+ for (int i = 0; i < points.length(); i++) {
+ anchorPoints[i] = points.getDouble(i);
+ }
+ bundle.putDoubleArray("infoWindowAnchor", anchorPoints);
+ } else if (value instanceof JSONObject && ((JSONObject) value).has("x") && ((JSONObject) value).has("y")) {
+ double[] anchorPoints = new double[2];
+ anchorPoints[0] = ((JSONObject) value).getDouble("x");
+ anchorPoints[1] = ((JSONObject) value).getDouble("y");
+ bundle.putDoubleArray("infoWindowAnchor", anchorPoints);
+ }
+ }
+ }
+
+ } else if (JSONArray.class.isInstance(value)) {
+ float[] hsv = new float[3];
+ JSONArray arrayRGBA = (JSONArray) value;
+ Color.RGBToHSV(arrayRGBA.getInt(0), arrayRGBA.getInt(1), arrayRGBA.getInt(2), hsv);
+ bundle = new Bundle();
+ bundle.putFloat("iconHue", hsv[0]);
+ } else {
+ bundle = new Bundle();
+ bundle.putString("url", (String) value);
+ }
+
+ if (opts.has("animation")) {
+ bundle.putString("animation", opts.getString("animation"));
+ }
+ PluginMarker.this.setIcon_(marker, bundle, new PluginAsyncInterface() {
+
+ @Override
+ public void onPostExecute(final Object object) {
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ Marker marker = (Marker) object;
+ if (opts.has("visible")) {
+ try {
+ marker.setVisible(opts.getBoolean("visible"));
+ } catch (JSONException e) {
+ }
+ } else {
+ marker.setVisible(true);
+ }
+
+
+ // Animation
+ String markerAnimation = null;
+ if (opts.has("animation")) {
+ try {
+ markerAnimation = opts.getString("animation");
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+ if (markerAnimation != null) {
+ PluginMarker.this.setMarkerAnimation_(marker, markerAnimation, new PluginAsyncInterface() {
+
+ @Override
+ public void onPostExecute(Object object) {
+ Marker marker = (Marker) object;
+ callback.onSuccess(marker);
+ }
+
+ @Override
+ public void onError(String errorMsg) {
+ callback.onError(errorMsg);
+ }
+ });
+ } else {
+ callback.onSuccess(marker);
+ }
+ }
+ });
+ }
+
+ @Override
+ public void onError(String errorMsg) {
+ callback.onError(errorMsg);
+ }
+
+ });
+ } else {
+ //--------------------------
+ // Case: no icon property
+ //--------------------------
+ String markerAnimation = null;
+ if (opts.has("animation")) {
+ markerAnimation = opts.getString("animation");
+ }
+ if (markerAnimation != null) {
+ // Execute animation
+ PluginMarker.this.setMarkerAnimation_(marker, markerAnimation, new PluginAsyncInterface() {
+
+ @Override
+ public void onPostExecute(Object object) {
+ callback.onSuccess(marker);
+ }
+
+ @Override
+ public void onError(String errorMsg) {
+ callback.onError(errorMsg);
+ }
+
+ });
+ } else {
+ // Return the result if does not specify the icon property.
+ callback.onSuccess(marker);
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ callback.onError("" + e.getMessage());
+ }
+ }
+ });
+ }
+ });
+
+ }
+
+ private void setDropAnimation_(final Marker marker, final PluginAsyncInterface callback) {
+ final long startTime = SystemClock.uptimeMillis();
+ final long duration = 100;
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ final Handler handler = new Handler();
+ final Projection proj = map.getProjection();
+ final LatLng markerLatLng = marker.getPosition();
+ final Point markerPoint = proj.toScreenLocation(markerLatLng);
+ final Point startPoint = new Point(markerPoint.x, 0);
+
+ final Interpolator interpolator = new LinearInterpolator();
+
+ handler.post(new Runnable() {
+ @Override
+ public void run() {
+ LatLng startLatLng = proj.fromScreenLocation(startPoint);
+ long elapsed = SystemClock.uptimeMillis() - startTime;
+ float t = interpolator.getInterpolation((float) elapsed / duration);
+
+ if(startLatLng != null) {
+ double lng = t * markerLatLng.longitude + (1 - t) * startLatLng.longitude;
+ double lat = t * markerLatLng.latitude + (1 - t) * startLatLng.latitude;
+ marker.setPosition(new LatLng(lat, lng));
+ }
+
+ if (t < 1.0) {
+ // Post again 16ms later.
+ handler.postDelayed(this, 16);
+ } else {
+ marker.setPosition(markerLatLng);
+ callback.onPostExecute(marker);
+ }
+ }
+ });
+ }
+ });
+ }
+
+ /**
+ * Bounce animation
+ * http://android-er.blogspot.com/2013/01/implement-bouncing-marker-for-google.html
+ */
+ private void setBounceAnimation_(final Marker marker, final PluginAsyncInterface callback) {
+ final long startTime = SystemClock.uptimeMillis();
+ final long duration = 2000;
+ final Interpolator interpolator = new BounceInterpolator();
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ final Handler handler = new Handler();
+ final Projection projection = map.getProjection();
+ final LatLng markerLatLng = marker.getPosition();
+ final Point startPoint = projection.toScreenLocation(markerLatLng);
+ startPoint.offset(0, -200);
+
+
+ handler.post(new Runnable() {
+ @Override
+ public void run() {
+ LatLng startLatLng = projection.fromScreenLocation(startPoint);
+ long elapsed = SystemClock.uptimeMillis() - startTime;
+ float t = interpolator.getInterpolation((float) elapsed / duration);
+
+ if(startLatLng != null) {
+ double lng = t * markerLatLng.longitude + (1 - t) * startLatLng.longitude;
+ double lat = t * markerLatLng.latitude + (1 - t) * startLatLng.latitude;
+ marker.setPosition(new LatLng(lat, lng));
+ }
+
+ if (t < 1.0) {
+ // Post again 16ms later.
+ handler.postDelayed(this, 16);
+ } else {
+ marker.setPosition(markerLatLng);
+ callback.onPostExecute(marker);
+ }
+ }
+ });
+ }
+ });
+
+ }
+
+ private void setMarkerAnimation_(Marker marker, String animationType, PluginAsyncInterface callback) {
+ Animation animation = null;
+ try {
+ animation = Animation.valueOf(animationType.toUpperCase(Locale.US));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ if (animation == null) {
+ callback.onPostExecute(marker);
+ return;
+ }
+ switch (animation) {
+ case DROP:
+ this.setDropAnimation_(marker, callback);
+ break;
+
+ case BOUNCE:
+ this.setBounceAnimation_(marker, callback);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ /**
+ * http://android-er.blogspot.com/2013/01/implement-bouncing-marker-for-google.html
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setAnimation(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String markerId = args.getString(0);
+ String animation = args.getString(1);
+ final Marker marker = this.getMarker(markerId);
+ Log.d(TAG, "--->setAnimation: markerId = " + markerId + ", animation = " + animation);
+ if (marker == null) {
+ callbackContext.error("marker is null");
+ return;
+ }
+
+ this.setMarkerAnimation_(marker, animation, new PluginAsyncInterface() {
+
+ @Override
+ public void onPostExecute(Object object) {
+ callbackContext.success();
+ }
+
+ @Override
+ public void onError(String errorMsg) {
+ callbackContext.error(errorMsg);
+ }
+
+ });
+ }
+
+ /**
+ * Show the InfoWindow bound with the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void showInfoWindow(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final String id = args.getString(0);
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ Marker marker = getMarker(id);
+ if (marker != null) {
+ marker.showInfoWindow();
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Set rotation for the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setRotation(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ float rotation = (float) args.getDouble(1);
+ String id = args.getString(0);
+ this.setFloat("setRotation", id, rotation, callbackContext);
+ }
+
+ /**
+ * Set opacity for the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setOpacity(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ float alpha = (float) args.getDouble(1);
+ String id = args.getString(0);
+ this.setFloat("setAlpha", id, alpha, callbackContext);
+ }
+
+ /**
+ * Set zIndex for the marker (dummy code, not available on Android V2)
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setZIndex(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ float zIndex = (float) args.getDouble(1);
+ String id = args.getString(0);
+ Marker marker = getMarker(id);
+ this.setFloat("setZIndex", id, zIndex, callbackContext);
+ }
+
+ /**
+ * set position
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setPosition(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final String id = args.getString(0);
+ final LatLng position = new LatLng(args.getDouble(1), args.getDouble(2));
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ Marker marker = getMarker(id);
+ if (marker != null) {
+ marker.setPosition(position);
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Set flat for the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setFlat(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ boolean isFlat = args.getBoolean(1);
+ String id = args.getString(0);
+ this.setBoolean("setFlat", id, isFlat, callbackContext);
+ }
+
+ /**
+ * Set visibility for the object
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setVisible(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ boolean isVisible = args.getBoolean(1);
+ String id = args.getString(0);
+
+ Marker marker = this.getMarker(id);
+ if (marker == null) {
+ callbackContext.success();
+ return;
+ }
+ String propertyId = "marker_property_" + id;
+ JSONObject properties = null;
+ if (self.pluginMap.objects.containsKey(propertyId)) {
+ properties = (JSONObject) self.pluginMap.objects.get(propertyId);
+ } else {
+ properties = new JSONObject();
+ }
+ properties.put("isVisible", isVisible);
+ self.pluginMap.objects.put(propertyId, properties);
+
+ this.setBoolean("setVisible", id, isVisible, callbackContext);
+ }
+
+ /**
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setDisableAutoPan(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ boolean disableAutoPan = args.getBoolean(1);
+ String id = args.getString(0);
+ Marker marker = this.getMarker(id);
+ if (marker == null) {
+ callbackContext.success();
+ return;
+ }
+ String propertyId = "marker_property_" + id;
+ JSONObject properties = null;
+ if (self.pluginMap.objects.containsKey(propertyId)) {
+ properties = (JSONObject) self.pluginMap.objects.get(propertyId);
+ } else {
+ properties = new JSONObject();
+ }
+ properties.put("disableAutoPan", disableAutoPan);
+ self.pluginMap.objects.put(propertyId, properties);
+ callbackContext.success();
+ }
+
+ /**
+ * Set title for the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setTitle(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String title = args.getString(1);
+ String id = args.getString(0);
+ this.setString("setTitle", id, title, callbackContext);
+ }
+
+ /**
+ * Set the snippet for the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setSnippet(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String snippet = args.getString(1);
+ String id = args.getString(0);
+ this.setString("setSnippet", id, snippet, callbackContext);
+ }
+
+ /**
+ * Hide the InfoWindow binded with the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void hideInfoWindow(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final String id = args.getString(0);
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ Marker marker = getMarker(id);
+ if (marker != null) {
+ marker.hideInfoWindow();
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Remove the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void remove(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final String id = args.getString(0);
+ final Marker marker = this.getMarker(id);
+ if (marker == null) {
+ callbackContext.success();
+ return;
+ }
+
+ /*
+ String[] cacheKeys = iconCacheKeys.toArray(new String[iconCacheKeys.size()]);
+ for (int i = 0; i < cacheKeys.length; i++) {
+ AsyncLoadImage.removeBitmapFromMemCahce(cacheKeys[i]);
+ }
+ */
+
+ String propertyId = "marker_property_" + id;
+ pluginMap.objects.remove(propertyId);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ pluginMap.objects.remove(id);
+ _removeMarker(marker);
+
+ callbackContext.success();
+ }
+ });
+ }
+
+ protected void _removeMarker(Marker marker) {
+ if (marker == null || marker.getTag() == null) {
+ return;
+ }
+ //---------------------------------------------
+ // Removes marker safely
+ // (prevent the `un-managed object exception`)
+ //---------------------------------------------
+ String iconCacheKey = "marker_icon_" + marker.getTag();
+ marker.setTag(null);
+ marker.remove();
+
+ //---------------------------------------------------------------------------------
+ // If no marker uses the icon image used be specified this marker, release it
+ //---------------------------------------------------------------------------------
+ if (pluginMap.objects.containsKey(iconCacheKey)) {
+ String cacheKey = (String) pluginMap.objects.remove(iconCacheKey);
+ if (iconCacheKeys.containsKey(cacheKey)) {
+ int count = iconCacheKeys.get(cacheKey);
+ count--;
+ if (count < 1) {
+ AsyncLoadImage.removeBitmapFromMemCahce(cacheKey);
+ iconCacheKeys.remove(cacheKey);
+ } else {
+ iconCacheKeys.put(cacheKey, count);
+ }
+ }
+ pluginMap.objects.remove(iconCacheKey);
+ }
+ }
+
+ /**
+ * Set anchor for the icon of the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setIconAnchor(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ float anchorX = (float) args.getDouble(1);
+ float anchorY = (float) args.getDouble(2);
+ String id = args.getString(0);
+ Marker marker = this.getMarker(id);
+
+ Bundle imageSize = (Bundle) self.pluginMap.objects.get("marker_imageSize_" + id);
+ if (imageSize != null) {
+ this._setIconAnchor(marker, anchorX, anchorY, imageSize.getInt("width"), imageSize.getInt("height"));
+ }
+ callbackContext.success();
+ }
+
+
+ /**
+ * Set anchor for the InfoWindow of the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setInfoWindowAnchor(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ float anchorX = (float) args.getDouble(1);
+ float anchorY = (float) args.getDouble(2);
+ String id = args.getString(0);
+ Marker marker = this.getMarker(id);
+
+ Bundle imageSize = (Bundle) self.pluginMap.objects.get("marker_imageSize_" + id);
+ if (imageSize != null) {
+ this._setInfoWindowAnchor(marker, anchorX, anchorY, imageSize.getInt("width"), imageSize.getInt("height"));
+ }
+ callbackContext.success();
+ }
+
+ /**
+ * Set draggable for the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setDraggable(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ Boolean draggable = args.getBoolean(1);
+ String id = args.getString(0);
+ this.setBoolean("setDraggable", id, draggable, callbackContext);
+ }
+
+ /**
+ * Set icon of the marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setIcon(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ Marker marker = this.getMarker(id);
+ Object value = args.get(1);
+ Bundle bundle = null;
+ if (JSONObject.class.isInstance(value)) {
+ JSONObject iconProperty = (JSONObject) value;
+ bundle = PluginUtil.Json2Bundle(iconProperty);
+
+ // The `anchor` for icon
+ if (iconProperty.has("anchor")) {
+ value = iconProperty.get("anchor");
+ if (JSONArray.class.isInstance(value)) {
+ JSONArray points = (JSONArray) value;
+ double[] anchorPoints = new double[points.length()];
+ for (int i = 0; i < points.length(); i++) {
+ anchorPoints[i] = points.getDouble(i);
+ }
+ bundle.putDoubleArray("anchor", anchorPoints);
+ } else if (value instanceof JSONObject && ((JSONObject) value).has("x") && ((JSONObject) value).has("y")) {
+ double[] anchorPoints = new double[2];
+ anchorPoints[0] = ((JSONObject) value).getDouble("x");
+ anchorPoints[1] = ((JSONObject) value).getDouble("y");
+ bundle.putDoubleArray("anchor", anchorPoints);
+ }
+ }
+ } else if (JSONArray.class.isInstance(value)) {
+ float[] hsv = new float[3];
+ JSONArray arrayRGBA = (JSONArray) value;
+ Color.RGBToHSV(arrayRGBA.getInt(0), arrayRGBA.getInt(1), arrayRGBA.getInt(2), hsv);
+ bundle = new Bundle();
+ bundle.putFloat("iconHue", hsv[0]);
+ } else if (String.class.isInstance(value)) {
+ bundle = new Bundle();
+ bundle.putString("url", (String) value);
+ }
+ if (bundle != null) {
+ this.setIcon_(marker, bundle, new PluginAsyncInterface() {
+
+ @Override
+ public void onPostExecute(Object object) {
+ callbackContext.success();
+ }
+
+ @Override
+ public void onError(String errorMsg) {
+ callbackContext.error(errorMsg);
+ }
+ });
+ } else {
+ callbackContext.success();
+ }
+ }
+
+ protected void setIcon_(final Marker marker, final Bundle iconProperty, final PluginAsyncInterface callback) {
+ boolean noCaching = false;
+ if (iconProperty.containsKey("noCache")) {
+ noCaching = iconProperty.getBoolean("noCache");
+ }
+ if (iconProperty.containsKey("iconHue")) {
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ float hue = iconProperty.getFloat("iconHue");
+ marker.setIcon(BitmapDescriptorFactory.defaultMarker(hue));
+ }
+ });
+ callback.onPostExecute(marker);
+ return;
+ }
+
+ String iconUrl = iconProperty.getString("url");
+ if (iconUrl == null) {
+ callback.onPostExecute(marker);
+ return;
+ }
+
+ int width = -1;
+ int height = -1;
+ if (iconProperty.containsKey("size")) {
+ Bundle sizeInfo = (Bundle) iconProperty.get("size");
+ width = sizeInfo.getInt("width", width);
+ height = sizeInfo.getInt("height", height);
+ }
+
+
+ final AsyncLoadImage.AsyncLoadImageOptions options = new AsyncLoadImage.AsyncLoadImageOptions();
+ options.url = iconUrl;
+ options.width = width;
+ options.height = height;
+ options.noCaching = noCaching;
+ final int taskId = options.hashCode();
+
+ final AsyncLoadImageInterface onComplete = new AsyncLoadImageInterface() {
+ @Override
+ public void onPostExecute(AsyncLoadImage.AsyncLoadImageResult result) {
+ iconLoadingTasks.remove(taskId);
+
+ if (result == null || result.image == null) {
+ callback.onPostExecute(marker);
+ return;
+ }
+ if (marker == null) {
+ callback.onError("marker is removed");
+ return;
+ }
+ if (result.image.isRecycled()) {
+ //Maybe the task was canceled by map.clean()?
+ callback.onError("Can not get image for marker. Maybe the task was canceled by map.clean()?");
+ return;
+ }
+
+ synchronized (marker) {
+ String markerTag = marker.getTag() + "";
+ String markerIconTag = "marker_icon_" + markerTag;
+ String markerImgSizeTag = "marker_imageSize_" + markerTag;
+
+ String currentCacheKey = (String) pluginMap.objects.get(markerIconTag);
+ if (result.cacheKey != null && result.cacheKey.equals(currentCacheKey)) {
+ synchronized (iconCacheKeys) {
+ if (iconCacheKeys.containsKey(currentCacheKey)) {
+ int count = iconCacheKeys.get(currentCacheKey);
+ count--;
+ if (count < 1) {
+ AsyncLoadImage.removeBitmapFromMemCahce(currentCacheKey);
+ iconCacheKeys.remove(currentCacheKey);
+ } else {
+ iconCacheKeys.put(currentCacheKey, count);
+ }
+ }
+ }
+ }
+
+ if (icons.containsKey(markerIconTag)) {
+ Bitmap icon = icons.remove(markerIconTag);
+ if (icon != null && !icon.isRecycled()) {
+ icon.recycle();
+ }
+ icon = null;
+ }
+ icons.put(markerTag, result.image);
+
+ //-------------------------------------------------------
+ // Counts up the markers that use the same icon image.
+ //-------------------------------------------------------
+ if (result.cacheHit) {
+ if (marker == null || marker.getTag() == null) {
+ callback.onPostExecute(marker);
+ return;
+ }
+ String hitCountKey = markerIconTag;
+ pluginMap.objects.put(hitCountKey, result.cacheKey);
+ if (!iconCacheKeys.containsKey(result.cacheKey)) {
+ iconCacheKeys.put(result.cacheKey, 1);
+ } else {
+ int count = iconCacheKeys.get(result.cacheKey);
+ iconCacheKeys.put(result.cacheKey, count + 1);
+ }
+ //Log.d(TAG, "----> " + result.cacheKey + " = " + iconCacheKeys.get(result.cacheKey));
+ }
+
+ //------------------------
+ // Draw label on icon
+ //------------------------
+ if (iconProperty.containsKey("label")) {
+ result.image = drawLabel(result.image, iconProperty.getBundle("label"));
+ }
+ BitmapDescriptor bitmapDescriptor = BitmapDescriptorFactory.fromBitmap(result.image);
+ if (bitmapDescriptor == null || marker == null || marker.getTag() == null) {
+ callback.onPostExecute(marker);
+ return;
+ }
+
+ //------------------------
+ // Sets image as icon
+ //------------------------
+ marker.setIcon(bitmapDescriptor);
+ bitmapDescriptor = null;
+
+ //---------------------------------------------
+ // Save the information for the anchor property
+ //---------------------------------------------
+ Bundle imageSize = new Bundle();
+ imageSize.putInt("width", result.image.getWidth());
+ imageSize.putInt("height", result.image.getHeight());
+ self.pluginMap.objects.remove(markerImgSizeTag);
+ self.pluginMap.objects.put(markerImgSizeTag, imageSize);
+
+ result.image.recycle();
+ result.image = null;
+
+ // The `anchor` of the `icon` property
+ if (iconProperty.containsKey("anchor")) {
+ double[] anchor = iconProperty.getDoubleArray("anchor");
+ if (anchor != null && anchor.length == 2) {
+ _setIconAnchor(marker, anchor[0], anchor[1], imageSize.getInt("width"), imageSize.getInt("height"));
+ }
+ }
+
+
+ // The `anchor` property for the infoWindow
+ if (iconProperty.containsKey("infoWindowAnchor")) {
+ double[] anchor = iconProperty.getDoubleArray("infoWindowAnchor");
+ if (anchor != null && anchor.length == 2) {
+ _setInfoWindowAnchor(marker, anchor[0], anchor[1], imageSize.getInt("width"), imageSize.getInt("height"));
+ }
+ }
+
+ callback.onPostExecute(marker);
+ }
+ }
+ };
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ AsyncLoadImage task = new AsyncLoadImage(cordova, webView, options, onComplete);
+ task.execute();
+ iconLoadingTasks.put(taskId, task);
+ }
+ });
+ }
+
+
+ private void _setIconAnchor(final Marker marker, double anchorX, double anchorY, final int imageWidth, final int imageHeight) {
+ // The `anchor` of the `icon` property
+ anchorX = anchorX * density;
+ anchorY = anchorY * density;
+ final double fAnchorX = anchorX;
+ final double fAnchorY = anchorY;
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ marker.setAnchor((float) (fAnchorX / imageWidth), (float) (fAnchorY / imageHeight));
+ }
+ });
+ }
+
+ private void _setInfoWindowAnchor(final Marker marker, double anchorX, double anchorY, final int imageWidth, final int imageHeight) {
+ // The `anchor` of the `icon` property
+ anchorX = anchorX * density;
+ anchorY = anchorY * density;
+ final double fAnchorX = anchorX;
+ final double fAnchorY = anchorY;
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ marker.setInfoWindowAnchor((float) (fAnchorX / imageWidth), (float) (fAnchorY / imageHeight));
+ }
+ });
+ }
+
+ protected Bitmap drawLabel(Bitmap image, Bundle labelOptions) {
+ String text = labelOptions.getString("text");
+ if (text == null || text.length() == 0) {
+ return image;
+ }
+ Bitmap newIcon = Bitmap.createBitmap(image);
+ Canvas canvas = new Canvas(newIcon);
+ image.recycle();
+ image = null;
+
+ int fontSize = 10;
+ if (labelOptions.containsKey("fontSize")) {
+ fontSize = labelOptions.getInt("fontSize");
+ }
+ paint.setTextSize(fontSize * density);
+
+ int color = Color.BLACK;
+ if (labelOptions.containsKey("color")) {
+ color = labelOptions.getInt("color");
+ }
+ boolean bold = false;
+ if (labelOptions.containsKey("bold")) {
+ bold = labelOptions.getBoolean("bold");
+ }
+ paint.setFakeBoldText(bold);
+ boolean italic = false;
+ if (labelOptions.containsKey("italic")) {
+ italic = labelOptions.getBoolean("italic");
+ }
+ if (italic && bold) {
+ paint.setTypeface(Typeface.create(Typeface.DEFAULT, Typeface.BOLD_ITALIC));
+ } else if (italic) {
+ paint.setTypeface(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC));
+ } else if (bold) {
+ paint.setTypeface(Typeface.create(Typeface.DEFAULT, Typeface.BOLD));
+ } else {
+ paint.setTypeface(Typeface.DEFAULT);
+ }
+ paint.setColor(color);
+
+
+ Rect rect = new Rect();
+ canvas.getClipBounds(rect);
+ int cHeight = rect.height();
+ int cWidth = rect.width();
+ paint.setTextAlign(Paint.Align.LEFT);
+ paint.getTextBounds(text, 0, text.length(), rect);
+ float x = cWidth / 2f - rect.width() / 2f - rect.left;
+ float y = cHeight / 2f + rect.height() / 2f - rect.bottom;
+ canvas.drawText(text, x, y, paint);
+ return newIcon;
+ }
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginMarkerCluster.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginMarkerCluster.java
new file mode 100644
index 0000000..f9a220e
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginMarkerCluster.java
@@ -0,0 +1,779 @@
+package plugin.google.maps;
+
+import android.graphics.Bitmap;
+import android.os.Bundle;
+import android.util.Log;
+
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.LatLngBounds;
+import com.google.android.gms.maps.model.Marker;
+import com.google.android.gms.maps.model.MarkerOptions;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class PluginMarkerCluster extends PluginMarker {
+
+ private final static Map pluginMarkers = new ConcurrentHashMap();
+ private final static Map waitCntManager = new ConcurrentHashMap();
+ private final static Map debugFlags = new ConcurrentHashMap();
+ private final static ArrayList deleteMarkers = new ArrayList();
+
+ private final Object semaphore = new Object();
+ private boolean stopFlag = false;
+ private final Object deleteThreadLock = new Object();
+
+ enum STATUS {
+ WORKING,
+ CREATED,
+ DELETED
+ }
+
+ @Override
+ public void initialize(CordovaInterface cordova, final CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ if (!deleteThread.isAlive()) {
+ deleteThread.start();
+ }
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ stopFlag = true;
+ }
+
+ @Override
+ protected void clear() {
+ super.clear();
+ synchronized (semaphore) {
+ synchronized (pluginMarkers) {
+ synchronized (deleteMarkers) {
+ String clusterId_markerId;
+ if (pluginMarkers.size() > 0) {
+ String[] keys = pluginMarkers.keySet().toArray(new String[pluginMarkers.size()]);
+ for (int i = 0; i < keys.length; i++) {
+ clusterId_markerId = keys[i];
+ pluginMarkers.put(clusterId_markerId, STATUS.DELETED);
+ deleteMarkers.add(clusterId_markerId);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ //---------------------
+ // Delete thread
+ //---------------------
+ private Thread deleteThread = new Thread(new Runnable() {
+ @Override
+ public void run() {
+ while(!stopFlag) {
+ synchronized (deleteThreadLock) {
+ try {
+ deleteThreadLock.wait();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ if (deleteMarkers.size() == 0) {
+ continue;
+ }
+
+ cordova.getActivity().runOnUiThread(removeOverlaysOnUiThread);
+ }
+ }
+ });
+
+ private Runnable removeOverlaysOnUiThread = new Runnable() {
+ @Override
+ public void run() {
+ synchronized (deleteMarkers) {
+ String markerId;
+ Marker marker;
+ STATUS status;
+ String cacheKey;
+ if (deleteMarkers.size() > 0) {
+ String[] targetIDs = deleteMarkers.toArray(new String[deleteMarkers.size()]);
+
+ for (int i = targetIDs.length - 1; i > -1; i--) {
+ markerId = targetIDs[i];
+
+ marker = self.getMarker(markerId);
+ synchronized (pluginMarkers) {
+ status = pluginMarkers.get(markerId);
+
+ if (!STATUS.WORKING.equals(status)) {
+ synchronized (pluginMap.objects) {
+ _removeMarker(marker);
+ marker = null;
+
+ cacheKey = (String) pluginMap.objects.remove("marker_icon_" + markerId);
+ if (cacheKey != null && iconCacheKeys.containsKey(cacheKey)) {
+ int count = iconCacheKeys.get(cacheKey);
+ if (count < 1) {
+ iconCacheKeys.remove(cacheKey);
+ AsyncLoadImage.removeBitmapFromMemCahce(cacheKey);
+ } else {
+ iconCacheKeys.put(cacheKey, count - 1);
+ }
+ }
+
+
+ pluginMap.objects.remove(markerId);
+ pluginMap.objects.remove("marker_property_" + markerId);
+ pluginMap.objects.remove("marker_imageSize_" + markerId);
+ }
+ pluginMarkers.remove(markerId);
+ deleteMarkers.remove(i);
+ } else {
+ pluginMarkers.put(markerId, STATUS.DELETED);
+ }
+ }
+ }
+ }
+ }
+ System.gc();
+ }
+ };
+
+
+ public void remove(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String clusterId = args.getString(0);
+ //Log.d(TAG, "-->remove = " + clusterId);
+ synchronized (debugFlags) {
+ debugFlags.remove(clusterId);
+ waitCntManager.remove(clusterId);
+ }
+ synchronized (pluginMarkers) {
+ for(String key: pluginMarkers.keySet()) {
+ if (key.startsWith(clusterId)) {
+ //Log.d(TAG, "-->delete = " + key);
+ pluginMarkers.put(key, STATUS.CREATED);
+ deleteMarkers.add(key);
+ }
+ }
+ }
+
+ /*
+ String cacheKey;
+ Set keySet = pluginMap.objects.keySet();
+ Marker marker;
+ String[] objectIdArray = keySet.toArray(new String[keySet.size()]);
+ for (String objectId : objectIdArray) {
+ if (objectId.contains(clusterId)) {
+ if (objectId.startsWith("marker_icon")) {
+ cacheKey = (String) pluginMap.objects.remove(objectId);
+
+ if (iconCacheKeys.containsKey(cacheKey)) {
+ int count = iconCacheKeys.get(cacheKey);
+ if (count < 1) {
+ iconCacheKeys.remove(cacheKey);
+ AsyncLoadImage.removeBitmapFromMemCahce(cacheKey);
+ } else {
+ iconCacheKeys.put(cacheKey, count - 1);
+ }
+ }
+ } else if (objectId.startsWith("marker_property_") ||
+ objectId.startsWith("marker_imageSize_")) {
+ pluginMap.objects.remove(objectId);
+ //} else if (objectId.startsWith("marker_")) {
+ // marker = (Marker) pluginMap.objects.remove(objectId);
+ // marker.remove();
+ } else {
+ pluginMap.objects.remove(objectId);
+ }
+ }
+ }
+ */
+ synchronized (deleteThreadLock) {
+ deleteThreadLock.notify();
+ }
+
+ callbackContext.success();
+ }
+ /**
+ * Create a marker
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void create(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ JSONObject params = args.getJSONObject(1);
+ String hashCode = args.getString(2);
+ JSONArray positionList = params.getJSONArray("positionList");
+ JSONArray geocellList = new JSONArray();
+ JSONObject position;
+
+ for (int i = 0; i < positionList.length(); i++) {
+ position = positionList.getJSONObject(i);
+ geocellList.put(getGeocell(position.getDouble("lat"), position.getDouble("lng"), 12));
+ }
+
+ String id = "markercluster_" + hashCode;
+ debugFlags.put(id, params.getBoolean("debug"));
+
+ final JSONObject result = new JSONObject();
+ try {
+ result.put("geocellList", geocellList);
+ result.put("hashCode", hashCode);
+ result.put("__pgmId", id);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+
+ callbackContext.success(result);
+ }
+
+
+ public void redrawClusters(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+
+ final HashSet updateClusterIDs = new HashSet();
+ final HashMap changeProperties = new HashMap();
+ final String clusterId = args.getString(0);
+ final boolean isDebug = debugFlags.get(clusterId);
+ final JSONObject params = args.getJSONObject(1);
+
+ String markerId, clusterId_markerId;
+ JSONArray new_or_update = null;
+ if (params.has("new_or_update")) {
+ new_or_update = params.getJSONArray("new_or_update");
+ }
+
+ //---------------------------
+ // Determine new or update
+ //---------------------------
+ int new_or_updateCnt = 0;
+ if (new_or_update != null) {
+ new_or_updateCnt = new_or_update.length();
+ }
+ JSONObject clusterData, positionJSON;
+ Bundle properties;
+ boolean isNew;
+ for (int i = 0; i < new_or_updateCnt; i++) {
+ clusterData = new_or_update.getJSONObject(i);
+ positionJSON = clusterData.getJSONObject("position");
+ markerId = clusterData.getString("__pgmId");
+ clusterId_markerId = clusterId + "-" + markerId;
+
+ // Save the marker properties
+ pluginMap.objects.put("marker_property_" + clusterId_markerId, clusterData);
+
+ // Set the WORKING status flag
+ synchronized (pluginMarkers) {
+ pluginMarkers.put(clusterId_markerId, STATUS.WORKING);
+ }
+ updateClusterIDs.add(clusterId_markerId);
+
+ // Prepare the marker properties for addMarker()
+ properties = new Bundle();
+ properties.putDouble("lat", positionJSON.getDouble("lat"));
+ properties.putDouble("lng", positionJSON.getDouble("lng"));
+ if (clusterData.has("title")) {
+ properties.putString("title", clusterData.getString("title"));
+ }
+ properties.putString("__pgmId", clusterId_markerId);
+
+ if (clusterData.has("icon")) {
+ Object iconObj = clusterData.get("icon");
+
+ if (iconObj instanceof String) {
+ Bundle iconProperties = new Bundle();
+ iconProperties.putString("url", (String) iconObj);
+ properties.putBundle("icon", iconProperties);
+
+ } else if (iconObj instanceof JSONObject) {
+ JSONObject icon = clusterData.getJSONObject("icon");
+ Bundle iconProperties = PluginUtil.Json2Bundle(icon);
+ if (clusterData.has("isClusterIcon") && clusterData.getBoolean("isClusterIcon")) {
+ if (icon.has("label")) {
+ JSONObject label = icon.getJSONObject("label");
+ if (isDebug) {
+ label.put("text", markerId);
+ } else {
+ label.put("text", clusterData.getInt("count") + "");
+ }
+ if (label.has("color")) {
+ label.put("color", PluginUtil.parsePluginColor(label.getJSONArray("color")));
+ }
+ iconProperties.putBundle("label", PluginUtil.Json2Bundle(label));
+ } else {
+ Bundle label = new Bundle();
+ if (isDebug) {
+ label.putString("text", markerId);
+ } else {
+ label.putInt("fontSize", 15);
+ label.putBoolean("bold", true);
+ label.putString("text", clusterData.getInt("count") + "");
+ }
+ iconProperties.putBundle("label", label);
+ }
+ }
+ if (icon.has("anchor")) {
+ double[] anchor = new double[2];
+ anchor[0] = icon.getJSONArray("anchor").getDouble(0);
+ anchor[1] = icon.getJSONArray("anchor").getDouble(1);
+ iconProperties.putDoubleArray("anchor", anchor);
+ }
+ if (icon.has("infoWindowAnchor")) {
+ double[] anchor = new double[2];
+ anchor[0] = icon.getJSONArray("infoWindowAnchor").getDouble(0);
+ anchor[1] = icon.getJSONArray("infoWindowAnchor").getDouble(1);
+ iconProperties.putDoubleArray("infoWindowAnchor", anchor);
+ }
+ properties.putBundle("icon", iconProperties);
+ }
+ }
+
+ changeProperties.put(clusterId_markerId, properties);
+ }
+
+ //Log.d(TAG, "---> deleteCnt : " + deleteCnt + ", newCnt : " + newCnt + ", updateCnt : " + updateCnt + ", reuseCnt : " + reuseCnt);
+
+ if (updateClusterIDs.size() == 0) {
+ deleteProcess(clusterId, params);
+ callbackContext.success();
+ return;
+ }
+
+ //---------------------------
+ // mapping markers on the map
+ //---------------------------
+ final JSONObject allResults = new JSONObject();
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ Iterator iterator;
+ String clusterId_markerId;
+ Bundle markerProperties;
+ Marker marker;
+ Boolean isNew;
+
+ //---------
+ // new or update
+ //---------
+ int waitCnt = updateClusterIDs.size();
+ int currentCnt = 0;
+ waitCntManager.put(clusterId, updateClusterIDs.size());
+ iterator = updateClusterIDs.iterator();
+ while (iterator.hasNext()) {
+ currentCnt++;
+ clusterId_markerId = iterator.next();
+ //Log.d(TAG, "---> progress = " + currentCnt + "/ " + waitCnt + ", " + clusterId_markerId);
+ synchronized (pluginMarkers) {
+ pluginMarkers.put(clusterId_markerId, STATUS.WORKING);
+ }
+ isNew = !pluginMap.objects.containsKey(clusterId_markerId);
+
+ // Get the marker properties
+ markerProperties = changeProperties.get(clusterId_markerId);
+ if (clusterId_markerId.contains("-marker_")) {
+ //-------------------
+ // regular marker
+ //-------------------
+ if (isNew) {
+ final String fMarkerId = clusterId_markerId;
+ JSONObject properties = (JSONObject) pluginMap.objects.get("marker_property_" + clusterId_markerId);
+ try {
+ _create(clusterId_markerId, properties, new ICreateMarkerCallback() {
+ @Override
+ public void onSuccess(Marker marker) {
+
+ synchronized (pluginMarkers) {
+ if (pluginMarkers.get(fMarkerId) == STATUS.DELETED) {
+ _removeMarker(marker);
+ pluginMarkers.remove(fMarkerId);
+ } else {
+ pluginMarkers.put(fMarkerId, STATUS.CREATED);
+
+
+ JSONObject result = new JSONObject();
+ if (icons.containsKey(fMarkerId)) {
+ Bitmap icon = icons.get(fMarkerId);
+ try {
+ result.put("width", icon.getWidth() / density);
+ result.put("height", icon.getHeight() / density);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ } else {
+ try {
+ result.put("width", 24);
+ result.put("height", 42);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ try {
+ allResults.put(fMarkerId.split("-")[1], result);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ decreaseWaitCnt(clusterId);
+ }
+
+ @Override
+ public void onError(String message) {
+ synchronized (pluginMarkers) {
+ pluginMarkers.put(fMarkerId, STATUS.DELETED);
+ }
+ Log.e(TAG, message);
+ decreaseWaitCnt(clusterId);
+ synchronized (deleteMarkers) {
+ deleteMarkers.add(fMarkerId);
+ }
+ }
+ });
+ } catch (JSONException e) {
+ e.printStackTrace();
+ decreaseWaitCnt(clusterId);
+ }
+ } else {
+ marker = getMarker(clusterId_markerId);
+ //----------------------------------------
+ // Set the title and snippet properties
+ //----------------------------------------
+ if (markerProperties.containsKey("title")) {
+ marker.setTitle(markerProperties.getString("title"));
+ }
+ if (markerProperties.containsKey("snippet")) {
+ marker.setSnippet(markerProperties.getString("snippet"));
+ }
+ synchronized (pluginMarkers) {
+ if (pluginMarkers.get(clusterId_markerId) == STATUS.DELETED) {
+ _removeMarker(marker);
+ pluginMarkers.remove(clusterId_markerId);
+ } else {
+ pluginMarkers.put(clusterId_markerId, STATUS.CREATED);
+ }
+ }
+ decreaseWaitCnt(clusterId);
+ }
+ continue;
+ }
+ //--------------------------
+ // cluster icon
+ //--------------------------
+ if (isNew) {
+ // If the requested id is new location, create a marker
+ marker = map.addMarker(new MarkerOptions()
+ .position(new LatLng(markerProperties.getDouble("lat"), markerProperties.getDouble("lng")))
+ .visible(false));
+ marker.setTag(clusterId_markerId);
+
+ // Store the marker instance with markerId
+ synchronized (pluginMap.objects) {
+ pluginMap.objects.put(clusterId_markerId, marker);
+ }
+ } else {
+ marker = getMarker(clusterId_markerId);
+ }
+ //----------------------------------------
+ // Set the title and snippet properties
+ //----------------------------------------
+ if (markerProperties.containsKey("title")) {
+ marker.setTitle(markerProperties.getString("title"));
+ }
+ if (markerProperties.containsKey("snippet")) {
+ marker.setSnippet(markerProperties.getString("snippet"));
+ }
+/*
+ if (!isNew) {
+ synchronized (pluginMarkers) {
+ pluginMarkers.put(markerId, STATUS.CREATED);
+ }
+ decreaseWaitCnt(clusterId);
+ continue;
+ }
+*/
+ if (markerProperties.containsKey("icon")) {
+ Bundle icon = markerProperties.getBundle("icon");
+ final String fMarkerId = clusterId_markerId;
+ //Log.d(TAG, "---> targetMarkerId = " + targetMarkerId + ", marker = " + marker);
+ setIconToClusterMarker(clusterId_markerId, marker, icon, new PluginAsyncInterface() {
+ @Override
+ public void onPostExecute(Object object) {
+ //--------------------------------------
+ // Marker was updated
+ //--------------------------------------
+ decreaseWaitCnt(clusterId);
+ synchronized (pluginMarkers) {
+ //Log.d(TAG, "create : " + fMarkerId + " = CREATED");
+ pluginMarkers.put(fMarkerId, STATUS.CREATED);
+ }
+ }
+
+ @Override
+ public void onError(String errorMsg) {
+ //--------------------------------------
+ // Could not read icon for some reason
+ //--------------------------------------
+ Log.e(TAG, errorMsg);
+ decreaseWaitCnt(clusterId);
+ synchronized (deleteMarkers) {
+ deleteMarkers.add(fMarkerId);
+ }
+ synchronized (pluginMarkers) {
+ pluginMarkers.put(fMarkerId, STATUS.DELETED);
+ }
+ }
+ });
+ } else {
+ //--------------------
+ // No icon for marker
+ //--------------------
+ synchronized (pluginMarkers) {
+ //Log.d(TAG, "create : " + clusterId_markerId + " = CREATED");
+ pluginMarkers.put(clusterId_markerId, STATUS.CREATED);
+ }
+ decreaseWaitCnt(clusterId);
+ }
+ }
+ updateClusterIDs.clear();
+
+
+ }
+ });
+ synchronized (semaphore) {
+ try {
+ semaphore.wait();
+ deleteProcess(clusterId, params);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ callbackContext.success(allResults);
+
+ }
+ private void deleteProcess(final String clusterId, final JSONObject params) {
+ if (!params.has("delete")) {
+ return;
+ }
+ cordova.getThreadPool().submit(new Runnable() {
+ @Override
+ public void run() {
+
+ try {
+ JSONArray deleteClusters = params.getJSONArray("delete");
+ if (deleteClusters != null) {
+ //-------------------------------------
+ // delete markers on the delete thread
+ //-------------------------------------
+ int deleteCnt = deleteClusters.length();
+ String clusterId_markerId;
+ for (int i = 0; i < deleteCnt; i++) {
+ clusterId_markerId = clusterId + "-" + deleteClusters.getString(i);
+ deleteMarkers.add(clusterId_markerId);
+ }
+
+ synchronized (deleteThreadLock) {
+ deleteThreadLock.notify();
+ }
+
+ }
+ } catch (Exception e) {e.printStackTrace();}
+ }
+ });
+ }
+
+ private void decreaseWaitCnt(String clusterId) {
+
+ //--------------------------------------
+ // Icon is set to marker
+ //--------------------------------------
+ synchronized (waitCntManager) {
+ int waitCnt = waitCntManager.get(clusterId);
+ waitCnt = waitCnt - 1;
+ //Log.d(TAG, "--->waitCnt = " + waitCnt);
+ if (waitCnt == 0) {
+ synchronized (semaphore) {
+ semaphore.notify();
+ }
+
+ }
+ waitCntManager.put(clusterId, waitCnt);
+ }
+ }
+
+ private void setIconToClusterMarker(final String markerId, final Marker marker, final Bundle iconProperty, final PluginAsyncInterface callback) {
+ synchronized (pluginMarkers) {
+ if (STATUS.DELETED.equals(pluginMarkers.get(markerId))) {
+ synchronized (pluginMap.objects) {
+ PluginMarkerCluster.this._removeMarker(marker);
+ pluginMap.objects.remove(markerId);
+ pluginMap.objects.remove("marker_property_" + markerId);
+ }
+ pluginMarkers.remove(markerId);
+ callback.onError("marker has been removed");
+ return;
+ }
+ }
+ PluginMarkerCluster.super.setIcon_(marker, iconProperty, new PluginAsyncInterface() {
+ @Override
+ public void onPostExecute(Object object) {
+ Marker marker = (Marker) object;
+ synchronized (pluginMarkers) {
+ if (STATUS.DELETED.equals(pluginMarkers.get(markerId))) {
+ synchronized (pluginMap.objects) {
+ PluginMarkerCluster.this._removeMarker(marker);
+ pluginMap.objects.remove(markerId);
+ pluginMap.objects.remove("marker_property_" + markerId);
+ }
+ pluginMarkers.remove(markerId);
+ callback.onPostExecute(null);
+ return;
+ }
+ marker.setVisible(true);
+
+ //Log.d(TAG, "create : " + markerId + " = CREATED");
+ pluginMarkers.put(markerId, STATUS.CREATED);
+ callback.onPostExecute(object);
+ }
+ }
+
+ @Override
+ public void onError(String errorMsg) {
+ synchronized (pluginMap.objects) {
+ if (marker != null && marker.getTag() != null) {
+ PluginMarkerCluster.this._removeMarker(marker);
+ }
+ pluginMap.objects.remove(markerId);
+ pluginMap.objects.remove("marker_property_" + markerId);
+ pluginMarkers.remove(markerId);
+ pluginMap.objects.remove(markerId);
+ pluginMarkers.put(markerId, STATUS.DELETED);
+ }
+ callback.onPostExecute(errorMsg);
+ }
+ });
+ }
+
+
+
+ // The maximum *practical* geocell resolution.
+ private static final int GEOCELL_GRID_SIZE = 4;
+ public static final String GEOCELL_ALPHABET = "0123456789abcdef";
+
+ private String getGeocell(double lat, double lng, int resolution) {
+ StringBuilder cell = new StringBuilder();
+ double north = 90.0;
+ double south = -90.0;
+ double east = 180.0;
+ double west = -180.0;
+ double subcell_lng_span, subcell_lat_span;
+ byte x, y;
+ while(cell.length() < resolution + 1) {
+ subcell_lng_span = (east - west) / GEOCELL_GRID_SIZE;
+ subcell_lat_span = (north - south) / GEOCELL_GRID_SIZE;
+
+ x = (byte)Math.min(Math.floor(GEOCELL_GRID_SIZE * (lng - west) / (east - west)), GEOCELL_GRID_SIZE - 1);
+ y = (byte)Math.min(Math.floor(GEOCELL_GRID_SIZE * (lat - south) / (north - south)), GEOCELL_GRID_SIZE - 1);
+ cell.append(_subdiv_char(x, y));
+
+ south += subcell_lat_span * y;
+ north = south + subcell_lat_span;
+
+ west += subcell_lng_span * x;
+ east = west + subcell_lng_span;
+ }
+ return cell.toString();
+ }
+ private char _subdiv_char(int posX, int posY) {
+ return GEOCELL_ALPHABET.charAt(
+ (posY & 2) << 2 |
+ (posX & 2) << 1 |
+ (posY & 1) << 1 |
+ (posX & 1) << 0);
+ }
+
+ private double[] _subdiv_xy(char cellChar) {
+ int charI = GEOCELL_ALPHABET.indexOf(cellChar);
+ return new double[]{
+ (double)((charI & 4) >> 1 | (charI & 1) >> 0) + 0.0f,
+ (double)((charI & 8) >> 2 | (charI & 2) >> 1) + 0.0f
+ };
+ }
+
+ private LatLngBounds computeBox(String geocell) {
+
+ //String tmp[] = geocell.split("-");
+ //geocell = tmp[1];
+
+ double subcell_lng_span, subcell_lat_span;
+ double x, y;
+ double xy[];
+ BoundBox bbox = new BoundBox(90.0, 180.0, -90.0, -180.0);
+
+ while (geocell.length() > 0) {
+ subcell_lng_span = (double)(bbox.getEast() - bbox.getWest()) / (double)GEOCELL_GRID_SIZE;
+ subcell_lat_span = (double)(bbox.getNorth() - bbox.getSouth()) / (double)GEOCELL_GRID_SIZE;
+
+ xy = _subdiv_xy(geocell.charAt(0));
+ x = xy[0];
+ y = xy[1];
+
+ bbox = new BoundBox(bbox.getSouth() + subcell_lat_span * (y + 1.0f),
+ bbox.getWest() + subcell_lng_span * (double)(x + 1.0f),
+ bbox.getSouth() + subcell_lat_span * y,
+ bbox.getWest() + subcell_lng_span * x);
+
+ geocell = geocell.substring(1);
+ }
+ LatLng sw = new LatLng(bbox.getSouth(), bbox.getWest());
+ LatLng ne = new LatLng(bbox.getNorth(), bbox.getEast());
+ return new LatLngBounds(sw, ne);
+ }
+
+ private class BoundBox {
+ double north_, south_, east_, west_;
+
+ BoundBox(double north, double east, double south, double west) {
+ if (south > north) {
+ south_ = north;
+ north_ = south;
+ } else {
+ south_ = south;
+ north_ = north;
+ }
+ west_ = west;
+ east_ = east;
+ }
+
+
+ public double getNorth() {
+ return north_;
+ }
+
+ public double getSouth() {
+ return south_;
+ }
+
+ public double getWest() {
+ return west_;
+ }
+
+ public double getEast() {
+ return east_;
+ }
+ }
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginPolygon.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginPolygon.java
new file mode 100644
index 0000000..231cd58
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginPolygon.java
@@ -0,0 +1,753 @@
+package plugin.google.maps;
+
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.LatLngBounds;
+import com.google.android.gms.maps.model.Polygon;
+import com.google.android.gms.maps.model.PolygonOptions;
+
+import org.apache.cordova.CallbackContext;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Set;
+
+//Future implement
+//TODO: https://codepen.io/jhawes/pen/ujdgK
+
+
+public class PluginPolygon extends MyPlugin implements MyPluginInterface {
+
+ private String polygonHashCode;
+
+ /**
+ * Create polygon
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @Override
+ public void create(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ self = this;
+
+ final PolygonOptions polygonOptions = new PolygonOptions();
+ int color;
+ final LatLngBounds.Builder builder = new LatLngBounds.Builder();
+ final JSONObject properties = new JSONObject();
+ final ArrayList holeBounds = new ArrayList();
+ final ArrayList path = new ArrayList();
+ final ArrayList> holePaths = new ArrayList>();
+
+ JSONObject opts = args.getJSONObject(1);
+ final String hashCode = args.getString(2);
+ polygonHashCode = hashCode;
+ if (opts.has("points")) {
+ JSONArray points = opts.getJSONArray("points");
+ ArrayList path2 = PluginUtil.JSONArray2LatLngList(points);
+ for (int i = 0; i < path2.size(); i++) {
+ polygonOptions.add(path2.get(i));
+ path.add(path2.get(i));
+ builder.include(path2.get(i));
+ }
+ }
+
+ if (opts.has("holes")) {
+ JSONArray holes = opts.getJSONArray("holes");
+ int i;
+ JSONArray latLngArray;
+ ArrayList hole;
+ Iterator iterator;
+ LatLng latLng;
+ LatLngBounds.Builder builder2;
+ for (i = 0; i < holes.length(); i++) {
+ latLngArray = holes.getJSONArray(i);
+ hole = PluginUtil.JSONArray2LatLngList(latLngArray);
+ polygonOptions.addHole(hole);
+ holePaths.add(hole);
+ iterator = hole.iterator();
+ builder2 = new LatLngBounds.Builder();
+ while (iterator.hasNext()) {
+ latLng = iterator.next();
+ builder2.include(latLng);
+ }
+ holeBounds.add(builder2.build());
+ }
+ }
+ if (opts.has("strokeColor")) {
+ color = PluginUtil.parsePluginColor(opts.getJSONArray("strokeColor"));
+ polygonOptions.strokeColor(color);
+ }
+ if (opts.has("fillColor")) {
+ color = PluginUtil.parsePluginColor(opts.getJSONArray("fillColor"));
+ polygonOptions.fillColor(color);
+ }
+ if (opts.has("strokeWidth")) {
+ polygonOptions.strokeWidth((float)(opts.getDouble("strokeWidth") * density));
+ }
+ if (opts.has("visible")) {
+ polygonOptions.visible(opts.getBoolean("visible"));
+ }
+ if (opts.has("geodesic")) {
+ polygonOptions.geodesic(opts.getBoolean("geodesic"));
+ }
+ if (opts.has("zIndex")) {
+ polygonOptions.zIndex(opts.getInt("zIndex"));
+ }
+ if (opts.has("clickable")) {
+ properties.put("isClickable", opts.getBoolean("clickable"));
+ } else {
+ properties.put("isClickable", true);
+ }
+ properties.put("isVisible", polygonOptions.isVisible());
+ properties.put("zIndex", polygonOptions.getZIndex());
+ properties.put("isGeodesic", polygonOptions.isGeodesic());
+
+ // Since this plugin uses own detecting process,
+ // set false to the clickable property.
+ polygonOptions.clickable(false);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ Polygon polygon = map.addPolygon(polygonOptions);
+ String id = hashCode;
+ polygon.setTag(hashCode);
+ pluginMap.objects.put("polygon_"+ id, polygon);
+ pluginMap.objects.put("polygon_bounds_" + id, builder.build());
+ pluginMap.objects.put("polygon_path_" + id, path);
+ pluginMap.objects.put("polygon_holePaths_" + id, holePaths);
+ pluginMap.objects.put("polygon_property_" + id, properties);
+
+ JSONObject result = new JSONObject();
+ try {
+ result.put("hashCode", hashCode);
+ result.put("__pgmId", "polygon_"+ id);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ callbackContext.success(result);
+ }
+ });
+ }
+
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ Set keySet = pluginMap.objects.keys;
+ if (keySet.size() > 0) {
+ String[] objectIdArray = keySet.toArray(new String[keySet.size()]);
+
+ for (String objectId : objectIdArray) {
+ if (pluginMap.objects.containsKey(objectId)) {
+ if (objectId.contains("property")) {
+ Polygon polygon = (Polygon) pluginMap.objects.remove(objectId.replace("property_", ""));
+ if (polygon != null) {
+ polygon.remove();
+ }
+ }
+ Object object = pluginMap.objects.remove(objectId);
+ object = null;
+
+ }
+ }
+ }
+ }
+ });
+
+ }
+
+ /**
+ * set fill color
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setFillColor(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ int color = PluginUtil.parsePluginColor(args.getJSONArray(1));
+ this.setInt("setFillColor", id, color, callbackContext);
+ }
+
+ /**
+ * set stroke color
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setStrokeColor(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ int color = PluginUtil.parsePluginColor(args.getJSONArray(1));
+ this.setInt("setStrokeColor", id, color, callbackContext);
+ }
+
+ /**
+ * set stroke width
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void setStrokeWidth(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ float width = (float)(args.getDouble(1) * density);
+ this.setFloat("setStrokeWidth", id, width, callbackContext);
+ }
+
+ /**
+ * set z-index
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void setZIndex(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final float zIndex = (float) args.getDouble(1);
+ this.setFloat("setZIndex", id, zIndex, callbackContext);
+ }
+
+ /**
+ * set geodesic
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setGeodesic(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ boolean isGeodisic = args.getBoolean(1);
+ this.setBoolean("setGeodesic", id, isGeodisic, callbackContext);
+ }
+
+ /**
+ * Remove the polygon
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void remove(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final Polygon polygon = this.getPolygon(id);
+ if (polygon == null) {
+ callbackContext.success();
+ return;
+ }
+ pluginMap.objects.remove(id);
+
+ pluginMap.objects.remove("polygon_bounds_" + polygonHashCode);
+ pluginMap.objects.remove("polygon_property_" + polygonHashCode);
+ pluginMap.objects.remove("polygon_path_" + polygonHashCode);
+ pluginMap.objects.remove("polygon_holePaths_" + polygonHashCode);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ polygon.remove();
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Set points
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void removePointAt(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final int index = args.getInt(1);
+ final Polygon polygon = this.getPolygon(id);
+
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ String propertyId = "polygon_path_" + polygonHashCode;
+ final ArrayList path = (ArrayList)pluginMap.objects.get(propertyId);
+ if (path.size() > 0) {
+ path.remove(index);
+ }
+ pluginMap.objects.put(propertyId, path);
+
+ //-----------------------------------
+ // Recalculate the polygon bounds
+ //-----------------------------------
+ propertyId = "polygon_bounds_" + polygonHashCode;
+ if (path.size() > 0) {
+ pluginMap.objects.put(propertyId, PluginUtil.getBoundsFromPath(path));
+ } else {
+ pluginMap.objects.remove(propertyId);
+ }
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ if (path.size() > 0) {
+ try {
+ polygon.setPoints(path);
+ } catch (Exception e) {
+ // Ignore this error
+ //e.printStackTrace();
+ }
+ } else {
+ polygon.setVisible(false);
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Set points
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setPoints(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ String id = args.getString(0);
+ final JSONArray positionList = args.getJSONArray(1);
+
+
+ final Polygon polygon = this.getPolygon(id);
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ String propertyId = "polygon_path_" + polygonHashCode;
+ final ArrayList path = (ArrayList)pluginMap.objects.get(propertyId);
+ path.clear();
+ JSONObject position;
+ for (int i = 0; i < positionList.length(); i++) {
+ position = positionList.getJSONObject(i);
+ path.add(new LatLng(position.getDouble("lat"), position.getDouble("lng")));
+ }
+ pluginMap.objects.put(propertyId, path);
+
+ //-----------------------------------
+ // Recalculate the polygon bounds
+ //-----------------------------------
+ propertyId = "polygon_bounds_" + polygonHashCode;
+ pluginMap.objects.put(propertyId, PluginUtil.getBoundsFromPath(path));
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Update the polygon
+ polygon.setPoints(path);
+ if (path.size() > 0) {
+ polygon.setVisible(polygon.isVisible());
+ } else {
+ polygon.setVisible(false);
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Insert a point
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void insertPointAt(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final int index = args.getInt(1);
+ JSONObject position = args.getJSONObject(2);
+ final LatLng latLng = new LatLng(position.getDouble("lat"), position.getDouble("lng"));
+
+ final Polygon polygon = this.getPolygon(id);
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ boolean shouldBeVisible = false;
+ String propertyId = "polygon_path_" + polygonHashCode;
+ final ArrayList path = (ArrayList)pluginMap.objects.get(propertyId);
+ if (path.size() == 0) {
+ JSONObject properties = (JSONObject)pluginMap.objects.get("polygon_property_" + polygonHashCode);
+ if (properties.getBoolean("isVisible")) {
+ shouldBeVisible = true;
+ }
+ }
+ path.add(index, latLng);
+ pluginMap.objects.put(propertyId, path);
+
+ //-----------------------------------
+ // Recalculate the polygon bounds
+ //-----------------------------------
+ propertyId = "polygon_bounds_" + polygonHashCode;
+ pluginMap.objects.put(propertyId, PluginUtil.getBoundsFromPath(path));
+
+ final boolean changeToVisible = shouldBeVisible;
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Update the polygon
+ polygon.setPoints(path);
+ if (changeToVisible) {
+ polygon.setVisible(true);
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Set points
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setPointAt(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final int index = args.getInt(1);
+ JSONObject position = args.getJSONObject(2);
+ final LatLng latLng = new LatLng(position.getDouble("lat"), position.getDouble("lng"));
+
+ final Polygon polygon = this.getPolygon(id);
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ String propertyId = "polygon_path_" + polygonHashCode;
+ final ArrayList path = (ArrayList)pluginMap.objects.get(propertyId);
+ path.set(index, latLng);
+ pluginMap.objects.put(propertyId, path);
+
+ //-----------------------------------
+ // Recalculate the polygon bounds
+ //-----------------------------------
+ propertyId = "polygon_bounds_" + polygonHashCode;
+ pluginMap.objects.put(propertyId, PluginUtil.getBoundsFromPath(path));
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Update the polygon
+ polygon.setPoints(path);
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Set points
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setHoles(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final JSONArray holeList = args.getJSONArray(1);
+ final Polygon polygon = this.getPolygon(id);
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ String propertyId = "polygon_holePaths_" + polygonHashCode;
+ final ArrayList> holes = (ArrayList>) pluginMap.objects.get(propertyId);
+ for (int i = 0; i < holes.size(); i++) {
+ holes.get(i).clear();
+ }
+ holes.clear();
+
+ JSONObject position;
+ for (int i = 0; i < holeList.length(); i++) {
+ ArrayList hole = new ArrayList();
+ JSONArray holePositions = holeList.getJSONArray(i);
+ for (int j = 0; j < holePositions.length(); j++) {
+ position = holePositions.getJSONObject(j);
+ hole.add(new LatLng(position.getDouble("lat"), position.getDouble("lng")));
+ }
+ holes.add(hole);
+ }
+
+
+ pluginMap.objects.put(propertyId, holes);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Update the polygon
+ polygon.setHoles(holes);
+ callbackContext.success();
+ }
+ });
+ }
+ /**
+ * Set points
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void insertPointOfHoleAt(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final int holeIndex = args.getInt(1);
+ final int pointIndex = args.getInt(2);
+ JSONObject position = args.getJSONObject(3);
+ final LatLng latLng = new LatLng(position.getDouble("lat"), position.getDouble("lng"));
+
+ final Polygon polygon = this.getPolygon(id);
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ String propertyId = "polygon_holePaths_" + polygonHashCode;
+ final ArrayList> holes = (ArrayList>) pluginMap.objects.get(propertyId);
+ ArrayList hole = null;
+ if (holeIndex < holes.size()) {
+ hole = holes.get(holeIndex);
+ }
+ if (hole == null) {
+ hole = new ArrayList();
+ }
+ if (holes.size() == 0) {
+ holes.add(hole);
+ }
+ hole.add(pointIndex, latLng);
+ pluginMap.objects.put(propertyId, holes);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Update the polygon
+ polygon.setHoles(holes);
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Set points
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setPointOfHoleAt(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final int holeIndex = args.getInt(1);
+ final int pointIndex = args.getInt(2);
+ JSONObject position = args.getJSONObject(3);
+ final LatLng latLng = new LatLng(position.getDouble("lat"), position.getDouble("lng"));
+
+ final Polygon polygon = this.getPolygon(id);
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ String propertyId = "polygon_holePaths_" + polygonHashCode;
+ final ArrayList> holes = (ArrayList>) pluginMap.objects.get(propertyId);
+ ArrayList hole = null;
+ if (holeIndex < holes.size()) {
+ hole = holes.get(holeIndex);
+ }
+ if (hole == null) {
+ hole = new ArrayList();
+ }
+ if (holes.size() == 0) {
+ holes.add(hole);
+ }
+ hole.set(pointIndex, latLng);
+ pluginMap.objects.put(propertyId, holes);
+
+ final ArrayList newHole = hole;
+
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Update the polygon
+ polygon.setHoles(holes);
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Set points
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void removePointOfHoleAt(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final int holeIndex = args.getInt(1);
+ final int pointIndex = args.getInt(2);
+
+ final Polygon polygon = this.getPolygon(id);
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ String propertyId = "polygon_holePaths_" + polygonHashCode;
+ final ArrayList> holes = (ArrayList>) pluginMap.objects.get(propertyId);
+ ArrayList hole = null;
+ if (holeIndex < holes.size()) {
+ hole = holes.get(holeIndex);
+ }
+ if (hole == null) {
+ hole = new ArrayList();
+ }
+ if (holes.size() == 0) {
+ holes.add(hole);
+ }
+ hole.remove(pointIndex);
+ pluginMap.objects.put(propertyId, holes);
+
+ final ArrayList newHole = hole;
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Update the polygon
+ polygon.setHoles(holes);
+ callbackContext.success();
+ }
+ });
+ }
+
+
+ public void insertHoleAt(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final int holeIndex = args.getInt(1);
+
+ JSONArray holeJson = args.getJSONArray(2);
+ final ArrayList newHole = PluginUtil.JSONArray2LatLngList(holeJson);
+
+ final Polygon polygon = this.getPolygon(id);
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ String propertyId = "polygon_holePaths_" + polygonHashCode;
+ final ArrayList> holes = (ArrayList>) pluginMap.objects.get(propertyId);
+ holes.add(holeIndex, newHole);
+ pluginMap.objects.put(propertyId, holes);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Update the polygon
+ try {
+ polygon.setHoles(holes);
+ } catch (Exception e) {
+ // Ignore this error
+ //e.printStackTrace();
+ }
+ callbackContext.success();
+ }
+ });
+ }
+
+ /**
+ * Set points
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setHoleAt(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final int holeIndex = args.getInt(1);
+
+ JSONArray holeJson = args.getJSONArray(2);
+ final ArrayList newHole = PluginUtil.JSONArray2LatLngList(holeJson);
+
+ final Polygon polygon = this.getPolygon(id);
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ String propertyId = "polygon_holePaths_" + polygonHashCode;
+ final ArrayList> holes = (ArrayList>) pluginMap.objects.get(propertyId);
+ holes.set(holeIndex, newHole);
+ pluginMap.objects.put(propertyId, holes);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Update the polygon
+ polygon.setHoles(holes);
+ callbackContext.success();
+ }
+ });
+ }
+
+
+ /**
+ * Set points
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void removeHoleAt(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final int holeIndex = args.getInt(1);
+
+ final Polygon polygon = this.getPolygon(id);
+
+ //------------------------
+ // Update the hole list
+ //------------------------
+ String propertyId = "polygon_holePaths_" + polygonHashCode;
+ final ArrayList> holes = (ArrayList>) pluginMap.objects.get(propertyId);
+ holes.remove(holeIndex);
+ pluginMap.objects.put(propertyId, holes);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ // Update the polygon
+ polygon.setHoles(holes);
+ callbackContext.success();
+ }
+ });
+ }
+ /**
+ * Set visibility for the object
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setVisible(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ final boolean isVisible = args.getBoolean(1);
+ String id = args.getString(0);
+
+ final Polygon polygon = this.getPolygon(id);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ polygon.setVisible(isVisible);
+ }
+ });
+ String propertyId = "polygon_property_" + polygonHashCode;
+ JSONObject properties = (JSONObject)pluginMap.objects.get(propertyId);
+ properties.put("isVisible", isVisible);
+ pluginMap.objects.put(propertyId, properties);
+ callbackContext.success();
+ }
+
+ /**
+ * Set clickable for the object
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setClickable(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final boolean clickable = args.getBoolean(1);
+ String propertyId = id.replace("polygon_", "polygon_property_");
+ JSONObject properties = (JSONObject)pluginMap.objects.get(propertyId);
+ properties.put("isClickable", clickable);
+ pluginMap.objects.put(propertyId, properties);
+ callbackContext.success();
+ }
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginPolyline.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginPolyline.java
new file mode 100644
index 0000000..8d1f52c
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginPolyline.java
@@ -0,0 +1,334 @@
+package plugin.google.maps;
+
+import android.graphics.Color;
+import android.util.Log;
+
+import com.google.android.gms.maps.model.CircleOptions;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.LatLngBounds;
+import com.google.android.gms.maps.model.MarkerOptions;
+import com.google.android.gms.maps.model.Polyline;
+import com.google.android.gms.maps.model.PolylineOptions;
+
+import org.apache.cordova.CallbackContext;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PluginPolyline extends MyPlugin implements MyPluginInterface {
+ private String polylineHashCode;
+
+ /**
+ * Create polyline
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void create(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ self = this;
+
+ final PolylineOptions polylineOptions = new PolylineOptions();
+ int color;
+ final LatLngBounds.Builder builder = new LatLngBounds.Builder();
+ final JSONObject properties = new JSONObject();
+
+ JSONObject opts = args.getJSONObject(1);
+ final String hashCode = args.getString(2);
+ polylineHashCode = hashCode;
+
+ if (opts.has("points")) {
+ JSONArray points = opts.getJSONArray("points");
+ List path = PluginUtil.JSONArray2LatLngList(points);
+ int i = 0;
+ for (i = 0; i < path.size(); i++) {
+ polylineOptions.add(path.get(i));
+ builder.include(path.get(i));
+ }
+ }
+ if (opts.has("color")) {
+ color = PluginUtil.parsePluginColor(opts.getJSONArray("color"));
+ polylineOptions.color(color);
+ }
+ if (opts.has("width")) {
+ polylineOptions.width((float)(opts.getDouble("width") * density));
+ }
+ if (opts.has("visible")) {
+ polylineOptions.visible(opts.getBoolean("visible"));
+ }
+ if (opts.has("geodesic")) {
+ polylineOptions.geodesic(opts.getBoolean("geodesic"));
+ }
+ if (opts.has("zIndex")) {
+ polylineOptions.zIndex(opts.getInt("zIndex"));
+ }
+ if (opts.has("clickable")) {
+ properties.put("isClickable", opts.getBoolean("clickable"));
+ } else {
+ properties.put("isClickable", true);
+ }
+ properties.put("isVisible", polylineOptions.isVisible());
+
+ // Since this plugin provide own click detection,
+ // disable default clickable feature.
+ polylineOptions.clickable(false);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ Polyline polyline = map.addPolyline(polylineOptions);
+ polyline.setTag(hashCode);
+ String id = "polyline_" + hashCode;
+ pluginMap.objects.put(id, polyline);
+
+ String boundsId = "polyline_bounds_" + hashCode;
+ pluginMap.objects.put(boundsId, builder.build());
+
+ String propertyId = "polyline_property_" + hashCode;
+ pluginMap.objects.put(propertyId, properties);
+
+ try {
+ JSONObject result = new JSONObject();
+ result.put("hashCode", hashCode);
+ result.put("__pgmId", id);
+ callbackContext.success(result);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ callbackContext.error("" + e.getMessage());
+ }
+ }
+
+ });
+ }
+
+
+ /**
+ * set color
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setStrokeColor(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ int color = PluginUtil.parsePluginColor(args.getJSONArray(1));
+ this.setInt("setColor", id, color, callbackContext);
+ }
+
+ /**
+ * set width
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setStrokeWidth(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ float width = (float)(args.getDouble(1) * density);
+ this.setFloat("setWidth", id, width, callbackContext);
+ }
+
+ /**
+ * set z-index
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setZIndex(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ float zIndex = (float) args.getDouble(1);
+ this.setFloat("setZIndex", id, zIndex, callbackContext);
+ }
+
+
+ /**
+ * Remove the polyline
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void remove(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final Polyline polyline = this.getPolyline(id);
+ if (polyline == null) {
+ callbackContext.success();
+ return;
+ }
+ pluginMap.objects.remove(id);
+
+ id = "polyline_bounds_" + polylineHashCode;
+ pluginMap.objects.remove(id);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ polyline.remove();
+ callbackContext.success();
+ }
+ });
+ }
+ public void setPoints(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ String id = args.getString(0);
+ final JSONArray positionList = args.getJSONArray(1);
+
+ final Polyline polyline = this.getPolyline(id);
+ // Recalculate the polygon bounds
+ final String propertyId = "polyline_bounds_" + polylineHashCode;
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ try {
+ List path = polyline.getPoints();
+ path.clear();
+ JSONObject position;
+ for (int i = 0; i < positionList.length(); i++) {
+ position = positionList.getJSONObject(i);
+ path.add(new LatLng(position.getDouble("lat"), position.getDouble("lng")));
+ }
+ polyline.setPoints(path);
+ pluginMap.objects.put(propertyId, PluginUtil.getBoundsFromPath(path));
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ callbackContext.success();
+ }
+ });
+ }
+ public void removePointAt(final JSONArray args, CallbackContext callbackContext) throws JSONException {
+
+ String id = args.getString(0);
+ final int index = args.getInt(1);
+ final Polyline polyline = this.getPolyline(id);
+
+ // Recalculate the polygon bounds
+ final String propertyId = "polyline_bounds_" + polylineHashCode;
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ List path = polyline.getPoints();
+ if (path.size() > index) {
+ path.remove(index);
+ if (path.size() > 0) {
+ pluginMap.objects.put(propertyId, PluginUtil.getBoundsFromPath(path));
+ } else {
+ pluginMap.objects.remove(propertyId);
+ }
+
+ polyline.setPoints(path);
+ }
+ }
+ });
+ callbackContext.success();
+ }
+ public void insertPointAt(final JSONArray args, CallbackContext callbackContext) throws JSONException {
+
+ String id = args.getString(0);
+ final int index = args.getInt(1);
+ JSONObject position = args.getJSONObject(2);
+ final LatLng latLng = new LatLng(position.getDouble("lat"), position.getDouble("lng"));
+
+ final Polyline polyline = this.getPolyline(id);
+
+
+ // Recalculate the polygon bounds
+ final String propertyId = "polyline_bounds_" + polylineHashCode;
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ List path = polyline.getPoints();
+ if (path.size() >= index) {
+ path.add(index, latLng);
+ polyline.setPoints(path);
+ pluginMap.objects.put(propertyId, PluginUtil.getBoundsFromPath(path));
+ }
+ }
+ });
+ callbackContext.success();
+ }
+ public void setPointAt(final JSONArray args, CallbackContext callbackContext) throws JSONException {
+
+ String id = args.getString(0);
+ final int index = args.getInt(1);
+ JSONObject position = args.getJSONObject(2);
+ final LatLng latLng = new LatLng(position.getDouble("lat"), position.getDouble("lng"));
+
+
+ final Polyline polyline = this.getPolyline(id);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ List path = polyline.getPoints();
+ if (path.size() > index) {
+ path.set(index, latLng);
+
+ // Recalculate the polygon bounds
+ String propertyId = "polyline_bounds_" + polylineHashCode;
+ pluginMap.objects.put(propertyId, PluginUtil.getBoundsFromPath(path));
+
+ polyline.setPoints(path);
+ }
+ }
+ });
+ callbackContext.success();
+ }
+
+ /**
+ * set geodesic
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setGeodesic(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ boolean isGeodisic = args.getBoolean(1);
+ this.setBoolean("setGeodesic", id, isGeodisic, callbackContext);
+ }
+
+ /**
+ * Set visibility for the object
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setVisible(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final boolean isVisible = args.getBoolean(1);
+
+ final Polyline polyline = this.getPolyline(id);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ polyline.setVisible(isVisible);
+ }
+ });
+ String propertyId = "polyline_property_" + polylineHashCode;
+ JSONObject properties = (JSONObject)pluginMap.objects.get(propertyId);
+ properties.put("isVisible", isVisible);
+ pluginMap.objects.put(propertyId, properties);
+ callbackContext.success();
+ }
+
+ /**
+ * Set clickable for the object
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setClickable(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ final boolean clickable = args.getBoolean(1);
+ String propertyId = id.replace("polyline_", "polyline_property_");
+ JSONObject properties = (JSONObject)pluginMap.objects.get(propertyId);
+ properties.put("isClickable", clickable);
+ pluginMap.objects.put(propertyId, properties);
+ callbackContext.success();
+ }
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginStreetViewPanorama.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginStreetViewPanorama.java
new file mode 100644
index 0000000..b85a51e
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginStreetViewPanorama.java
@@ -0,0 +1,459 @@
+package plugin.google.maps;
+
+import android.app.Activity;
+import android.graphics.Point;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.google.android.gms.maps.OnStreetViewPanoramaReadyCallback;
+import com.google.android.gms.maps.StreetViewPanorama;
+import com.google.android.gms.maps.StreetViewPanoramaOptions;
+import com.google.android.gms.maps.StreetViewPanoramaView;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.StreetViewPanoramaCamera;
+import com.google.android.gms.maps.model.StreetViewPanoramaLink;
+import com.google.android.gms.maps.model.StreetViewPanoramaLocation;
+import com.google.android.gms.maps.model.StreetViewPanoramaOrientation;
+import com.google.android.gms.maps.model.StreetViewSource;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Locale;
+
+
+public class PluginStreetViewPanorama extends MyPlugin implements
+ IPluginView, StreetViewPanorama.OnStreetViewPanoramaCameraChangeListener,
+ StreetViewPanorama.OnStreetViewPanoramaChangeListener,
+ StreetViewPanorama.OnStreetViewPanoramaClickListener {
+
+ private Activity mActivity;
+ private StreetViewPanoramaView panoramaView;
+ private StreetViewPanorama panorama;
+ private String panoramaId;
+ private boolean isVisible = true;
+ private boolean isClickable = true;
+ private final String TAG = "StreetView";
+ private String divId;
+ private int viewDepth = 0;
+
+ @Override
+ public void initialize(CordovaInterface cordova, final CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ mActivity = cordova.getActivity();
+ }
+
+ public int getViewDepth() {
+ return viewDepth;
+ }
+ public String getDivId() {
+ return this.divId;
+ }
+ public String getOverlayId() {
+ return this.panoramaId;
+ }
+ public ViewGroup getView() {
+ return this.panoramaView;
+ }
+
+
+ public boolean getVisible() {
+ return isVisible;
+ }
+ public boolean getClickable() {
+ return isClickable;
+ }
+ public void getPanorama(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ JSONObject meta = args.getJSONObject(0);
+ panoramaId = meta.getString("__pgmId");
+ viewDepth = meta.getInt("depth");
+
+ JSONObject jsOptions = args.getJSONObject(1);
+ divId = args.getString(2);
+
+ StreetViewPanoramaOptions svOptions = new StreetViewPanoramaOptions();
+ if (jsOptions.has("camera")) {
+ JSONObject cameraOpts = jsOptions.getJSONObject("camera");
+ Object target = cameraOpts.get("target");
+ if (target instanceof JSONObject) {
+ JSONObject targetJson = cameraOpts.getJSONObject("target");
+ LatLng position = new LatLng(targetJson.getDouble("lat"), targetJson.getDouble("lng"));
+
+ if (cameraOpts.has("source")) {
+ StreetViewSource source = "OUTDOOR".equals(cameraOpts.getString("source")) ?
+ StreetViewSource.OUTDOOR : StreetViewSource.DEFAULT;
+ if (cameraOpts.has("radius")) {
+ svOptions.position(position, cameraOpts.getInt("radius"), source);
+ } else {
+ svOptions.position(position, source);
+ }
+ } else {
+ if (cameraOpts.has("radius")) {
+ svOptions.position(position, cameraOpts.getInt("radius"));
+ } else {
+ svOptions.position(position);
+ }
+ }
+ } else if (target instanceof String) {
+ svOptions.panoramaId(cameraOpts.getString("target"));
+ }
+
+ if (cameraOpts.has("bearing") ||
+ cameraOpts.has("tilt") ||
+ cameraOpts.has("zoom")) {
+ StreetViewPanoramaCamera.Builder builder = StreetViewPanoramaCamera.builder();
+ if (cameraOpts.has("bearing")) {
+ builder.bearing = (float) cameraOpts.getDouble("bearing");
+ }
+ if (cameraOpts.has("tilt")) {
+ builder.tilt = (float) cameraOpts.getDouble("tilt");
+ }
+ if (cameraOpts.has("zoom")) {
+ builder.zoom = (float) cameraOpts.getDouble("zoom");
+ }
+ svOptions.panoramaCamera(builder.build());
+ }
+ }
+
+ if (jsOptions.has("gestures")) {
+ JSONObject gestures = jsOptions.getJSONObject("gestures");
+ if (gestures.has("panning")) {
+ svOptions.panningGesturesEnabled(gestures.getBoolean("panning"));
+ }
+ if (gestures.has("zoom")) {
+ svOptions.zoomGesturesEnabled(gestures.getBoolean("zoom"));
+ }
+ }
+
+ if (jsOptions.has("controls")) {
+ JSONObject controls = jsOptions.getJSONObject("controls");
+ if (controls.has("navigation")) {
+ svOptions.userNavigationEnabled(controls.getBoolean("navigation"));
+ }
+ if (controls.has("streetNames")) {
+ svOptions.streetNamesEnabled(controls.getBoolean("streetNames"));
+ }
+ }
+ panoramaView = new StreetViewPanoramaView(mActivity, svOptions);
+
+ mActivity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ panoramaView.onCreate(null);
+ panoramaView.setTag(getViewDepth());
+
+ panoramaView.getStreetViewPanoramaAsync(new OnStreetViewPanoramaReadyCallback() {
+ @Override
+ public void onStreetViewPanoramaReady(StreetViewPanorama streetViewPanorama) {
+ panoramaView.onResume();
+ panorama = streetViewPanorama;
+
+ panorama.setOnStreetViewPanoramaCameraChangeListener(PluginStreetViewPanorama.this);
+ panorama.setOnStreetViewPanoramaChangeListener(PluginStreetViewPanorama.this);
+ panorama.setOnStreetViewPanoramaClickListener(PluginStreetViewPanorama.this);
+
+ // Don't support this because iOS does not support this feature.
+ //panorama.setOnStreetViewPanoramaLongClickListener(PluginStreetViewPanorama.this);
+
+
+ mapCtrl.mPluginLayout.addPluginOverlay(PluginStreetViewPanorama.this);
+ callbackContext.success();
+ }
+ });
+ }
+ });
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ }
+
+ @Override
+ public void onPause(boolean multitasking) {
+ super.onPause(multitasking);
+ if (panoramaView != null && panoramaView.isActivated()) {
+ panoramaView.onPause();
+ }
+
+ //mapCtrl.mPluginLayout.removePluginOverlay(this.panoramaId);
+
+ }
+ @Override
+ public void onResume(boolean multitasking) {
+ super.onResume(multitasking);
+ if (panoramaView != null && panoramaView.isActivated()) {
+ panoramaView.onResume();
+ }
+ //mapCtrl.mPluginLayout.addPluginOverlay(PluginStreetViewPanorama.this);
+ }
+
+ public void attachToWebView(JSONArray args, final CallbackContext callbackContext) {
+ mapCtrl.mPluginLayout.addPluginOverlay(this);
+ callbackContext.success();
+ }
+
+ public void detachFromWebView(JSONArray args, final CallbackContext callbackContext) {
+ mapCtrl.mPluginLayout.removePluginOverlay(this.panoramaId);
+ callbackContext.success();
+ }
+
+ public void setPanningGesturesEnabled(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final boolean boolValue = args.getBoolean(0);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ panorama.setPanningGesturesEnabled(boolValue);
+ callbackContext.success();
+ }
+ });
+ }
+
+ public void setZoomGesturesEnabled(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final boolean boolValue = args.getBoolean(0);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ panorama.setZoomGesturesEnabled(boolValue);
+ callbackContext.success();
+ }
+ });
+ }
+
+ public void setNavigationEnabled(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final boolean boolValue = args.getBoolean(0);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ panorama.setUserNavigationEnabled(boolValue);
+ callbackContext.success();
+ }
+ });
+ }
+
+ public void setStreetNamesEnabled(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final boolean boolValue = args.getBoolean(0);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ panorama.setStreetNamesEnabled(boolValue);
+ callbackContext.success();
+ }
+ });
+ }
+ public void setVisible(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ final boolean boolValue = args.getBoolean(0);
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ panoramaView.setVisibility(boolValue ? View.VISIBLE : View.INVISIBLE);
+ callbackContext.success();
+ }
+ });
+ }
+
+
+ public void setPosition(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ try {
+ JSONObject cameraOpts = args.getJSONObject(0);
+ Object target = cameraOpts.get("target");
+
+ if (target instanceof JSONObject) {
+ JSONObject targetJson = (JSONObject)target;
+ LatLng position = new LatLng(targetJson.getDouble("lat"), targetJson.getDouble("lng"));
+
+ if (cameraOpts.has("source")) {
+ StreetViewSource source = "OUTDOOR".equals(cameraOpts.getString("source")) ?
+ StreetViewSource.OUTDOOR : StreetViewSource.DEFAULT;
+ if (cameraOpts.has("radius")) {
+ panorama.setPosition(position, cameraOpts.getInt("radius"), source);
+ } else {
+ panorama.setPosition(position, source);
+ }
+ } else {
+ if (cameraOpts.has("radius")) {
+ panorama.setPosition(position, cameraOpts.getInt("radius"));
+ } else {
+ panorama.setPosition(position);
+ }
+ }
+ } else if (target instanceof String) {
+ panorama.setPosition(cameraOpts.getString("target"));
+ }
+
+ callbackContext.success();
+ } catch (JSONException e) {
+ e.printStackTrace();
+ callbackContext.error("" + e.getMessage());
+ }
+ }
+ });
+ }
+
+ public void setPov(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ try {
+ final JSONObject cameraPosition = args.getJSONObject(0);
+
+ StreetViewPanoramaCamera currentCamera = panorama.getPanoramaCamera();
+ float bearing = cameraPosition.has("bearing") ? (float) cameraPosition.getDouble("bearing") : currentCamera.bearing;
+ float tilt = cameraPosition.has("tilt") ? (float) cameraPosition.getDouble("tilt") : currentCamera.tilt;
+ float zoom = cameraPosition.has("zoom") ? (float) cameraPosition.getDouble("zoom") : currentCamera.zoom;
+ long duration = cameraPosition.has("duration") ? (long) cameraPosition.getDouble("duration") : 1000;
+
+ StreetViewPanoramaCamera newCamera = new StreetViewPanoramaCamera.Builder()
+ .bearing(bearing)
+ .zoom(zoom)
+ .tilt(tilt)
+ .build();
+ panorama.animateTo(newCamera, duration);
+
+ callbackContext.success();
+ } catch (Exception e) {
+ e.printStackTrace();
+ callbackContext.error("" + e.getMessage());
+ }
+ }
+ });
+ }
+
+ public void remove(JSONArray args, final CallbackContext callbackContext) {
+ mapCtrl.mPluginLayout.removePluginOverlay(this.panoramaId);
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ panorama.setOnStreetViewPanoramaLongClickListener(null);
+ panorama.setOnStreetViewPanoramaClickListener(null);
+ panorama.setOnStreetViewPanoramaChangeListener(null);
+ panorama.setOnStreetViewPanoramaCameraChangeListener(null);
+
+ System.gc();
+ Runtime.getRuntime().gc();
+ if (callbackContext != null) {
+ callbackContext.success();
+ }
+ PluginStreetViewPanorama.this.onDestroy();
+ }
+ });
+ }
+
+ @Override
+ public void onStreetViewPanoramaCameraChange(StreetViewPanoramaCamera streetViewPanoramaCamera) {
+ try {
+ JSONObject camera = new JSONObject();
+ camera.put("bearing", streetViewPanoramaCamera.bearing);
+ camera.put("tilt", streetViewPanoramaCamera.tilt);
+ camera.put("zoom", streetViewPanoramaCamera.zoom);
+
+// StreetViewPanoramaOrientation svOrientation = streetViewPanoramaCamera.getOrientation();
+// JSONObject orientation = new JSONObject();
+// orientation.put("bearing", svOrientation.bearing);
+// orientation.put("tilt", svOrientation.tilt);
+// camera.put("orientation", orientation);
+
+ String jsonStr = camera.toString(0);
+ jsCallback(
+ String.format(
+ Locale.ENGLISH,
+ "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName:'%s', callback:'_onPanoramaCameraChange', args: [%s]});}",
+ panoramaId, panoramaId, "panorama_camera_change", jsonStr));
+ } catch (Exception e) {
+ // ignore
+ e.printStackTrace();
+ }
+
+ }
+
+ private void jsCallback(final String js) {
+ this.mActivity.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ webView.loadUrl(js);
+ }
+ });
+ }
+
+ @Override
+ public void onStreetViewPanoramaChange(StreetViewPanoramaLocation streetViewPanoramaLocation) {
+ try {
+ String jsonStr = "null";
+ if (streetViewPanoramaLocation != null) {
+ JSONObject location = new JSONObject();
+ location.put("panoId", streetViewPanoramaLocation.panoId);
+
+ JSONObject position = new JSONObject();
+ position.put("lat", streetViewPanoramaLocation.position.latitude);
+ position.put("lng", streetViewPanoramaLocation.position.longitude);
+ location.put("latLng", position);
+
+ JSONArray links = new JSONArray();
+ for (StreetViewPanoramaLink stLink : streetViewPanoramaLocation.links) {
+ JSONObject link = new JSONObject();
+ link.put("panoId", stLink.panoId);
+ link.put("bearing", stLink.bearing);
+ links.put(link);
+ }
+ location.put("links", links);
+
+ jsonStr = location.toString(0);
+ }
+ jsCallback(
+ String.format(
+ Locale.ENGLISH,
+ "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName:'%s', callback:'_onPanoramaLocationChange', args: [%s]});}",
+ panoramaId, panoramaId, "panorama_location_change", jsonStr));
+ } catch (Exception e) {
+ // ignore
+ e.printStackTrace();
+ }
+
+ }
+
+ @Override
+ public void onStreetViewPanoramaClick(StreetViewPanoramaOrientation streetViewPanoramaOrientation) {
+
+ try {
+ JSONObject clickInfo = new JSONObject();
+ JSONObject orientation = new JSONObject();
+ orientation.put("bearing", streetViewPanoramaOrientation.bearing);
+ orientation.put("tilt", streetViewPanoramaOrientation.tilt);
+ clickInfo.put("orientation", orientation);
+
+ Point point = panorama.orientationToPoint(streetViewPanoramaOrientation);
+ JSONArray pointArray = new JSONArray();
+ pointArray.put((int)((double)point.x / (double)density));
+ pointArray.put((int)((double)point.y / (double)density));
+ clickInfo.put("point", pointArray);
+
+ String jsonStr = clickInfo.toString(0);
+ jsCallback(
+ String.format(
+ Locale.ENGLISH,
+ "javascript:if('%s' in plugin.google.maps){plugin.google.maps['%s']({evtName:'%s', callback:'_onPanoramaEvent', args: [%s]});}",
+ panoramaId, panoramaId, "panorama_click", jsonStr));
+ } catch (Exception e) {
+ // ignore
+ e.printStackTrace();
+ }
+
+ }
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginTileOverlay.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginTileOverlay.java
new file mode 100644
index 0000000..05ca806
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginTileOverlay.java
@@ -0,0 +1,224 @@
+package plugin.google.maps;
+
+import android.content.res.AssetManager;
+import android.view.View;
+import android.webkit.WebView;
+
+import com.google.android.gms.maps.model.TileOverlay;
+import com.google.android.gms.maps.model.TileOverlayOptions;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaPreferences;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class PluginTileOverlay extends MyPlugin implements MyPluginInterface {
+
+
+ /**
+ * Create tile overlay
+ *
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void create(final JSONArray args,
+ final CallbackContext callbackContext) throws JSONException {
+
+
+ final JSONObject opts = args.getJSONObject(1);
+ final String id = args.getString(2);
+ final int tileSize = opts.getInt("tileSize");
+
+
+ final TileOverlayOptions options = new TileOverlayOptions();
+ if (opts.has("zIndex")) {
+ options.zIndex((float)opts.getDouble("zIndex"));
+ }
+ if (opts.has("visible")) {
+ options.visible(opts.getBoolean("visible"));
+ }
+ if (opts.has("opacity")) {
+ options.transparency((float)(1 - opts.getDouble("opacity")));
+ }
+
+ boolean isDebug = false;
+ if (opts.has("debug")) {
+ isDebug = opts.getBoolean("debug");
+ }
+ final boolean _isDebug = isDebug;
+
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ String userAgent = "";
+ if (opts.has("userAgent")) {
+ try {
+ userAgent = opts.getString("userAgent");
+ } catch (JSONException e) {
+ //e.printStackTrace();
+ }
+ }
+ if ("".equals(userAgent)) {
+ View browserView = webView.getView();
+ String browserViewName = browserView.getClass().getName();
+ if ("org.xwalk.core.XWalkView".equals(browserViewName) ||
+ "org.crosswalk.engine.XWalkCordovaView".equals(browserViewName)) {
+
+ CordovaPreferences preferences = webView.getPreferences();
+ // Set xwalk webview settings by Cordova preferences.
+ String xwalkUserAgent = preferences == null ? "" : preferences.getString("xwalkUserAgent", "");
+ if (!xwalkUserAgent.isEmpty()) {
+ userAgent = xwalkUserAgent;
+ }
+
+ String appendUserAgent = preferences.getString("AppendUserAgent", "");
+ if (!appendUserAgent.isEmpty()) {
+ userAgent = userAgent + " " + appendUserAgent;
+ }
+ } else {
+ userAgent = ((WebView) webView.getEngine().getView()).getSettings().getUserAgentString();
+ }
+ }
+
+ String currentPageUrl = webView.getUrl();
+
+ AssetManager assetManager = cordova.getActivity().getAssets();
+ final PluginTileProvider tileProvider = new PluginTileProvider(pluginMap.getOverlayId(), id, webView, assetManager, currentPageUrl, userAgent, tileSize, _isDebug);
+ tileProvider.setOnCacheClear(new PluginTileProvider.OnCacheClear() {
+ @Override
+ public void onCacheClear(int hashCode) {
+ TileOverlay tileOverlay = (TileOverlay)PluginTileOverlay.this.getTileOverlay(hashCode+"");
+ if (tileOverlay != null) {
+ tileOverlay.clearTileCache();
+ System.gc();
+ }
+ }
+ });
+ options.tileProvider(tileProvider);
+
+
+ TileOverlay tileOverlay = map.addTileOverlay(options);
+ //String id = tileOverlay.getId();
+
+ pluginMap.objects.put("tileoverlay_" + id, tileOverlay);
+ pluginMap.objects.put("tileprovider_" + id, tileProvider);
+
+ try {
+ JSONObject result = new JSONObject();
+ result.put("hashCode", id);
+ result.put("__pgmId", "tileoverlay_" + id);
+ callbackContext.success(result);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ callbackContext.error("" + e.getMessage());
+ }
+ }
+ });
+ }
+
+ @SuppressWarnings("unused")
+ public void onGetTileUrlFromJS(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ String urlKey = args.getString(1);
+ String tileUrl = args.getString(2);
+ String pluginId = "tileprovider_" + id;
+ if (pluginMap.objects.containsKey(pluginId)) {
+ ((PluginTileProvider)(this.pluginMap.objects.get(pluginId))).onGetTileUrlFromJS(urlKey, tileUrl);
+ }
+ callbackContext.success();
+ }
+
+ /**
+ * set z-index
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ @SuppressWarnings("unused")
+ public void setZIndex(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ float zIndex = (float) args.getDouble(1);
+ this.setFloat("setZIndex", id, zIndex, callbackContext);
+ }
+
+ /**
+ * Set visibility for the object
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setVisible(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ boolean visible = args.getBoolean(1);
+ String id = args.getString(0);
+ this.setBoolean("setVisible", id, visible, callbackContext);
+ }
+ /**
+ * Remove this tile layer
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void remove(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ String id = args.getString(0);
+ TileOverlay tileOverlay = (TileOverlay)pluginMap.objects.get(id);
+ if (tileOverlay == null) {
+ callbackContext.success();
+ return;
+ }
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+
+ try {
+ String id = args.getString(0);
+ TileOverlay tileOverlay = (TileOverlay)pluginMap.objects.remove(id);
+ if (tileOverlay != null) {
+ tileOverlay.clearTileCache();
+ tileOverlay.remove();
+ tileOverlay = null;
+ }
+ id = id.replace("tileoverlay_", "tileprovider_");
+
+ if (pluginMap.objects.containsKey(id)) {
+ ((PluginTileProvider)(pluginMap.objects.get(id))).remove();
+ }
+ //pluginMap.objects.put(id, null);
+ PluginTileProvider provider = (PluginTileProvider) pluginMap.objects.remove(id);
+ provider = null;
+ callbackContext.success();
+ } catch (JSONException e) {
+ e.printStackTrace();
+ callbackContext.error("" + e.getMessage());
+
+ }
+ }
+ });
+ }
+
+ /**
+ * Set fadeIn for the object
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setFadeIn(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ boolean visible = args.getBoolean(1);
+ String id = args.getString(0);
+ this.setBoolean("setFadeIn", id, visible, callbackContext);
+ }
+ /**
+ * Set opacity for the tile layer
+ * @param args
+ * @param callbackContext
+ * @throws JSONException
+ */
+ public void setOpacity(JSONArray args, CallbackContext callbackContext) throws JSONException {
+ double opacity = 1 - args.getDouble(1);
+ String id = args.getString(0);
+ this.setFloat("setTransparency", id, (float)opacity, callbackContext);
+ }
+
+}
diff --git a/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginTileProvider.java b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginTileProvider.java
new file mode 100644
index 0000000..1bbb3b8
--- /dev/null
+++ b/node_modules/cordova-plugin-googlemaps/src/android/plugin/google/maps/PluginTileProvider.java
@@ -0,0 +1,440 @@
+package plugin.google.maps;
+
+import android.annotation.SuppressLint;
+import android.content.res.AssetManager;
+import android.graphics.Bitmap;
+import android.graphics.Bitmap.Config;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.os.Handler;
+import android.os.Looper;
+import android.text.Layout;
+import android.text.StaticLayout;
+import android.text.TextPaint;
+import android.util.Log;
+
+import com.google.android.gms.maps.model.Tile;
+import com.google.android.gms.maps.model.TileProvider;
+
+import org.apache.cordova.CordovaWebView;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Locale;
+
+public class PluginTileProvider implements TileProvider {
+ private final String TAG = "TileProvider";
+ private int tileSize = 512;
+ private Paint tilePaint = new Paint(Paint.FILTER_BITMAP_FLAG);
+ private Paint debugPaint = null;
+ private TextPaint debugTextPaint = null;
+ private String userAgent = null;
+ private static BitmapCache tileCache = null;
+ private OnCacheClear listener = null;
+ private String webPageUrl = null;
+ private AssetManager assetManager;
+ private CordovaWebView webView;
+ private String mapId, pluginId;
+ private final HashMap
+
+