admanagekit-mcp-server 1.2.4 → 1.2.6

package/content/README.md

@@ -5,7 +5,11 @@
 
 AdManageKit is a comprehensive Android library designed to simplify the integration and management of Google AdMob ads, Google Play Billing, and User Messaging Platform (UMP) consent.
 
-**Latest Version `4.4.5`** is a **patch release**. No API changed. It fixes a `BannerAdView` bug that renders a **blank banner slot inside Jetpack Compose**: swapping the shimmer placeholder for the loaded `AdView` raises an ordinary `requestLayout()`, which cannot cross Compose's `AndroidView` interop boundary once any ancestor already carries a pending layout flag — so Compose never re-measured the subtree and the freshly attached `AdView` was left at 0×0. The ad loaded, `onAdLoaded`/`onAdImpression` fired and the impression was **logged and billed**, but the slot stayed blank until a rotation or resize forced a full traversal. Both the AdMob and `BannerWaterfall` success paths now force the measure/layout pass themselves. Also picks up the Next-Gen GMA SDK **1.4.0**, AGP **9.3.2** and Firebase BOM **34.18.0**. See [Release Notes v4.4.5](docs/release-notes/RELEASE_NOTES_v4.4.5.md).
+**Latest Version `4.4.7`** is a **build and packaging release**. No API changed and no library source file changed — the subject is the library's **consumer ProGuard rules**, which were pinning several thousand classes as un-shrinkable in every app that depends on AdManageKit. `ad-manage-kit-compose` shipped `-keep class androidx.compose.** { *; }`, a rule R8 applies to every consuming app with no way to opt out: it retained **7221 classes, 57262 methods and 23964 fields** of the Compose runtime whether the app used them or not — and even for apps that never call an AdManageKit composable. All five modules now ship a wired, **deliberately empty** `consumer-rules.pro`; the library uses no reflection, JNI or serialization, and AAPT2 already emits the view-constructor keeps each app actually needs. On the sample app this is **11.99 MB → 7.89 MB** of APK (−34%) and 21.3 MB → **12.5 MB** of dex (−41%). **If you run R8, you get this by upgrading** — nothing to configure, and you can delete any defensive `-keep class com.i2hammad.admanagekit.** { *; }` you carry. See [Release Notes v4.4.7](docs/release-notes/RELEASE_NOTES_v4.4.7.md).
+
+**Version `4.4.6`** is a **maintenance release**. No API changed and no library source file changed — the whole diff is dependencies and docs. It **downgrades** `androidx.work:work-runtime` **2.11.2 → 2.9.1**: WorkManager **2.10 and 2.11** call `JobScheduler.forNamespace` whenever `SDK_INT >= 34`, and modified or spoofed ROMs that report API 34 over an older framework have no such method — the `NoSuchMethodError` then kills the **whole process during bind** (`Unable to get provider androidx.startup.InitializationProvider`), because `androidx.startup` builds WorkManager in a `ContentProvider` installed before `Application.onCreate` runs. 2.9.1 is the last release without that call. AdManageKit has no WorkManager code of its own; the pin only steers the version the ads SDK pulls in, and since Gradle resolves the **highest** version in the graph, an app that declares 2.10/2.11 itself keeps the crash — pin `androidx.work:work-runtime:2.9.1` in your app too. Also picks up AGP **9.4.0**, Firebase BOM **34.19.0**, Compose BOM **2026.09.00** and Yandex Mobile Ads **8.4.0**. See [Release Notes v4.4.6](docs/release-notes/RELEASE_NOTES_v4.4.6.md).
+
+**Version `4.4.5`** is a **patch release**. No API changed. It fixes a `BannerAdView` bug that renders a **blank banner slot inside Jetpack Compose**: swapping the shimmer placeholder for the loaded `AdView` raises an ordinary `requestLayout()`, which cannot cross Compose's `AndroidView` interop boundary once any ancestor already carries a pending layout flag — so Compose never re-measured the subtree and the freshly attached `AdView` was left at 0×0. The ad loaded, `onAdLoaded`/`onAdImpression` fired and the impression was **logged and billed**, but the slot stayed blank until a rotation or resize forced a full traversal. Both the AdMob and `BannerWaterfall` success paths now force the measure/layout pass themselves. Also picks up the Next-Gen GMA SDK **1.4.0**, AGP **9.3.2** and Firebase BOM **34.18.0**. See [Release Notes v4.4.5](docs/release-notes/RELEASE_NOTES_v4.4.5.md).
 
 **Version `4.4.4`** is a **critical billing hotfix**. No API changed. It repairs a regression introduced in 4.4.3, where the Play Billing connection was never started at all: `connectToGooglePlayBilling()` guarded on `billingClient.isReady()`, which reports `true` the instant a client is built, so `startConnection(...)` was skipped on every fresh client. Setup never ran, no product details or entitlement were ever fetched, and there was **no failure callback and no error log** to explain it. **If you ship the billing module on 4.4.3, upgrade.** Also fixes a long-standing bug where a timed-out setup reported itself as initialized — permanently suppressing the host app's `if (!initBillingFinish) initBilling()` retry — and adds `DEBUG` logging across the billing connection lifecycle. See [Release Notes v4.4.4](docs/release-notes/RELEASE_NOTES_v4.4.4.md).
 
@@ -37,7 +41,7 @@ Since **4.2.0** the library runs on the Google Mobile Ads **Next-Gen SDK** (`ads
 
 ## Next-Gen GMA SDK
 
-As of v4.2.0, AdManageKit runs on Google's **Next-Gen Google Mobile Ads SDK** (`com.google.android.libraries.ads.mobile.sdk`, stable `1.4.0` as of 4.4.5) instead of the legacy `com.google.android.gms:play-services-ads`. This isn't a branch or an opt-in — it's the only version of AdManageKit going forward.
+As of v4.2.0, AdManageKit runs on Google's **Next-Gen Google Mobile Ads SDK** (`com.google.android.libraries.ads.mobile.sdk`, stable `1.4.0` as of 4.4.7) instead of the legacy `com.google.android.gms:play-services-ads`. This isn't a branch or an opt-in — it's the only version of AdManageKit going forward.
 
 ### Why the move
 
@@ -201,15 +205,15 @@ dependencyResolutionManagement {
 **Step 2:** Add dependencies to your app's `build.gradle`:
 
 ```groovy
-implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit:v4.4.5'
-implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-billing:v4.4.5'
-implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-core:v4.4.5'
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit:v4.4.7'
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-billing:v4.4.7'
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-core:v4.4.7'
 
 // For Jetpack Compose support
-implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-compose:v4.4.5'
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-compose:v4.4.7'
 
 // For Yandex Ads multi-provider support
-implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-yandex:v4.4.5'
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-yandex:v4.4.7'
 ```
 
 **Step 3:** Ensure your app's `compileSdk` is **37 or higher** (required transitively as of 4.2.0).
@@ -783,6 +787,8 @@ Register it **before** `initBilling`. Products land in `unfetched` when the id i
 - [Multi-Provider Waterfall](docs/MULTI_PROVIDER_WATERFALL.md)
 - [Yandex Integration](docs/YANDEX_INTEGRATION.md)
 - [Billing Integration Guide](docs/APP_PURCHASE_GUIDE.md)
+- [Release Notes v4.4.7](docs/release-notes/RELEASE_NOTES_v4.4.7.md)
+- [Release Notes v4.4.6](docs/release-notes/RELEASE_NOTES_v4.4.6.md)
 - [Release Notes v4.4.5](docs/release-notes/RELEASE_NOTES_v4.4.5.md)
 - [Release Notes v4.4.4](docs/release-notes/RELEASE_NOTES_v4.4.4.md)
 - [Release Notes v4.4.3](docs/release-notes/RELEASE_NOTES_v4.4.3.md)

package/content/docs/release-notes/RELEASE_NOTES_v4.4.6.md

@@ -0,0 +1,110 @@
+# Release Notes — v4.4.6
+
+**Release Date:** 2026-09-14
+
+## Overview
+
+v4.4.6 is a **maintenance release**. No API was added, removed or changed, and **no library source file changed** — the entire diff is `gradle/libs.versions.toml`, the five publication blocks, and documentation.
+
+The one change worth reading is a deliberate **downgrade** of WorkManager to **2.9.1**. WorkManager 2.10 and 2.11 call `JobScheduler.forNamespace` on any device reporting `SDK_INT >= 34`; on modified or spoofed ROMs that report API 34 over an older framework the method is absent, and the resulting `NoSuchMethodError` kills the process at startup via `androidx.startup`'s `WorkManagerInitializer`. 2.9.1 is the last release without that call. It also picks up AGP **9.4.0**, Firebase BOM **34.19.0**, Compose BOM **2026.09.00** and Yandex Mobile Ads **8.4.0**.
+
+Upgrading is a drop-in from 4.4.x.
+
+---
+
+## Changed
+
+### WorkManager pinned back to 2.9.1 (a downgrade, on purpose)
+
+`androidx.work:work-runtime` moves **2.11.2 → 2.9.1**. This is the only dependency in the catalog moving backwards, and it is intentional.
+
+**The defect.** WorkManager **2.10 and 2.11** call `android.app.job.JobScheduler.forNamespace` whenever `Build.VERSION.SDK_INT >= 34`. That method genuinely exists on API 34 — but modified and spoofed ROMs that *report* API 34 while running an older framework underneath do not have it. Constructing the WorkManager singleton on such a device throws `NoSuchMethodError`.
+
+That throw is fatal rather than merely inconvenient because `androidx.startup` auto-initializes WorkManager through `WorkManagerInitializer`, which runs from `InitializationProvider` — a `ContentProvider`. `ActivityThread.handleBindApplication` installs content providers **after** `Application.attachBaseContext` but **before** `Application.onCreate`, so there is no user code on the stack to catch it and nothing in the app has run yet. The process dies during bind:
+
+```
+Fatal Exception: java.lang.RuntimeException: Unable to get provider
+androidx.startup.InitializationProvider: java.lang.NoSuchMethodError:
+No virtual method forNamespace(Ljava/lang/String;)Landroid/app/job/JobScheduler;
+in class Landroid/app/job/JobScheduler; or its super classes
+(declaration of 'android.app.job.JobScheduler' appears in /system/framework/framework.jar)
+    at android.app.ActivityThread.installProvider(ActivityThread.java:7467)
+    at android.app.ActivityThread.installContentProviders(ActivityThread.java:6973)
+    at android.app.ActivityThread.handleBindApplication(ActivityThread.java:6744)
+```
+
+In a minified build the `StartupException` between the two appears under its obfuscated name (`y40:` or similar), so match on the `InitializationProvider` + `forNamespace` pair rather than on the middle frame. `declaration ... appears in /system/framework/framework.jar` is the confirmation that the device's framework really is older than the API level it advertises.
+
+**2.9.1 is the last release without that call**, which is why the pin lands exactly there rather than at some newer 2.10.x or 2.11.x patch — the call is present throughout both lines.
+
+**This is a host-device problem, not an ads problem.** No source file in any of AdManageKit's five modules references `androidx.work`. The dependency is declared purely to control which version lands in the graph — the Next-Gen GMA SDK asks for `work-runtime:2.7.0` transitively, and this entry is what decides where that resolves. The downgrade changes nothing about the library's behavior, surface, or minimum requirements; it only moves a pin.
+
+**The pin does not override your app.** It is an `implementation` dependency, so it lands in the published POM at `runtime` scope, and Gradle's conflict resolution still picks the **highest** version across the whole graph. If your app declares 2.10 or 2.11 directly, or depends on anything that does, you resolve that version and you keep the crash. Check what you actually resolve:
+
+```bash
+./gradlew :app:dependencies --configuration releaseRuntimeClasspath | grep androidx.work
+```
+
+If that shows 2.10.x or 2.11.x and you are seeing `NoSuchMethodError` on `JobScheduler.forNamespace` in your startup crash reports, pin it in the app as well:
+
+```kotlin
+dependencies {
+    implementation("androidx.work:work-runtime:2.9.1")
+}
+```
+
+**If you need 2.10+ APIs**, do not downgrade your app to match the library. Take the auto-initializer out of the startup path instead, so a failure is catchable rather than fatal — remove `WorkManagerInitializer` in the manifest and initialize WorkManager yourself inside a guard:
+
+```xml
+<provider
+    android:name="androidx.startup.InitializationProvider"
+    android:authorities="${applicationId}.androidx-startup"
+    tools:node="merge">
+    <meta-data
+        android:name="androidx.work.WorkManagerInitializer"
+        android:value="androidx.startup"
+        tools:node="remove" />
+</provider>
+```
+
+Then have your `Application` implement `androidx.work.Configuration.Provider`. WorkManager falls back to on-demand initialization at the first `WorkManager.getInstance(context)` call — which happens on your own thread, in your own code, where a `NoSuchMethodError` can be caught and degrade that one feature instead of killing the process. Nothing in AdManageKit depends on which version resolves, or on WorkManager being initialized at all.
+
+### Other dependency updates
+
+- Android Gradle Plugin **9.3.2 → 9.4.0**
+- Firebase BOM **34.18.0 → 34.19.0**
+- Compose BOM **2026.08.00 → 2026.09.00**
+- Yandex Mobile Ads **8.3.0 → 8.4.0**
+- Robolectric (test only) **4.16.1 → 4.17**
+
+Unchanged: Google Mobile Ads Next-Gen SDK **1.4.0**, Play Billing **9.1.0**, Kotlin **2.2.10**, UMP **4.0.0**, Compose compiler **1.5.8**.
+
+## Fixed
+
+### A stray leading space in the `workRuntime` catalog entry
+
+The downgraded version was written as `" 2.9.1"` — with a leading space. Gradle does not trim version strings, so it treats that as a distinct and unresolvable coordinate rather than 2.9.1. Caught before tagging; the published 4.4.6 resolves `androidx.work:work-runtime:2.9.1` cleanly, verified against `:AdManageKit:dependencies`.
+
+## Notes
+
+- No behavioral change in any ad, billing, consent or waterfall path. The existing 176 tests pass unchanged
+- Robolectric stays pinned to SDK 35 via `robolectric.properties`; the 4.17 bump does not change that
+- There is nothing to migrate — upgrading is a one-line version bump from 4.4.5
+
+---
+
+## Upgrading
+
+```gradle
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit:v4.4.6'
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-billing:v4.4.6'
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-core:v4.4.6'
+
+// For Jetpack Compose support
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-compose:v4.4.6'
+
+// For Yandex Ads multi-provider support
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-yandex:v4.4.6'
+```
+
+No code changes are required.

package/content/docs/release-notes/RELEASE_NOTES_v4.4.7.md

@@ -0,0 +1,133 @@
+# Release Notes — v4.4.7
+
+**Release Date:** 2026-09-22
+
+## Overview
+
+v4.4.7 is a **build and packaging release**. No API was added, removed or changed, and **no library source file changed** — the diff is the five modules' ProGuard rule files, their build scripts, `gradle.properties`, the sample app's release build type, and documentation.
+
+The subject is the library's **consumer ProGuard rules**. A consumer rule is not advice: AGP appends it to the R8 configuration of every app that depends on the module, and the app has no way to opt out. `ad-manage-kit-compose` shipped `-keep class androidx.compose.** { *; }`, which meant every consuming app kept the entire Compose runtime un-shrinkable, un-optimizable and un-obfuscatable — including apps that never call a single AdManageKit composable.
+
+All five modules now ship a wired, **deliberately empty** `consumer-rules.pro`. On the sample app the result is **11.99 MB → 7.89 MB** of APK and **21.3 MB → 12.5 MB** of uncompressed dex.
+
+**If your app runs R8, you get this by upgrading.** There is nothing to configure and nothing to migrate.
+
+---
+
+## Changed
+
+### `ad-manage-kit-compose` no longer pins the Compose runtime in consuming apps
+
+The module's `consumer-rules.pro` contained three package-wide keeps. Measured with the AGP 9 R8 configuration analyzer against the sample app, their keep radius was:
+
+| Rule | Classes | Methods | Fields |
+|---|---:|---:|---:|
+| `-keep class androidx.compose.** { *; }` | 7221 | 57262 | 23964 |
+| `-keep class com.google.android.gms.ads.** { *; }` | 97 | 506 | 329 |
+| `-keep class com.i2hammad.admanagekit.compose.** { *; }` | 47 | 446 | 168 |
+
+R8 reads each as `DONT_SHRINK, DONT_OPTIMIZE, DONT_OBFUSCATE`. The first alone retained Compose runtime, foundation, UI and Material3 in their entirety — and it also **defeated Compose's own consumer rules**, which deliberately grant R8 latitude it can no longer use once the package is pinned wholesale:
+
+```
+-keep,allowobfuscation,allowshrinking class * extends androidx.compose.ui.node.ModifierNodeElement
+```
+
+None of the three rules was load-bearing. The module's composables are ordinary Kotlin functions that reach the view layer through `AndroidView` factory lambdas. There is no reflection, no `Class.forName`, no resource-name lookup and no serialization anywhere in the module, so R8 already resolves every edge from the consuming app's own call sites.
+
+### All five modules now ship a wired, empty `consumer-rules.pro`
+
+`ad-manage-kit-core`, `ad-manage-kit-billing` and `ad-manage-kit-yandex` previously declared no `consumerProguardFiles` at all, and `ad-manage-kit`'s file existed but was blank — so the contract was accidental rather than stated. Each file now carries the reasoning for why it holds no rules, so the next person to hit an R8 problem has something to read rather than a blank file to guess at.
+
+No module in the library uses reflection, `Class.forName`, JNI, `Parcelable`, `Serializable` or reflective serialization.
+
+**The ad views need no keep rule.** `BannerAdView`, `NativeBannerSmall`/`Medium`, `NativeLarge` and `NativeTemplateView` are inflated from XML, but AAPT2 already emits the matching rule into the generated `aapt_rules.txt` for exactly the views each app's own layouts reference:
+
+```
+-keep class com.i2hammad.admanagekit.admob.BannerAdView { <init>(android.content.Context, android.util.AttributeSet); }
+-keep class com.i2hammad.admanagekit.admob.NativeTemplateView { <init>(android.content.Context, android.util.AttributeSet); }
+```
+
+That is strictly better than a library rule, which would pin all five views in all apps regardless of use.
+
+**The native templates survive resource shrinking.** All 38 are referenced statically as `R.layout.*` constants from `NativeAdTemplate`, so R8 and the resource shrinker both keep them — along with the `ad_headline` / `ad_media` / `ad_body` / `ad_call_to_action` / `ad_app_icon` ids inside them, which `YandexNativeProvider` resolves by name through `Resources.getIdentifier`. Verified against the shrunk `resources.arsc`.
+
+If you add a new template asset id that is reached **only** by name, it needs a `tools:keep` entry in `res/raw/keep.xml` — that is the one case in this library where shrinking can outrun the code.
+
+### The sample app now builds release with R8 on
+
+`isMinifyEnabled` and `isShrinkResources` were both `false`. That is why none of the above was noticed: R8 had **never run anywhere in this repository**, so the rules shipped to consumers were never once exercised by the project that ships them. They now are, on every release build.
+
+Measured on the sample app, which depends on all five modules, Yandex included:
+
+| | Before | After | |
+|---|---:|---:|---:|
+| APK | 11.99 MB | **7.89 MB** | −34% |
+| dex (uncompressed) | 21.3 MB / 3 files | **12.5 MB / 2 files** | −41% |
+| Live classes | 37713 | **29297** | −22% |
+| Live methods | 186338 | **131255** | −30% |
+| Live fields | 106589 | **76004** | −29% |
+| Classes pinned by keep rules | 19307 | **11856** | −39% |
+
+Your own numbers will differ — the sample app is not a typical consumer, and an app that does not depend on `ad-manage-kit-yandex` starts from a very different baseline.
+
+### Two AGP 9 migration flags returned to their defaults
+
+`gradle.properties` carried:
+
+```properties
+android.r8.strictFullModeForKeepRules=false
+android.r8.optimizedResourceShrinking=false
+```
+
+Both were set in **v3.5.6**, the release that moved the project from AGP 8.13.1 to 9.0.1, described in that commit as being "for improved build stability during the transition". Nothing ever exercised them, because minification was off — the transition they were guarding was over before R8 ran for the first time. Both are now left at their AGP 9 defaults: strict full mode stops a member-less `-keep class X` from silently pinning X's members, and optimized resource shrinking lets unreachable resources actually go.
+
+These are project-local build settings and do not affect consuming apps.
+
+### The library modules still publish unminified AARs
+
+`isMinifyEnabled = false` remains set on all five modules, deliberately — a published AAR must keep its public API under its real names or consumers cannot compile against it, and shrinking there would only remove code the consuming app's R8 removes anyway, with far better whole-program information. Each module's `proguard-rules.pro` now says so.
+
+The one in `ad-manage-kit` previously ended with:
+
+```
+-keep class * {
+    *;
+}
+```
+
+Inert while minification was off, but a rule that would have disabled shrinking, optimization and obfuscation for the **entire program** the moment anyone switched it on. It is gone.
+
+## Notes
+
+- **Nothing to migrate.** An app that already enables R8 simply builds smaller after the upgrade. An app carrying its own defensive `-keep class com.i2hammad.admanagekit.** { *; }` can delete it — the library never needed it — though leaving it costs only size
+- **Verification boundary.** The removals are backed by a full R8 configuration-analyzer pass (no keep rule in the minified sample app now traces back to a project file — only AGP's own `proguard-android-optimize.txt` defaults), by confirming the shrunk `resources.arsc` still carries every native template layout and every dynamically-resolved `ad_*` id, and by the AAPT2-generated constructor keeps being present as described. The existing **176 tests pass unchanged**, but they run on the unminified debug variant and therefore do not cover R8 output. On-device verification of a minified release build is recommended, particularly for Yandex native templates — the only place in the library that resolves resources by name
+- **`ad-manage-kit-yandex` remains the dominant cost in a minified build**, and it is not the library's to remove. The Yandex Mobile Ads SDK's own consumer rules pin 5788 distinct classes (5631 under `-keepnames class yads.**` alone), and the AppMetrica tree it pulls in pins a further 2297. Apps using only the AdMob providers avoid all of it by not depending on the module
+- No dependency versions changed in this release
+
+### Checking your own build
+
+To see which rules dominate your app's keep radius (AGP 9.3+):
+
+```bash
+./gradlew :app:analyzeReleaseR8Config
+```
+
+The report lands in `app/build/reports/r8/`. Rules are ranked by how many classes, methods and fields each one pins, with the originating dependency or file named — which is how the Compose rule above was found.
+
+---
+
+## Upgrading
+
+```gradle
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit:v4.4.7'
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-billing:v4.4.7'
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-core:v4.4.7'
+
+// For Jetpack Compose support
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-compose:v4.4.7'
+
+// For Yandex Ads multi-provider support
+implementation 'com.github.i2hammad.AdManageKit:ad-manage-kit-yandex:v4.4.7'
+```
+
+No code changes are required.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "admanagekit-mcp-server",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "MCP server for AdManageKit Android library - documentation lookup and code generation",
   "main": "dist/index.js",
   "bin": {