Questa pagina è stata tradotta dall'API Cloud Translation.

Generazione di link ad azioni e-mail

A volte le app mobile devono interagire con gli utenti e chiedere loro di intraprendere determinate azioni inviando email.

Gli SDK client di Firebase consente di inviare agli utenti email contenenti link da utilizzare per la reimpostazione della password, la verifica dell'indirizzo email e l'accesso basato su email. Queste email basate su modelli vengono inviate da Google e hanno una personalizzazione limitata.

Se invece preferisci utilizzare i tuoi modelli di email e il tuo recapito delle email questa pagina spiega come utilizzare l'SDK Admin Firebase. per generare in modo programmatico i link delle azioni per i flussi di cui sopra, che includere nelle email inviate agli utenti.

Questa funzionalità offre i seguenti vantaggi:

Personalizzare i modelli email. Sono incluse la possibilità di aggiungere nuovi stili e branding personalizzato, modificare testo e loghi, rivolgersi agli utenti per nome anziché per nome e cognome e così via.
Applica modelli diversi a seconda del contesto. Ad esempio, se l'utente verificare l'email per iscriversi a una newsletter, è possibile che il contesto forniti nei contenuti dell'email. Un altro esempio è l'accesso tramite link via email: scenario questo può essere attivato dallo stesso utente o come invito da un altro utente. Il contesto deve essere incluso nell'email.
Localizza modelli email personalizzati.
Possibilità di generare il collegamento da un ambiente server sicuro.
Possibilità di personalizzare la modalità di apertura del link, tramite un'app mobile o una browser e come trasferire ulteriori informazioni sullo stato, ecc.
Possibilità di personalizzare il dominio del link dinamico utilizzato per i flussi di app mobile quando creando il link di azione dell'email e persino specificare un link dinamico diverso dominio in base al contesto o all'app mobile.

Inizializza ActionCodeSettings

Prima di poter generare un link all'azione email, potrebbe essere necessario inizializzare un'istanzaActionCodeSettings.

ActionCodeSettings ti consentono di passare uno stato aggiuntivo tramite un URL di continuazione accessibile dopo che l'utente fa clic sul link dell'email. Ciò fornisce inoltre all'utente possibilità di tornare all'app dopo il completamento dell'azione. Inoltre, puoi specificare se gestire il link all'azione email direttamente da un'applicazione mobile quando è installata o da un browser.

Per i link che devono essere aperti tramite un'app mobile, devi attivare Firebase Dynamic Links ed eseguire alcune attività per rilevare questi link dalla tua app mobile. Consulta le istruzioni su come configurare Firebase Dynamic Links per le azioni email.

Per inizializzare un'istanza ActionCodeSettings, fornisci i seguenti dati:

Parametro	Tipo	Descrizione
`url`	stringa	Imposta il link (URL di stato/continua) che ha significati diversi. in diversi contesti: Quando il link viene gestito nei widget delle azioni web, si tratta della nel parametro di query `continueUrl`. Quando il link viene gestito direttamente nell'app, si tratta della `continueUrl` parametro di query nel link diretto della Link dinamico.
`iOS`	({bundleId: string}\|undefined)	Imposta l'ID del pacchetto. Verrà tentato di aprire il link in un'app Apple, se è installata. L'app deve essere registrata nella console.
`android`	({packageName: string, installApp:boolean\|undefined, minimumVersion: string\|undefined}\|undefined)	Imposta il nome del pacchetto Android. Questo proverà ad aprire il link in un App per Android, se installata. Se viene superato il criterio `installApp`, specifica se installare l'app per Android se il dispositivo la supporta e l'app non è già installata. Se questo campo viene fornito senza `packageName`, viene generato un errore che spiega che `packageName` deve essere specificato insieme a questo campo. Se è specificato `minimumVersion` e una versione precedente del l'app viene installata, l'utente viene indirizzato al Play Store per eseguire l'upgrade dell'app. L'app per Android deve essere registrata nella console.
`handleCodeInApp`	(booleano\|non definito)	Se il link di azione dell'email verrà aperto in un'app mobile o sul web prima il link. Il valore predefinito è false. Se impostato su true, il link al codice di azione verrà inviato come link universale o link app Android e verrà aperto dall'app, se installata. In caso falso, il codice verrà inviato prima il widget web e poi su Continua reindirizza all'app se installato.
`dynamicLinkDomain`	(stringa\|undefined)	Imposta il dominio (o sottodominio) del link dinamico da utilizzare per il link corrente se deve essere aperto utilizzando Firebase Dynamic Links. Poiché è possibile configurare più domini di link dinamici per progetto, questo campo consente di sceglierne uno esplicitamente. Se non viene specificato alcun dominio, verrà utilizzato il dominio meno recente per impostazione predefinita.

L'esempio seguente illustra come inviare un link di verifica email che si aprirà inizialmente in un'app mobile come link dinamico Firebase (app Apple com.example.ios o app Android com.example.android in cui verrà installata l'app se non è già installata e la versione minima è 12). Il link diretto conterrà il payload dell'URL di continuahttps://www.example.com/checkout?cartId=1234. Il dominio del link dinamico utilizzato è coolapp.page.link, che deve essere configurato per essere utilizzato con Firebase Dynamic Link.

Node.js

const actionCodeSettings = {
  // URL you want to redirect back to. The domain (www.example.com) for
  // this URL must be whitelisted in the Firebase Console.
  url: 'https://www.example.com/checkout?cartId=1234',
  // This must be true for email link sign-in.
  handleCodeInApp: true,
  iOS: {
    bundleId: 'com.example.ios',
  },
  android: {
    packageName: 'com.example.android',
    installApp: true,
    minimumVersion: '12',
  },
  // FDL custom domain.
  dynamicLinkDomain: 'coolapp.page.link',
};

Java

ActionCodeSettings actionCodeSettings = ActionCodeSettings.builder()
    .setUrl("https://www.example.com/checkout?cartId=1234")
    .setHandleCodeInApp(true)
    .setIosBundleId("com.example.ios")
    .setAndroidPackageName("com.example.android")
    .setAndroidInstallApp(true)
    .setAndroidMinimumVersion("12")
    .setDynamicLinkDomain("coolapp.page.link")
    .build();

Python

action_code_settings = auth.ActionCodeSettings(
    url='https://www.example.com/checkout?cartId=1234',
    handle_code_in_app=True,
    ios_bundle_id='com.example.ios',
    android_package_name='com.example.android',
    android_install_app=True,
    android_minimum_version='12',
    dynamic_link_domain='coolapp.page.link',
)

Vai

actionCodeSettings := &auth.ActionCodeSettings{
	URL:                   "https://www.example.com/checkout?cartId=1234",
	HandleCodeInApp:       true,
	IOSBundleID:           "com.example.ios",
	AndroidPackageName:    "com.example.android",
	AndroidInstallApp:     true,
	AndroidMinimumVersion: "12",
	DynamicLinkDomain:     "coolapp.page.link",
}

C#

var actionCodeSettings = new ActionCodeSettings()
{
    Url = "https://www.example.com/checkout?cartId=1234",
    HandleCodeInApp = true,
    IosBundleId = "com.example.ios",
    AndroidPackageName = "com.example.android",
    AndroidInstallApp = true,
    AndroidMinimumVersion = "12",
    DynamicLinkDomain = "coolapp.page.link",
};

Per scoprire di più, consulta Passare lo stato nelle azioni email.

Generare il link dell'email di reimpostazione della password

Per generare un link per la reimpostazione della password, fornisci l'indirizzo email dell'utente esistente e un oggetto ActionCodeSettings facoltativo. L'operazione verrà risolta con il link all'azione email. L'indirizzo email utilizzato deve appartenere a un utente esistente.

Node.js

// Admin SDK API to generate the password reset link.
const userEmail = 'user@example.com';
getAuth()
  .generatePasswordResetLink(userEmail, actionCodeSettings)
  .then((link) => {
    // Construct password reset email template, embed the link and send
    // using custom SMTP server.
    return sendCustomPasswordResetEmail(userEmail, displayName, link);
  })
  .catch((error) => {
    // Some error occurred.
  });

Java

String email = "user@example.com";
try {
  String link = FirebaseAuth.getInstance().generatePasswordResetLink(
      email, actionCodeSettings);
  // Construct email verification template, embed the link and send
  // using custom SMTP server.
  sendCustomEmail(email, displayName, link);
} catch (FirebaseAuthException e) {
  System.out.println("Error generating email link: " + e.getMessage());
}

Python

email = 'user@example.com'
link = auth.generate_password_reset_link(email, action_code_settings)
# Construct password reset email from a template embedding the link, and send
# using a custom SMTP server.
send_custom_email(email, link)

Vai

email := "user@example.com"
link, err := client.PasswordResetLinkWithSettings(ctx, email, actionCodeSettings)
if err != nil {
	log.Fatalf("error generating email link: %v\n", err)
}

// Construct password reset template, embed the link and send
// using custom SMTP server.
sendCustomEmail(email, displayName, link)

C#

var email = "user@example.com";
var link = await FirebaseAuth.DefaultInstance.GeneratePasswordResetLinkAsync(
    email, actionCodeSettings);
// Construct email verification template, embed the link and send
// using custom SMTP server.
SendCustomEmail(email, displayName, link);

Una volta generato, il collegamento può essere inserito nella sezione di reimpostazione della password personalizzata per inviare un'email all'utente corrispondente tramite un server SMTP personalizzato.

Se non utilizzi la pagina di destinazione predefinita per la reimpostazione della password e stai creando il tuo gestore personalizzato, consulta la sezione sulla creazione di gestori di azioni email personalizzate.

Genera link di verifica email

Per generare un link di verifica email, fornisci l'email non verificata dell'utente esistente e un oggetto ActionCodeSettings facoltativo. L'operazione verrà risolta con il link di azione dell'email. L'indirizzo email utilizzato deve appartenere a un utente esistente.

Node.js

// Admin SDK API to generate the email verification link.
const useremail = 'user@example.com';
getAuth()
  .generateEmailVerificationLink(useremail, actionCodeSettings)
  .then((link) => {
    // Construct email verification template, embed the link and send
    // using custom SMTP server.
    return sendCustomVerificationEmail(useremail, displayName, link);
  })
  .catch((error) => {
    // Some error occurred.
  });

Java

String email = "user@example.com";
try {
  String link = FirebaseAuth.getInstance().generateEmailVerificationLink(
      email, actionCodeSettings);
  // Construct email verification template, embed the link and send
  // using custom SMTP server.
  sendCustomEmail(email, displayName, link);
} catch (FirebaseAuthException e) {
  System.out.println("Error generating email link: " + e.getMessage());
}

Python

email = 'user@example.com'
link = auth.generate_email_verification_link(email, action_code_settings)
# Construct email from a template embedding the link, and send
# using a custom SMTP server.
send_custom_email(email, link)

Vai

email := "user@example.com"
link, err := client.EmailVerificationLinkWithSettings(ctx, email, actionCodeSettings)
if err != nil {
	log.Fatalf("error generating email link: %v\n", err)
}

// Construct email verification template, embed the link and send
// using custom SMTP server.
sendCustomEmail(email, displayName, link)

C#

var email = "user@example.com";
var link = await FirebaseAuth.DefaultInstance.GenerateEmailVerificationLinkAsync(
    email, actionCodeSettings);
// Construct email verification template, embed the link and send
// using custom SMTP server.
SendCustomEmail(email, displayName, link);

Una volta generato, il link può essere inserito nella verifica personalizzata. per inviare un'email all'utente corrispondente tramite un server SMTP personalizzato.

Se non utilizzi la pagina di destinazione predefinita per la verifica email e stai creando il tuo gestore personalizzato, consulta la sezione sulla creazione di gestori di azioni email personalizzati.

Generare un link email per l'accesso

Prima di poter autenticare gli utenti con l'accesso tramite link via email, dovrai abilita l'accesso tramite link via email per il tuo progetto Firebase.

Per generare un link di accesso, fornisci l'indirizzo email dell'utente e un ActionCodeSettings . In questo caso, l'oggetto ActionCodeSettings deve fornire informazioni su dove restituire l'utente dopo aver fatto clic sul link per accedere completamento. L'operazione verrà risolta con il link all'azione email.

A differenza della reimpostazione della password e della verifica email, l'email utilizzata non devono necessariamente appartenere a un utente esistente, in quanto questa operazione può essere utilizzata consentire ai nuovi utenti di accedere alla tua app tramite un link email.

Node.js

// Admin SDK API to generate the sign in with email link.
const useremail = 'user@example.com';
getAuth()
  .generateSignInWithEmailLink(useremail, actionCodeSettings)
  .then((link) => {
    // Construct sign-in with email link template, embed the link and
    // send using custom SMTP server.
    return sendSignInEmail(useremail, displayName, link);
  })
  .catch((error) => {
    // Some error occurred.
  });

Java

String email = "user@example.com";
try {
  String link = FirebaseAuth.getInstance().generateSignInWithEmailLink(
      email, actionCodeSettings);
  // Construct email verification template, embed the link and send
  // using custom SMTP server.
  sendCustomEmail(email, displayName, link);
} catch (FirebaseAuthException e) {
  System.out.println("Error generating email link: " + e.getMessage());
}

Python

email = 'user@example.com'
link = auth.generate_sign_in_with_email_link(email, action_code_settings)
# Construct email from a template embedding the link, and send
# using a custom SMTP server.
send_custom_email(email, link)

Vai

email := "user@example.com"
link, err := client.EmailSignInLink(ctx, email, actionCodeSettings)
if err != nil {
	log.Fatalf("error generating email link: %v\n", err)
}

// Construct sign-in with email link template, embed the link and send
// using custom SMTP server.
sendCustomEmail(email, displayName, link)

C#

var email = "user@example.com";
var link = await FirebaseAuth.DefaultInstance.GenerateSignInWithEmailLinkAsync(
    email, actionCodeSettings);
// Construct email verification template, embed the link and send
// using custom SMTP server.
SendCustomEmail(email, displayName, link);

Una volta generato, il collegamento può essere inserito nell'indirizzo email di accesso personalizzato. quindi inviato per email all'utente corrispondente tramite un server SMTP personalizzato.

Scopri di più sull'autenticazione degli utenti con Firebase tramite link email. In questo modo, potrai fornire informazioni su come completare l'accesso una volta che l'utente fa clic sul link e viene reindirizzato all'app.