Skip to content

Changelog

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.
  • 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.
  • 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/[email protected] on npm, or the matching iOS XCFramework.
  • 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.
  • 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.
  • 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.
  • Intermediate build available on Maven Central Snapshots and npm as @supersdk/[email protected]. The repository has a completed three-platform release record for 3.0.5-SNAPSHOT.
  • 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.
  • 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.

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.

Section titled “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.

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.

  • 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)

Section titled “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": "<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)

Section titled “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.
  • 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.

  • 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)

Section titled “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.

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.

Section titled “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.

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.

  • 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.
  • 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.

📌 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)

Section titled “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.
  • 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)

Section titled “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).
  • 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/.

📌 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

Section titled “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.

📌 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)

Section titled “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 <input type="file" capture>).
  • 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).

📌 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)

Section titled “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.

📌 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)

Section titled “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.

Google Play Subscription (supersdk-pay-google plugin)

Section titled “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.

New: Unified suenc response obfuscation capability (Android / iOS / JSSDK / Super Server four-end)

Section titled “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.

📌 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)

Section titled “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.

📌 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.

  • 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.
  • 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.
  • 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.

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).

  • 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.
  • 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.

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)

Section titled “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)

Section titled “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.

📌 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.

  • 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.
  • 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.
  • 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.
  • 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.

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.

  • 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.
  • 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.

Android AdMob Optional Provider and Rewarded Interstitial H5 Bridge

  • 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.
  • 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.

Google Play Billing 9 Compliance Upgrade and Offline Package Remote Update (Android / iOS / JSSDK)

  • 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.
  • 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.”

WebView bottom immersive switch (Android / iOS)

  • 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.

Migrate three-platform event reporting to the self-owned event pipeline v2 endpoint (Android / iOS / JSSDK)

  • 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 {}).

SDK self-contained settings decoupling (Android / iOS / JSSDK)

  • 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:<configuration>}; 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=<aid>; for explicit remote configuration names, please use Android createSettingsWithConfigName(configName) / iOS createSettings(configName:).

Host app cloud control configuration configName fix (Android / iOS / JSSDK)

  • 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=<aid>.

openPage public API adjustment: Container hosting → URL routing (dual-platform · ⚠️ Breaking)

Changes (Container Navigation · Cross-Platform Consistency · ⚠️ Breaking)

Section titled “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.
  • 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.

WebView Video Fullscreen + Underlying WebView Exposure + Back Button Fix (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.
  • 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).

WebView identifies target="_blank" / window.open and uniformly routes to openPage (both platforms).

Added (Container Navigation · Cross-Platform Consistency)

Section titled “Added (Container Navigation · Cross-Platform Consistency)”
  • H5 <a target="_blank"> 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

deviceId degradation value fix (Android)

Fix (Device ID · Android · SDK-B001-deviceId-000)

Section titled “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)

Google Login Fix (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=<getType()> class=<subclass> msg=<message>; 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).
  • 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).

SDK-F038 · Unified Payment Contract (SDK returns to pass-through)

  • 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).
  • 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.

Accumulate all SDK changes after version 0.39 (Pay namespace refactoring + JSSDK documentation and wrapper completion).

  • 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.
  • JSSDK adds 3 new JSB frontend wrappers: addEventCommonParam / setStatusBarDarkMode / showKeyboard
  • onJSBridgeReady internal comment annotation
  • 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

Accumulates all changes after .36 (.37/.38 not cut separately)

  • 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 <input type="file">.
    • 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
  • 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)
  • JSSDK documentation sync Pay Bridge purchase / onProgress interfaces
  • Add IFileChooserHost integration documentation (Android SDK host self-wrapping path)
  • 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.
  • JSSDK/JSBridge Documentation Supplement: downloadWithCache Parameters, Return Values, Caching Strategies, and Exception Behaviors
  • 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.
  • 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.
  • 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+).
  • 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
  • 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.
  • 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
  • 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.
  • 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
  • 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).
  • 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.
  • 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.
  • 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
  • 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
  • getEnv adds the wappVersion field, returning the current WApp (offline package) version number; returns an empty string for non-offline package pages.
  • 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.
  • 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.
  • Remove the direct dependency on the Google Play Install Referrer library and switch to obtaining install_referrer via reflection to reduce external SDK dependencies.
  • 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.
  • Event reporting: The SReporter reporting interface uniformly uses the baseURL of ApiHelper/SApiHelper for concatenation, supporting host app-defined domains.
  • Publish document synchronization: release_doc/supersdk/dev/JSSDK/supersdk.js synchronized to the latest version.
  • 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).
  • 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.
  • 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).
  • 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.