@capgo/nativegeocoder 0.0.1

package/CapgoNativegeocoder.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapgoNativegeocoder'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '12.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/README.md

@@ -0,0 +1,98 @@
+# @capgo/nativegeocoder
+
+Capacitor plugin for native forward and reverse geocoding
+
+## Install
+
+```bash
+npm install @capgo/nativegeocoder
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`reverseGeocode(...)`](#reversegeocode)
+* [`forwardGeocode(...)`](#forwardgeocode)
+* [Interfaces](#interfaces)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### reverseGeocode(...)
+
+```typescript
+reverseGeocode(options: reverseOptions) => Promise<{ addresses: Adress[]; }>
+```
+
+| Param         | Type                                                      |
+| ------------- | --------------------------------------------------------- |
+| **`options`** | <code><a href="#reverseoptions">reverseOptions</a></code> |
+
+**Returns:** <code>Promise&lt;{ addresses: Adress[]; }&gt;</code>
+
+--------------------
+
+
+### forwardGeocode(...)
+
+```typescript
+forwardGeocode(options: ForwardOptions) => Promise<{ addresses: Adress[]; }>
+```
+
+| Param         | Type                                                      |
+| ------------- | --------------------------------------------------------- |
+| **`options`** | <code><a href="#forwardoptions">ForwardOptions</a></code> |
+
+**Returns:** <code>Promise&lt;{ addresses: Adress[]; }&gt;</code>
+
+--------------------
+
+
+### Interfaces
+
+
+#### Adress
+
+| Prop                        | Type                  |
+| --------------------------- | --------------------- |
+| **`latitude`**              | <code>string</code>   |
+| **`longitude`**             | <code>string</code>   |
+| **`countryCode`**           | <code>string</code>   |
+| **`postalCode`**            | <code>string</code>   |
+| **`administrativeArea`**    | <code>string</code>   |
+| **`subAdministrativeArea`** | <code>string</code>   |
+| **`locality`**              | <code>string</code>   |
+| **`subLocality`**           | <code>string</code>   |
+| **`thoroughfare`**          | <code>string</code>   |
+| **`subThoroughfare`**       | <code>string</code>   |
+| **`areasOfInterest`**       | <code>string[]</code> |
+| **`formatted_address`**     | <code>string</code>   |
+
+
+#### reverseOptions
+
+| Prop                | Type                 |
+| ------------------- | -------------------- |
+| **`latitude`**      | <code>number</code>  |
+| **`longitude`**     | <code>number</code>  |
+| **`useLocale`**     | <code>boolean</code> |
+| **`defaultLocale`** | <code>string</code>  |
+| **`maxResults`**    | <code>number</code>  |
+| **`apiKey`**        | <code>string</code>  |
+
+
+#### ForwardOptions
+
+| Prop                | Type                 |
+| ------------------- | -------------------- |
+| **`addressString`** | <code>string</code>  |
+| **`useLocale`**     | <code>boolean</code> |
+| **`defaultLocale`** | <code>string</code>  |
+| **`maxResults`**    | <code>number</code>  |
+| **`apiKey`**        | <code>string</code>  |
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,58 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.1'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.2.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.2'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.3.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:4.2.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 30
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 21
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 30
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    jcenter()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="ee.forgr.capacitor_nativegeocoder">
+</manifest>

package/android/src/main/java/ee/forgr/plugin/nativegeocoder/NativeGeocoder.java

@@ -0,0 +1,239 @@
+package ee.forgr.capacitor_nativegeocoder;
+
+import android.util.Log;
+
+public class NativeGeocoder {
+
+    public Context context;
+    /**
+     * Reverse geocode a given latitude and longitude to find location address
+     * @param latitude double
+     * @param longitude double
+     * @param call PluginCall
+     */
+    private 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(options);
+        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() : "");
+                    placemark.put("longitude", !String.valueOf(address.getLongitude()).isEmpty() ? 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);
+                }
+                call.resolve(resultObj);
+            } 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 options JSONObject
+     * @param call PluginCall
+     */
+    private 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
+                            JSONObject placemark = new JSONObject();
+                            placemark.put("latitude", latitude);
+                            placemark.put("longitude", longitude);
+                            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 {
+                    call.resolve(resultObj);
+                }
+
+            } 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(JSONObject options) {
+        NativeGeocoderOptions geocoderOptions = new NativeGeocoderOptions();
+
+        if (options != null) {
+            try {
+                geocoderOptions.useLocale = !options.has("useLocale") || options.getBoolean("useLocale");
+            } catch (JSONException e) {
+                geocoderOptions.useLocale = true;
+            }
+
+            if (options.has("defaultLocale")) {
+                try {
+                    geocoderOptions.defaultLocale = options.getString("defaultLocale");
+                } catch (JSONException e) {
+                    geocoderOptions.defaultLocale = null;
+                }
+            } else {
+                geocoderOptions.defaultLocale = null;
+            }
+            if (options.has("maxResults")) {
+                try {
+                    geocoderOptions.maxResults = options.getInt("maxResults");
+                } catch (JSONException e) {
+                    geocoderOptions.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.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;
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                locale = Locale.forLanguageTag(geocoderOptions.defaultLocale);
+            } else {
+                String[] parts = geocoderOptions.defaultLocale.split("[-_]", -1);
+                if (parts.length == 1)
+                    locale = new Locale(parts[0]);
+                else if (parts.length == 2 || (parts.length == 3 && parts[2].startsWith("#")))
+                    locale = new Locale(parts[0], parts[1]);
+                else
+                    locale = new Locale(parts[0], parts[1], parts[2]);
+            }
+            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/plugin/nativegeocoder/NativeGeocoderPlugin.java

@@ -0,0 +1,39 @@
+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 NativeGeocoder implementation = new NativeGeocoder();
+
+    @Override
+    public void load() {
+        super.load();
+        implementation.context = this.getContext()
+    }
+
+    @PluginMethod
+    public void reverseGeocode(PluginCall call) {
+        String addressString = call.getString("addressString");
+        if (addressString == null) {
+            call.reject("Missing addressString");
+            return;
+        }
+        implementation.reverseGeocode(addressString, call)
+    }
+    @PluginMethod
+    public void forwardGeocode(PluginCall call) {
+        Number latitude = call.getNumber("latitude");
+        Number longitude = call.getNumber("longitude");
+        if (latitude == null || longitude == null) {
+            call.reject("Missing latitude or longitude");
+            return;
+        }
+        implementation.forwardGeocode(latitude, longitude, call)
+    }
+}