@capawesome/capacitor-maps-launcher 0.0.1

package/ios/Plugin/MapsLauncher.swift

@@ -0,0 +1,182 @@
+import Foundation
+import Capacitor
+import CoreLocation
+import MapKit
+import UIKit
+
+@objc public class MapsLauncher: NSObject {
+    static let appAppleMaps = "appleMaps"
+    static let appGoogleMaps = "googleMaps"
+    static let appWaze = "waze"
+    static let schemeGoogleMaps = "comgooglemaps"
+    static let schemeWaze = "waze"
+
+    private let plugin: MapsLauncherPlugin
+
+    init(plugin: MapsLauncherPlugin) {
+        self.plugin = plugin
+    }
+
+    @objc public func getAvailableApps(completion: @escaping (GetAvailableAppsResult?, Error?) -> Void) {
+        var apps = [Self.appAppleMaps]
+        if canOpen(Self.schemeGoogleMaps) {
+            apps.append(Self.appGoogleMaps)
+        }
+        if canOpen(Self.schemeWaze) {
+            apps.append(Self.appWaze)
+        }
+        completion(GetAvailableAppsResult(apps: apps), nil)
+    }
+
+    @objc public func navigate(_ options: NavigateOptions, completion: @escaping (Error?) -> Void) {
+        switch options.app {
+        case nil, Self.appAppleMaps:
+            openAppleMaps(options, completion: completion)
+        case Self.appGoogleMaps:
+            openGoogleMaps(options, completion: completion)
+        case Self.appWaze:
+            openWaze(options, completion: completion)
+        default:
+            completion(CustomError.appNotAvailable)
+        }
+    }
+
+    private func appleMapsDirectionsMode(_ travelMode: String?) -> String {
+        switch travelMode {
+        case "walking":
+            return MKLaunchOptionsDirectionsModeWalking
+        case "transit":
+            return MKLaunchOptionsDirectionsModeTransit
+        case "driving":
+            return MKLaunchOptionsDirectionsModeDriving
+        default:
+            return MKLaunchOptionsDirectionsModeDefault
+        }
+    }
+
+    private func appleMapsDirflg(_ travelMode: String?) -> String? {
+        switch travelMode {
+        case "walking":
+            return "w"
+        case "transit":
+            return "r"
+        case "driving":
+            return "d"
+        default:
+            return nil
+        }
+    }
+
+    private func buildAppleMapsUrl(_ options: NavigateOptions) -> URL? {
+        var components = URLComponents(string: "https://maps.apple.com/")
+        var queryItems = [URLQueryItem(name: "daddr", value: formatDestination(options.destination))]
+        if let start = options.start {
+            queryItems.append(URLQueryItem(name: "saddr", value: formatDestination(start)))
+        }
+        if let dirflg = appleMapsDirflg(options.travelMode) {
+            queryItems.append(URLQueryItem(name: "dirflg", value: dirflg))
+        }
+        components?.queryItems = queryItems
+        return components?.url
+    }
+
+    private func buildUrl(scheme: String, queryItems: [URLQueryItem]) -> URL? {
+        var components = URLComponents()
+        components.scheme = scheme
+        components.host = ""
+        components.queryItems = queryItems
+        return components.url
+    }
+
+    private func canOpen(_ scheme: String) -> Bool {
+        guard let url = URL(string: scheme + "://") else {
+            return false
+        }
+        return UIApplication.shared.canOpenURL(url)
+    }
+
+    private func formatDestination(_ destination: Destination) -> String {
+        if let coordinate = destination.coordinate {
+            return "\(coordinate.latitude),\(coordinate.longitude)"
+        }
+        return destination.address ?? ""
+    }
+
+    private func googleDirectionsMode(_ travelMode: String?) -> String {
+        switch travelMode {
+        case "walking", "bicycling", "transit":
+            return travelMode ?? "driving"
+        default:
+            return "driving"
+        }
+    }
+
+    private func open(_ url: URL, completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async {
+            UIApplication.shared.open(url, options: [:]) { success in
+                completion(success ? nil : CustomError.launchFailed)
+            }
+        }
+    }
+
+    private func openAppleMaps(_ options: NavigateOptions, completion: @escaping (Error?) -> Void) {
+        let canUseMapItems = options.destination.coordinate != nil && (options.start == nil || options.start?.coordinate != nil)
+        if canUseMapItems, let destinationCoordinate = options.destination.coordinate {
+            let destinationItem = MKMapItem(placemark: MKPlacemark(coordinate: destinationCoordinate))
+            var items: [MKMapItem] = []
+            if let startCoordinate = options.start?.coordinate {
+                items.append(MKMapItem(placemark: MKPlacemark(coordinate: startCoordinate)))
+            } else {
+                items.append(MKMapItem.forCurrentLocation())
+            }
+            items.append(destinationItem)
+            let launchOptions = [MKLaunchOptionsDirectionsModeKey: appleMapsDirectionsMode(options.travelMode)]
+            DispatchQueue.main.async {
+                MKMapItem.openMaps(with: items, launchOptions: launchOptions)
+                completion(nil)
+            }
+        } else {
+            guard let url = buildAppleMapsUrl(options) else {
+                completion(CustomError.launchFailed)
+                return
+            }
+            open(url, completion: completion)
+        }
+    }
+
+    private func openGoogleMaps(_ options: NavigateOptions, completion: @escaping (Error?) -> Void) {
+        guard canOpen(Self.schemeGoogleMaps) else {
+            completion(CustomError.appNotAvailable)
+            return
+        }
+        var queryItems = [URLQueryItem(name: "daddr", value: formatDestination(options.destination))]
+        if let start = options.start {
+            queryItems.append(URLQueryItem(name: "saddr", value: formatDestination(start)))
+        }
+        queryItems.append(URLQueryItem(name: "directionsmode", value: googleDirectionsMode(options.travelMode)))
+        guard let url = buildUrl(scheme: Self.schemeGoogleMaps, queryItems: queryItems) else {
+            completion(CustomError.launchFailed)
+            return
+        }
+        open(url, completion: completion)
+    }
+
+    private func openWaze(_ options: NavigateOptions, completion: @escaping (Error?) -> Void) {
+        guard canOpen(Self.schemeWaze) else {
+            completion(CustomError.appNotAvailable)
+            return
+        }
+        var queryItems: [URLQueryItem] = []
+        if let coordinate = options.destination.coordinate {
+            queryItems.append(URLQueryItem(name: "ll", value: "\(coordinate.latitude),\(coordinate.longitude)"))
+        } else if let address = options.destination.address {
+            queryItems.append(URLQueryItem(name: "q", value: address))
+        }
+        queryItems.append(URLQueryItem(name: "navigate", value: "yes"))
+        guard let url = buildUrl(scheme: Self.schemeWaze, queryItems: queryItems) else {
+            completion(CustomError.launchFailed)
+            return
+        }
+        open(url, completion: completion)
+    }
+}

package/ios/Plugin/MapsLauncherPlugin.swift

@@ -0,0 +1,71 @@
+import Foundation
+import Capacitor
+
+@objc(MapsLauncherPlugin)
+public class MapsLauncherPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "MapsLauncherPlugin"
+    public let jsName = "MapsLauncher"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "getAvailableApps", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getDefaultApp", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "navigate", returnType: CAPPluginReturnPromise)
+    ]
+    public static let tag = "MapsLauncherPlugin"
+
+    private var implementation: MapsLauncher?
+
+    override public func load() {
+        self.implementation = MapsLauncher(plugin: self)
+    }
+
+    @objc func getAvailableApps(_ call: CAPPluginCall) {
+        implementation?.getAvailableApps { result, error in
+            if let error = error {
+                self.rejectCall(call, error)
+                return
+            }
+            self.resolveCall(call, result)
+        }
+    }
+
+    @objc func getDefaultApp(_ call: CAPPluginCall) {
+        rejectCallAsUnimplemented(call)
+    }
+
+    @objc func navigate(_ call: CAPPluginCall) {
+        do {
+            let options = try NavigateOptions(call)
+            implementation?.navigate(options) { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                    return
+                }
+                self.resolveCall(call)
+            }
+        } catch {
+            self.rejectCall(call, error)
+        }
+    }
+
+    private func rejectCall(_ call: CAPPluginCall, _ error: Error) {
+        CAPLog.print("[", MapsLauncherPlugin.tag, "] ", error)
+        let code = (error as? CustomError)?.code
+        call.reject(error.localizedDescription, code)
+    }
+
+    private func rejectCallAsUnimplemented(_ call: CAPPluginCall) {
+        call.unimplemented("This method is not available on this platform.")
+    }
+
+    private func resolveCall(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    private func resolveCall(_ call: CAPPluginCall, _ result: Result?) {
+        if let result = result?.toJSObject() as? JSObject {
+            call.resolve(result)
+        } else {
+            call.resolve()
+        }
+    }
+}

package/ios/Plugin/Protocols/Result.swift

@@ -0,0 +1,5 @@
+import Capacitor
+
+@objc public protocol Result {
+    @objc func toJSObject() -> AnyObject
+}

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@capawesome/capacitor-maps-launcher",
+  "version": "0.0.1",
+  "description": "Capacitor plugin to launch navigation apps with turn-by-turn directions.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Plugin/",
+    "CapawesomeCapacitorMapsLauncher.podspec",
+    "Package.swift"
+  ],
+  "author": "Robin Genz <mail@robingenz.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/capawesome-team/capacitor-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/capawesome-team/capacitor-plugins/issues"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/capawesome-team/"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/capawesome"
+    }
+  ],
+  "homepage": "https://capawesome.io/docs/plugins/maps-launcher/",
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native",
+    "maps",
+    "navigation",
+    "launch navigator"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin -destination generic/platform=iOS && cd ..",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api MapsLauncherPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "ios:pod:install": "cd ios && pod install --repo-update && cd ..",
+    "ios:spm:install": "cd ios && swift package resolve && cd ..",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "8.0.0",
+    "@capacitor/cli": "8.0.0",
+    "@capacitor/core": "8.0.0",
+    "@capacitor/docgen": "0.3.1",
+    "@capacitor/ios": "8.0.0",
+    "@ionic/eslint-config": "0.4.0",
+    "eslint": "8.57.0",
+    "prettier-plugin-java": "2.6.7",
+    "rimraf": "6.1.2",
+    "rollup": "4.53.3",
+    "swiftlint": "2.0.0",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}