@capgo/capacitor-nativegeocoder 8.0.32

package/android/src/main/java/ee/forgr/capacitor_nativegeocoder/NativeGeocoder.java

@@ -0,0 +1,229 @@
+package ee.forgr.capacitor_nativegeocoder;
+
+import android.content.Context;
+import android.location.Address;
+import android.location.Geocoder;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.PluginCall;
+import java.util.List;
+import java.util.Locale;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+class NativeGeocoderOptions {
+
+    boolean useLocale = true;
+    String defaultLocale = null;
+    int maxResults = 1;
+}
+
+public class NativeGeocoder {
+
+    private Geocoder geocoder;
+    public Context context;
+
+    /**
+     * Reverse geocode a given latitude and longitude to find location address
+     * @param latitude double
+     * @param longitude double
+     * @param call PluginCall
+     */
+    public void reverseGeocode(double latitude, double longitude, PluginCall call) {
+        if (latitude == 0 || longitude == 0) {
+            call.reject("Expected two non-empty double arguments.");
+            return;
+        }
+
+        if (!Geocoder.isPresent()) {
+            call.reject("Geocoder is not present on this device/emulator.");
+            return;
+        }
+
+        NativeGeocoderOptions geocoderOptions = getNativeGeocoderOptions(call);
+        geocoder = createGeocoderWithOptions(geocoderOptions);
+
+        try {
+            List<Address> geoResults = geocoder.getFromLocation(latitude, longitude, geocoderOptions.maxResults);
+            if (geoResults.size() > 0) {
+                int maxResultObjects = geoResults.size() >= geocoderOptions.maxResults ? geoResults.size() : geoResults.size();
+                JSONArray resultObj = new JSONArray();
+
+                for (int i = 0; i < maxResultObjects; i++) {
+                    Address address = geoResults.get(i);
+
+                    // https://developer.android.com/reference/android/location/Address.html
+                    JSONObject placemark = new JSONObject();
+                    placemark.put("latitude", !String.valueOf(address.getLatitude()).isEmpty() ? address.getLatitude() : 0);
+                    placemark.put("longitude", !String.valueOf(address.getLongitude()).isEmpty() ? address.getLongitude() : 0);
+                    placemark.put("countryCode", address.getCountryCode() != null ? address.getCountryCode() : "");
+                    placemark.put("countryName", address.getCountryName() != null ? address.getCountryName() : "");
+                    placemark.put("postalCode", address.getPostalCode() != null ? address.getPostalCode() : "");
+                    placemark.put("administrativeArea", address.getAdminArea() != null ? address.getAdminArea() : "");
+                    placemark.put("subAdministrativeArea", address.getSubAdminArea() != null ? address.getSubAdminArea() : "");
+                    placemark.put("locality", address.getLocality() != null ? address.getLocality() : "");
+                    placemark.put("subLocality", address.getSubLocality() != null ? address.getSubLocality() : "");
+                    placemark.put("thoroughfare", address.getThoroughfare() != null ? address.getThoroughfare() : "");
+                    placemark.put("subThoroughfare", address.getSubThoroughfare() != null ? address.getSubThoroughfare() : "");
+                    placemark.put(
+                        "areasOfInterest",
+                        address.getFeatureName() != null ? new JSONArray(new String[] { address.getFeatureName() }) : new JSONArray()
+                    );
+
+                    resultObj.put(placemark);
+                }
+                JSObject ret = new JSObject();
+                ret.put("addresses", resultObj);
+                call.resolve(ret);
+            } else {
+                call.reject("Cannot get an address.");
+            }
+        } catch (Exception e) {
+            String errorMsg = e.getMessage();
+            if (e.getMessage().equals("grpc failed") && !isNetworkAvailable()) {
+                errorMsg = "No Internet Access";
+            }
+            call.reject("Geocoder:getFromLocationName Error: " + errorMsg);
+        }
+    }
+
+    /**
+     * Forward geocode a given address to find coordinates
+     * @param addressString String
+     * @param call PluginCall
+     */
+    public void forwardGeocode(String addressString, PluginCall call) {
+        if (addressString == null || addressString.length() == 0) {
+            call.reject("Expected a non-empty string argument.");
+            return;
+        }
+
+        if (!Geocoder.isPresent()) {
+            call.reject("Geocoder is not present on this device/emulator.");
+            return;
+        }
+
+        NativeGeocoderOptions geocoderOptions = getNativeGeocoderOptions(call);
+        geocoder = createGeocoderWithOptions(geocoderOptions);
+
+        try {
+            List<Address> geoResults = geocoder.getFromLocationName(addressString, geocoderOptions.maxResults);
+
+            if (geoResults.size() > 0) {
+                int maxResultObjects = geoResults.size() >= geocoderOptions.maxResults ? geoResults.size() : geoResults.size();
+                JSONArray resultObj = new JSONArray();
+
+                for (int i = 0; i < maxResultObjects; i++) {
+                    Address address = geoResults.get(i);
+
+                    try {
+                        String latitude = String.valueOf(address.getLatitude());
+                        String longitude = String.valueOf(address.getLongitude());
+
+                        if (!latitude.isEmpty() && !longitude.isEmpty()) {
+                            // https://developer.android.com/reference/android/location/Address.html
+                            JSObject placemark = new JSObject();
+                            placemark.put("latitude", address.getLatitude());
+                            placemark.put("longitude", address.getLongitude());
+                            placemark.put("countryCode", address.getCountryCode() != null ? address.getCountryCode() : "");
+                            placemark.put("countryName", address.getCountryName() != null ? address.getCountryName() : "");
+                            placemark.put("postalCode", address.getPostalCode() != null ? address.getPostalCode() : "");
+                            placemark.put("administrativeArea", address.getAdminArea() != null ? address.getAdminArea() : "");
+                            placemark.put("subAdministrativeArea", address.getSubAdminArea() != null ? address.getSubAdminArea() : "");
+                            placemark.put("locality", address.getLocality() != null ? address.getLocality() : "");
+                            placemark.put("subLocality", address.getSubLocality() != null ? address.getSubLocality() : "");
+                            placemark.put("thoroughfare", address.getThoroughfare() != null ? address.getThoroughfare() : "");
+                            placemark.put("subThoroughfare", address.getSubThoroughfare() != null ? address.getSubThoroughfare() : "");
+                            placemark.put(
+                                "areasOfInterest",
+                                address.getFeatureName() != null
+                                    ? new JSONArray(new String[] { address.getFeatureName() })
+                                    : new JSONArray()
+                            );
+
+                            resultObj.put(placemark);
+                        }
+                    } catch (RuntimeException e) {
+                        e.printStackTrace();
+                    }
+                }
+
+                if (resultObj.length() == 0) {
+                    call.reject("Cannot get latitude and/or longitude.");
+                } else {
+                    JSObject ret = new JSObject();
+                    ret.put("addresses", resultObj);
+                    call.resolve(ret);
+                }
+            } else {
+                call.reject("Cannot find a location.");
+            }
+        } catch (Exception e) {
+            String errorMsg = e.getMessage();
+            if (e.getMessage().equals("grpc failed") && !isNetworkAvailable()) {
+                errorMsg = "No Internet Access";
+            }
+            call.reject("Geocoder:getFromLocationName Error: " + errorMsg);
+        }
+    }
+
+    /**
+     * Get network connection
+     * @return boolean
+     */
+    private boolean isNetworkAvailable() {
+        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        NetworkInfo activeNetworkInfo = null;
+        if (connectivityManager != null) {
+            activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
+        }
+        return activeNetworkInfo != null && activeNetworkInfo.isConnected();
+    }
+
+    /**
+     * Get a valid NativeGeocoderOptions object
+     * @param options JSONObject
+     * @return NativeGeocoderOptions
+     */
+    private NativeGeocoderOptions getNativeGeocoderOptions(PluginCall options) {
+        NativeGeocoderOptions geocoderOptions = new NativeGeocoderOptions();
+
+        if (options != null) {
+            geocoderOptions.useLocale = options.getBoolean("useLocale", false);
+            geocoderOptions.defaultLocale = options.getString("defaultLocale", null);
+            geocoderOptions.maxResults = options.getInt("maxResults", 1);
+            if (geocoderOptions.maxResults > 0) {
+                int MAX_RESULTS_COUNT = 5;
+                geocoderOptions.maxResults = Math.min(geocoderOptions.maxResults, MAX_RESULTS_COUNT);
+            } else {
+                geocoderOptions.maxResults = 1;
+            }
+        } else {
+            geocoderOptions.useLocale = true;
+            geocoderOptions.defaultLocale = null;
+            geocoderOptions.maxResults = 1;
+        }
+
+        return geocoderOptions;
+    }
+
+    /**
+     * Create a Geocoder with NativeGeocoderOptions
+     * @param geocoderOptions NativeGeocoderOptions
+     * @return Geocoder
+     */
+    private Geocoder createGeocoderWithOptions(NativeGeocoderOptions geocoderOptions) {
+        if (geocoderOptions.defaultLocale != null && !geocoderOptions.defaultLocale.isEmpty()) {
+            Locale locale = Locale.forLanguageTag(geocoderOptions.defaultLocale);
+            geocoder = new Geocoder(context.getApplicationContext(), locale);
+        } else {
+            if (geocoderOptions.useLocale) {
+                geocoder = new Geocoder(context.getApplicationContext(), Locale.getDefault());
+            } else {
+                geocoder = new Geocoder(context.getApplicationContext(), Locale.ENGLISH);
+            }
+        }
+        return geocoder;
+    }
+}

package/android/src/main/java/ee/forgr/capacitor_nativegeocoder/NativeGeocoderPlugin.java

@@ -0,0 +1,53 @@
+package ee.forgr.capacitor_nativegeocoder;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+@CapacitorPlugin(name = "NativeGeocoder")
+public class NativeGeocoderPlugin extends Plugin {
+
+    private final String pluginVersion = "8.0.32";
+
+    private NativeGeocoder implementation = new NativeGeocoder();
+
+    @Override
+    public void load() {
+        super.load();
+        implementation.context = this.getContext();
+    }
+
+    @PluginMethod
+    public void reverseGeocode(PluginCall call) {
+        Double latitude = call.getDouble("latitude");
+        Double longitude = call.getDouble("longitude");
+        if (latitude == null || longitude == null) {
+            call.reject("Missing latitude or longitude");
+            return;
+        }
+        implementation.reverseGeocode(latitude, longitude, call);
+    }
+
+    @PluginMethod
+    public void forwardGeocode(PluginCall call) {
+        String addressString = call.getString("addressString");
+        if (addressString == null) {
+            call.reject("Missing addressString");
+            return;
+        }
+        implementation.forwardGeocode(addressString, call);
+    }
+
+    @PluginMethod
+    public void getPluginVersion(final PluginCall call) {
+        try {
+            final JSObject ret = new JSObject();
+            ret.put("version", this.pluginVersion);
+            call.resolve(ret);
+        } catch (final Exception e) {
+            call.reject("Could not get plugin version", e);
+        }
+    }
+}

package/dist/docs.json

@@ -0,0 +1,298 @@
+{
+  "api": {
+    "name": "NativeGeocoderPlugin",
+    "slug": "nativegeocoderplugin",
+    "docs": "",
+    "tags": [],
+    "methods": [
+      {
+        "name": "reverseGeocode",
+        "signature": "(options: ReverseOptions) => Promise<{ addresses: Address[]; }>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "ReverseOptions"
+          }
+        ],
+        "returns": "Promise<{ addresses: Address[]; }>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "id The bundle id to delete (note, this is the bundle id, NOT the version name)"
+          },
+          {
+            "name": "returns",
+            "text": "an Promise with the list of addresses according to maxResults"
+          },
+          {
+            "name": "throws",
+            "text": "An error if the something went wrong"
+          },
+          {
+            "name": "since",
+            "text": "0.0.1"
+          }
+        ],
+        "docs": "Convert latitude and longitude to an address",
+        "complexTypes": [
+          "Address",
+          "ReverseOptions"
+        ],
+        "slug": "reversegeocode"
+      },
+      {
+        "name": "forwardGeocode",
+        "signature": "(options: ForwardOptions) => Promise<{ addresses: Address[]; }>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "ForwardOptions"
+          }
+        ],
+        "returns": "Promise<{ addresses: Address[]; }>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "an Promise with the list of addresses according to maxResults"
+          },
+          {
+            "name": "throws",
+            "text": "An error if the something went wrong"
+          },
+          {
+            "name": "since",
+            "text": "0.0.1"
+          }
+        ],
+        "docs": "Convert an address to latitude and longitude",
+        "complexTypes": [
+          "Address",
+          "ForwardOptions"
+        ],
+        "slug": "forwardgeocode"
+      },
+      {
+        "name": "getPluginVersion",
+        "signature": "() => Promise<{ version: string; }>",
+        "parameters": [],
+        "returns": "Promise<{ version: string; }>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "an Promise with version for this device"
+          },
+          {
+            "name": "throws",
+            "text": "An error if the something went wrong"
+          }
+        ],
+        "docs": "Get the native Capacitor plugin version",
+        "complexTypes": [],
+        "slug": "getpluginversion"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "Address",
+      "slug": "address",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "latitude",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "number"
+        },
+        {
+          "name": "longitude",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "number"
+        },
+        {
+          "name": "countryCode",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "countryName",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "postalCode",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "administrativeArea",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "subAdministrativeArea",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "locality",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "subLocality",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "thoroughfare",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "subThoroughfare",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "areasOfInterest",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string[]"
+        }
+      ]
+    },
+    {
+      "name": "ReverseOptions",
+      "slug": "reverseoptions",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "latitude",
+          "tags": [],
+          "docs": "latitude is a number representing the latitude of the location.",
+          "complexTypes": [],
+          "type": "number"
+        },
+        {
+          "name": "longitude",
+          "tags": [],
+          "docs": "longitude is a number representing the longitude of the location.",
+          "complexTypes": [],
+          "type": "number"
+        },
+        {
+          "name": "useLocale",
+          "tags": [],
+          "docs": "Localise the results to the given locale.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
+        },
+        {
+          "name": "defaultLocale",
+          "tags": [],
+          "docs": "locale is a string in the format of language_country, for example en_US.",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "maxResults",
+          "tags": [],
+          "docs": "Max number of results to return.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "apiKey",
+          "tags": [],
+          "docs": "Only used for web platform to use google api",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "resultType",
+          "tags": [],
+          "docs": "Only used for web platform to use google api",
+          "complexTypes": [],
+          "type": "string | undefined"
+        }
+      ]
+    },
+    {
+      "name": "ForwardOptions",
+      "slug": "forwardoptions",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "addressString",
+          "tags": [],
+          "docs": "address is a string of the address to be geocoded.",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "useLocale",
+          "tags": [],
+          "docs": "Localise the results to the given locale.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
+        },
+        {
+          "name": "defaultLocale",
+          "tags": [],
+          "docs": "locale is a string in the format of language_country, for example en_US.",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "maxResults",
+          "tags": [],
+          "docs": "Max number of results to return.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "apiKey",
+          "tags": [],
+          "docs": "Only used for web platform to use google api",
+          "complexTypes": [],
+          "type": "string | undefined"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [],
+  "pluginConfigs": []
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,98 @@
+export interface Address {
+    latitude: number;
+    longitude: number;
+    countryCode: string;
+    countryName: string;
+    postalCode: string;
+    administrativeArea: string;
+    subAdministrativeArea: string;
+    locality: string;
+    subLocality: string;
+    thoroughfare: string;
+    subThoroughfare: string;
+    areasOfInterest: string[];
+}
+export interface ForwardOptions {
+    /**
+     * address is a string of the address to be geocoded.
+     */
+    addressString: string;
+    /**
+     * Localise the results to the given locale.
+     */
+    useLocale?: boolean;
+    /**
+     * locale is a string in the format of language_country, for example en_US.
+     */
+    defaultLocale?: string;
+    /**
+     * Max number of results to return.
+     */
+    maxResults?: number;
+    /**
+     * Only used for web platform to use google api
+     */
+    apiKey?: string;
+}
+export interface ReverseOptions {
+    /**
+     * latitude is a number representing the latitude of the location.
+     */
+    latitude: number;
+    /**
+     * longitude is a number representing the longitude of the location.
+     */
+    longitude: number;
+    /**
+     * Localise the results to the given locale.
+     */
+    useLocale?: boolean;
+    /**
+     * locale is a string in the format of language_country, for example en_US.
+     */
+    defaultLocale?: string;
+    /**
+     * Max number of results to return.
+     */
+    maxResults?: number;
+    /**
+     * Only used for web platform to use google api
+     */
+    apiKey?: string;
+    /**
+     * Only used for web platform to use google api
+     */
+    resultType?: string;
+}
+export interface NativeGeocoderPlugin {
+    /**
+     * Convert latitude and longitude to an address
+     *
+     * @param id The bundle id to delete (note, this is the bundle id, NOT the version name)
+     * @returns {Promise<{addresses: Address[]}>} an Promise with the list of addresses according to maxResults
+     * @throws An error if the something went wrong
+     * @since 0.0.1
+     */
+    reverseGeocode(options: ReverseOptions): Promise<{
+        addresses: Address[];
+    }>;
+    /**
+     * Convert an address to latitude and longitude
+     *
+     * @returns {Promise<{addresses: Address[]}>} an Promise with the list of addresses according to maxResults
+     * @throws An error if the something went wrong
+     * @since 0.0.1
+     */
+    forwardGeocode(options: ForwardOptions): Promise<{
+        addresses: Address[];
+    }>;
+    /**
+     * Get the native Capacitor plugin version
+     *
+     * @returns {Promise<{ id: string }>} an Promise with version for this device
+     * @throws An error if the something went wrong
+     */
+    getPluginVersion(): Promise<{
+        version: string;
+    }>;
+}

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["export interface Address {\n  latitude: number;\n  longitude: number;\n  countryCode: string;\n  countryName: string;\n  postalCode: string;\n  administrativeArea: string;\n  subAdministrativeArea: string;\n  locality: string;\n  subLocality: string;\n  thoroughfare: string;\n  subThoroughfare: string;\n  areasOfInterest: string[];\n}\n\nexport interface ForwardOptions {\n  /**\n   * address is a string of the address to be geocoded.\n   */\n  addressString: string;\n  /**\n   * Localise the results to the given locale.\n   */\n  useLocale?: boolean;\n  /**\n   * locale is a string in the format of language_country, for example en_US.\n   */\n  defaultLocale?: string;\n  /**\n   * Max number of results to return.\n   */\n  maxResults?: number;\n  /**\n   * Only used for web platform to use google api\n   */\n  apiKey?: string;\n}\nexport interface ReverseOptions {\n  /**\n   * latitude is a number representing the latitude of the location.\n   */\n  latitude: number;\n  /**\n   * longitude is a number representing the longitude of the location.\n   */\n  longitude: number;\n  /**\n   * Localise the results to the given locale.\n   */\n  useLocale?: boolean;\n  /**\n   * locale is a string in the format of language_country, for example en_US.\n   */\n  defaultLocale?: string;\n  /**\n   * Max number of results to return.\n   */\n  maxResults?: number;\n  /**\n   * Only used for web platform to use google api\n   */\n  apiKey?: string;\n  /**\n   * Only used for web platform to use google api\n   */\n  resultType?: string;\n}\nexport interface NativeGeocoderPlugin {\n  /**\n   * Convert latitude and longitude to an address\n   *\n   * @param id The bundle id to delete (note, this is the bundle id, NOT the version name)\n   * @returns {Promise<{addresses: Address[]}>} an Promise with the list of addresses according to maxResults\n   * @throws An error if the something went wrong\n   * @since 0.0.1\n   */\n  reverseGeocode(options: ReverseOptions): Promise<{ addresses: Address[] }>;\n  /**\n   * Convert an address to latitude and longitude\n   *\n   * @returns {Promise<{addresses: Address[]}>} an Promise with the list of addresses according to maxResults\n   * @throws An error if the something went wrong\n   * @since 0.0.1\n   */\n  forwardGeocode(options: ForwardOptions): Promise<{ addresses: Address[] }>;\n\n  /**\n   * Get the native Capacitor plugin version\n   *\n   * @returns {Promise<{ id: string }>} an Promise with version for this device\n   * @throws An error if the something went wrong\n   */\n  getPluginVersion(): Promise<{ version: string }>;\n}\n"]}