feat(google-maps): Add getMapType method

google-maps/README.md

@@ -278,6 +278,7 @@ export default MyMap;
 * [`removeMarkers(...)`](#removemarkers)
 * [`destroy()`](#destroy)
 * [`setCamera(...)`](#setcamera)
+* [`getMapType()`](#getmaptype)
 * [`setMapType(...)`](#setmaptype)
 * [`enableIndoorMaps(...)`](#enableindoormaps)
 * [`enableTrafficLayer(...)`](#enabletrafficlayer)
@@ -422,6 +423,19 @@ setCamera(config: CameraConfig) => Promise<void>
 --------------------
 
 
+### getMapType()
+
+```typescript
+getMapType() => Promise<MapType>
+```
+
+Get current map type
+
+**Returns:** <code>Promise&lt;<a href="#maptype">MapType</a>&gt;</code>
+
+--------------------
+
+
 ### setMapType(...)
 
 ```typescript

google-maps/android/src/main/java/com/capacitorjs/plugins/googlemaps/CapacitorGoogleMap.kt

@@ -416,6 +416,27 @@ class CapacitorGoogleMap(
         }
     }
 
+    fun getMapType(callback: (type: String, error: GoogleMapsError?) -> Unit) {
+        try {
+            googleMap ?: throw GoogleMapNotAvailable()
+            CoroutineScope(Dispatchers.Main).launch {
+                val mapType: String = when (googleMap?.mapType) {
+                    MAP_TYPE_NORMAL -> "Normal"
+                    MAP_TYPE_HYBRID -> "Hybrid"
+                    MAP_TYPE_SATELLITE -> "Satellite"
+                    MAP_TYPE_TERRAIN -> "Terrain"
+                    MAP_TYPE_NONE -> "None"
+                    else -> {
+                        "Normal"
+                    }
+                }
+                callback(mapType, null);
+            }
+        }  catch (e: GoogleMapsError) {
+            callback("", e)
+        }
+    }
+
     fun setMapType(mapType: String, callback: (error: GoogleMapsError?) -> Unit) {
         try {
             googleMap ?: throw GoogleMapNotAvailable()

google-maps/android/src/main/java/com/capacitorjs/plugins/googlemaps/CapacitorGoogleMapsPlugin.kt

@@ -375,6 +375,31 @@ class CapacitorGoogleMapsPlugin : Plugin() {
         }
     }
 
+    @PluginMethod
+    fun getMapType(call: PluginCall) {
+        try {
+            val id = call.getString("id")
+            id ?: throw InvalidMapIdError()
+
+            val map = maps[id]
+            map ?: throw MapNotFoundError()
+
+            map.getMapType() { type, err ->
+
+                if (err != null) {
+                    throw err
+                }
+                val data = JSObject()
+                data.put("type", type)
+                call.resolve(data)
+            }
+        } catch (e: GoogleMapsError) {
+            handleError(call, e)
+        } catch (e: Exception) {
+            handleError(call, e)
+        }
+    }
+
     @PluginMethod
     fun setMapType(call: PluginCall) {
         try {

google-maps/ios/Plugin/CapacitorGoogleMapsPlugin.m

@@ -13,6 +13,7 @@
    CAP_PLUGIN_METHOD(disableClustering, CAPPluginReturnPromise);
    CAP_PLUGIN_METHOD(destroy, CAPPluginReturnPromise);
    CAP_PLUGIN_METHOD(setCamera, CAPPluginReturnPromise);
+   CAP_PLUGIN_METHOD(getMapType, CAPPluginReturnPromise);
    CAP_PLUGIN_METHOD(setMapType, CAPPluginReturnPromise);
    CAP_PLUGIN_METHOD(enableIndoorMaps, CAPPluginReturnPromise);
    CAP_PLUGIN_METHOD(enableTrafficLayer, CAPPluginReturnPromise);

google-maps/ios/Plugin/CapacitorGoogleMapsPlugin.swift

@@ -21,6 +21,22 @@ extension GMSMapViewType {
             return .normal
         }
     }
+    static func toString(mapType: GMSMapViewType) -> String {
+        switch mapType {
+        case .normal:
+            return "Normal"
+        case .hybrid:
+            return "Hybrid"
+        case .satellite:
+            return "Satellite"
+        case .terrain:
+            return "Terrain"
+        case .none:
+            return "None"
+        default:
+            return "Normal"
+        }
+    }
 }
 
 extension CGRect {
@@ -275,6 +291,26 @@ public class CapacitorGoogleMapsPlugin: CAPPlugin, GMSMapViewDelegate {
         }
     }
 
+    @objc func getMapType(_ call: CAPPluginCall) {
+        do {
+            guard let id = call.getString("id") else {
+                throw GoogleMapErrors.invalidMapId
+            }
+
+            guard let map = self.maps[id] else {
+                throw GoogleMapErrors.mapNotFound
+            }
+
+            let mapType = GMSMapViewType.toString(mapType: map.getMapType())
+
+            call.resolve([
+                "type": mapType
+            ])
+        } catch {
+            handleError(call, error: error)
+        }
+    }
+
     @objc func setMapType(_ call: CAPPluginCall) {
         do {
             guard let id = call.getString("id") else {

google-maps/ios/Plugin/Map.swift

@@ -303,6 +303,10 @@ public class Map {
 
     }
 
+    func getMapType() -> GMSMapViewType {
+        return self.mapViewController.GMapView.mapType
+    }
+
     func setMapType(mapType: GMSMapViewType) throws {
         DispatchQueue.main.sync {
             self.mapViewController.GMapView.mapType = mapType

google-maps/src/implementation.ts

@@ -126,6 +126,7 @@ export interface CapacitorGoogleMapsPlugin extends Plugin {
   disableClustering(args: { id: string }): Promise<void>;
   destroy(args: DestroyMapArgs): Promise<void>;
   setCamera(args: CameraArgs): Promise<void>;
+  getMapType(args: { id: string }): Promise<{ type: string }>;
   setMapType(args: MapTypeArgs): Promise<void>;
   enableIndoorMaps(args: IndoorMapArgs): Promise<void>;
   enableTrafficLayer(args: TrafficLayerArgs): Promise<void>;

google-maps/src/map.ts

@@ -5,7 +5,6 @@ import type {
   CameraConfig,
   Marker,
   MapPadding,
-  MapType,
   MapListenerCallback,
   MapReadyCallbackData,
   CameraIdleCallbackData,
@@ -15,7 +14,7 @@ import type {
   MarkerClickCallbackData,
   MyLocationButtonClickCallbackData,
 } from './definitions';
-import { LatLngBounds } from './definitions';
+import { LatLngBounds, MapType } from './definitions';
 import type { CreateMapArgs } from './implementation';
 import { CapacitorGoogleMaps } from './implementation';
 
@@ -37,6 +36,10 @@ export interface GoogleMapInterface {
   removeMarkers(ids: string[]): Promise<void>;
   destroy(): Promise<void>;
   setCamera(config: CameraConfig): Promise<void>;
+  /**
+   * Get current map type
+   */
+  getMapType(): Promise<MapType>;
   setMapType(mapType: MapType): Promise<void>;
   enableIndoorMaps(enabled: boolean): Promise<void>;
   enableTrafficLayer(enabled: boolean): Promise<void>;
@@ -316,6 +319,11 @@ export class GoogleMap {
     });
   }
 
+  async getMapType(): Promise<MapType> {
+    const { type } = await CapacitorGoogleMaps.getMapType({ id: this.id });
+    return MapType[type as keyof typeof MapType];
+  }
+
   /**
    * Sets the type of map tiles that should be displayed.
    *

google-maps/src/web.ts

@@ -9,7 +9,7 @@ import {
 } from '@googlemaps/markerclusterer';
 
 import type { Marker } from './definitions';
-import { LatLngBounds } from './definitions';
+import { MapType, LatLngBounds } from './definitions';
 import type {
   AccElementsArgs,
   AddMarkerArgs,
@@ -123,6 +123,17 @@ export class CapacitorGoogleMapsWeb
     });
   }
 
+  async getMapType(_args: { id: string }): Promise<{ type: string }> {
+    let type = this.maps[_args.id].map.getMapTypeId();
+    if (type !== undefined) {
+      if (type === 'roadmap') {
+        type = MapType.Normal;
+      }
+      return { type };
+    }
+    throw new Error('Map type is undefined');
+  }
+
   async setMapType(_args: MapTypeArgs): Promise<void> {
     this.maps[_args.id].map.setMapTypeId(_args.mapType);
   }