Skip to main content

billdog_flutter 1.2.0-beta.1 copy "billdog_flutter: ^1.2.0-beta.1" to clipboard
billdog_flutter: ^1.2.0-beta.1 copied to clipboard

BillDog SDK for Flutter — monetization, paywalls, subscriptions and BillDog Auth sign-in. Thin bridge over the native iOS/Android SDKs with inline native paywall rendering.

Changelog #

All notable changes to the BillDog Flutter SDK will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

1.2.0-beta.1 - 2026-11-20 #

  • EntitlementInfo.isInBillingRetry: the store is retrying a failed renewal of the subscription behind the entitlement (the server now reports the billing_retry state).

1.1.2-beta.5 - 2026-11-18 #

Changed — the RevenueCat bridge (billdog_revenuecat) #

  • Ready for pub.dev: it ships at the suite version, pins billdog_flutter exactly and allows purchases_flutter 10.1 to 11.x. The README no longer points at a private Git repository. It is published once its device testing is done.
  • With RevenueCat configured purchasesAreCompletedBy: myApp, BillDog's native SDK owns finishing for the bridge: it records each purchase while it is unfinished, then finishes, acknowledges or consumes it, so consumables are recorded on iOS and Android. Before, nothing finished such a purchase and Google Play refunded it after 3 days. Only the RevenueCat bridge (PurchaseCapability.revenueCatBridge) gets this. The plugin reads the mode natively (revenueCatPurchasesAreCompletedBy, billDogFinishesTransactions).
  • iOS: promotional offers, signed by RevenueCat (PurchaseCapability.signsPromotionalOffers); an offer it can't sign or the App Store refuses is bought at the standard price and reported (promotional_offer_not_applied).
  • Android: the catalogue id native hands over (sku:basePlan:offer) is split, so RevenueCat is asked for Play's own product id; a product id that pinned a base plan or offer used to be "product not found" every time. A base plan RevenueCat doesn't list is "product not found", never another plan; an offer Play doesn't list for the user buys the base plan.
  • restoreOnLaunch only reads RevenueCat's customer info instead of calling restorePurchases, which can ask for an App Store sign-in. It doesn't sync either: RevenueCat's syncPurchases can alias app user ids and is meant for apps that don't buy through RevenueCat.
  • A failed RevenueCat purchase reaches the native SDK as the matching BillDog error (network, store error with RevenueCat's code, product not found, configuration…) instead of an unknown error.
  • iOS can sell Apple's 12-month commitment plans (billingPlans capability) with purchases_flutter 10.16 or later.
  • RevenueCatGateway gained getCustomerInfo(), purchasesAreCompletedBy(), billDogFinishesTransactions() and getPromotionalOffer(), and BillDogRecorder gained reportPromotionalOfferNotApplied(); custom implementations must add them.

Fixed — purchases report the product bought (Android) #

  • billdog_revenuecat returned the Play transaction's product on Android: the subscription id only (premium for premium:yearly), and for a DEFERRED plan change the product being replaced. It now returns the product the purchase was made with. With the native SDK's matching fix, purchase_completed, the purchase callbacks and purchase()'s result name the product bought; a plan change adds product_change and carries a price only when Play charges the full price at the change.

Added — monthly plans with a 12-month commitment #

  • Product.installmentsInfo (InstallmentsInfo) for Apple's monthly-with-12-month-commitment plan ("<yearly-id>:monthly", iOS 26.4+, not in the US or Singapore) and Play installment plans; price is the installment, and purchasePackage buys the monthly plan. Entitlement.commitment (EntitlementCommitment). Guide: https://billdog.io/docs/commitment-plans

Changed — iOS installs without the BillDogFull CocoaPods trunk pod #

  • The plugin no longer depends on the BillDogFull pod from CocoaPods trunk, which takes no new versions after 2 December 2026.
  • With CocoaPods (SwiftPM off), the plugin's pod vendors BillDogFull.xcframework: at pod install, billdog_ios_binary.rb downloads it from the billdogai/billdog-ios-spm GitHub release for this version and refuses it unless its SHA-256 matches the package's ios/ios-binary.json. The first pod install needs network access to github.com; the zip is then cached in ~/Library/Caches/BillDog.
  • With Swift Package Manager on, Package.swift resolves billdog-ios-spm at exactly this version (it was from: 1.0.2-beta.3), the same binary the CocoaPods path checks. It no longer declares the FlutterFramework package, which Flutter generates only from 3.41, so SwiftPM builds resolve on older Flutter versions too.
  • Nothing to change in your app. If your Podfile also adds the BillDogFull pod itself, remove that line: the vendored framework and the pod conflict.

Changed — presentSurvey says why a survey was not shown #

  • A survey the native SDK doesn't show resolves presentSurvey with status: 'not_presented' and the new SurveyResult.reason, where it resolved dismissed. The reason is already_presenting (another survey is open or loading; iOS and Android now show one at a time and leave the open one alone), disabled, consent, show_once, sampling, intercept, recurring, wait_period, display_conditions, not_eligible, no_presenter (iOS), or the server's own reason when it declined this user (e.g. audience_not_matched). Check for not_presented wherever you treat dismissed as "the user closed it".

Fixed — Play Billing in release builds (Android) #

  • Flutter minifies Android release builds with R8, and the Android SDK then decided Play Billing was missing: canMakePayments() answered false and purchases made outside the app were not observed. The bundled Android SDK now finds Play Billing in minified builds.

Changed — package metadata #

  • pub.dev topics: in-app-purchase, subscriptions, paywall, monetization, analytics. The repository link to a private repository is removed, and issue_tracker points at https://billdog.io/support.

1.1.1-beta.5 - 2026-11-03 #

Added — session replay #

  • BillDogSessionReplay.start({sampleRate, maskAllInputs, maskAllText, maskAllImages}) / stop(), BillDogReplayRoot (wrap the app once) and BillDogReplayMask (always covered). The screen is captured and masked in Dart from the render tree — text, text fields (obscured ones always), images and marked subtrees — because the native recorders see one Flutter view; each frame is encoded and uploaded by the native SDK, under its opt-out, replay consent, sampling, session and customer. The dashboard's Session Replay switch does not start it in a Flutter app.

Fixed: RevenueCat and Superwall bridges #

  • billdog_superwall compiles again: superwallkit_flutter 2.8.0, which ^2.6.0 resolves to, added purchaseFromGooglePlayWithReplacement to PurchaseController, and the controller implements the class. It now extends it, as Superwall's docs show, and inherits that member's default body (it calls purchaseFromGooglePlay). Verified against 2.6.0 and 2.8.0.
  • billdog_superwall: purchaseFromGooglePlay(productId, basePlanId, offerId) buys the base plan and offer Superwall's paywall selected, as the native Android controller does. They are passed as the Play product id product:basePlan[:offer], so native buys that base plan (the offer when Play lists it for the user, else the base plan itself). It used to drop both, and Play sold the product's first base plan.
  • billdog_revenuecat (iOS): a RevenueCat getOfferings() failure no longer fails the purchase. RevenueCat fails it whenever the project has no offerings, the usual case when BillDog owns the paywall, and offline. The product is then fetched by its id and bought as a store product, as the native iOS and Android integrations do; a package in the offerings is still preferred, so RevenueCat attributes its offering.

Round 3 platform parity #

  • BillDogOptions.customUrlScheme: the web-checkout return scheme, forwarded to native. Unset, native uses the app-specific <bundle id>.billdog / <applicationId>.billdog instead of the shared billdog://.
  • Per-purpose consent (setConsent(purpose, …), hasConsent(purpose)) goes through the native facade on both platforms, so it drops the kept placement answers as the blanket setters do.
  • Android: the USE_EXACT_ALARM strip stays (a no-op once billdog-notifications no longer declares it).

Fixed: the iOS APNs token never reached BillDog #

  • BillDogPush.requestPermission() asked iOS for the APNs token, but iOS hands it only to the application delegate, and the plugin had no hook there: no device_tokens row was created, so no BillDog push reached an iOS app unless its developer wrote AppDelegate code (device-confirmed on an iPhone). The plugin is now an application delegate (addApplicationDelegate, as firebase_messaging and OneSignal capture it) and registers the token itself; firebase_messaging still receives it too. A token that arrives before configure is registered when configure runs, and an opted-in install asks iOS for its token again at every configure (the token can change). A failed registration is logged (usually: no aps-environment entitlement). Android is unchanged: pass the FCM token to BillDogPush.setDeviceToken.

Removed: public APIs that could never work #

  • BillDogVirtualCurrency.addCurrency / deductCurrency / grantCurrency / exchangeCurrency, with onBalanceChanged, onTransaction, VirtualCurrencyExchange and VirtualCurrencyBalanceChange (only those calls fed them). Every wallet write needs the project's secret key; the server answers the app's publishable key 403 ("Public keys cannot make write operations"), so each call failed on every device. Virtual currencies are read-only in the client, as in RevenueCat's SDKs: credit and spend from your server (POST /v1/virtual-currency/transactions or /adjustments), then read the balance with getBalance. The native managers keep them deprecated, failing at once without a request.
  • getBalance / getTransactionHistory(currencyId:) take a currency code ('COINS') as well as its id: the server resolves either (history with a code was a 500 before).

Native capabilities Dart could not reach #

Each goes through both plugins to the real native call.

  • Subscription status is native's from launch: BillDog.shared.subscriptionStatus read unknown for a whole session after a relaunch, because native sends onSubscriptionStatusChanged only on a change and a relaunch restores the same status it then fetches. configure now seeds it with a native read; getSubscriptionStatus() reads native's current status on demand (and stores it); subscriptionStatusStream gives the current status, then every change (Superwall parity).
  • register keeps the no-paywall code: a placement with no paywall is PlacementError(NoPaywallConfiguredError) (wire code NO_PAYWALL_CONFIGURED); it was UnknownError. NoPaywallConfiguredError is a new BillDogError subclass: an exhaustive switch over BillDogError needs the case. registerPlacement still reports it through onSkipped.
  • Store: BillDog.beginRefundRequest({productId, entitlementId}) → RefundRequestStatus (Apple's refund sheet; Play's order history on Android), checkTrialOrIntroDiscountEligibility → IntroEligibility per id, getStorefrontCountryCode(), getProducts(ids) (products outside an offering), purchaseConsumable(productId, quantity), purchaseCustom(CustomProduct) (a non-store product through your PurchaseController), checkUserAccess({userId}) → UserAccess, executeAction(...) (server-side paywall actions).
  • Attribution (RevenueCat parity): setAttribution(map) and the named setters (setAdjustId, setAppsflyerId, setMixpanelDistinctID, ... setMediaSource, setCampaign, setAdGroup, setCreative, setPushToken), each to the native consent-gated setter; collectDeviceIdentifiers().
  • Feedback: captureFeedback(...), presentFeedbackWidget([options]).
  • Paywall: onProductSelectionChange(componentId) stream.
  • Analytics: BillDogAnalytics.isOptedOut(), getAnonymousId(), fetchAttribution().
  • Experiments: BillDogFeatureFlags.getVariant(experimentId) → ExperimentAssignment, setAttributes, trackConversion, trackImpression, and the onAssignmentChanged stream (the native ab_variant_assigned).
  • Surveys: armEventTriggeredSurveys(), prefetch(surveyId), flushOfflineQueue(), setEnabled(bool), and for a survey UI of your own: startSurvey, submitResponse(surveyId, [SurveyAnswer]), recordPartialResponse, abandonSurvey, dismissSurvey, trackSurveyEvent.
  • Push: addOutcome / addUniqueOutcome, canRequestPermission(), getToken(), setOpensActionURLOnTap, local reminders (scheduleTrialReminders, scheduleRenewalReminder, scheduleExpiryReminder with a ReminderSubscription, cancelNotificationsForSubscription, cancelAllNotifications, which cancels BillDog's reminders only), the tray (getDeliveredNotifications, clearAllNotifications, removeNotification, removeGroupedNotifications), and the onPermissionChanged / onSubscriptionChanged streams.

One status set, sign-in close, PaywallView.onOpenUrl on Android, iOS tap dedupe #

  • Subscription status is the native wire set, as in React Native: a lapsed subscriber is now SubscriptionStatus.expired (SubscriptionStatusType.expired, added last) and the delegate hears expired; it was inactive. SubscriptionStatus.inactive / SubscriptionStatusType.inactive stay so existing code compiles, marked deprecated, and are never reported. Compare against expired; an exhaustive switch over SubscriptionStatusType needs the new case.
  • PaywallPresentationHandler.onOAuthSuccess(info, signIn) — a registerPlacement paywall that closed after a verified sign-in made on it, with no purchase or restore. Called just before onDismiss, on iOS and Android (native PaywallPresentationHandler.onOAuthSuccess). The handler heard it as a plain dismissal.
  • PaywallView.onOpenUrl on Android — an "Open URL" tap and the Terms / Privacy links reach it (native PaywallScreen(onOpenUrl)); it never fired on Android. On both platforms, a PaywallView with onOpenUrl takes the URL (the paywall does not open it), and one without it lets the paywall open it — on iOS the URL used to go to Dart regardless, so a view without the callback opened nothing.
  • BillDogPush.notificationOpened is safe for any tap on iOS too: a tap BillDog's delegate already recorded (including one firebase_messaging forwards to it) is not counted twice (native fix).

Following the native push, flags, status, error and wall sign-in fixes #

  • Subscription status — the plugins pass the one native wire value (active | trial | gracePeriod | expired | notSubscribed | unknown) and Dart maps it once. A user who never subscribed is now SubscriptionStatus.notSubscribed (SubscriptionStatusType.notSubscribed, added last) instead of inactive. (A lapsed subscriber is expired since the section above.)
  • PlacementOAuthSuccess on Android — a full-screen wall that closes after a verified sign-in reports it on Android too (it was PlacementDismissed).
  • Typed errors on iOS — ProofInvalidError.proof and PurchaseOwnerConflictError.retryable are filled on iOS as on Android.
  • getPresentationResult on Android — an error keeps its wire code, so PresentError.error is the typed error.
  • Virtual currency on iOS — history rows carry metadata, and the real timestamp (native fix).
  • Push
    • iOS: the plugin installs BillDog's notification delegate while the app launches (when no other delegate is set), so the tap that cold-launches the app is recorded and delivered. Opt out with the Info.plist Boolean io.billdog.notifications.LAUNCH_HOOK = false.
    • Android: a tap that reaches the running app (onNewIntent) is recorded and delivered; it was lost, because FlutterActivity does not call setIntent.
    • Both: a tap that arrives before onNotificationClick has a listener is held and delivered to the first one. NotificationClick.notificationId is BillDog's id on both platforms.
    • New BillDogPush.getPermissionStatus() (PushPermissionStatus, notDetermined on Android before the prompt) and BillDogPush.isOptedIn().
    • New BillDogOptions.autoSchedulesPurchaseReminders (default false, as natively): local renewal / expiry reminders after a purchase are now opt-in.
  • BillDog.shared.canMakePayments({features}) — App Store / Google Play availability (RevenueCat parity).
  • Removed bridge workarounds the native SDKs made unnecessary: the "no paywall configured" message match, hand-mapped skip reasons, lowercased enum names (wireValue now), and the iOS notification-id fallback. Flags need no bridge-side fetch: the first read fetches natively.

Native parity (needs the native SDKs of this release) #

  • Feature flags — BillDogFeatureFlags.getFeatureFlag / getFeatureFlagVariant / getFeatureFlagPayload / getFeatureFlags / isReady / waitForFlags / reloadFeatureFlags, over the native A/B module, now registered at configure on both platforms (Android depends on billdog-ab-test). The exposure ($feature_flag_called) is sent natively, never from Dart; BillDogOptions.sendFeatureFlagEvents turns it off. Registering the module also makes a survey gated on a flag follow the flag: without one the native presenter showed it to everyone.
  • Consent — BillDog.setConsentRequired / setConsentGiven / setConsent(ConsentPurpose, …) / hasConsent / consentHeaderValue, the native ConsentManager (React Native's surface). Callable before configure. On a consent-required project (EU by default) the server drops gated events that carry no consent envelope; a Flutter app could not send one.
  • Virtual currency — BillDogVirtualCurrency (balance, all currencies, transaction history; the wallet writes were removed again later in this release, see Removed), the native manager registered at configure (Android depends on billdog-virtual-currency).
  • Push — BillDogPush.setDeviceToken (APNs hex / FCM token), requestPermission, optOut, notificationOpened(data) for taps another plugin received, onNotificationClick, and installNotificationCenterDelegate (iOS). The native notifications module is registered at configure (Android depends on billdog-notifications, which records taps from the opened intent).
  • Exceptions — BillDogAnalytics.captureException(error, stackTrace:) through the native exception capture, with the Dart type, message and stack; opt-in BillDogOptions.captureFlutterErrors chains FlutterError.onError and PlatformDispatcher.onError (posthog-flutter's model).
  • Google Play plan change — purchase(…, googleProductChangeInfo:) / purchasePackage(…, googleProductChangeInfo:) with GoogleProductChangeInfo(oldProductId, replacementMode:). Buying a sibling plan without it started a second Play subscription billing beside the first. Ignored on iOS (purchases_flutter parity).

Fixed (native parity) #

  • Android: BillDog Auth was never configured — the first signUp / requestCode / attempt / passkey call crashed the app on an uninitialised base URL, and a hosted Facebook sign-in's session was dropped. The plugin now calls BillDogAuth.configure at configure, as the React Native bridge does.
  • iOS inline PaywallView Restore ran twice and an empty restore reached Dart as onRestore. The paywall now runs it once, shows "No Subscription Found" on the embedded paywall (native fix in PaywallViewController), and onRestore means a restore that gave access, as on Android.
  • Subscription status names — BillDogDelegate.onSubscriptionStatusChanged hears the Dart SubscriptionStatusType name on both platforms (it was active on iOS, ACTIVE on Android), and an expired subscriber is no longer unknown (it is expired, see above).
  • reset() / logOut() — the native SDKs now read and publish the new guest's customer info, so customerInfoStream (and billdog_superwall's status sync) stop showing the signed-out user's entitlements (RevenueCat logOut parity).

Added #

  • integrations/billdog_revenuecat (unpublished, publish_to: none) — keep RevenueCat (purchases_flutter ≥ 10.1) for purchases and use BillDog for paywalls and analytics, with the native integrations' behaviour: BillDogRevenueCat.configure(apiKey) registers a RevenueCatPurchaseController (purchases and restores through RevenueCat, StoreKit's transaction id as evidence on iOS, the Play order id on Android), sweeps the store on every RevenueCat customer-info update, and logs RevenueCat in and out with BillDog. billdog_flutter does not depend on purchases_flutter.
  • PurchaseController.setIdentity(String?) — called after native accepts identify / logIn / reset / logOut (the native BillDogPurchaseAdapter.setIdentity). Default: nothing; a throw is logged, never surfaced.
  • BillDogInAppMessages.instance — dashboard in-app messages (Messaging → In-App), which a Flutter app could not show at all: neither plugin registered the native in-app module (Android did not even depend on billdog-inappmessages), and the only in-app call, showInAppMessages, is Google Play's billing messages. Now: checkForMessages(trigger) (an "On Specific Event" event name, or a message id), the trigger store, setPaused, the queue, frequency-cap reset, suppression, and the click / click-result / will+did display / will+did dismiss callbacks as streams (native handlers are installed only while a stream is listened to). The message UI is the native SDK's. Same API shape as React Native's InAppMessagesManager.

Changed #

  • BillDog.presentSurvey(id) completes when the survey closes, with how it ended: a SurveyResult (now exported) — completed with the respondent and the submitted answers, or dismissed before Submit (completed: false, status: 'dismissed'). A survey that cannot be shown throws a PlatformException with code SURVEY; Dart-only mode returns null. It used to complete at once with nothing — the native presenter was called with no handler — so an app could not tell a submitted survey from an abandoned one, or from one never shown. Code that awaits it now waits until the survey closes; don't await it if the next step should not wait. React Native's presentSurvey resolves the same way.

Fixed #

  • Android: surveys can be shown. The plugin did not depend on io.billdog:billdog-survey-compose, which holds the survey UI, so every presentSurvey failed with "SurveyActivity not found" — and, with no handler to report it, nothing was shown and nothing was said.

Added #

  • BillDogSurveys.instance: listAvailableSurveys(), fetchSurvey(id) (typed SurveyDefinition → pages → questions → choices, with the server's shouldShow/reason), hasCompletedSurvey(id), registerEventTrigger(id, eventNames) and registerEvent(name). presentSurvey was the only survey call this package had; the native SDKs and React Native had the rest. These throw on a missing plugin rather than reading as "no surveys". hasCompletedSurvey is the native SDKs' record, which they keep only for show_once surveys.
  • BillDog.setProxyURL(url, trustedForProofs: true) — an opted-in proxy also gets the customer proofs (the BillDog Auth session and the device key), so customer-scoped calls such as BillDogAuth.deleteAccount() work behind it instead of answering ProofRequiredError. Default false: unchanged. The proofs go to exactly the proxy's scheme, host and port, over https (plain http only to a loopback/private-network host in a DEBUG native build); re-setting the proxy without the flag, or clearing it, withdraws the trust. Both platforms need the native SDKs of the same release (iOS BillDogConfig.setProxyURL(_:trustedForProofs:), Android BillDog.setProxyURL(url, trustedForProofs)).
  • BillDogAuth.hasStoredSession() — whether a refresh token is stored, with no network (the native SDKs' and React Native's hasStoredSession, Auth0 canRenew()). isSignedIn() is false on a cold launch until restore() runs; this is the launch check that says a session is there to restore. Flutter had no way to tell "signed out" from "not restored yet".

Changed #

  • AuthAttemptResult.mfaToken / attempt(mfaToken:) docs: a FAILED second factor spends the challenge too (the server spends it before checking the code), so after a wrong or already-used code start again from the first factor.

Added #

  • BillDogAuth.account() and activeSessions(), and the TOTP factor calls enrolTotp, confirmFactor, listFactors, removeFactor and regenerateBackupCodes — the native SDKs' account, session and second-factor API, which nothing in this package could reach: a Flutter app could not list its sessions or enrol a second factor. Each is proved natively with the stored refresh token, which still never reaches Dart. Works with the 1.1.1-beta.4 native SDKs.
  • BillDog.setProxyURL(url) (RevenueCat Purchases.setProxyURL, the native SDKs' and React Native's setProxyURL): routes every edge-function call through a reverse proxy or a test backend. There was no way to point the Flutter SDK anywhere but production. Call it before configure; it throws when the plugin is missing rather than silently not applying.

Fixed #

  • purchasePackage buys the package: the native SDK buys its own copy of it (RevenueCat purchasePackage), attributed to the package's own offering and placement, with the promotional (iOS) or Play (Android) offer the dashboard pins on it. It bought the package's product by id, so when that product was in more than one offering (experiment arms, a seasonal or placement offering) the purchase was credited to the first loaded offering selling it, and on Android it took that offering's pinned Play offer, not the package's. Package.presentedOfferingContext carries the offering, placement and experiment the native SDK stamped on the package. A package no longer loaded is bought by its product, still credited to its offering. Needs the native SDKs of the same release.
  • billdog_superwall: a purchase is attributed to the BillDog offering behind the Superwall paywall on screen, when SuperwallBillDogPurchaseController(offeringMap: …) names it (Superwall paywall identifier → BillDog offering identifier). The bridge learns which paywall is on screen from the events passed to forwardSuperwallEvent (paywallOpen / paywallClose). Without it a product sold in more than one offering was credited to the first loaded offering selling it. Any other purchase is attributed as before. BillDogGateway gains offerings() and purchase's presentedOfferingContext.
  • BillDog.purchase(productId, presentedOfferingContext:) names the offering the purchase is attributed to, ahead of the first loaded offering selling the product; PresentedOfferingContext is exported. Needs the native SDKs of the same release (PurchaseParams.presentedOfferingContext).

Added (also in this release) #

  • BillDogDelegate.onPurchaseCancelled(productId): both plugins dropped the native SDK's cancel callback, so Dart never heard it.
  • CustomerInfo.activeSubscriptions and subscriptionExpirationDates, which both native SDKs carry (RevenueCat's activeSubscriptions / allExpirationDates).

Fixed (also in this release) #

  • Android: the inline PaywallView no longer crashes. A FlutterActivity gives the paywall's Compose view no lifecycle owner; the view now brings its own (released on dispose), and a Google sign-in that cannot be launched there answers an error instead of crashing. The inline view also forwards onRestore.
  • BillDogDelegate.onPaywallSkipped hears a skipped placement from register() and registerPlacement() on both platforms, once per skip. It never reached a Flutter app from register().
  • billdog_superwall: Superwall events forwarded with forwardSuperwallEvent are recorded under Superwall's own names (superwall_paywall_open, …), as the native iOS and Android bridges do; they used the enum case (superwall_paywallOpen).
  • billdog_superwall: a successful restore stays restored when the status sync after it fails (it turned into failed), and a redeemed web checkout in handleCustomPaywallAction / handleDeepLink returns true instead of throwing. Purchase attribution sends the package's own presentedOfferingContext (placement, paywall, experiment, variant), not only the offering id.
  • iOS: the plugin no longer adds lottie-ios. The SDK links its own Lottie, so apps carried two copies (158 "Class … is implemented in both" warnings at launch, with either copy running).
  • Picks up the native iOS and Android fixes in this release, among them: WebView paywalls render in the WebView on iOS (they fell back to the native renderer, where a sign-in button does nothing); Android reads the customer's access at launch (subscriptionStatus stayed unknown in a Flutter app) and shows in-app messages, journey steps and event-triggered surveys; Android release builds minified with R8 on AGP 9 no longer crash at start; logOut() and reset() end and revoke a held BillDog Auth session; customer info refreshes right after a BillDog Auth sign-in; custom attributes are saved on the server; a paywall button's Purchase buys that button's product; Android restore() results carry their Play order id; push delivery, opens, action buttons and action URLs work; survey state (triggers, show_once, drafts, retry) works on Android; and the survey and in-app message fixes listed in the iOS and Android changelogs.

1.1.1-beta.4 - 2026-10-24 #

Added #

  • PaywallAlreadyPresentedError (wire code PAYWALL_ALREADY_PRESENTED). The iOS and Android SDKs now refuse a paywall asked for while another is on screen or still opening (a double tap on a button that calls register), and nothing on screen changes; "Show Another Paywall" still opens on top. register returns PlacementError with this error, with the native reason on iOS. Both plugins used to report it as an UnknownError. Needs the native SDK release that includes the refusal.
  • PaywallPresentationHandler gains onPurchaseSuccess, onRestore, onLoadingStateChange, onFinish and onSkipped. onPurchaseSuccess returns a PostPurchaseBehavior; keepOpen keeps the paywall open. The plugin waits up to 2 seconds for the answer and closes the paywall without one. On Android the native SDK asks on the main thread, where Flutter also delivers Dart's answer, so the plugin does not wait there: the callback runs and the paywall closes.

Changed #

  • BillDogError is sealed and has a new subtype, PaywallAlreadyPresentedError: a switch over BillDogError that lists every subtype needs a case for it.

Fixed #

  • iOS: the plugin compiles at its declared iOS 15 floor. 1.1.1-beta.3 fails to compile on iOS for any app whose deployment target is below 16: it called the iOS 16 passkey deletion API unguarded. On iOS 15 BillDogAuth.deletePasskey() now fails with passkey_failed, as registering and signing in with a passkey already do.
  • The analytics overrides in BillDogOptions — analyticsSessionTimeout, analyticsEnabled, analyticsFlushInterval, analyticsBatchSize, analyticsMaxQueueSize, analyticsSamplingRate — now reach the native SDK, which applies them over the dashboard's values (seconds for the interval and timeout, as documented). They were never passed to native, so none took effect. On Android the background analytics sync, which runs without your app's configure, now applies them too.
  • registerPlacement's handler follows the paywall live, through the native SDKs' presentation handler: onLoadingStateChange, onPresent, onPurchaseSuccess, onRestore, onDismiss and onFinish fire as they happen. onSkip (and the new onSkipped, with the reason) fires when nothing is shown: no paywall configured, already entitled, or holdout. onError fires when the paywall could not be shown, and a refused second paywall's text names PAYWALL_ALREADY_PRESENTED. Before, none of these was called, except onSkip when the native plugin was missing. register still reports no paywall as a PlacementError, as the native closure API does, and its result is unchanged.
  • BillDogOptions.logLevel takes effect: it reaches the native SDK, and the Dart logger follows it too. It was read nowhere, so only enableLogging counted. A set level overrides enableLogging (messages at that level and above), as natively. The plugin's own native messages go through the native logger too, so they follow the same settings.
  • Android: BillDogOptions.localeOverride takes effect. The Android SDK never applied a configured locale (see its changelog). A blank localeOverride is no override.
  • A locale set with setLocaleOverride() in an earlier launch reaches native paywalls and surveys at configure. It was restored in Dart only, so they showed another language than the one getEffectiveLocale() reported.
  • customerInfoStream receives every customer-info update the native SDK makes: a renewal, a refund or revoke, an Ask-to-Buy or Play pending purchase approved later, a purchase on a native paywall. It was fed only by getCustomerInfo() calls made from Dart, so the app (and the Superwall integration) kept the old entitlements until its next read.
  • logIn/identify (as another user) and logOut/reset drop the cached CustomerInfo. A new customerInfoStream listener and entitlementsForProduct() used to get the previous user's info, and a getCustomerInfo() started before the switch could publish it after.

1.1.1-beta.3 - 2026-10-17 #

Fixed (from the iOS and Android SDKs) #

  • A paywall product list bound to the offering shows every package, not only as many as it has authored cards; a one-time product's card shows no bare "/".
  • Shadows and theme colours are drawn as designed (shadows drawn once on Android, {value, unit} geometry read, inner shadows, theme tokens and hsl alpha).
  • iOS: an app that only calls configure() sends analytics, and a journey action is not delivered twice across logIn.

Added #

  • BillDog.shared.preloadPaywalls(placementIds) and BillDog.shared.preloadAllPaywalls(), calling the native SDK's preload: each placement is resolved and its answer kept for registerPlacement (which then presents at once and refreshes it in the background), its wall's images, fonts and renderer warmed. Neither was reachable from Flutter before.

1.0.2-beta.3 - 2026-10-03 #

Added #

  • Purchase recording as store evidence (purchase-recording proposal r3.1 §6.4): StoreEvidence (with fromInAppPurchase, which maps a StoreKit 1 restore to the original transaction id), PurchaseRecording, BillDog.recordPurchase, syncStorePurchases, purchaseRecordingIssues, storeAccountToken, and observePurchaseResult(evidence:, transactionId:).
  • PurchaseController.purchase(PurchaseRequest) and restore(), defaulted to the per-store methods, return PurchaseOutcome / RestoreOutcome with the purchase's evidence. capabilities and storeKitVersion declare what the controller can honour.

Changed (breaking) #

  • The native forwarding controllers send the full purchase request (offer token, upgrade, quantity, the customer's store-account token) and carry the evidence back. Android used to send only the product id and a hardcoded store.
  • A host purchase Dart does not answer within five minutes, or one in flight when the engine detaches, is Pending, not a failure or a hang.
  • A PurchaseController subclass may no longer declare its own members named purchase, restore, capabilities or storeKitVersion.
  • An embedded paywall's failed restore is reported as an error, not a restore (iOS).
  • OfferingResult carries the placement as the server describes it: placementInfo (PlacementInfo), presentation (PlacementPresentation: gated, holdout, withheld, withheldReason), experiment (PlacementExperiment, with variantName) and campaign (PlacementCampaign), on every outcome. gated, placementId, experimentId and variantId are read from them. The plugins used to send null for every display field, the variant name and the campaign.
  • Every failure a channel method reports is a typed BillDogError carrying the server's wire code: PlacementError.error, PresentError.error, RestoreFailed.error, WebCheckoutResult.failure, Failed.error; getCustomerInfo, getPaywall, identify, setUserAttributes and hasAccessForPlacement throw one; BillDogAuth.deleteAccount() throws ReauthRequiredError / ProofRequiredError / ProofInvalidError. BillDogDelegate.onPurchaseFailed receives a BillDogError, not a string.
  • A missing native plugin is a failure for restorePurchases (RestoreFailed), register (PlacementError) and getPresentationResult (PresentError); an empty native answer to getOffering is OfferingFailed. These used to read as an empty restore, a dismissal, "no paywall" and "nothing configured".
  • presentSurvey on an unconfigured SDK is an error, not a silent success.
  • showInAppMessages returns whether they were shown (false on iOS, which has no equivalent); it used to answer as if it had worked everywhere.
  • setSandboxMode is removed: it was a no-op on both platforms (sandbox is decided by the API-key prefix).
  • getOffering(placement) returns an OfferingResult (OfferingAvailable, OfferingHoldout, OfferingWithheld, OfferingNotConfigured, OfferingFailed) instead of Offering?. A holdout, a withheld placement and a refusal are reported as themselves; no other offering is substituted.
  • hasAccessForPlacement is asynchronous and asks the native SDK. It used to read a value nothing wrote, and answered true for every placement.
  • PurchaseController.restorePurchases returns RestoreResult. The deprecated RestorationResult alias is removed.
  • Headless paywall events carry no paywall_id. placement_identifier holds the placement identifier; placement_id is sent only when the placement's server id is known.

Added #

  • getOfferings(): the project's default offering. No placement identifier is sent.
  • purchase(productId), purchasePackage(package), purchaseViaWeb(productId) and completeWebCheckout(uri).
  • BillDogAuth.deleteAccount().
  • Typed server refusals: ProofRequiredError, ProofInvalidError (proof), ReauthRequiredError (maxAgeSeconds), AccessDeniedError (selector), PurchaseOwnerConflictError (retryable), PlacementAccessWithheldError, PlacementNotFoundError.
  • BillDogDelegate.onWebCheckoutRedeemed(RedemptionOutcome): the native onDidRedeemLink, every outcome included (RedemptionRefused carries the server's typed refusal).
  • integrations/billdog_superwall: an optional Superwall purchase controller backed by BillDog.

Fixed #

  • Every BillDogAuth and BillDogOrganizations call threw MissingPluginException: Dart invoked them on the billdog channel while both plugins handle them on io.billdog.flutter/sdk.
  • iOS: reset() tore the native SDK down (it called native reset()); every call after a logout failed until configure ran again. It now calls native logOut(), as Android does.

Removed #

  • The unused pigeon schema (pigeons/billdog_api.dart) and the pigeon dev-dependency. No generated code existed; the channels are hand-written.
  • The Dart journey action poller. It invoked checkPendingActions and completeAction, which neither plugin handled. The native SDKs fetch, execute and report journey actions themselves.

1.0.1-beta.2 #

Fixes iOS dependency resolution. The published podspec declared s.dependency 'BillDog' — a pod that has never existed on the CocoaPods trunk — so pod install failed with "Unable to find a specification for BillDog". It now depends on BillDogFull (which the Swift sources already imported) with a version floor naming the pre-release (>= 1.0.0-beta.2), since CocoaPods will not select a pre-release for an unversioned or ~> requirement.

No Dart API or behaviour changes.

1.0.0-beta.2 #

Initial public beta. Thin bridge over the native BillDog iOS/Android SDKs, with inline native paywall rendering via a PlatformView.

Added #

  • Paywall presentation and inline native paywall view (PaywallView).
  • Purchases: purchase, restore, and host-driven PurchaseController bridge.
  • Identity: logIn / logOut / identify with attribute support and persistence across configure.
  • Analytics event tracking.
  • Customer info stream, offerings, packages, entitlements, and subscription status models.
  • Localization helpers, including CLDR-parity RTL locale detection.
  • Delegate dispatch for paywall/purchase lifecycle callbacks.
  • Hand-written MethodChannel bridge (io.billdog.flutter/sdk) to the native SDKs. (This entry used to claim pigeon-generated channels; no pigeon output was ever generated or consumed, and the unused schema has been removed.)
0
likes
140
points
891
downloads

Documentation

Documentation
API reference

Publisher

verified publisherbilldog.io

Weekly Downloads

BillDog SDK for Flutter — monetization, paywalls, subscriptions and BillDog Auth sign-in. Thin bridge over the native iOS/Android SDKs with inline native paywall rendering.

Homepage
View/report issues

Topics

#in-app-purchase #subscriptions #paywall #monetization #analytics

License

MIT (license)

Dependencies

flutter, shared_preferences

More

Packages that depend on billdog_flutter

Packages that implement billdog_flutter