rea
Reverse engineer anything with agents, from app behavior down to native binaries.
- 474k
- TypeScript
- MIT
- 4 h ago
Kotlin extensions (KTX) for the Maps SDK and Utility Library for Android
Repo googlemaps/android-maps-ktx, read from GitHub 1 min ago. googlemaps has not joined Take My Repo.
googlemaps/android-maps-ktx is a public repo on GitHub by googlemaps. Kotlin extensions (KTX) for the Maps SDK and Utility Library for Android. It declares the Apache-2.0 license on GitHub. It is written mainly in Kotlin, has 361 stars and last changed on 2026-11-16. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Warning
This repository is archived and no longer maintained. All functionality has moved to android-maps-utils (v6.0.0+).
All functionality previously provided by this repository (Kotlin extensions, DSL builders, and Coroutines support for the Maps SDK for Android and Maps SDK for Android Utility Library) has moved into android-maps-utils.
v6.0.0+), where all extensions (maps-ktx and maps-utils-ktx) are natively consolidated under the canonical com.google.maps.android.* packages.Legacy releases remain available on Maven Central and source code remains available here for reference, but no further releases, security updates, or dependency bumps will be published in this repository.
This repository contains Kotlin extensions (KTX) for:
It enables you to write more concise, idiomatic Kotlin. Each set of extensions can be used independently or together.
dependencies {
// KTX for the Maps SDK for Android library
implementation 'com.google.maps.android:maps-ktx:6.4.1' // {x-release-please-version}
// KTX for the Maps SDK for Android Utility Library
implementation 'com.google.maps.android:maps-utils-ktx:6.4.1' // {x-release-please-version}
}This library incorporates an internal usage attribution ID to help the Google Maps Platform team better understand library usage and guide future development. This ID is generated during the build process and is automatically registered using androidx.startup.
If you wish to opt-out of this attribution, you can do so by removing the InitializationProvider from your app's manifest:
<provider android:name="androidx.startup.InitializationProvider" android:authorities="${applicationId}.androidx-startup" tools:node="remove" />
With this KTX library, you should be able to take advantage of several Kotlin language features such as extension functions, named parameters and default arguments, destructuring declarations, and coroutines.
This repository includes a Material 3 demo app that illustrates the use of this KTX library.
For interactive examples, visual flows, and code region breakdowns, check out the immersive KTX Flow Snippets Catalog.
To run the demo app, you'll have to:
secrets.properties (this file should NOT be under version control to protect your API key)secrets.properties that looks like MAPS_API_KEY=YOUR_API_KEY, where YOUR_API_KEY is the API key you obtained in the first stepSee GoogleMap.kt for all available extensions.
Adding a Marker:
Before
GoogleMap googleMap = // ... LatLng sydney = new LatLng(-33.852, 151.211); MarkerOptions markerOptions = new MarkerOptions() .position(sydney) .title("Marker in Sydney"); Marker marker = googleMap.addMarker(markerOptions);
After
val googleMap = // ... val sydney = LatLng(-33.852, 151.211) val marker = googleMap.addMarker { position(sydney) title("Marker in Sydney") }
See SupportMapFragment.kt for implementation and the KTX Flow Snippets Catalog for usage examples.
Accessing a GoogleMap instance can be retrieved using coroutines vs. traditional the callback mechanism. The example here demonstrates how you can use this feature alongside with Lifecycle-aware coroutine scopes provided in Android’s Architecture Components. To use this, you'll need to add the following to your build.gradle dependencies:
implementation 'androidx.lifecycle:lifecycle-runtime-ktx:<latest-version>'
Before
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); SupportMapFragment mapFragment = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map)); mapFragment.getMapAsync(new OnMapReadyCallback() { @Override public void onMapReady(GoogleMap googleMap) { // Access GoogleMap instance here } }); }
After
override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) val mapFragment = supportFragmentManager.findFragmentById(R.id.map) as? SupportMapFragment lifecycleScope.launch { lifecycle.repeatOnLifecycle(Lifecycle.State.CREATED) { val googleMap = mapFragment?.awaitMap() } } }
See GoogleMap.kt for implementation and the KTX Flow Snippets Catalog for usage examples.
Listing to camera events can be collected via Kotlin Flow.
Before
val googleMap = //... googleMap.setOnCameraIdleListener(() -> { /* ... */ }); googleMap.setOnCameraMoveCanceledListener(() -> { /* ... */ }); googleMap.setOnCameraMoveListener(() -> { /* ... */ }); googleMap.setOnCameraMoveStartedListener(reason -> { /* ... */ });
After
// To be invoked within a coroutine scope googleMap.cameraIdleEvents().collect { //... } googleMap.cameraMoveCanceledEvents().collect { //... } googleMap.cameraMoveEvents().collect { //... } googleMap.cameraMoveStartedEvents().collect { //... }
See Polygon.kt for implementation.
Checking if a LatLng is contained within a Polygon:
Before
Polygon polygon = // some polygon LatLng latLng = new LatLng(-6.1751, 106.8650); boolean contains = PolyUtil.containsLocation(latLng, polygon.getPoints(), true);
After
val polygon: Polygon = // some polygon val latLng = LatLng(60.030994, 29.317658) val contains = polygon.contains(latLng)
See GeoJson.kt for implementation and the KTX Flow Snippets Catalog for usage examples.
Creating a GeoJsonLayer object:
Before
GeoJsonLayer layer = new GeoJsonLayer( map, geoJsonFile, null, polygonManager, null, groundOverlayManager );
After
val layer = geoJsonLayer( map = map, geoJsonFile = geoJsonFile, polygonManager = polygonManager, groundOverlayManager = groundOverlayManager )
See Point.kt for implementation.
Destructuring properties of a Point:
Before
Point point = new Point(1.0, 2.0); double x = point.x; double y = point.y;
After
val point = Point(1.0, 2.0) val (x, y) = point
See LocationManager.kt and ClusterManager.kt for implementations and the KTX Flow Snippets Catalog for usage examples.
Warning
Single-Subscriber Invariant (Cold Flows):
The underlying Google Maps SDK only supports a single listener slot (e.g., one setOnMarkerClickListener at a time). Because these are cold flows, if you have multiple active collectors subscribing to the same KTX flow concurrently, the latest subscriber will hijack the listener slot. Furthermore, cancelling any one collector will trigger its awaitClose block and completely unregister the listener on the SDK, silently breaking all remaining active collectors!
If you need multiple observers to collect from the same stream, always share the flow using .shareIn() to convert it into a hot SharedFlow:
val sharedClicks = storeCollection.clickEvents() .shareIn( scope = lifecycleScope, started = SharingStarted.WhileSubscribed(5000), replay = 0 )
You can listen to both coarse and fine device location changes reactively as cold Flows that start and stop location updates automatically based on active subscribers:
GPS_PROVIDER, requires ACCESS_FINE_LOCATION permission):
locationManager.fineLocationEvents(minTimeMs = 1000L, minDistanceM = 1f)NETWORK_PROVIDER with passive fallback, requires ACCESS_COARSE_LOCATION permission):
locationManager.coarseLocationEvents(minTimeMs = 5000L, minDistanceM = 5f)val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager // Emits GPS location updates dynamically under ACCESS_FINE_LOCATION permission lifecycleScope.launch { lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) { try { locationManager.fineLocationEvents(minTimeMs = 2000L, minDistanceM = 1f) .collect { location -> // React to new device coordinate updates } } catch (e: CancellationException) { // Triggers if GPS was disabled in Android settings mid-stream } } }
Instead of overriding camera idle listeners and setting single click listener callbacks manually:
val clusterManager = ClusterManager<MyItem>(context, map, markerManager) lifecycleScope.launch { lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) { launch { clusterManager.clusterClickEvents().collect { cluster -> // React to clicked clusters } } launch { clusterManager.clusterItemClickEvents().collect { myItem -> // React to clicked cluster items } } } }
Set separate KTX flow-based click listeners per styled collection:
val storeCollection = markerManager.newCollection() lifecycleScope.launch { lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) { storeCollection.clickEvents().collect { marker -> // React to clicked store markers } } }
This repository includes a local Gemini Agentic Skill configured under the standard .gemini/ directory to assist developers (and autonomous coding agents) inside their IDE and workspaces when modifying, testing, or using this KTX library.
The skill provides progressive-disclosure reference guides, customized workspace config behaviors, and style enforcement rules protecting KTX reactive architecture.
SharedFlow safety.The skill is automatically discovered and utilized by Gemini Code Assist in supported IDEs (such as Android Studio, VS Code, or internal Google workflows). For manual reference or when pairing with autonomous coding assistants, you can consult the progressive-disclosure markdown guides inside .gemini/skills/android-maps-ktx/references/ directly.
You can learn more about all the extensions provided by this library by reading the documentation.
Contributions are welcome and encouraged! If you'd like to contribute, send us a pull request and refer to our code of conduct and contributing guide.
This library calls the addInternalUsageAttributionId method, which helps Google understand which libraries and samples are helpful to developers and is optional. Instructions for opting out of the identifier are provided below.
If you wish to disable this, you can do so by removing the initializer in your AndroidManifest.xml using the tools:node="remove" attribute:
<provider android:name="androidx.startup.InitializationProvider" android:authorities="${applicationId}.androidx-startup" android:exported="false" tools:node="merge"> <meta-data android:name="com.google.maps.android.ktx.utils.attribution.AttributionIdInitializer" tools:node="remove" /> </provider>
This library uses Google Maps Platform services. Use of Google Maps Platform services through this library is subject to the Google Maps Platform Terms of Service.
If your billing address is in the European Economic Area, effective on 8 July 2025, the Google Maps Platform EEA Terms of Service will apply to your use of the Services. Functionality varies by region. Learn more.
This library is not a Google Maps Platform Core Service. Therefore, the Google Maps Platform Terms of Service (e.g. Technical Support Services, Service Level Agreements, and Deprecation Policy) do not apply to the code in this library.
This library is offered via an open source license. It is not governed by the Google Maps Platform Support Technical Support Services Guidelines, the SLA, or the Deprecation Policy. However, any Google Maps Platform services used by the library remain subject to the Google Maps Platform Terms of Service.
This library adheres to semantic versioning to indicate when backwards-incompatible changes are introduced. Accordingly, while the library is in version 0.x, backwards-incompatible changes may be introduced at any time.
If you find a bug, or have a feature request, please file an issue on GitHub. If you would like to get answers to technical questions from other Google Maps Platform developers, ask through one of our developer community channels. If you'd like to contribute, please check the contributing guide.
You can also discuss this library on our Discord server.
googlemaps/android-maps-ktx is a public repo on GitHub by googlemaps. Kotlin extensions (KTX) for the Maps SDK and Utility Library for Android.
It declares the Apache-2.0 license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-16. GitHub counts 11 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Reverse engineer anything with agents, from app behavior down to native binaries.
React Native Mapview component for iOS + Android

Flutter makes it easy and fast to build beautiful apps for mobile and beyond
f.k.a. Awesome ChatGPT Prompts. Share, discover, and collect prompts from the community. Free and open source — self-host for your organization with complete privacy.

Your favorite self-hostable alternative to Google Timeline (Google Location History)
Python client library for Google Maps API Web Services

Maps SDK for Android Utility Library
Node.js client library for Google Maps API Web Services
Java client library for Google Maps API Web Services

Jetpack Compose composables for the Maps SDK for Android
Utility libraries for Google Maps JavaScript API v3
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/googlemaps/android-maps-ktxTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.