Google Maps SDK — vad är det, Google Maps och API för utveckling

Vad är Google Maps SDK?

Google Maps SDK — är en omfattande plattform för utvecklare som tillhandahåller verktyg för att arbeta med geografisk data i applikationer. Plattformen inkluderar flera API:er: Maps SDK (kartvisning), Routes API (rutter), Places API (platssökning och geodata) och Geocoding API (konvertering av adresser till koordinater). Varje SDK integreras separat och har sin egen faktureringsmodell.

Till skillnad från Apple MapKit erbjuder Google Maps SDK en bredare datamängd: information om 250 miljoner platser, realtidstrafik, Street View-panoramor och Indoor Maps för inomhusmiljöer. Enligt Statista (2025) innehar Google Maps Platform 75 % av marknaden för kart-SDK:er i mobila applikationer. Den främsta fördelen är en enda API-nyckel för alla Google Maps-tjänster och plattformsoberoende integration (Android, iOS, webb).

API-nyckel och säkerhetskonfiguration

API-nyckel — ett obligatoriskt element för att arbeta med Google Maps SDK. Nyckeln skapas i Google Cloud Console och knyts till ett specifikt projekt. För Android krävs SHA-1 för applikationscertifikatet, för iOS — Bundle Identifier. Google rekommenderar att begränsa användningen av API-nyckeln efter IP-adresser, HTTP-referer eller applikationspaket för att förhindra obehörig åtkomst.

Maps SDK för Android: integration och möjligheter

Maps SDK för Android — är ett bibliotek som visar interaktiva Google Kartor inuti en Android-applikation via MapView eller SupportMapFragment. SDK stöder: anpassade kartstilar, markörer med informationsfönster, polygoner och polylinjer, trafik- och transportlager, samt beröringshändelser och gester (zooma, rotera, luta). Kartor använder OpenGL för rendering och ger 60 FPS på moderna enheter.

Integrationen börjar med att lägga till ett beroende i build.gradle och konfigurera API-nyckeln via AndroidManifest.xml. Google Maps SDK för Android kräver Google Play Services på enheten. Om Google Play Services saknas (t.ex. på Huawei-enheter utan Google-tjänster) visas inte kartorna. För sådana fall rekommenderar Google alternativa lösningar eller WebView med JavaScript Maps API.

// AndroidManifest.xml — metadata för API-nyckel
// <meta-data android:name="com.google.android.geo.API_KEY"
//     android:value="YOUR_API_KEY"/>

// Kartfragment i Activity
class MapActivity : AppCompatActivity(),
    OnMapReadyCallback {

    private lateinit var map: GoogleMap

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_map)
        val mapFragment = supportFragmentManager
            .findFragmentById(R.id.map) as SupportMapFragment
        mapFragment.getMapAsync(this)
    }

    override fun onMapReady(googleMap: GoogleMap) {
        map = googleMap
        val sydney = LatLng(-33.8688, 151.2093)
        map.addMarker(MarkerOptions().position(sydney)
            .title("Sydney"))
        map.moveCamera(CameraUpdateFactory
            .newLatLngZoom(sydney, 12f))
    }
}

Google Maps SDK på Android stöder Indoor Maps — visning av byggnadsplaner (flygplatser, köpcentrum). För att aktivera räcker det att ställa in map.isIndoorEnabled = true. Trafiklagret (Traffic Layer) visar vägtrafik i realtid — data uppdateras var 2-5 minut. Transportlagret (Transit Layer) visar kollektivtrafikrutter i supporterade städer.

Maps SDK för iOS: konfiguration och användning

Maps SDK för iOS ger samma möjligheter som Android-versionen men anpassad för Apple-plattformen. Integrationen sker via Swift Package Manager eller CocoaPods. Maps SDK för iOS använder Google-servrar för rendering av kartor men kan samarbeta med Apple MapKit för inbyggd navigering. SDK stöder iOS 15 och senare, samt SwiftUI via UIViewRepresentable.

En speciell egenskap för iOS-versionen är obligatorisk konfiguration av Info.plist med angivande av API-nyckel och tillägg av URL-schema för Google Maps. Till skillnad från Android kräver iOS SDK inte Google Play Services men kräver installerad Google Maps-app för vissa funktioner (t.ex. öppna kartor i navigering). För plattformsoberoende projekt rekommenderar Google en enda API-nyckel per projekt, aktiverad för båda plattformarna.

import GoogleMaps

class MapViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        let camera = GMSCameraPosition.camera(
            withLatitude: 55.7558,
            longitude: 37.6173,
            zoom: 10
        )
        let mapView = GMSMapView.map(
            withFrame: view.frame,
            camera: camera
        )
        self.view = mapView

        let marker = GMSMarker()
        marker.position = CLLocationCoordinate2D(
            latitude: 55.7558,
            longitude: 37.6173
        )
        marker.title = "Moscow"
        marker.map = mapView
    }
}

På iOS stöder Google Maps SDK anpassade stilar via en JSON-fil i Google Maps Styling-format. Stilar gör det möjligt att ändra färger på vägar, vatten, parker och byggnader enligt applikationens design. Även Heatmap Layer för visualisering av datatäthet, KML och GeoJSON för import av geografisk data från externa källor stöds.

Places API: platssökning och geokodning

Places API — är Google Maps Platform-tjänsten för att hämta information om geografiska platser: adresser, koordinater, betyg, öppettider, foton och recensioner. Places API fungerar i två lägen: Place Search (sökning efter platser baserat på text eller radie) och Place Details (hämtning av detaljerad information om en specifik plats baserat på Place ID). SDK finns tillgänglig för Android, iOS och som REST API.

Places SDK för Android och iOS gör det möjligt att bädda in adressautokomplettering (Place Autocomplete) direkt i applikationens textfält. Detta är en nyckelfunktion för leverans-, taxi- och logistikapplikationer — användaren börjar skriva en adress och SDK föreslår alternativ från Google Maps-databasen. Place Autocomplete minskar antalet adressinmatningsfel med 80 % jämfört med manuell inmatning. Fakturering Places API: $2.83 per 1000 Place Details-förfrågningar, Place Search — $4.71 per 1000.

// Sökning efter plats baserat på text på Android
val placesClient = Places.createClient(context)
val request = FindCurrentPlaceRequest.builder(
    listOf(Place.Field.NAME, Place.Field.ADDRESS)
).build()

placesClient.findCurrentPlace(request)
    .addOnSuccessListener { response ->
        for (placeLikelihood in response.placeLikelihoods) {
            Log.d("Places", "${placeLikelihood.place.name} - ${placeLikelihood.likelihood}")
        }
    }

Place Autocomplete: adressautokomplettering

Geocoding API — omvänd geokodning (koordinater → adress) och direkt (adress → koordinater). Används för att konvertera en användares inmatade adress till koordinater för visning på kartan. Geocoding API faktureras separat: $4.71 per 1000 förfrågningar. Google tillhandahåller 200 gratis förfrågningar per dag per konto för testning.

Directions API: bygga rutter

Directions API — tjänst för beräkning av rutter mellan två eller flera punkter med hänsyn till transportsätt (bil, till fots, cykel, kollektivtrafik). API returnerar flera alternativa rutter med angivande av avstånd, restid, steg-för-steg-instruktioner och polylinje för att rita rutten på kartan. Directions API finns tillgänglig som REST API och via klient-SDK:er.

Utökad funktionalitet — Routes API (nytt API, rekommenderat av Google sedan 2024). Routes API erbjuder förbättrad routning med hänsyn till realtidstrafik, ekologiskt fotavtryck (eco-friendly routing) och prediktiv analys av ankomsttid. Enligt Google beräknar Routes API restiden 20 % mer exakt i stadsmiljö jämfört med klassiska Directions API. Routes API faktureras: $5.00 per 1000 förfrågningar.

// Ruttförfrågan via Routes API
val client = OkHttpClient()
val requestBody = """
    {
        "origin": {"location": {"latLng": {"latitude": 55.75, "longitude": 37.61}}},
        "destination": {"location": {"latLng": {"latitude": 55.79, "longitude": 37.79}}},
        "travelMode": "DRIVE",
        "routingPreference": "TRAFFIC_AWARE"
    }
""".trimIndent()

val request = Request.Builder()
    .url("https://routes.googleapis.com/directions/v2:computeRoutes")
    .header("X-Goog-Api-Key", apiKey)
    .header("Content-Type", "application/json")
    .post(requestBody.toRequestBody())
    .build()

client.newCall(request).enqueue(object : Callback {
    override fun onResponse(call: Call, response: Response) {
        Log.d("Route", response.body?.string() ?: "")
    }
})

Directions API stöder upp till 25 mellanliggande punkter (waypoints) för en rutt. Mellanliggande punkter kan anges som koordinater eller Place ID. För att optimera ordningen på punkter (handelsresandeproblemet), använd parametern optimize:true. Fakturering: Directions API — $4.71 per 1000 förfrågningar (upp till 10 punkter), varje ytterligare punkt lägger till 50 % till kostnaden för förfrågan.

Anpassning av kartor: stilar, markörer och informationsfönster

Google Maps SDK erbjuder omfattande anpassningsmöjligheter: ändring av kartans färgschema via JSON-stilar, tillägg av anpassade markörer (inklusive animerade), informationsfönster (InfoWindow) med godtyckligt innehåll och överlagring av grafiska lager (GroundOverlay, Circle, Polygon). Anpassning gör det möjligt att anpassa kartan till applikationens varumärke och förbättra användarupplevelsen.

Kartstilar utförs via Google Maps Styling Wizard eller en JSON-fil i Map Style-format. Färger på vägar (featureType: road), vatten (water), parker (poi.park), byggnader (building) och andra element kan ändras. För kartor i applikationens mörka tema, använd en nattstil med mörk bakgrund och dämpade färger. Google Maps stöder upp till 100 stilregler i en JSON-fil.

Clustering: klustring av markörer för prestanda

Clustering — sammanslagning av markörer i kluster vid ett stort antal punkter på kartan. Google Maps SDK för Android och iOS innehåller ett inbyggt klusterverktyg (com.google.maps.android:android-maps-utils). Clustering förhindrar att kartan överbelastas med markörer vid zoomnivåer under en viss nivå. Vid zoom delas klustret automatiskt upp i enskilda markörer. Enligt Google förbättrar klustring kartans prestanda med 40 % vid 1000+ markörer.

Kodexempel: karta med markörer i Kotlin

Fullständigt exempel på visning av karta med anpassad markör, ruttpolylinje och informationsfönster. Applikationen visar en karta över Moskva med en intressepunkt och rutten dit från stadens centrum. Koden demonstrerar grundläggande funktioner i Google Maps SDK: lägga till markör, rita polylinje, flytta kamera och hantera klick.

class MapDemoActivity : AppCompatActivity(), OnMapReadyCallback {

    override fun onMapReady(map: GoogleMap) {
        val kremlin = LatLng(55.7513, 37.6189)
        val gorkyPark = LatLng(55.7311, 37.6116)

        map.addMarker(MarkerOptions()
            .position(kremlin)
            .title("Kreml")
            .icon(BitmapDescriptorFactory.defaultMarker(
                BitmapDescriptorFactory.HUE_RED)))

        map.addPolyline(PolylineOptions()
            .add(kremlin, gorkyPark)
            .width(5f)
            .color(Color.parseColor("#2196F3")))

        map.moveCamera(CameraUpdateFactory
            .newLatLngZoom(kremlin, 13f))

        map.setOnInfoWindowClickListener { marker ->
            Toast.makeText(this,
                "${marker.title} clicked",
                Toast.LENGTH_SHORT).show()
        }
    }
}

Prestandarekommendationer: använd asynkron laddning av markörer via ClusterManager vid fler än 200 punkter, begränsa antalet synliga polylinjer (Google rekommenderar inte mer än 100 samtidigt), använd Lite Mode för kartor som inte kräver full funktionalitet (rullning utan att ändra zoom). Lite Mode minskar minnesförbrukningen med 50 % och påskyndar kartladdningen 2 gånger.

Priser och gränser för Google Maps Platform

Google Maps Platform använder en Pay-as-you-go-betalningsmodell med en månatlig gratisgräns på $200 krediter. Varje API faktureras separat: Maps SDK — $2.83 per 1000 kartladdningar, Places API — $4.71 per 1000 förfrågningar, Directions API — $4.71 per 1000 rutter. Routes API (rekommenderat) — $5.00 per 1000 förfrågningar. Den gratis gränsen på $200 täcker vanligtvis upp till 70 000 kartladdningar per månad.

För projekt med hög belastning erbjuder Google rabatter vid volymer från 500 000 förfrågningar per månad. Google Maps SDK faktureras inte för visning av baskartan utan interaktion — avgift tas endast ut för laddning (map load). Varje gång användaren öppnar skärmen med kartan räknas det som en laddning. Optimering: cachning av kartplattor minskar antalet laddningar vid återöppning.

Gränser: 300 förfrågningar per minut för Places API (kan ökas till 3000 via kvot i Cloud Console). För Directions API — 100 förfrågningar per minut. Överskridande av gränsen returnerar felet OVER_QUERY_LIMIT. Google rekommenderar exponentiell fördröjning (exponential backoff) för upprepade förfrågningar. Användningsövervakning finns tillgänglig i Google Cloud Console med en fördröjning på upp till 5 minuter.