public final class Invites

Mints an invite and returns it immediately.

This never blocks and never fails for want of a network. The code is generated on the device, so Invite.getUrl is usable at once; registration with the link service is queued and retried until it lands. A link clicked before that registration arrives is still attributed, because the server records the click against the code and joins it when the registration turns up.

Shares an invite through the native share sheet and reports the outcome.

The invite funnel’s invite_shared event is emitted from here, and only when the platform confirms the user actually shared – a dismissed sheet reports invite_share_dismissed instead. That is what makes the “shared” number a measurement rather than an assumption.

Reports the outcome of a share your application performed itself, rather than through share. Use this when the invite goes out through your own user interface – a contact picker, a message composer, a copy-link button – so the funnel still records whether it was really sent.

invite_shared is emitted only when result says the user actually shared; a dismissed sheet reports invite_share_dismissed instead. Calling this is optional and calling it twice for one share double counts, so call it once, from the share callback.

Registers the listener that receives the invite behind this install.

An answer that arrived before the listener was registered – which happens routinely on a cold launch from a link, because the platform delivers the link before the application starts – is delivered as soon as this is called.

Looks for an invite: first in the launch argument, then, when this looks like a fresh install, by asking the link service.

Safe and cheap to call on every start; it will not attribute twice and will not report twice.

Call it on every start rather than only the first. A lookup that ended with “not yet” – the invite exists but the inviter minted it offline and their registration has not reached the service – is retried here, at most once per retry interval, so an invite that becomes claimable during the session is picked up in the session rather than on the next cold start. flush does the same for an application that knows it has just regained connectivity.

Points the invite machinery at a different link service. Defaults to the Codename One cloud, honouring the cloudServerURL display property.

Set the invite.domain build hint to the same host. This changes where links are MINTED and nothing else. The Android intent filter and the iOS associated-domain entitlement are written at BUILD time from that hint, so a host set only here is a host the installed app does not claim: every invite link opens the browser instead of the app, and neither the OS nor the framework reports anything. A mismatch is logged once, because it cannot be refused – pointing at a staging service and accepting the browser is a legitimate thing to do.

A bare host is accepted and read as https://. Anything else that is not HTTPS is REFUSED: Invite.getUrl() promises an absolute https url, and the generated Android filter and iOS associated domain match nothing else, so an http:// base mints links that always open the browser – and it would pass the host check below, which compares hosts and not schemes.

Forgets every trace of invite attribution on this device: the pending lookup, the resolved attribution and the referral dimensions.

Analytics.resetClientId triggers this for you, because an erasure that left the referral dimensions behind would re-link the fresh identity to the same inviter.

Whether the link service has acknowledged this invite.

An unacknowledged invite is still shareable and still attributes – registration is retried until it lands – so this is a diagnostic rather than a gate.