IA 🔥 Tendance Accueil Créer une application Outils gratuits Documentation Tarifs Comparer Guide de publication Actualités Contact À propos
Créer un APK gratuit

API du pont JavaScript

Connexion et clés d'accès

Un vrai sélecteur de compte Google, natif plutôt qu'une redirection web, et des passkeys via le Credential Manager d'Android - navigator.credentials fonctionne comme dans Chrome, ou utilisez AppMint.passkey avec les options JSON de votre serveur.

AppMint.passkey assistant#

window.AppMint.passkey — create(options), get(options), isAvailable(), origin(), assetLinks()

Exemple

Les passkeys (connexion par empreinte, visage ou verrouillage d'écran - sans mot de passe) via le gestionnaire de passkeys d'Android, à partir des options JSON produites par votre serveur de passkeys.

Renvoie : create(optionsJSON) → promesse de la RegistrationResponseJSON ; get(optionsJSON) → promesse de l'AuthenticationResponseJSON (envoyez l'une ou l'autre à votre serveur pour la vérifier). Les deux sont rejetées avec une DOMException (err.name, et err.reason = un code court). isAvailable() → booléen, origin() → chaîne, assetLinks() → tableau - tous immédiatement. Nécessite : Android 9+ avec les services Google Play, un serveur de passkeys, et les deux étapes de configuration ci-dessous. Aucun interrupteur de compilation.

Se connecter :

async function signInWithPasskey() {
  if (!window.AppMint || !window.AppMint.passkey || !window.AppMint.passkey.isAvailable()) {
    alert('Passkeys are not available on this phone.');
    return;
  }
  var options = await (await fetch('https://your-domain.com/passkey/login-options')).json();
  var answer;
  try {
    answer = await window.AppMint.passkey.get(options);   // rpId must be your domain
  } catch (err) {
    if (err.name === 'NotAllowedError') return;          // cancelled, or no passkey on this phone
    alert('Passkey problem: ' + err.message);
    return;
  }
  var res = await fetch('https://your-domain.com/passkey/login-verify', {
    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(answer)
  });
  if (res.ok) showAccount();
}

Créez-en un (après que l'utilisateur s'est connecté autrement) :

async function addPasskey() {
  var options = await (await fetch('https://your-domain.com/passkey/register-options')).json();
  try {
    var answer = await window.AppMint.passkey.create(options);
    await fetch('https://your-domain.com/passkey/register-verify', {
      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(answer)
    });
  } catch (err) {
    if (err.name === 'InvalidStateError') alert('You already have a passkey here.');
    else if (err.name !== 'NotAllowedError') alert('Passkey problem: ' + err.message);
  }
}

Configuration à faire une seule fois : lancez ceci dans l'application installée DEPUIS Google Play (Play signe avec sa propre clé) :

console.log(JSON.stringify(window.AppMint.passkey.assetLinks(), null, 2));
// save as https://your-domain.com/.well-known/assetlinks.json
console.log(window.AppMint.passkey.origin());
// android:apk-key-hash:...  — add to your server's expected origins

Remarques : err.name / err.reason : NotAllowedError (cancelled, no_credential, interrupted), InvalidStateError (existe déjà), SecurityError avec not_linked (assetlinks.json ne liste pas l'application) ou rp_mismatch (le rpId n'est pas le domaine de cette page), NotSupportedError / unavailable (Android < 9 ou pas de services Play), TypeError / invalid_options (une page intégrée à l'application n'a pas de domaine, donc définissez rp.id / rpId sur votre domaine). window.AppMint.passkey n'existe que dans l'application ; dans un navigateur, utilisez navigator.credentials (le même code fonctionne aussi dans l'application).

WebToApkAuth.signInWithGoogle assistant#

window.WebToApkAuth.signInWithGoogle(webClientId)

Exemple

Connecte l'utilisateur avec son compte Google via le sélecteur de compte propre à Android, et vous donne un jeton d'identité Google. Google bloque sa page de connexion dans les WebViews des applications (« disallowed_useragent ») ; ce chemin natif n'est pas bloqué.

Renvoie : une promesse de {ok:true, idToken, email, displayName, profilePictureUri}. Elle est REJETÉE avec une Error dont message est le code (cancelled, google_play_services_unavailable, missing_web_client_id, failed, …). Nécessite : votre identifiant de client Web OAuth (se terminant par .apps.googleusercontent.com), et les empreintes SHA-1 et SHA-256 de l'application enregistrées auprès de votre projet Google / Firebase (depuis le fichier _signkey_info.txt de votre compilation, et la clé de signature d'application de Play si vous publiez sur Play). Aucun interrupteur de compilation.

Avec Firebase Authentication (SDK compat) :

var WEB_CLIENT_ID = '1234567890-abc.apps.googleusercontent.com';

document.getElementById('google-button').addEventListener('click', async function () {
  if (!window.WebToApkAuth) {
    alert('Google sign-in works in the app.');     // or run your normal web sign-in here
    return;
  }
  try {
    var r = await window.WebToApkAuth.signInWithGoogle(WEB_CLIENT_ID);
    var cred = firebase.auth.GoogleAuthProvider.credential(r.idToken);
    await firebase.auth().signInWithCredential(cred);
    showWelcome(r.displayName || r.email);
  } catch (err) {
    if (err.message === 'cancelled') return;                   // user closed the picker
    if (err.message === 'google_play_services_unavailable') {
      alert('No Google account or Google Play services on this phone.');
      return;
    }
    alert('Google sign-in failed: ' + err.message);
  }
});

Avec votre propre serveur - envoyez le jeton d'identité (ID token) et vérifiez-le là-bas (ne lui faites jamais confiance dans la page seule) :

async function signInWithMyServer() {
  var r = await window.WebToApkAuth.signInWithGoogle(WEB_CLIENT_ID);
  await fetch('https://your-domain.com/auth/google', {
    method: 'POST', headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ idToken: r.idToken })
  });
}

Avec Supabase Auth (transmettez le jeton d'identité à signInWithIdToken):

async function signInWithSupabase() {
  if (!window.WebToApkAuth) {
    return supabase.auth.signInWithOAuth({ provider: 'google' });   // normal web sign-in in a browser
  }
  try {
    var r = await window.WebToApkAuth.signInWithGoogle(WEB_CLIENT_ID);
    var res = await supabase.auth.signInWithIdToken({ provider: 'google', token: r.idToken });
    if (res.error) throw res.error;
    showWelcome(res.data.user.email);
  } catch (err) {
    if (err.message !== 'cancelled') alert('Google sign-in failed: ' + err.message);
  }
}

Remarques : Passez l'identifiant du client Web. Sans argument, l'assistant utilise window.firebaseConfig._googleWebClientId si votre page le définit, puis le client Web du google-services.json importé pour cette application (uniquement quand ce fichier est celui de votre propre projet Firebase avec la connexion Google activée - jamais une compilation AppMint Push) ; si rien de tout cela n'existe, il est rejeté avec missing_web_client_id. Une page qui n'est pas celle de l'application (un site externe ouvert dans l'application) est refusée avec foreign_origin. Utilisez l'identifiant du client WEB, pas celui d'un client Android. « No credentials available » signifie généralement que le SHA-1 n'est pas enregistré. Cet assistant n'existe que dans l'application - dans un navigateur, utilisez votre connexion web habituelle. Appelez-le depuis un toucher sur un bouton.

WebToApkAuth.signOutGoogle assistant#

window.WebToApkAuth.signOutGoogle()

Exemple

Efface le choix de connexion Google enregistré par Android, pour que le prochain signInWithGoogle affiche à nouveau le sélecteur de compte au lieu de réutiliser silencieusement le dernier compte.

Renvoie : une promesse de {ok:true} ; rejetée avec une Error dont message indique ce qui s'est mal passé. Nécessite : rien.

Appelez-le en même temps que votre propre déconnexion :

document.getElementById('sign-out').addEventListener('click', async function () {
  await firebase.auth().signOut();            // your normal sign-out (Firebase here)
  if (window.WebToApkAuth) {
    try {
      await window.WebToApkAuth.signOutGoogle();
    } catch (err) {
      console.log('Could not clear the Google choice: ' + err.message);
    }
  }
  showSignInScreen();
});

Un bouton « Changer de compte » : effacez le choix enregistré, puis reconnectez-vous pour que l'utilisateur choisisse un autre compte :

async function switchGoogleAccount() {
  if (!window.WebToApkAuth) return;
  await firebase.auth().signOut();
  try { await window.WebToApkAuth.signOutGoogle(); } catch (err) { /* nothing saved to clear */ }
  try {
    var r = await window.WebToApkAuth.signInWithGoogle('1234567890-abc.apps.googleusercontent.com');
    await firebase.auth().signInWithCredential(firebase.auth.GoogleAuthProvider.credential(r.idToken));
  } catch (err) {
    if (err.message !== 'cancelled') alert('Google sign-in failed: ' + err.message);
    showSignInScreen();
  }
}

Déconnectez d'abord l'utilisateur de votre propre serveur, puis effacez le choix Google sans laisser un échec bloquer la déconnexion :

async function signOutEverywhere() {
  await fetch('https://your-domain.com/auth/logout', { method: 'POST', credentials: 'include' });
  localStorage.removeItem('profile');
  if (window.WebToApkAuth) {
    var r = await window.WebToApkAuth.signOutGoogle()
      .catch(function (err) { return { ok: false, error: err.message }; });
    if (!r.ok) console.log('Google choice not cleared: ' + r.error);
  }
  location.replace('/login');
}

Remarques : Cela ne met pas fin à la session de votre application - déconnectez vous-même l'utilisateur de votre backend. Cela réinitialise seulement le compte Google que le téléphone proposera la prochaine fois.

navigator.credentials standard web#

navigator.credentials.create / get({ publicKey }) — passkeys

Exemple

Appels de passkeys WebAuthn standard. Une WebView Android normale ne peut pas les faire ; dans l'application, ils passent par le gestionnaire de passkeys d'Android, si bien que le code et les bibliothèques écrits pour Chrome (SimpleWebAuthn, Hanko, Corbado, Auth0) fonctionnent sans changement.

Renvoie : une promesse d'un PublicKeyCredential (avec .toJSON()), exactement comme Chrome ; rejetée avec une DOMException. Nécessite : Android 9+ avec les services Google Play, un serveur de passkeys, le assetlinks.json de votre domaine listant l'application, et votre serveur acceptant l'origine de l'application (voir AppMint.passkey). Aucun interrupteur de compilation.

Connectez-vous avec l'API standard (options venant de votre serveur, champs binaires sous forme d'ArrayBuffers) :

async function signIn() {
  if (!window.PublicKeyCredential) { alert('Passkeys are not supported here.'); return; }
  var ok = await PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
  if (!ok) { alert('This phone cannot use passkeys.'); return; }

  try {
    var json = await (await fetch('https://your-domain.com/passkey/login-options')).json();
    var publicKey = PublicKeyCredential.parseRequestOptionsFromJSON(json);  // provided in the app too
    var cred = await navigator.credentials.get({ publicKey: publicKey });
    await fetch('https://your-domain.com/passkey/login-verify', {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(cred.toJSON())
    });
  } catch (err) {
    if (err.name !== 'NotAllowedError') alert('Passkey problem: ' + err.message);
  }
}

Enregistrer une passkey :

async function register() {
  if (!window.PublicKeyCredential) return;
  try {
    var json = await (await fetch('https://your-domain.com/passkey/register-options')).json();
    var cred = await navigator.credentials.create({
      publicKey: PublicKeyCredential.parseCreationOptionsFromJSON(json)
    });
    await fetch('https://your-domain.com/passkey/register-verify', {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(cred.toJSON())
    });
  } catch (err) {
    if (err.name === 'InvalidStateError') alert('You already have a passkey here.');
    else if (err.name !== 'NotAllowedError') alert('Passkey problem: ' + err.message);
  }
}

Décidez quels boutons de connexion afficher selon ce que le téléphone prend en charge (l'autoremplissage des passkeys est désactivé dans l'application, gardez donc un bouton) :

async function setupSignInButtons() {
  if (!window.PublicKeyCredential) return;
  var caps = typeof PublicKeyCredential.getClientCapabilities === 'function'
    ? await PublicKeyCredential.getClientCapabilities() : {};
  var platform = caps.passkeyPlatformAuthenticator ||
    await PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
  document.getElementById('passkey-button').hidden = !platform;
  if (caps.conditionalGet) startPasskeyAutofill();   // false in the app; true in some browsers
}

Remarques : L'autoremplissage des passkeys dans un champ de texte (mediation: 'conditional') n'est pas disponible dans l'application - isConditionalMediationAvailable() répond false et l'appel est rejeté avec NotSupportedError ; lancez la connexion depuis un bouton. signal (AbortController) fonctionne. Une page intégrée à l'application n'a pas de domaine propre : définissez rp.id / rpId sur votre domaine. Les appels sans publicKey (mots de passe, OTP) vont à la WebView comme avant.

OTPCredential standard web#

navigator.credentials.get({ otp: { transport: ['sms'] } }) — WebOTP

Exemple

L'API standard WebOTP : le code de connexion reçu par SMS se remplit tout seul. Android affiche la feuille de Google « Autoriser cette application à lire ce message ? » - aucune autorisation SMS.

Renvoie : une promesse d'un OTPCredential {type:'otp', code}. Rejetée avec AbortError quand l'utilisateur touche Refuser ou que le signal interrompt, InvalidStateError après cinq minutes sans SMS, NotSupportedError sans les services Google Play. Nécessite : rien à activer. Le SMS doit SE TERMINER par une ligne nommant l'hôte de cette page : @<host> #<code>.

const input = document.querySelector('input[autocomplete="one-time-code"]');

if ('OTPCredential' in window) {
  const ac = new AbortController();
  document.querySelector('form').addEventListener('submit', () => ac.abort());
  navigator.credentials.get({ otp: { transport: ['sms'] }, signal: ac.signal })
    .then((otp) => { input.value = otp.code; input.form.requestSubmit(); })
    .catch((e) => console.log('Type the code instead:', e.name));
}

Le SMS envoyé par votre serveur (la dernière ligne est la liaison) :

Your Acme code is 482913.

@acme.example #482913

Après « Renvoyer le code », lancez une nouvelle demande (elle remplace celle qui attend encore, qui est alors rejetée avec AbortError) :

async function resendAndWait(phone) {
  await fetch('/api/send-code', {
    method: 'POST', headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ phone })
  });
  if (!('OTPCredential' in window)) return;
  try {
    const otp = await navigator.credentials.get({ otp: { transport: ['sms'] } });
    await verifyCode(otp.code);
  } catch (e) {
    if (e.name === 'InvalidStateError') showMessage('No SMS yet. Tap Resend to try again.');
  }
}

Remarques : l'hôte doit être celui de la page elle-même - pour une application basée sur un site web, c'est votre domaine (le SMS que Chrome lit déjà) ; pour une application hors ligne ou créée par l'IA, c'est appassets.androidplatform.net. Un message destiné à un autre hôte est ignoré et l'application continue d'attendre. Page principale uniquement (les codes liés à une origine intégrée, @top #code @iframe, ne sont pas pris en charge). Une seule demande attend à la fois ; une nouvelle annule l'ancienne. Événement associé : appmint:otp.

__otpCancel pont#

window.WebToApk.__otpCancel(requestId: String)

Abandonne une demande WebOTP en attente (AbortSignal, ou une nouvelle demande l'a remplacée).

Exemple

Transport interne derrière l'annulation d'une demande WebOTP (AbortSignal). Les pages utilisent l'API standard ; n'appelez jamais ceci directement - les méthodes __ peuvent changer sans préavis.

Renvoie : rien. Nécessite : rien à activer.

Utilisez l'API publique :

const ac = new AbortController();
const cred = await navigator.credentials.get({ otp: { transport: ['sms'] }, signal: ac.signal });
codeInput.value = cred.code;
ac.abort();   // the pending get() rejects with AbortError

Cessez d'attendre dès que l'utilisateur commence à saisir lui-même le code :

const input = document.querySelector('input[autocomplete="one-time-code"]');
const ac = new AbortController();
input.addEventListener('input', () => ac.abort(), { once: true });

navigator.credentials.get({ otp: { transport: ['sms'] }, signal: ac.signal })
  .then((cred) => { input.value = cred.code; })
  .catch((e) => { if (e.name !== 'AbortError') console.log('No code:', e.name); });

Annulez l'attente lorsque l'utilisateur revient en arrière pour modifier son numéro de téléphone :

let otpAbort = null;

function waitForSms() {
  otpAbort = new AbortController();
  return navigator.credentials.get({ otp: { transport: ['sms'] }, signal: otpAbort.signal });
}

document.getElementById('change-number').addEventListener('click', () => {
  if (otpAbort) { otpAbort.abort(); otpAbort = null; }   // the pending get() rejects with AbortError
  showPhoneStep();
});

Remarques : Implémenté dans le shell de l'application (WebApiPolyfills.kt). Le même code de page fonctionne sans changement dans Chrome.

__otpStart pont#

window.WebToApk.__otpStart(requestId: String)

WebOTP : attend (jusqu'à cinq minutes) un SMS via la feuille SMS User Consent de Google - aucune autorisation SMS. La réponse est `appmint:otp {requestId, message|error}`.

Exemple

Transport interne derrière navigator.credentials.get({ otp: { transport: ['sms'] } }). Les pages utilisent l'API standard ; n'appelez jamais ceci directement - les méthodes __ peuvent changer sans préavis.

Renvoie : rien ; la réponse arrive comme l'événement appmint:otp {requestId, message} ou {requestId, error} (cancelled, timeout, unavailable). Nécessite : rien à activer.

Utilisez l'API publique :

const ac = new AbortController();
const cred = await navigator.credentials.get({ otp: { transport: ['sms'] }, signal: ac.signal });
codeInput.value = cred.code;

Arrêtez d'attendre après une minute grâce à un signal de délai d'expiration :

async function waitForCode(input) {
  if (!('OTPCredential' in window)) return;
  try {
    const cred = await navigator.credentials.get({
      otp: { transport: ['sms'] },
      signal: AbortSignal.timeout(60000)
    });
    input.value = cred.code;
  } catch (e) {
    // TimeoutError after 60 s, AbortError when the user taps Deny
    showMessage('Type the code from the SMS.');
  }
}

Indiquez à l'utilisateur quoi faire ensuite à partir du nom de l'erreur :

async function readOtp() {
  try {
    const cred = await navigator.credentials.get({ otp: { transport: ['sms'] } });
    return cred.code;
  } catch (e) {
    if (e.name === 'InvalidStateError') showResendButton();      // no SMS within five minutes
    else if (e.name === 'NotSupportedError') showManualEntry();  // no Google Play services
    return null;                                                  // AbortError: the user tapped Deny
  }
}

Remarques : Implémenté dans le shell de l'application (WebApiPolyfills.kt). Le même code de page fonctionne sans changement dans Chrome.

passkeyIsAvailable pont#

window.WebToApk.passkeyIsAvailable(): Boolean

Vrai sur Android 9+ avec les services Google Play - les téléphones capables de conserver une passkey.

Exemple

Indique si ce téléphone peut utiliser des passkeys. Les pages utilisent normalement l'API publique AppMint.passkey.isAvailable() (ou PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable()), qui enveloppe cet appel.

Renvoie : un booléen, immédiatement - true sur Android 9+ avec les services Google Play et une WebView assez récente pour le canal des passkeys. Nécessite : rien.

L'API publique :

var canPasskey = !!(window.AppMint && window.AppMint.passkey && window.AppMint.passkey.isAvailable());
document.getElementById('passkey-button').hidden = !canPasskey;

L'appel brut, si vous en avez besoin :

var canPasskey = !!window.WebToApk &&
  typeof window.WebToApk.passkeyIsAvailable === 'function' &&
  window.WebToApk.passkeyIsAvailable() === true;

Proposez « Ajouter une passkey » une fois après une connexion par mot de passe, uniquement sur les téléphones qui peuvent en conserver une (la vérification standard, même code dans Chrome) :

async function offerPasskeyAfterLogin() {
  var ok = !!window.PublicKeyCredential &&
    await PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
  if (!ok) return;                                   // Android below 9 or no Google Play services
  if (localStorage.getItem('passkey-offered')) return;
  localStorage.setItem('passkey-offered', '1');
  document.getElementById('add-passkey-banner').hidden = false;
}

Remarques : Quand cette valeur est false, AppMint.passkey.create/get sont rejetés avec NotSupportedError. Masquez le bouton passkey et proposez votre autre méthode de connexion.

passkeyOrigin pont#

window.WebToApk.passkeyOrigin(): String

L'origine qu'un serveur de clés d'accès voit depuis cette application : `android:apk-key-hash:<base64url SHA-256>`.

Exemple

Donne l'origine que votre serveur de passkeys voit pour cette application : android:apk-key-hash:<base64url SHA-256 of the signing certificate>. Les pages utilisent normalement l'API publique AppMint.passkey.origin(), qui enveloppe cet appel.

Renvoie : une chaîne, immédiatement ("" si le certificat ne peut pas être lu). Nécessite : rien.

Exécutez ceci une fois dans l'application installée DEPUIS Google Play, et ajoutez la valeur aux origines autorisées de votre serveur :

if (window.AppMint && window.AppMint.passkey) {
  console.log(window.AppMint.passkey.origin());   // android:apk-key-hash:Lir5oIjf552K...
}

L'appel brut donne la même chaîne :

if (window.WebToApk && typeof window.WebToApk.passkeyOrigin === 'function') {
  console.log(window.WebToApk.passkeyOrigin());
}

Affichez l'origine sur un écran de paramètres masqué, pour pouvoir la lire depuis l'installation Play sans débogueur :

var out = document.getElementById('passkey-origin');
var origin = (window.AppMint && window.AppMint.passkey) ? window.AppMint.passkey.origin() : '';

if (!origin) {
  out.textContent = 'Open this screen in the installed app.';
} else {
  out.textContent = origin;               // android:apk-key-hash:...
  out.style.userSelect = 'all';           // one long-press selects the whole value
}

Remarques : Google Play resigne votre application ; un APK de test donne donc une valeur différente de l'installation depuis Play. Exemple avec SimpleWebAuthn : expectedOrigin: ['https://your-domain.com', 'android:apk-key-hash:...'].

signInWithGoogle pont#

window.WebToApk.signInWithGoogle(serverClientId: String, callbackId: String)

===== Connexion Google native via Credential Manager ===== Contourne le blocage OAuth de Google dans les WebViews Android (erreur disallowed_useragent) en exécutant le flux de connexion en Android natif et en ne transmettant à JS que le jeton d'identité Google obtenu, que le SDK Web Firebase consomme via GoogleAuthProvider.credential(idToken) + signInWithCredential(...). Contrat JS : window.WebToApk.signInWithGoogle(serverClientId, callbackId) serverClientId "" = le client Web (type 3) du google-services.json du créateur pour ce package ; sans lui, erreur "missing_web_client_id". Une page qui n'est pas celle de l'application reçoit l'erreur "foreign_origin". -> à la fin, window.__webToApkAuth[callbackId](resultJsonString) est appelé resultJsonString = '{"ok":true,"idToken":"...","email":"...","displayName":"..."}' ou '{"ok":false,"error":"<message>"}'

Exemple

Lance la connexion Google native (sélecteur de compte d'Android) et répond avec un jeton d'identité Google. Les pages utilisent normalement l'assistant Promise WebToApkAuth.signInWithGoogle(webClientId), qui enveloppe cet appel.

Renvoie : rien. La réponse arrive plus tard : le shell appelle window.__webToApkAuth[callbackId](json) avec '{"ok":true,"idToken":"...","email":"...","displayName":"...","profilePictureUri":"..."}' ou '{"ok":false,"error":"<code>","detail":"..."}', puis supprime cette entrée. Nécessite : votre identifiant de client Web OAuth, et le SHA-1 / SHA-256 de l'application enregistrés auprès de votre projet Google ou Firebase. Aucun interrupteur de compilation.

L'assistant (recommandé) :

async function googleSignIn() {
  if (!window.WebToApkAuth) return null;
  try {
    var r = await window.WebToApkAuth.signInWithGoogle('1234567890-abc.apps.googleusercontent.com');
    return r.idToken;
  } catch (err) {
    if (err.message !== 'cancelled') alert('Google sign-in failed: ' + err.message);
    return null;
  }
}

L'appel brut (ordre des arguments : identifiant du client web, puis l'identifiant de votre callback) :

function googleSignInRaw(done) {
  if (!window.WebToApk || typeof window.WebToApk.signInWithGoogle !== 'function') return;
  var id = 'g_' + Date.now();
  window.__webToApkAuth = window.__webToApkAuth || {};
  window.__webToApkAuth[id] = function (json) {
    var r = JSON.parse(json);
    if (r.ok) done(r.idToken, r.email);
    else if (r.error !== 'cancelled') alert('Google sign-in failed: ' + r.error);
  };
  window.WebToApk.signInWithGoogle('1234567890-abc.apps.googleusercontent.com', id);
}

L'appel brut avec un identifiant de client vide, qui utilise le client Web du google-services.json que vous avez importé :

function googleSignInFromUploadedFile() {
  return new Promise(function (resolve, reject) {
    if (!window.WebToApk || typeof window.WebToApk.signInWithGoogle !== 'function') {
      return reject(new Error('not_in_app'));
    }
    var id = 'g_' + Date.now();
    window.__webToApkAuth = window.__webToApkAuth || {};
    window.__webToApkAuth[id] = function (json) {
      var r = JSON.parse(json);
      if (r.ok) resolve(r); else reject(new Error(r.error));
    };
    window.WebToApk.signInWithGoogle('', id);
  });
}

googleSignInFromUploadedFile()
  .then(function (r) { showProfile(r.displayName, r.profilePictureUri); })
  .catch(function (e) {
    if (e.message === 'missing_web_client_id') console.log('Pass your Web client ID: the uploaded file has none.');
  });

Remarques : Codes d'erreur : cancelled (l'utilisateur a fermé le sélecteur), google_play_services_unavailable (aucun compte ou fournisseur Google - c'est aussi ce que donne un enregistrement SHA-1 manquant), missing_web_client_id (aucun transmis, et aucun client Web dans le google-services.json que vous avez importé), foreign_origin (la page affichée n'est pas celle de l'application), failed, unexpected_credential_type, parse_failed: .... Un premier argument vide utilise le client Web de votre propre google-services.json importé quand il en contient un. Vérifiez le jeton d'identité sur votre serveur (ou transmettez-le à Firebase avec GoogleAuthProvider.credential(idToken)).

signOutGoogle pont#

window.WebToApk.signOutGoogle(callbackId: String)

Efface l'état enregistré du Credential Manager pour que le prochain appel à signInWithGoogle affiche à nouveau le sélecteur de compte (au lieu de resélectionner silencieusement le dernier compte). Les applications générées doivent l'appeler lors d'une déconnexion demandée par l'utilisateur, en plus de firebase.auth().signOut().

Exemple

Efface l'état de connexion Google enregistré par Android, pour que la prochaine connexion affiche à nouveau le sélecteur de compte. Les pages utilisent normalement l'assistant Promise WebToApkAuth.signOutGoogle(), qui enveloppe cet appel.

Renvoie : rien. La réponse arrive plus tard : le shell appelle window.__webToApkAuth[callbackId](json) avec '{"ok":true}' ou '{"ok":false,"error":"..."}'. Nécessite : rien.

L'assistant (recommandé) :

async function signOut() {
  await myBackendSignOut();                          // end your own session first
  if (window.WebToApkAuth) {
    try { await window.WebToApkAuth.signOutGoogle(); } catch (err) { /* nothing to undo */ }
  }
}

L'appel brut :

if (window.WebToApk && typeof window.WebToApk.signOutGoogle === 'function') {
  var id = 'gout_' + Date.now();
  window.__webToApkAuth = window.__webToApkAuth || {};
  window.__webToApkAuth[id] = function (json) {
    var r = JSON.parse(json);
    if (!r.ok) console.log('Google sign-out failed: ' + r.error);
  };
  window.WebToApk.signOutGoogle(id);
}

L'appel brut enveloppé dans une Promise, utilisé quand l'utilisateur supprime son compte :

function clearGoogleChoice() {
  return new Promise(function (resolve) {
    if (!window.WebToApk || typeof window.WebToApk.signOutGoogle !== 'function') return resolve(false);
    var id = 'gout_' + Date.now();
    window.__webToApkAuth = window.__webToApkAuth || {};
    window.__webToApkAuth[id] = function (json) { resolve(JSON.parse(json).ok === true); };
    window.WebToApk.signOutGoogle(id);
  });
}

async function deleteAccount() {
  await fetch('https://your-domain.com/account', { method: 'DELETE', credentials: 'include' });
  await clearGoogleChoice();          // the next sign-in starts from the account picker
  showSignInScreen();
}

Remarques : Cela ne déconnecte pas l'utilisateur de Firebase ni de votre serveur - faites-le vous-même.

Généré à partir de l'environnement d'exécution de l'application et de ses fichiers d'exemple à chaque compilation de la documentation. Lire en Markdown · Toutes les familles.

Vérifié par rapport au pont publié le 22/10/2026.