NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
pub.dev
pub.dev
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.
Last release 19 days ago
03 Nov 2026
Ships fairly regularly
a new release about every 2 weeks
Unknown
no stable releases
Nothing withdrawn
no release was ever pulled
4 months old
6 releases · first in 2026
Drag across the ruler to compare, or tap a release to open it.
The native managers keep them deprecated, failing at once without a request.
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.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.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://.setConsent(purpose, …), hasConsent(purpose)) goes through the native facade on both
platforms, so it drops the kept placement answers as the blanket setters do.USE_EXACT_ALARM strip stays (a no-op once billdog-notifications no longer declares it).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.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).Each goes through both plugins to the real native call.
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.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).setAttribution(map) and the named setters (setAdjustId,
setAppsflyerId, setMixpanelDistinctID, ... setMediaSource, setCampaign, setAdGroup,
setCreative, setPushToken), each to the native consent-gated setter;
collectDeviceIdentifiers().captureFeedback(...), presentFeedbackWidget([options]).onProductSelectionChange(componentId) stream.BillDogAnalytics.isOptedOut(), getAnonymousId(), fetchAttribution().BillDogFeatureFlags.getVariant(experimentId) → ExperimentAssignment,
setAttributes, trackConversion, trackImpression, and the onAssignmentChanged stream
(the native ab_variant_assigned).armEventTriggeredSurveys(), prefetch(surveyId), flushOfflineQueue(),
setEnabled(bool), and for a survey UI of your own: startSurvey,
submitResponse(surveyId, [SurveyAnswer]), recordPartialResponse, abandonSurvey,
dismissSurvey, trackSurveyEvent.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.PaywallView.onOpenUrl on Android, iOS tap dedupeSubscriptionStatus.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).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).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.metadata, and the real timestamp
(native fix).io.billdog.notifications.LAUNCH_HOOK = false.onNewIntent) is recorded and delivered; it
was lost, because FlutterActivity does not call setIntent.onNotificationClick has a listener is held and delivered
to the first one. NotificationClick.notificationId is BillDog's id on both platforms.BillDogPush.getPermissionStatus() (PushPermissionStatus, notDetermined on Android
before the prompt) and BillDogPush.isOptedIn().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).wireValue now), and the
iOS notification-id fallback. Flags need no bridge-side fetch: the first read fetches natively.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.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.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).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).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).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).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.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.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).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.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.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.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".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.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.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).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).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.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).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.Your coding agent can read these notes before it upgrades. Set up the MCP server →
One column per month.
PaywallAlreadyPresentedError (wire code PAYWALL_ALREADY_PRESENTED). The iOS and Android SDKs now refuse a paywall asked for while another is on screen
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.BillDogError is sealed and has a new subtype, PaywallAlreadyPresentedError: a
switch over BillDogError that lists every subtype needs a case for it.BillDogAuth.deletePasskey() now fails with passkey_failed, as registering and
signing in with a passkey already do.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.BillDogOptions.localeOverride takes effect. The Android SDK never applied a
configured locale (see its changelog). A blank localeOverride is no override.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.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 "
{value, unit}
geometry read, inner shadows, theme tokens and hsl alpha).configure() sends analytics, and a journey action is not
delivered twice across logIn.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.PurchaseController.restorePurchases returns RestoreResult. The deprecated RestorationResult alias is removed.
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.Pending, not a failure or a hang.PurchaseController subclass may no longer declare its own members named
purchase, restore, capabilities or storeKitVersion.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.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.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.paywall_id. placement_identifier holds
the placement identifier; placement_id is sent only when the placement's
server id is known.getOfferings(): the project's default offering. No placement identifier is
sent.purchase(productId), purchasePackage(package), purchaseViaWeb(productId)
and completeWebCheckout(uri).BillDogAuth.deleteAccount().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.BillDogAuth and BillDogOrganizations call threw
MissingPluginException: Dart invoked them on the billdog channel while
both plugins handle them on io.billdog.flutter/sdk.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.pigeons/billdog_api.dart) and the pigeon
dev-dependency. No generated code existed; the channels are hand-written.checkPendingActions and
completeAction, which neither plugin handled. The native SDKs fetch,
execute and report journey actions themselves.Fixes iOS dependency resolution. The published podspec declared s.dependency 'BillDog' — a pod that has never existed on the CocoaPods trunk — so pod
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.
Initial public beta. Thin bridge over the native BillDog iOS/Android SDKs, with inline native paywall rendering via a PlatformView.
Initial public beta. Thin bridge over the native BillDog iOS/Android SDKs, with
inline native paywall rendering via a PlatformView.
PaywallView).PurchaseController bridge.logIn / logOut / identify with attribute support and
persistence across configure.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.)