# Changelog ## [3.0.9] - 2026-11-22 > Maven Central · iOS XCFramework · npm `latest` · Compared with `3.0.8-SNAPSHOT` · `d599124e2` - Build and distribution changed in 3 file(s), including `.github/workflows/sdk-release.yml`, `scripts/sdk-release-notes.mjs`, `scripts/sdk-release-notes.test.mjs`. ## [3.0.8-SNAPSHOT] - 2026-11-22 - Android hosts can preload an app open ad with `AdService.loadSplashAd` and choose when to show it. Banner and rewarded video ads use their existing interfaces. - Two optional Maven artifacts add Tencent GDT (`supersdk-ad-gdt`, API 23+) and CSJ for mainland China (`supersdk-ad-csj`, API 24+). Both support banner, rewarded video, and app open ads. The AdMob adapter also supports app open ads. The core SDK still supports API 23. - Web content in the Android host can select `GDT` or `CSJ` for banners and rewarded videos. The native host controls app open ads. This snapshot is available from Maven Central Snapshots, the iOS CDN, and npm. ## [3.0.7] - 2026-11-19 - This stable 3.0 release brings offline package version pinning, shared SDK version numbers, and the SwiftPM version-reporting fix to the production channels. - Use `3.0.7` on Maven Central, `@supersdk/jssdk@3.0.7` on npm, or the matching iOS XCFramework. ## [3.0.6-SNAPSHOT] - 2026-11-18 - Prebuilt iOS XCFrameworks moved to the CDN. Each release manifest provides a ZIP URL and a SHA-256 checksum. Hosts that previously copied the binary from the repository can use the URL in the version manifest. - Android and JSSDK adopted the same version. Release notifications now link to the corresponding documentation. ## [3.0.5-SNAPSHOT] - 2026-11-18 - The parallel Android, iOS, and JSSDK release completed. Release tooling fixed the Gradle memory settings, verification of versioned JSSDK bundles, npm registry propagation checks, and isolation of test files. - These changes affect how artifacts are built and distributed. Hosts can continue using the existing SDK interfaces. ## [3.0.4-SNAPSHOT] - 2026-11-18 - Intermediate build recorded in Maven Central Snapshots. There is no matching JSSDK version on npm. For a coordinated release across all three platforms, use `3.0.5-SNAPSHOT` or later. ## [3.0.3-SNAPSHOT] - 2026-11-18 - Intermediate build available on Maven Central Snapshots and npm as `@supersdk/jssdk@3.0.3-SNAPSHOT`. The repository has a completed three-platform release record for `3.0.5-SNAPSHOT`. ## [3.0.2-SNAPSHOT] - 2026-11-18 - Intermediate build recorded in Maven Central Snapshots. There is no matching JSSDK version on npm. For a coordinated release across all three platforms, use `3.0.5-SNAPSHOT` or later. ## [3.0.1-SNAPSHOT] - 2026-11-18 - The iOS SDK now reads its version from a generated source constant, including in SwiftPM source integrations. The prebuilt `3.0.0-SNAPSHOT` XCFramework already reported the correct version. - Both Android Maven artifacts and the iOS XCFramework use `3.0.1-SNAPSHOT`. JSSDK distribution files were generated with the same version. The first 3.x JSSDK package available on npm is `3.0.3-SNAPSHOT`. ## [3.0.0-SNAPSHOT] - 2026-11-18 > Beta version. Eight Android Maven modules published to Maven Central Snapshots, iOS XCFramework rebuilt from current source code, and JSSDK browser files distributed with documentation and templates. Functionality is identical to `1.0.0.69-SNAPSHOT`. ### Version rule change: Unified three-part version number across three platforms. - Starting from version `3.0.0`, Android, iOS, and JSSDK share the same three-part version number `x.y.z`. Prior to this, the frontend SDK used a four-part format `1.0.0.N-SNAPSHOT`, while JSSDK independently followed `2.x` (with the last version being `2.8.0`). - The beta version is `x.y.z-SNAPSHOT`, and the production version is `x.y.z`. - Integrator changes: Change the dependency version from `1.0.0.69-SNAPSHOT` to `3.0.0-SNAPSHOT`, keeping the snapshot repository configuration unchanged. - The SDK version reported at runtime (UA `SuperSDK/`, request header `X-SDK-Version`, `getEnv().sdkVersion`) is now consistent with the release version: previously, both native SDKs reported `1.0.0`; from this version onward, `3.0.0` is reported. The UA `SDKVersionCode/` changes from `1000001` to `3000000` (main × 1000000 + minor × 10000 + revision × 100). - Increment the revision number by 1 for each release; both the test and official versions are the next version `3.0.1`. Since npm version numbers can be published only once, the same test version number will not be published repeatedly. - The JSSDK `sdkVersion` has changed from `2.8.0` to `3.0.0-SNAPSHOT`, with no changes to other runtime behaviors. ## [1.0.0.69-SNAPSHOT] - 2026-11-17 > Dual-platform release: Android eight Maven modules upgraded simultaneously; iOS XCFramework rebuilt from current source code. Android template synchronously uses `1.0.0.69-SNAPSHOT`. This version includes two native changes: A/B testing (WS-12-S1 / S2 / S5 / S6, JSSDK 2.8.0) and offline package version isolation. Native changes require rebuilding the app to take effect. ### JSSDK 2.5.0 → 2.6.0 - Added `SuperSDK.experiment`: `ready` / `get` (synchronous, frozen on first read, default read triggers exposure) / `expose` / `getAll` / `refresh` / `setAttributes`; each tracking event automatically includes the exposed group ID `exp_vids` (v2.5.0, web path). - 2.6.0: If the container provides experiment bridge, `SuperSDK.experiment` is delegated to native code. The interface and return values remain unchanged. The native code is responsible for fetching results, freezing (shared with native code and other WebViews), reporting exposure (`source: "h5"`), and writing `exp_vids` for H5 events. The H5 no longer sends assign requests, nor does it report exposure or include `exp_vids` on its own. Old containers retain the web page path. ### JSSDK 2.6.0 → 2.7.0 (Server-side Experiment · WS-12-S6) - The `assign` result retains both client-side and server-side experiments, with each item in `getAll()` including a `type`. When `get(key)` reads a server-side experiment and returns that the user did not participate (`reason: "unknown"`), it does not freeze or trigger exposure, and concurrently logs a `SERVER_EXPERIMENT_READ` diagnostic. - Added synchronous methods `SuperSDK.experiment.getRequestHeaders()` (returns `{ "X-Super-AB-Vids": "" }`, or `{}` if the collection is empty), `appendVidsToUrl(url)` (appends or overwrites `super_ab_vids` while preserving other parameters and hash), and `fetch(input, init?)` (merges request headers and calls the global `fetch`, with SDK headers taking precedence for duplicate names). When calling, treat server experiments hit within the loaded namespace as read: frozen, counted as one **exposure**, and added to the set of exposed experiments (sharing the same collection as `exp_vids`). - In the web path, JSON POST requests sent by the SDK to the platform (assign, event tracking upload, monitoring, feedback, which already require preflight) automatically include `X-Super-AB-Vids`, containing only the currently exposed set, without triggering server-side experiment exposure. When the set is empty, the header is omitted. Configuration retrieval (settings GET, simple CORS request) does not include it to avoid adding new preflight checks. - When delegating to native within the host app, the three methods remain synchronous (reading the mirror), while `getExperimentRequestVids` is called asynchronously via JSB to fix the experiment with exposure. If the old container lacks this method, calculations are performed solely based on the mirror. - Integration points (CORS preflight, backend read order, verification, and finalization order) are detailed in the JSSDK documentation under the "Server-side Experiment" section. ### JSSDK 2.7.0 → 2.8.0 (Emergency Stop · WS-12-S5) - In the accepted complete assign response (excluding `not_modified` and responses discarded due to outdated `rules_version`, consistent with native), the keys listed in the `emergency_stopped` column: immediately unfreeze this page, after which `get` returns uninvolved (`reason: "paused"`, default payload) and no longer exposes; its `vid` is removed from the exposure set, and subsequent events `exp_vids` along with `getRequestHeaders()` / `appendVidsToUrl()` / `fetch()` no longer include it; one diagnostic `EMERGENCY_STOPPED` is sent per key. After the experiment resumes, this page remains stopped within the current session, and the group is re-read only upon the next page opening. - When native delegation occurs within the app, it is handled by the native side. Upon receiving the native "paused" response via `get` or after refreshing the mirror with `refresh()`, the value within the page is corrected, and the `vid` is removed from the mirror's exposure set. - Full (`rollout`) result behavior remains unchanged: participate, no exposure, not counted in `exp_vids` and request headers; testing has been completed. ### Added shared JSB (63 methods in total) - S6: `getExperimentRequestVids(callbackId, paramsJson)`, input `{}`, returns `{ vids }`; `getAllExperiments` adds `type` and `exposed` to each item. - `experimentReady`, `getAllExperiments`, `getExperiment`, `exposeExperiment`, and `setExperimentAttributes` all have the signature `(callbackId, paramsJson)` for asynchronous callbacks; the Android / iOS `BridgeProtocol` has been regenerated from `protocol/v1.json`. ### Android / iOS - Added native experiment interface `SExperiment` (`get` / `expose` / `getAll` / `awaitReady` / `setAttributes` / `addNamespaces` / `refresh` / listener), with identical names and semantics on both platforms: groups are calculated by the server based on device ID, the SDK is responsible for fetching and persisting data by `spid` + environment + device ID, session freezing (App backgrounded for more than 30 minutes is treated as a new session), exposure deduplication, and writing `exp_vids` when events are created. Integration instructions are available in the Android / iOS README. ### Offline Package Version Isolation and Origin Fallback Rules (Android / iOS) - Fix page resource mixing between local and online during offline package updates: Previously, after starting to download a new package, the old package became entirely unreadable, and resources within the package that did not match on Android would directly fall back to the online site. After installing the new package, pages currently running would read the new version files. - The page binds to the offline package version at load time; downloading, verifying, and installing a new package no longer affects reading the old package. The new version is used only for subsequent new pages, and the old version files are retained until the last page using them releases them. - After binding the version, if resources within the package are missing or fail to read, an error response is returned (with the reason provided in `X-Super-Offline-Error`), without fetching from the source or switching versions. - The package's `__super_meta.json` now includes an optional `remote_paths` field, declaring the paths under the package host that are allowed to connect to the network. `super_package.sh` now supports the `--remote-path` flag. For iOS offline pages, cross-origin requests without a network channel will return `remote_path_unsupported` when matched. - Added `PageLoadConfig.requireOffline` (Android `setRequireOffline(true)` / iOS `PageLoadConfig(requireOffline: true)`): When no valid offline package is available, display an error message with a retry entry instead of implicitly loading the online page. If not set, pages without an offline package will load entirely from the online page. - Offline package storage is changed to version-independent immutable directories; packages installed by older SDK versions are automatically migrated on first launch. Incomplete packages are not activated due to installation interruption, verification failure, or process restart. - Behavioral changes: Requests that share the same domain as the offline page and are not declared in `remote_paths` will no longer connect to the network; `getEnv().wappVersion` returns the version bound to the current page; during the download of a new package, `getPackage` / `getAllPackages` still return the installed version; offline package local responses are changed to `Cache-Control: no-store`. ## [1.0.0.68-SNAPSHOT] - 2026-11-12 > Dual-platform release: Android eight Maven modules upgraded simultaneously; iOS XCFramework rebuilt from the current source code. The Android template synchronously uses `1.0.0.68-SNAPSHOT`. ### Offline package supports independent CDN download. - The `pkg_path` in the v1 manifest `super_meta.json` for Android and iOS supports full HTTPS URLs, allowing the use of independent CDN domains without requiring a download domain whitelist; existing site-root-relative paths remain compatible. - The complete download URL is not double-encoded, preserving the CDN signature query parameters; business ownership `host`, installation directory, and version threshold remain isolated according to the page's origin host. - Preserve size, MD5, in-package version, and decompression verification; cross-origin downloads do not relax the consistency check between the `host` in the manifest and the business domain. - Old SDKs do not support absolute URLs; manifests for legacy apps continue to use relative paths. Mismatched `host` in custom domain manifests still requires server-side fixes. - Share 27 groups of download address contract use cases between both ends and include them in the offline package CI. ## [1.0.0.67-SNAPSHOT] - 2026-10-31 > Dual-platform release: Android eight Maven modules (api / base / impl / supersdk / auth-google / pay-google / ad-admob / push-firebase) upgraded simultaneously; iOS XCFramework rebuilt from the current source code. The bundled JSSDK synchronizes the latest payment parameter validation fix, and the Android template is upgraded to the same version. ### Payment fix - Android / iOS payment receipt pass-through business `accountId`, used by business services to identify the payment account; does not change the project identity `X-Aid`. - Google Play Payments adds a host-level `requireProfileId` switch (default: disabled). When enabled, `INVALID_PARAMS` is returned before initiating a charge if `profileId` is missing. - The JSSDK `pay.purchase` method returns `INVALID_PARAMS` when an inline `createOrder` is passed without the corresponding `pay` method, preventing the silent discard of order creation logic. ### iOS artifact update - Complete the shared push bridge protocol following the previous Android-only release: the four push JSB methods return `NOT_SUPPORTED` on iOS; this version does not include iOS Firebase push implementation. - The XCFramework includes device arm64 and simulator arm64 / x86_64, with build source records and verification information attached. ## [1.0.0.66-SNAPSHOT] - 2026-10-18 > 📌 **This release includes only Android (Maven) + JSSDK** (2026-10-18 · Linux build): `1.0.0.66-SNAPSHOT` with eight artifacts released simultaneously (`api` / `base` / `impl` / `supersdk` / `auth-google` / `pay-google` / `ad-admob` / **`push-firebase` new**). iOS xcframework **will not be rebuilt**; `release_doc/supersdk/1.0.0-SNAPSHOT/iOS/` retains existing artifacts. The current release environment is Linux, without Xcode. iOS source code (`PushBridge` stub + `AppBridge` injection / distribution) will be validated on macOS via `xcodegen generate && xcodebuild … test` and included in the next `--platform ios` release. > > Same batch switch: `supersimples` Android template `sdk.androidVersion` → `1.0.0.66-SNAPSHOT` (`1.0.0.65-SNAPSHOT` was released on both platforms on 2026-10-12; this version number cannot be reused). ### SuperPush Notification · Android Client (SDK-F042 · WS-18-S2) - **Core `PushService` (`supersdk-api` / `supersdk` / `supersdk-impl`)**: `SuperSDKProvider.getPushService()` adds a default `null` getter; `SuperSDK.getPushService()` static accessor; `SDKPushService.Builder().addProvider(…).allowUrlScheme(…)`; `PushService` provides `getToken / requestPermission / getPermissionStatus / setTags / setUserId / setListener / getStatus`, with safe invocation before initialization (listeners take effect immediately, tags / userId are queued and replayed). Registration logic is channel-agnostic: register to `POST /superapi/v2/push/register` upon first obtaining token, token refresh, `setAPIEnvironment` switch, tag / user ID change, permission result, or cold start / background-to-foreground visibility change. Fingerprint (env + token + tags + user_id + enabled + locale + version) deduplicates every 24 hours; failures do not retry within the process. `getStatus()` exposes `registered` and closed-set `lastError` (`TOKEN_UNAVAILABLE / NOT_FOUND / INVALID_REQUEST / RATE_LIMITED / NETWORK_ERROR / UNAVAILABLE`). Initialize only in the main process. - **New external package `com.supersdk:supersdk-push-firebase`** (depends only on `api + base`, includes `firebase-messaging`): `FirebasePushProvider` retrieves the token, `SuperFirebaseMessagingService` receives messages, and the host app builds a `supersdk_push_default` channel in the foreground to display the title, body, and large image. For Android 13+, the `POST_NOTIFICATIONS` permission is requested via `requestPermission`. Clicks are routed through `SuperPushTrampolineActivity`: launch the host app's main Activity → send a receipt to `POST /superapi/v2/push/opened` (≤2 seconds) → open the authoritative `url` returned by the server via the existing `NavigationService.openPage` path (zero host code required to open a specific page). If the receipt is unreachable, only the main Activity is launched without opening the URL; callbacks, events, and reporting still proceed with `verified=false`. Host apps with their own `FirebaseMessagingService` can use `tools:node="remove"` to forward `FirebasePushProvider.handleNewToken / handleMessage`. When unconnected (getter returns `null`), all components perform a silent no-op. - **Open Tracking**: When clicking a compliant `message_id`, the `$push_open` event is reported via the existing event pipeline (`message_id / url? / click_type / verified`), with exactly one event per click. - **`SuperSDK.setAPIEnvironment`** Added Step 5: Triggers push re-registration when connected (no change if not connected). - **Logs**: Unified tag for push notifications is `SuperPush`; on physical devices, use `adb logcat -s ss-SuperPush`. Logs do not contain complete `token`, `user_id`, or `tags` values. ### JSSDK 2.4.0 · `SuperSDK.push` namespace - Added `SuperSDK.push.getStatus() → { supported, permission, registered, lastError?, lastOpened? }`, `requestPermission() → { permission }` (callback timeout 120 seconds), `setTags(tags)`, `setUserId(id)` (`[]` / `null` / `''` = clear; boundaries determined by Native), and `onMessage(cb)` / `onOpened(cb)` (returns unsubscribe, delivers only to subscribed active WebViews). `lastOpened` is a one-time value; it is cleared once any WebView retrieves it. - Browser: `getStatus()` resolves `{ supported: false }`, otherwise rejects with `NOT_SUPPORTED`; Host app not connected: `supported: false` + `UNSUPPORTED`; Native version too old: `SDK_TOO_OLD`. - Added contract fixture `protocol/push-v1.json` (register / opened request/response, FCM mapping, error codes, `$push_open`), released with the public tarball, referenced by both server-side and Android unit tests. ### JSB Protocol (`protocol/v1.json` · Dual-side `BridgeProtocol` regeneration) - Methods 53 → **57**: `pushGetStatus(callbackId)`, `pushRequestPermission(callbackId)`, `pushSetTags(callbackId, tagsJson)`, `pushSetUserId(callbackId, userId?)`. - Event 4 → **6**: `push.message`, `push.opened` (BROADCAST channel). - Added alias `NO_ACTIVITY` to the `UNAVAILABLE` error group (no available Activity for `requestPermission`, retryable). - **iOS**: Added `PushBridge.swift` stub with four methods uniformly returning `NOT_SUPPORTED`. `AppBridge.swift` script injection and `handleMethod` are synchronized to ensure the shared manifest is consistent across both platforms. The actual implementation will be delivered with SDK-F043. **This batch of iOS source code has not been compiled or verified** (Linux environment). ### Documentation - `SUPERPUSH.md` Sections 2.1, 2.2, 2.4, and 2.5 are now formalized (Android delivered; iOS, Console, and CLI are still planned). Section 3 machine-side examples updated to include the `spid` field. - `Android/README.md` added "Optional Capability Module Integration · Push (supersdk-push-firebase)"; `GUIDE.md` capability overview "Message Push" row updated to "Android SDK delivered". - Add the `SuperSDK.push` chapter to `JSSDK.md` and synchronize it to `release_doc/supersdk/dev/JSSDK/`. ## [1.0.0.65-SNAPSHOT] - 2026-10-12 > 📌 **Dual-platform release**: Android Maven `1.0.0.65-SNAPSHOT` + iOS xcframework both rebuilt from source code. The `supersimples` Android template `sdk.androidVersion` is switched to `1.0.0.65-SNAPSHOT`. ### Internal API requests carry the host app identifier - Android automatically sends `X-Package-Name`, which is the package name of the host app's Application Context. - iOS automatically sends `X-Bundle-Id`, with the value `Bundle.main.bundleIdentifier`. - Internal API requests and backup line retries for settings, event reporting, attribution, short links, etc., all carry the corresponding platform identifier; null values are skipped, and host app network extensions cannot override identifiers already set by the SDK. - No additional configuration is required for the host app; existing request parameters and response handling remain compatible. ## [1.0.0.64-SNAPSHOT] - 2026-09-22 > 📌 **Dual-platform release**: Android Maven `1.0.0.64-SNAPSHOT` + iOS xcframework both rebuilt from source code. The `supersimples` Android template `sdk.androidVersion` is switched to `1.0.0.64-SNAPSHOT`. ### WebView Microphone Permission (Container Capability) H5 `navigator.mediaDevices.getUserMedia({ audio: true })` is handled by the SuperSDK container; the host app no longer needs to include `WebChromeClient` / `WKUIDelegate`. - **Android** - The container handles pure `AUDIO_CAPTURE`; requests containing `VIDEO_CAPTURE` or other non-audio resources are entirely denied. - Use `SuperPageActivity` / `IPageController.open()`: **No Java code required**; automatically injects the public `com.supersdk.api.page.IFileChooserHost`. - Self-packaging: The Activity implements this interface (including `launchMicrophonePermission`), registers the launcher in `onCreate`, and prohibits replacing `WebChromeClient`. - **The host app must declare `RECORD_AUDIO` independently (SDK does not merge it).** `CAMERA` is still merged by the SDK (for photo capture via ``). - **iOS 15+** - `SuperWebView` implements `WKUIDelegate.requestMediaCapturePermissionFor`: if `NSMicrophoneUsageDescription` is missing or empty for `microphone`, deny; otherwise, prompt. For `camera`, always prompt. For `cameraAndMicrophone`, if the microphone description is missing, deny; otherwise, prompt. It does not read `AVCaptureDevice`. - iOS 14 does not support this API; use the system default. `createPageView` / `createPageViewController` no longer require wrapping with UIDelegate. - **Host app Info.plist requires `NSMicrophoneUsageDescription`**; if missing, the container denies and does not start collection. - Demo / `supersimples` iOS template includes microphone usage description; fe-main test page adds getUserMedia audio button (requires https secure source). ## [1.0.0.63-SNAPSHOT] - 2026-09-16 > 📌 **This release is for Android (Maven) only**: `1.0.0.63-SNAPSHOT` has been published to Maven Central Snapshots (api / base / impl / supersdk / auth-google / pay-google / ad-admob released in the same batch). The iOS xcframework **has not been rebuilt**; `release_doc/supersdk/1.0.0-SNAPSHOT/iOS/` retains existing artifacts. The release environment for this batch is Linux, without Xcode. The iOS source code (`SFeedback` + JSB) will be released later after validation via `xcodegen generate && xcodebuild … test` on macOS. > > Same batch switch: `supersimples` Android template `sdk.androidVersion` switched from `1.0.0.62-SNAPSHOT` to `1.0.0.63-SNAPSHOT`. ### User Feedback (Android / iOS / JSSDK 2.3.0 / Super Server / Console) - **SDK Three-Platform Feedback Submission API**: JSSDK `SuperSDK.submitFeedback({ scene, subScene?, title, content, userId?, extra? }) → { feedbackId }` (in-app uses new shared JSB `submitFeedback(callbackId, paramsJson)`, web connects directly to `/v2/feedback`); Android `SFeedback.submit(FeedbackRequest, Callback)` (`com.supersdk.base.feedback`); iOS `SFeedback.submit(FeedbackRequest, completion:)`. The SDK automatically fills in `spid / env / device_id / platform / app_version / sdk_version / os_version / device_model`; `userId` is passed by the caller per request. - **Server-side**: Super Server adds `POST /superapi/v2/feedback` (and `/api/v2/feedback`) proxying to `console-main` for public ingestion via `POST /api/public/v2/feedback`. Rate limiting follows `spid/env` syntax with `clamp` → `fail-closed` strategy: 10 requests per minute per IP, 600 requests per minute per project. Process flow: parse project/environment → validate → ingest into `console_user_feedback`, recording submission time and user IP. Field rules: `scene` ≤ 64, `title` ≤ 200, `content` ≤ 5000, `sub_scene` ≤ 64, `user_id`/`device_id` ≤ 128, `extra` JSON object ≤ 4KB. - **Console**: Added the first item under "Business Operations" called "User Feedback" (`/feedback`), which also serves as the landing page for Business Operations: Lists scene / sub_scene / user_id / device_id / title / feedback time / status by project × environment; supports filtering by title/content keywords, scene, and status, along with server-side pagination; clicking a row opens a detail modal (content, user IP, platform/version/device, extra) with options to "Mark as Processed" or "Reopen". - The JSB protocol list has been increased to 53 methods; `BridgeProtocol` on both ends is regenerated from `protocol/v1.json`. ## [1.0.0.62-SNAPSHOT] - 2026-09-02 > 📌 **This release is for Android (Maven) only**: `1.0.0.62-SNAPSHOT` is published to Maven Central Snapshots (including `querySubscriptionOffers`). The iOS xcframework **has not been rebuilt**; `release_doc/supersdk/1.0.0-SNAPSHOT/iOS/` retains the 1.0.0.60 artifacts (`source_commit=40635ffd`). The release environment for this batch is Linux, with no Xcode available. > > Same batch switch: `supersimples` Android template `sdk.androidVersion` switched from `1.0.0.60-SNAPSHOT` to `1.0.0.62-SNAPSHOT`. ### Google Play eligible subscription offers(Android + JSSDK 2.2.0) - Added `SuperSDK.pay.querySubscriptionOffers({ provider, productIds })`, which returns only the eligible offers provided by the current Play account for `queryProductDetailsAsync()`. The structure includes product/base plan/nullable offer ID/tags/title/description/pricing phases, **excluding `offerToken`**. - Added Android public DTOs `SubscriptionOfferInfo` and `SubscriptionPricingPhase`, and integrated the flow `PayProvider → PayService → SDKPayService → PayBridge → AppBridge`; legacy providers and host apps maintain compatibility by defaulting to `NOT_SUPPORTED`. iOS shared JSB returns `NOT_SUPPORTED` only. - Subscription purchases no longer reuse historical `ProductDetails`; each purchase re-queries `ProductType.SUBS` to precisely match the latest eligible offer using `productId + basePlanId + nullable offerId`, then passes its token to `setOfferToken()`. Eligibility changes return `OFFER_UNAVAILABLE` without silently switching prices. - Remove the erroneous `new JSONObject(productDetails.toString())`; both product and offer DTOs are constructed entirely via BillingClient public getters, without relying on internal JSON, reflection, or `toString()`. - Add/Converge error contracts: `PRODUCT_NOT_FOUND`, `OFFER_UNAVAILABLE`, `BILLING_UNAVAILABLE`, `QUERY_FAILED`, `USER_CANCELLED`, `PURCHASE_FAILED`. Neither errors nor logs include the offer token. - `queryProducts()`, in-app purchases, and public behaviors of non-Google providers remain unchanged; Settings, UI ordering, Play Console full catalog, business order creation/entitlements, and server-side receipt verification are still outside the SDK scope. ## [1.0.0.61-SNAPSHOT] - 2026-08-31 ### Google Play Subscription (`supersdk-pay-google` plugin) - The `google_play` provider input now includes `productType: "subs"`, with `basePlanId` as required and `offerId` as optional. If `productType` is not provided, it continues to be processed as `inapp`, maintaining compatibility with one-time product purchases. - Use `ProductType.SUBS` to query subscription products, and precisely match `basePlanId + offerId` from the `SubscriptionOfferDetails` returned by Google; if `offerId` is omitted, select the offer for the base plan itself. - On successful match, write the corresponding `offerToken` to `BillingFlowParams.ProductDetailsParams`; if no match is found, return `OFFER_UNAVAILABLE` without launching the Billing UI. - The existing purchase compensation query for `ITEM_ALREADY_OWNED` follows the current purchase `productType`; subscriptions no longer query `INAPP` first. - `google_play`'s `restorePurchases` queries subscriptions only and no longer merges one-time items. - Added subscription query, base plan/offer selection, missing parameter/no match error handling, and restore purchase testing. > This version only updates the Android auxiliary package and parameter documentation; the SuperSDK core, `PayBridge`, and JSSDK runtime logic remain unchanged. The `supersdk-api` and `supersdk-base` modules released in the same Maven batch are unmodified and included solely to satisfy the transitive dependency of `supersdk-pay-google:1.0.0.61-SNAPSHOT` at the same version. ## [1.0.0.60-SNAPSHOT] - 2026-08-30 ### New: Unified suenc response obfuscation capability (Android / iOS / JSSDK / Super Server four-end) Lightweight response obfuscation protocol `suenc`: When the client explicitly requests `?suenc=1`, the server encodes the JSON response body using a custom Base64 table and returns `X-Su-Enc: b64t1`; the client transparently decodes it at the unified network layer. > ⚠️ **Only used to reduce the effectiveness of general keyword scanning and rule matching, not encryption**: Does not provide confidentiality, tamper resistance, or replay protection, and cannot prevent attackers who have obtained client-side code from restoring the encoding table. - **Codec Single Source of Truth**: `packages/jssdk/protocol/suenc-v1.json` + cross-language stable vector `suenc-v1-golden.json`, generated by `scripts/generate-suenc-contract.mjs` into JS / TS / Android / iOS four-platform constants (`--check` can verify generation drift). The encoding table must pass fail-closed validation as a valid full permutation of standard Base64 64 characters. **After `b64t1` release, the encoding table is immutable; new tables must use a new codec key.** - **SDK internal request auto-decoding**: covers all `settings`, `reportEvent`, `attribution`, and short links; **non-2xx responses are also decoded first** before constructing errors; each response is decoded at most once. When the response lacks `X-Su-Enc`, the behavior remains exactly as before. - **The SDK does not append `suenc=1` by default**: Enabling this feature is a release decision between the host app and the target server. The host app injects extended query parameters / headers into SDK internal requests via the newly added `HostNetworkExtensionService` (available on both sides, all optional, and disabled by default). **In case of conflict with SDK-native parameters, the SDK value always prevails** (header name comparison is case-insensitive). If the host app implementation throws an exception or returns an invalid value, the request is skipped and a sanitized log is output, without blocking the main flow. - **Prevent Plaintext Downgrade**: When the request includes `suenc=1` but receives a response without `X-Su-Enc`, the line is marked as failed (`SUENC_DOWNGRADE`). The system reuses the existing `baseUrl` rotation to switch to the next line, and **never passes the plaintext response to the business logic**. - **External API**: JSSDK `SuperSDK.getSuEncCapabilities()` / `SuperSDK.decodeSuEnc(encodedData, codec)` (synchronous pure functions, bypassing JSBridge); Android `SuperSDK.decodeSuEnc/getSuEncCapabilities`; iOS `SuperSDKManager.decodeSuEnc(_:codec:)/getSuEncCapabilities()`. Error codes: `UNSUPPORTED_SUENC_CODEC` / `SUENC_DECODE_FAILED` / `SUENC_INVALID_UTF8` / `SUENC_DOWNGRADE` / `SUENC_RESPONSE_TOO_LARGE` / `SUENC_PROTOCOL_ERROR`. - **Super Server**: Added response encoding middleware that applies only to `application/json` and `*+json` content types, preserving the original status code. Non-JSON responses (e.g., `attr.js`, `healthy`, short link redirects) are passed through unchanged. The `suenc` parameter is stripped before entering the business handler and forwarding to the upstream. **Compatibility**: Requests without `suenc=1` behave exactly as with older clients; all new host app interfaces are optional with default implementations, requiring zero changes for existing integrators. ## [1.0.0.59-SNAPSHOT] - 2026-08-30 > 📌 **Dual-Platform Release** (Unified version number across both platforms): This version's functional changes involve the **iOS** offline package loading mechanism; Android rebuilds with the version (no functional changes to content). ### Changes (iOS · Offline Package Request-Level Interception) - **Offline package loading is changed from `loadFileURL` to a custom scheme (`super-offline://`) request-level interception**, aligning with the Android `shouldInterceptRequest` semantics. Previously, offline hits via `loadFileURL` only mapped the main document; offline packages constructed with `base:'/'` (absolute path) + History routing (where sub-resources fall to the file system root → 404) resulted in a blank screen. After the modification, the page runs on a stable `super-offline://{host}` origin, `/` maps to the package directory, and each sub-resource is mapped to a local file by `OfflineSchemeHandler` per request, making both `base:'/'` and History routing functional. - Hit response alignment for Android: `200` + `Content-Type` (text type with `charset=utf-8`) + `Access-Control-Allow-Origin: *`; includes **SPA fallback** (no extension and not found → `index.html`) and **directory traversal guard** (parsed path must remain within the package directory); MIME table aligned with Android 33 items. - **Fix included**: Previously, `getEnv()`'s `wappVersion` was always empty when loading via `file://` (now `webView.url` is a scheme, and `getPackageForUrl` directly matches). - ⚠️ **iOS Offline Page origin changes to `super-offline://{host}` (not a real domain, not a secure context)**: Integration partners should note: ① If the offline page relies on Service Worker / WebCrypto, this scheme is unsupported (`super-offline://` is not a secure context); ② If the offline page calls your own backend API, it will be treated as cross-origin, requiring the backend to return CORS headers (when sending credentials with cookies, `*` cannot be used; instead, echo back the `origin` + `Allow-Credentials`); ③ POST/PUT bodies sent via fetch/XHR to this scheme will be discarded by WebKit; APIs must use absolute HTTPS URLs. ## [1.0.0.58-SNAPSHOT] - 2026-08-30 > 📌 **Dual-Platform Release**: This version rebuilds and releases the iOS xcframework on macOS (consolidating all outstanding iOS deliverables from version 1.0.0.54 onwards, including all iOS-side source code changes from 1.0.0.55 to 57) + Android Maven. > The JSBridge feature gap between iOS and Android has been eliminated in this version. ### Add (iOS) - **`showRewardedInterstitialAd` JSB**: Complete the iOS implementation (previously supported only on Android). Host injection mode: The `AdService` protocol adds `loadRewardedInterstitialAd` (with a default implementation, ensuring zero-breaking changes for legacy host providers); if not injected, it returns `NOT_IMPLEMENTED`. Behavior aligns with Android: full-screen ad mutual exclusion (`AD_ALREADY_SHOWING`), and `{dismissed, rewarded}` callbacks. - **`ShareController` Native Short Link API**: `SuperSDKManager.getShareController()` provides `requestShortUrl` / `requestShortUrlWithHtml` (supporting custom `baseUrl` prefix), aligned with Android `SuperSDK.getShareController()`; `ShareBridge` short link JSB delegates to the same implementation (consistent with Android architecture). H5 system sharing (`UIActivityViewController`) is natively built-in and requires no host app injection. ### Fix (iOS) - **`SReporter` duplicate `asyncFlush()` compilation error**: 1.0.0.55 (Android-only release, no macOS compilation verification) erroneously added duplicate internal declarations, causing subsequent iOS source code to fail compilation. Remove the duplicate version and retain the `asyncFlush() → flush()` semantics consistent with Android (persist to disk first, then upload). - **Add `GENERATE_INFOPLIST_FILE: YES` to the `SuperSDKTests` target** (`apps/ios/project.yml`): `xcodebuild test` can now run directly under the new Xcode version. ### Documentation - Remove the note "Currently supported only by Android native bridge" from `showRewardedInterstitialAd` in `JSSDK.md` (both platforms are now aligned). - iOS README added `ShareController - Short link generation` section. ## [1.0.0.57-SNAPSHOT] - 2026-08-17 > Merge release: `feat/sdk-api-environment` (project environment runtime) merged into staging > > This version = **1.0.0.55 project environment runtime** + **1.0.0.56 deviceId privacy compliance rectification**, > Previously, these were released separately on their respective branches and never coexisted in a single build. Integration partners should directly use this version. > Do not use 1.0.0.55 / 1.0.0.56 (each missing half). > > 📌 **This release covers Android (Maven) only**: The iOS source code and documentation are ready, but the xcframework has not been rebuilt yet. > `release_doc/supersdk/1.0.0-SNAPSHOT/iOS/` Keep existing artifacts unchanged. iOS requires separate handling on macOS. > Execute `bash scripts/publish.sh --platform ios` to generate the build package (cumulative missing iOS artifacts starting from version 1.0.0.54). ### Same batch switching - The `supersimples` Android template and related assertions have been updated from `1.0.0.55-SNAPSHOT` to `1.0.0.57-SNAPSHOT` (the `test_sdk_identity_contract` guard enforces "template version == derived VERSION_CODE"). The iOS template/mock remains pinned to the older `1.0.0.54` signature, with anchors temporarily split until the iOS artifacts are reissued and merged in the same batch. ### This version includes - 1.0.0.55-SNAPSHOT includes all content (init removed `environment` parameter · `setAPIEnvironment`/`getAPIEnvironment` · JSSDK 2.1.0 · `getNetEnv`/`ApiEnv` deprecated) — see the 1.0.0.55 entry below; **breaking changes and migration examples also apply to this version**. - 1.0.0.56-SNAPSHOT full content (removed `ANDROID_ID` reading · `HostConfigService.generateDeviceId()`) — see the 1.0.0.56 entry below. ## [1.0.0.56-SNAPSHOT] - 2026-08-17 > Device ID Privacy Compliance Remediation (Android) + Host App Taking Over Device ID Generation (Dual-Platform API) > > 📌 **This release covers Android (Maven) only**: The `generateDeviceId` source code and documentation for iOS are ready but not rebuilt. > xcframework, `release_doc/supersdk/1.0.0-SNAPSHOT/iOS/` keep existing artifacts unchanged. iOS requires macOS. > Execute `bash scripts/publish.sh --platform ios` separately to generate the package. ### Privacy Compliance (Android · Device Identifier) - **Remove `Settings.Secure.ANDROID_ID` reading**: Regulate the rectification notice "No explicit consent, the app collects AndroidID / requests to carry AndroidID". `SDevice.getOrCreateDeviceId` no longer reads ANDROID_ID; the deviceId defaults to **self-generated random UUID and persisted to SP**. - The deviceId downgrade chain is changed to: **Memory Cache → SP Persistent Value → Host `generateDeviceId()` → SDK Self-generated UUID**. The full link does not read system device identifiers such as ANDROID_ID, IMEI, MAC, or OAID. - **Existing legacy users are unaffected**: The 16-hex value written by older versions to SP continues to be used (`isValidAndroidId` is renamed to `isLegacyHexDeviceId` and serves solely for legacy compatibility checks), preventing attribution or retention breakpoints caused by device ID discontinuity. The regression value interception logic from BUG-SDK-B001 (all zeros / identical characters / Froyo collision values / non-hex / abnormal length) is preserved as-is. - iOS is not involved: `identifierForVendor` is an official Apple vendor identifier, not included in the reporting clause, and behavior remains unchanged. ### Added (Dual-end · Host app takes over deviceId) - `HostConfigService` adds an optional method `generateDeviceId()` (Android `@Nullable String` / iOS `String?`, both with default implementations, **non-breaking for existing host app integrations**). - Call only when the SDK needs to **generate a new deviceId** (on first install or when the local old value becomes invalid); the persisted deviceId continues to be used. A non-empty string is adopted and persisted (Android writes to SP, iOS writes to Keychain); returning `null`/`nil`/an empty string triggers the SDK's default logic. - The host app source ID allows custom formats and only rejects blank values (no SDK-side format validation is applied to prevent custom formats from being mistakenly judged as degraded and discarded). - Implementation requirements: **Synchronous fast return** (may be called early in the network request/event reporting path), stable return values on multiple calls; when the host app throws an exception, the SDK catches it and falls back to default logic. ## [1.0.0.55-SNAPSHOT] - 2026-08-15 > 📌 **This version of Android Maven has been released; iOS xcframework/SPM packages must be installed separately on macOS.** > `bash scripts/publish.sh --platform ios` Build release **(this release batch has no Xcode, consistent with the precedent of 1.0.0.54). > The **Android** SuperSDK template has been switched to this version and the new API in the same batch; the **iOS** template and MockSuperSDKPackage > Still mirroring 1.0.0.54 with the old signature (temporary anchor split in `test_ios_spm_template.py`), to be switched in the same batch and unified anchors after the iOS artifact is released. > Refresh the release document version directory (`release_doc/supersdk/1.0.0-SNAPSHOT/`) once the iOS artifacts are ready to avoid copying outdated binaries. ### Breaking Changes - **Remove `environment` parameter from `init`**: Android removes the `init(context, spid, environment, provider)` overload, keeping only `init(context, spid, provider)`; iOS `initialize` synchronously removes the `environment:` parameter. The project environment is now an independent runtime state, and `init` no longer touches it. ### Add - **`setAPIEnvironment(environment)` / `getAPIEnvironment()`** (Android `SuperSDK` static method / iOS `SuperSDKManager` instance method): Corresponds to the `env` in the top bar of the console, switchable at runtime (before or after `init`). The SDK does not persist data; the default is `prod` upon process startup. The host app must persist the value and call `set` after startup. Switching side effects: flush existing reported events for the old environment → switch value → clear cache in `settings` and re-fetch based on the new environment → refresh the live WebView UA. Full-link dynamic following for `settings` fetch (`env` parameter), reporting (`basic_data.env` + `X-Super-API-ENV` header), UA `ProjectEnv/`, and JSB `getEnv()`. - **JSSDK 2.1.0**: Same-name Promise interface. Web fallback mode is enabled (flush pending events before switching, settings request cache is naturally isolated by environment); `UNSUPPORTED` is set in the reject of `set` (environment controlled by the host app), and `get` passes through the native value. ### Deprecated - `HostConfigService.getNetEnv()` and `ApiEnv` (marked as `@Deprecated` in Android / documented as such in iOS): This "API network environment" dimension has never been consumed by the SDK. Use `setAPIEnvironment` for the project environment and `getSdkApiBaseUrls()` for the API domain. ### Migration Example - Android:`SuperSDK.init(context, "ab12cd34", "prod", provider)` → `SuperSDK.setAPIEnvironment("prod"); SuperSDK.init(context, "ab12cd34", provider)` - iOS:`initialize(spid:environment:provider:)` → `try setAPIEnvironment("prod"); try initialize(spid: "ab12cd34", provider: provider)` - JSSDK web: `initFallback({ spid, environment })` remains unchanged (as the initial value); use `await SuperSDK.setAPIEnvironment('staging')` to switch at runtime. ## [1.0.0.54-SNAPSHOT] - 2026-07-30 > BREAKING: The identity for the three-platform project is unified as `spid + environment`. > > 📌 **Android artifact actual release on 2026-08-09**: Code and documentation were completed on 2026-07-30, `vars.properties` > The `VERSION_CODE` was then stuck at 1000053, and the Maven release was not executed, so `1.0.0.54-SNAPSHOT` has long not existed, > The SIMP template has been pinned to it, causing the generated Android project's dependency resolution to fail with 404 errors and the app to crash immediately upon launch. The issue has been resolved, and new features have been added. > Offline Guard (`supersimples/tests/test_sdk_identity_contract.py`) fixes "Template Version == VERSION_CODE". > derived value" to prevent further drift. The iOS xcframework must be published separately on macOS using `bash scripts/publish.sh --platform ios`. ### Breaking Changes - Android initialization changed from `init(context, aid, provider)` to `init(context, spid, environment, provider)`; iOS changed from `initialize(aid:provider:)` to `initialize(spid:environment:provider:)`. `spid` must be an 8-character lowercase alphanumeric string issued by the console, and `environment` must be an explicit 1–10 character lowercase alphanumeric string; if omitted, the default is `prod`. - The JSSDK browser fallback is updated to `initFallback({ spid: 'ab12cd34', environment: 'prod' })`, and no longer accepts the legacy `aid`. Initialization now fully validates candidate configurations before submitting them in one go; failures will not pollute existing configurations. - JSB `getEnv()` switches from `aid` to `spid + environment`; the UA field switches from `HostAid` to `HostSpid + ProjectEnv`; and the settings query parameters switch from `aid` to `spid + env`. - The Web reporting payload uses `basic_data.host_spid` and `basic_data.env`, no longer faking the native semantic `basic_data.app_id`, and no longer sending `host_aid`. The compatible request header name remains `X-Aid`, but its value is `spid`, and `X-Super-API-ENV` is added; `X-Spid` is not added. - SIMP root configuration has migrated from `app_id` to `spid + environment`, and the same root value is projected to Android `BuildConfig`, iOS `SimpleConfig`, and Web `initFallback`. ### Migration Example - Android:`SuperSDK.init(context, "ab12cd34", "prod", provider)` - iOS:`try SuperSDKManager.shared.initialize(spid: "ab12cd34", environment: "prod", provider: provider)` - JSSDK:`SuperSDK.initFallback({ spid: 'ab12cd34', environment: 'prod' })` The `ab12cd34` in the example only demonstrates a valid format; you must replace it with the actual `spid` issued by the console during integration. The `basic_data.app_id` in native events and the AdMob App ID are independent concepts and must not be mechanically renamed. `release_doc/**/1.0.0-SNAPSHOT/**` is a historical release snapshot and will not be written back during this migration. ## [1.0.0.53-SNAPSHOT] - 2026-07-25 > Android AdMob Optional Provider and Rewarded Interstitial H5 Bridge ### Add - **Independent AdMob Provider**: Added `com.supersdk:supersdk-ad-admob`, integrating Google Mobile Ads `25.4.0` to fully implement five native `AdService` types: Rewarded, Interstitial, Banner, Native, and Rewarded Interstitial. The core `supersdk` does not carry any ad dependencies. - **Rewarded Interstitial JSBridge**: Android adds `showRewardedInterstitialAd(config, callbackId)`, and JSSDK adds `SuperSDK.showRewardedInterstitialAd(options)`; returns `{ dismissed, rewarded }`, retaining full-screen ad concurrency and unique final state protection. ### Integration Requirements - Before invoking Rewarded Interstitial via H5 or host app, the reward content description and a skippable intro must be displayed first. For legacy Android bridges or unsupported platforms, the JSSDK immediately returns `NOT_SUPPORTED`. - Supplement host app ID, five types of Ad Unit IDs, privacy consent, Provider registration, resource lifecycle, and device acceptance checklist. ## [1.0.0.52-SNAPSHOT] - 2026-07-24 > Google Play Billing 9 Compliance Upgrade and Offline Package Remote Update (Android / iOS / JSSDK) ### Add - **Offline Package Remote Manifest v1**: When the Android/iOS host app opens a page, it can detect `super_meta.json` in the background at the site root path, performing secure download and installation based on version, size, MD5, same-origin path, and in-package manifest; failure does not affect the current page, and changes take effect on the next load after success. - **Explicit Preload Interface**: Both sides provide `preloadPackage` / `preloadAllPackages`, supporting the host app to actively check and install offline packages; synchronously supplement `OFFLINE_PKG_SPEC.md` and build script artifacts. ### Change - **Google Play Billing Library upgraded to 9.1.0**: Updated the Billing dependency and one-time item offer compatibility logic in `supersdk-pay-google` to meet the requirements of Google Play Billing Library 8.0.0+; purchase, restore purchase, and error callback contracts remain unchanged. - **Unified semantics for offline package integration**: The `updatePackage*` methods on Android and iOS are renamed to `preloadPackage*` to align with the behavior of "pre-downloading and installing for effective use on the next load." ## [1.0.0.51-SNAPSHOT] - 2026-06-22 > WebView bottom immersive switch (Android / iOS) ### Add - **`setImmersiveBottom` Bottom Immersive Switch**: Android / iOS `SuperPageView` adds bottom immersive control; defaults to `true` to maintain existing behavior. Setting it to `false` shortens WebView content to above the bottom safe area/system navigation bar, while the page `env(safe-area-inset-bottom)` and UA `SafeAreaBottom` are set to zero. This is suitable for third-party sites like YouTube to align the bottom bar with the system bar, avoiding obstruction or extra white space. This setting applies only to the bottom; the top remains immersive. ## [1.0.0.50-SNAPSHOT] - 2026-06-21 > Migrate three-platform event reporting to the self-owned event pipeline v2 endpoint (Android / iOS / JSSDK) ### Change - **Event Reporting Endpoint Migration to v2**: Event reporting for Android / iOS / JSSDK is switched from `/superapi/rptEvent` to `/superapi/v2/reportEvent`, activating SuperSDK's native event pipeline. The server routes based on the `app_` prefix content within the `host_aid` field of the reporting payload: applications with the `app_` prefix are routed to the self-built collector, while others fall back to the legacy system, ensuring zero impact on the live environment. - **JSSDK `event_param` changed to object reporting**: `reportEvent(name, params)` now accepts `params` as a JSON object instead of a JSON string (aligned with Android / iOS to satisfy strict validation for self-built collectors; non-object parameters are normalized to `{}`). ## [1.0.0.49-SNAPSHOT] - 2026-06-21 > SDK self-contained settings decoupling (Android / iOS / JSSDK) ### Breaking Change - **Remove JSSDK `getSDKSettings()` / `getSDKSettingsByKey()`**: The SDK's dynamic capabilities will no longer reuse the host app's settings channel. For future SDK-specific dynamic capabilities, use dedicated interfaces. - **Remove the `getSDKSettingsAsync` / `getSDKSettingsByKeyAsync` JSB on the client**: Android and iOS no longer expose the SDK's own settings to H5. - **Offline package no longer automatically syncs by reading `offline_pkg` from settings**: Retain the ability to load cached offline packages and explicitly download/install them, while removing the coupling path that drives offline package updates via host/SDK settings. - **`/v2/settings` data format and historical settings alignment**: The server-side v2 successfully responds with `{code:"SUCCESS",msg:"",data:}`; Android/iOS also locally normalize the raw v2 response to this envelope and read compatibly by key `data[key]`. - **`SSettings.createSettings(namespace)` no longer infers the remote `configName`**: `namespace` is used solely for local cache / built-in configuration isolation, preventing historical usage `createSettings(SEnv.getAid())` from generating `configName=`; for explicit remote configuration names, please use Android `createSettingsWithConfigName(configName)` / iOS `createSettings(configName:)`. ## [1.0.0.48-SNAPSHOT] - 2026-06-21 > Host app cloud control configuration configName fix (Android / iOS / JSSDK) ### Fix - **Host configuration no longer treats `aid` as `configName`**: Parameterless requests to `getHostSettings()` / `getHostSettingsByKey()` do not include `configName`; `aid` serves solely as the application identifier parameter. - **JSSDK supports explicit configuration names**: Added optional parameters `getHostSettings(configName?)` and `getHostSettingsByKey(key, configName?)`. The client prioritizes the new JSB method and forwards the configuration name. - **Compatible with legacy JSB**: Retain the original `getHostSettingsAsync` / `getHostSettingsByKeyAsync`. Legacy call paths no longer include `configName`, preventing the generation of `configName=`. ## [1.0.0.46-SNAPSHOT] - 2026-06-21 > openPage public API adjustment: Container hosting → URL routing (dual-platform · ⚠️ Breaking) ### Changes (Container Navigation · Cross-Platform Consistency · ⚠️ Breaking) - **`NavigationService` interface changed from "SDK to container" to "provide URL, host decides how to open"**: The host receives `url + PageConfig` and returns `true` if handled independently or `false` to delegate to the SDK's default container (selective interception + SDK fallback, similar to `shouldOverrideUrlLoading`). - Android:`boolean openPage(Context, String url, PageConfig)` - iOS:`func openPage(url: String, config: PageConfig) -> Bool` - If the host app still wants to use the SDK's WebView container, retrieve `getPageController().createPageView()`, call `load(url)`, and display it manually (you can set `setOnClosePageListener` / `onClosePageListener` to handle the H5 `closePage` event). - **Remove `PageControlHandler` (both ends)**: The contract no longer returns the control handle; the default SDK page (`SuperPageActivity` / `SuperPageViewController`) closing is changed to page self-management (`OnClosePageListener → close itself`), and the frontend `appbridge.closePage()` behavior remains unchanged. - **Remove `DefaultNavigationService` (both ends)**: Inline the default opening logic back into the host app. - **Frontend `appbridge.openPage(url, config)` / `SuperSDK.openPage` invocation remains unchanged**; no new JSB added. ### Migration Guide - Old implementation `openPage(context, container, config) → PageControlHandler`: Change to `openPage(context/url, config) → boolean/Bool`; The previous logic of "placing the container" is changed to self-fetch `createPageView()` and `return true`; if not taken over, `return false`. ## [1.0.0.45-SNAPSHOT] - 2026-06-20 > WebView Video Fullscreen + Underlying WebView Exposure + Back Button Fix (Android) ### Add (Container Capabilities · Android) - **Support for full-screen HTML5 video playback within WebView**: `SuperWebview`'s `WebChromeClient` implements `onShowCustomView`/`onHideCustomView`, and uses `SViewUtils.findActivity` to traverse the view tree to locate the host Activity (compatible with WebViews created using an application context), attaching the video to the Activity's `decorView` for full-screen display and immersive hiding of the system bar. - **Adaptive Landscape Mode**: Landscape orientation is enforced only when the host Activity declares `configChanges=orientation|screenSize` in the manifest (satisfied by `SuperPageActivity`); otherwise, the current orientation is maintained to prevent Activity recreation from interrupting playback. - Prioritize exiting fullscreen on back button press; clear residual fullscreen views in `onDetachedFromWindow` to prevent leaks. - iOS natively supports full-screen video (`allowsInlineMediaPlayback`); this is an **Android-only platform difference**. - **`AbsSuperPageView.getWebView()`**: Exposes the underlying `WebView` instance for the host app to directly invoke native capabilities such as `evaluateJavascript` / `settings` (aligned with iOS `pageView.webView`). - ⚠️ Do not replace `WebViewClient`/`WebChromeClient` or reset `settings`, as this will break the built-in JSBridge and offline package interception. ### Fix (Back Key · Android) - **Demo `MainActivity` back button now routes to `handleBackPressed`**: Previously, using `canGoBack`/`goBack` directly bypassed frontend interception (`JSBridge.onBackPressed`). Now it aligns with the official documentation example (priority: frontend interception > page history back > exit). ## [1.0.0.44-SNAPSHOT] - 2026-06-20 > WebView identifies `target="_blank"` / `window.open` and uniformly routes to openPage (both platforms). ### Added (Container Navigation · Cross-Platform Consistency) - **H5 `` links and `window.open(url)` are now automatically recognized by the container and uniformly opened as a new page via `openPage` on the client side** (equivalent to `appbridge.openPage`, utilizing the host app's custom `NavigationService`); no additional adaptation is required for H5. - Android: Enable `setSupportMultipleWindows` + `setJavaScriptCanOpenWindowsAutomatically`; use `WebChromeClient.onCreateWindow` to intercept the target URL with a temporary WebView, then forward it to `NavigationBridge.openPage`. - iOS: Set `uiDelegate`; forward `openPage` and return `nil` (do not create a new `WKWebView`) when `targetFrame == nil` in `WKUIDelegate.createWebViewWith`. - Edge case: The approach where the minority of `window.open()` first open a blank page and then `document.write` cannot retrieve the URL (ignored), which does not conflict with the semantics of "jump to a new page". - **No changes to external API signatures** (no new JSB added); Demo `fe-main` page navigation group adds `_blank` / `window.open` regression test items ## [1.0.0.43-SNAPSHOT] - 2026-06-06 > deviceId degradation value fix (Android) ### Fix (Device ID · Android · SDK-B001-deviceId-000) - **Fix for partial online users returning degraded `deviceId` values ("000" / all-zero) that remain permanently unchanged**: `SDevice.getOrCreateDeviceId` originally only filtered a single known bad `ANDROID_ID` (`9774d56d682e549c`), failing to block other degraded values, and combined with cache-first logic, this caused the issue to become permanently fixed. - The `ANDROID_ID` validation has been upgraded from a blacklist single value to a **rule set** `isValidAndroidId` (16-character hex + excluding known bad values + excluding all identical characters + all hex). - Added `isDegenerateDeviceId`: Detect degenerate values (neither valid ANDROID_ID nor UUID) during cache read → discard and regenerate, **enabling self-healing for historically affected users**. - Log when degraded ANDROID_ID is hit (masked · length only) to confirm online distribution. - iOS is unaffected (`identifierForVendor` system UUID) · Knowledge Base G-deviceId-001 - ⚠️ Affected users' deviceId changes from degraded value to new UUID (one-time attribution breakpoint · correction priority) ## [1.0.0.42-SNAPSHOT] - 2026-06-05 > Google Login Fix (Android) ### Fix (Google Sign-In · Android) - **Fixed an issue where the first login/new client directly threw `NoCredentialException("No credentials available")` and the account selector did not pop up**: Changed `GoogleAuthProvider` from using `GetGoogleIdOption` (silent One Tap credential check) to `GetSignInWithGoogleOption` (explicit "Sign in with Google" button flow, forcing the account selector to pop up). - **Improve login failure observability (SDK-B001)**: `GoogleAuthProvider.onError` no longer swallows the structured type of `GetCredentialException` and returns `type= class= msg=`; `LoginBridge` failure callbacks now include `SLogger.e` in logcat (previously, failures only provided generalized logs from the AndroidX framework, making it impossible to pinpoint the exact cause). ### Description - This change applies exclusively to the **Android platform** (Credential Manager API); the SDK contains no iOS Google Sign-In provider, and the iOS `xcframework` has no equivalent update, retaining the previous version's binary. - No changes to external API signatures (JSSDK / Android README interfaces remain unchanged). ## [1.0.0.41-SNAPSHOT] - 2026-06-01 > SDK-F038 · Unified Payment Contract (SDK returns to pass-through) ### ⚠️ Breaking Change (SDK-F038) - **Payment contract unified to two provider methods + SDK pass-through**: provider = `{ createOrder(payParams)→json, pay(json)→three-state result }`, parameters are **opaque** to the SDK transmission layer; the SDK only routes and passes through JSON based on `provider` (no longer parsing productId/accountId/profileId). - `pay.purchase({provider, payParams})` internally aggregates `createOrder→pay`; no new `createAndPay` is added. - **Return `PurchaseResult` changed to three-state** `PayResult3State`: `{ status: finished|cancelled|error, orderToken?, phase?, code?, message? }`; `finished ≠ payment successful` (check order via business); **Receipt not in Native** - **JSB changed from positional parameters to a universal pipeline** `nativePay(provider, jsonString, callbackId)`; the old SDK lacks `nativePay` → `pay.purchase` rejects with `SDK_TOO_OLD`. - The live H5 must be upgraded in tandem (do not retain the old return alias); the `restorePurchases` contract must remain F036 unchanged. - **IAP**: The business implements only `createOrder`; `pay` is handled by the SDK's built-in `google_play`/`apple` provider (native payment · JSON self-read); **Third-party** businesses must implement `createOrder + pay` methods themselves. - **Receipt Guardian**: `provider.pay` returns the receipt to PayBridge → PayBridge forwards the host app configuration receipt endpoint + whitelisted tri-state to H5; backend performs independent signature verification; Google RTDN / Apple ASSN serve as fallback. - **IAP Dual-Platform Order Slot**: Android `obfuscatedAccountId`(accountId) + `obfuscatedProfileId`(orderToken) / iOS `appAccountToken`(orderToken); **orderToken must be a UUID** (internal Google provider validation, non-UUID → `INVALID_ORDER_TOKEN`). ### Description - iOS: This snapshot iOS `xcframework` **has not been rebuilt yet** (still the previous version binary · does not include F038 iOS changes); it will be completed after the independent iOS build process rebuilds it. Android AAR / JSSDK already includes F038. ## [1.0.0.40-SNAPSHOT] - 2026-06-01 > Accumulate all SDK changes after version 0.39 (Pay namespace refactoring + JSSDK documentation and wrapper completion). ### ⚠️ Breaking Change (SDK-F036) - **Refactored JS SDK payment capabilities into the `SuperSDK.pay` namespace**, removed 7 top-level payment APIs. - Added `SuperSDK.pay` namespace: `purchase` / `getProviders` / `registerProvider` / `restorePurchases` - The `purchase` input parameter signature has been changed from `productId` to `payParams` (nested structure). - Added `_webInlineInProgress` guard to prevent concurrent Web inline purchases. - See the "Migration Guide" and error code description in the "Payment" section of `JSSDK.md`. ### Added (SDK-F037) - JSSDK adds 3 new JSB frontend wrappers: `addEventCommonParam` / `setStatusBarDarkMode` / `showKeyboard` - `onJSBridgeReady` internal comment annotation ### Documentation (SDK-F037 / SDK-M001) - `pay.purchase` / `restorePurchases` return value: 10-field table + `purchaseState` enum + differences between Native and Web inline integration paths - Settings return structure and fallback explanation; three new method documents + API overview registration - Correct 6 errors in the JSSDK documentation and code: - IAP recommendation architecture example now uses nested `payParams` (the original flat structure will trigger `INVALID_PARAMS`). - `pay.purchase` timeout increased from 120s to 190s (aligned with the actual value of Native IAP). - Clean up deleted APIs from the timeout list, correct the legacy naming convention `pay.*`, and complete `requestLogin` along with the four core ad components. - `initFallback` baseUrl clarification: automatic completion of `/superapi` ## [1.0.0.39-SNAPSHOT] - 2026-05-24 > Accumulates all changes after .36 (.37/.38 not cut separately) ### Add - **Pay Bridge**: Added multi-provider purchase capability · Android + iOS + JS three-platform support - `SuperSDK.purchase(...)` supports multiple providers, including `GooglePayProvider`. - Add `onProgress` callback · Support polling progress UI - JS-side purchase timeout aligned with native (190s) · `GooglePayProvider.purchase` serialized to avoid concurrency - **SDK-F034**: `SNetwork` automatically injects `X-Aid` + `X-Device-Id` into commonHeaders for attribution correlation. - **SDK-F001**: Android WebView container adds support for ``. - Add `onShowFileChooser` override + Activity Result API path - Support for `accept` / `multiple` / `capture` attribute passthrough + fallback on cancellation / denial - The photo path uses FileProvider (subclass `SuperSdkFileProvider` to avoid conflicts during host app manifest merging · authority `${applicationId}.supersdk.fileprovider`) - Zero-cost integration: `SuperPageActivity` automatically injects `IFileChooserHost`. - Host app self-packaging path: `IFileChooserHost` action API (3 methods) - iOS WKWebView default support · No changes to iOS code in this release ### Change - Android SDK dependency upgrade: `appcompat` 1.1.0 → 1.6.1 · Added `androidx.activity` 1.6.1 + `androidx.core` 1.9.0 (unlocking Activity Result API) ### Documentation - JSSDK documentation sync Pay Bridge `purchase` / `onProgress` interfaces - Add `IFileChooserHost` integration documentation (Android SDK host self-wrapping path) ## [1.0.0.36-SNAPSHOT] - 2026-05-01 ### Add - Added `downloadWithCache(fileUrl, fileMd5, cacheTts, fileCacheKey?)` JSB/JSSDK API to support downloading and caching files, returning the local file path directly when the cache is hit. - Android/iOS dual-platform implementation of cache hit, TTL expiration, MD5 verification, temporary file cleanup, and metadata integrity verification. - The cache key prioritizes `fileCacheKey`; if not provided or empty, use the URL without the query string. ### Documentation - JSSDK/JSBridge Documentation Supplement: `downloadWithCache` Parameters, Return Values, Caching Strategies, and Exception Behaviors ## [1.0.0.35-SNAPSHOT] - 2026-04-21 ### Change - Event reporting supports multiple base URL fallback: automatically switch to the next base URL when the server returns 5xx errors or network failures occur, improving reporting stability. - The tracking event `new_user_today_utc8` has been added with the public parameter: determines whether it is a new user of the day based on UTC+8; `1` if new today, otherwise `0`. ## [1.0.0.34-SNAPSHOT] - 2026-04-09 ### Fix - Navigation bar height adaptation for Android versions below 10: `getSafeAreaInfo` correctly returns the virtual navigation bar height on lower-version devices, no longer fixedly returning 0. ## [1.0.0.33-SNAPSHOT] - 2026-04-08 ### Add - In Debug mode, WebView allows remote debugging (Android: Chrome DevTools, iOS: Safari Web Inspector). - Dual-end synchronization: Android `WebView.setWebContentsDebuggingEnabled(true)`, iOS `isInspectable = true` (iOS 16.4+). ## [1.0.0.32-SNAPSHOT] - 2026-04-06 ### Fix - Offline package SPA routing fallback: Frontend routes (e.g., `/home`) miss the offline package on refresh; now pathless routes automatically fallback to `index.html`. - Dual-platform (Android + iOS) synchronized fix ## [1.0.0.31-SNAPSHOT] - 2026-04-06 ### Change - The dual-end SDK API path has been migrated from `/api/` to `/superapi/`, aligning with the server-side routing evolution (F030). - Involved: event reporting, cloud control configuration, attribution retrieval, short link generation/HTML direct output, totaling 8 files and 12 locations. ## [1.0.0.30-SNAPSHOT] - 2026-04-06 ### Add - Debug Mode: The dual-end `HostConfigService` adds the `isDebugMode` interface, allowing the host app to optionally enable debug mode. - Debug Mode: When network requests fail, print complete request information (URL, body, header, response content) after enabling. - Android `SEnv.setDebug(boolean)` supports manually overriding the debug switch. - Android `SEnv.isDebug()` priority: setDebug > HostConfigService.isDebugMode > false - iOS `SEnv.isDebug` priority: `#if DEBUG` > `HostConfigService.isDebugMode` > `envType` ## [1.0.0.29-SNAPSHOT] - 2026-04-03 ### Add - JSSDK Non-Client Environment Fallback Support: Added `initFallback(config)` initialization fallback configuration to enable frontend projects to run and debug normally in the browser (F-JSSDK-001). - Add the `isFallbackMode()` API to determine if the current state is in fallback mode. - Page navigation APIs are downgraded to native browser behavior (window.open/close). - UI feedback is downgraded to console.log output. - Environment configuration class APIs return default null values in non-end environments (no longer reject). - reportEvent is downgraded to fetch for direct HTTP reporting (including the source: web_fallback flag) - Non-downgradable APIs uniformly return the error message "Not in app environment". - deviceId is automatically generated and persisted to localStorage. ## [1.0.0.27-SNAPSHOT] - 2026-02-25 ### Add - JSB short link generation supports a custom `base_url`: `requestShortUrl(url, baseUrl?)` and `requestShortUrlWithHtml(html, baseUrl?)` now include an optional `baseUrl` parameter to allow custom short link prefixes (e.g., `https://s.a.com/`). If not provided, the default behavior is maintained (F021). - Full-link support for Android/iOS/Web SDKs, backward compatible ## [1.0.0.26-SNAPSHOT] - 2026-02-23 ### Change - JSSDK Documentation Audit Revision: `callHostMethod` supplemented with no-timeout explanation; timeout instructions in notes changed to a categorized list of methods (5s/10s/30s/60s/no timeout). ## [1.0.0.25-SNAPSHOT] - 2026-02-23 ### Add - Offline package build time: `OfflinePackageState` adds a `buildTime` field (second-level timestamp), and `getEnv` returns `wappBuildTime`. - The frontend packaging tool `super_package.sh` automatically writes `build_time` to `__super_meta.json`. ### Change - The Demo App has been simplified to a single-page SuperSDK integration example, removing update checks, host app Settings, multi-tab logic, and sharing features. ## [1.0.0.24-SNAPSHOT] - 2026-02-22 ### Add - Short-link HTML direct output: `requestShortUrlWithHtml(html)` generates a short link from HTML content; accessing the short link directly renders the HTML page (without 302 redirection). - The server adds a `POST /api/shorturl/html` endpoint to support HTML content storage and direct rendering. - Full-link support for Android/iOS/Web SDK ## [1.0.0.23-SNAPSHOT] - 2026-02-19 ### Fix - JSBridge Ready Reliability: Detect whether JSBridge is ready when `onPageFinished` occurs; if not ready, actively retry triggering. - JSBridge Ready Reliability: When messages are buffered, retry triggering JSBridge ready after a 500ms delay to prevent callbacks from permanently hanging. - JSBridge Ready Reliability: Add error logs when the webview reference is null in AppBridge.onJSBridgeReady ## [1.0.0.22-SNAPSHOT] - 2026-02-15 ### Add - getEnv adds the wappVersion field, returning the current WApp (offline package) version number; returns an empty string for non-offline package pages. ## [1.0.0.21-SNAPSHOT] - 2026-02-15 ### Change - OfflinePackageState Simplified: Remove status, remoteVersion, and updateAvailable fields, retaining only host, localVersion, and source. - OfflinePackageState Simplified: Remove Status enum (Android) / OfflinePackageStatus enum (iOS) - OfflinePackageState Simplified: getAllPackages/getPackage/getPackageForUrl return only offline packages with normal status. - OfflinePackageState Simplified: The Source enum adds MANUAL to distinguish externally manually installed packages. ## [1.0.0.20-SNAPSHOT] - 2026-02-15 ### Fix - Offline package concurrency safety: Temporary filenames include UUIDs to prevent conflicts, ensuring multiple download tasks do not write to the same file. - Offline package concurrency safety: Add file existence check before MD5 calculation to avoid FileNotFoundException. - Offline package concurrency safety: Android status state modification moved to per-host lock, fixing the issue of reentrancy protection failure. - Offline package concurrency safety: iOS adds an initialization wait mechanism (NSCondition, 10s timeout) to align with Android. - Offline package concurrency safety: Add version comparison before download and installation to prevent the cloud control's older version from overwriting the newly installed version (version downgrade). - Offline package concurrency safety: Directory replacement changed to atomic rename swap to prevent FileNotFoundException caused by file deletion during WebView loading. ## [1.0.0.19-SNAPSHOT] - 2026-02-14 ### Change - Remove the direct dependency on the Google Play Install Referrer library and switch to obtaining install_referrer via reflection to reduce external SDK dependencies. ## [1.0.0.18-SNAPSHOT] - 2026-02-13 ### Fix - Offline package initialization: Split into an independent thread, no longer blocked by Settings initialization, resolving the issue where `initialized=false` causes the offline package to fail to match. - Offline package waiting logic: Correctly wait for initialization completion during URL interception (500ms polling, max 10s), no longer giving up directly after a 2s timeout. ## [1.0.0.17-SNAPSHOT] - 2026-02-13 ### Change - Event reporting: The `SReporter` reporting interface uniformly uses the `baseURL` of `ApiHelper`/`SApiHelper` for concatenation, supporting host app-defined domains. ## [1.0.0.16-SNAPSHOT] - 2026-02-09 ### Fix - Publish document synchronization: `release_doc/supersdk/dev/JSSDK/supersdk.js` synchronized to the latest version. ## [1.0.0.15-SNAPSHOT] - 2026-02-09 ### Change - JSBridge Optimization: `reportEvent` changed to a direct JSBridge method (no longer routed through `callHostMethod`). - JSBridge Optimization: `showToast` changed to SDK built-in implementation (Android uses system Toast, iOS uses custom overlay). - JSBridge Optimization: `openBrowser` changed to SDK built-in implementation (uses system browser to open). ## [1.0.0.14-SNAPSHOT] - 2026-02-08 ### Change - Architecture optimization: Decouple `SuperWebview` from `SuperPageActivity` and unify interaction via the `AbsSuperPageView` API. - Architecture optimization: `NavigationService.openPage()` parameter narrowed from `View` to `AbsSuperPageView`. - Architecture optimization: `NavigationBridge.openPage()` now uses `SuperPageView` instead of a bare `SuperWebview`. - API Optimization: `handleBackPressed(exitAction)` internally encapsulates `canGoBack/goBack`; callers only need to pass the exit action. - API Optimization: `AbsSuperPageView.fitSystemWindows(Activity)` adapts immersive safe areas with a single line of code. - API Optimization: `AbsSuperPageView.setOnClosePageListener(Runnable)` promoted to the API layer - Internal simplification: Remove the `SuperPageControlHandler` class; the handler is changed to an anonymous implementation. - Internal simplification: Remove `dispatchActivityResume/Pause`; `SuperWebview` automatically detects visibility changes via `onWindowVisibilityChanged`. ## [1.0.0.13-SNAPSHOT] - 2026-02-08 ### Add - Client broadcast: `sendBroadcast(eventKey, jsonData)` sends a broadcast to the frontend, which receives it via `SuperSDK.subscribe()`. - Client broadcast: `SuperSDK.broadcastToAll(eventKey, jsonData)` broadcasts to all WebViews. - Back button interception: The frontend listens for the back button via `SuperSDK.onBackPressed(callback)`, where `callback` returning `true` intercepts the event. - Safe Area Settings: `AbsSuperPageView.setSafeArea(statusBarHeight, navigationBarHeight)` uniformly sets the safe area. - Cloud control configuration split: `getSettings` is split into `getSDKSettings` (configName=supersdk, removed in 1.0.0.49-SNAPSHOT) and `getHostSettings()` (without configName). - App Information Retrieval: `SuperSDK.getAppName()` retrieves the host app name. - App Information Retrieval: `SuperSDK.getAppIcon()` retrieves the host app icon (Base64 format). ## [1.0.0.12-SNAPSHOT] - 2026-02-07 ### Add - Android SDK Initialization and Core Container Capabilities - iOS SDK Initialization and Core Container Capabilities - JS SDK Frontend Interaction Capabilities - JSBridge: Environment Information, Page Navigation, Sharing, Lifecycle, WebView Communication - File operations: download, read/write, ZIP compression/decompression - Attribution System - Native Block (Native Component Embedding) - Offline Package Management (Query, Update) - Cloud control configuration - Add the `ss-` prefix to SLogger log tags to facilitate filtering SDK logs. ---