Meilleures pratiques

Nous vous recommandons de créer un nouveau sous-système basé sur l’installation de jeu (par exemple ModioManagerSubsystem) qui dépend de ModioSubsystemet est responsable de la gestion de l’initialisation complète et du flux d’authentification pour votre jeu.

Flux recommandé

• Créez un sous-système pour gérer l’initialisation et l’authentification mod.io.
• Effectuez la connexion du sous-système en ligne (OSS) dans votre sous-système Initialize Fonction pour vous assurer que vous disposez d’un jeton Auth à plate-forme valide prêt à l’heure de l’authentification à mod.io en utilisant une connexion unique (SSO).
  • Connectez-vous avec le fournisseur d’identité en ligne.
  • Au cours du succès, obtenez un jeton de compte lié pour l’utilisateur actuel.
  • Au cours du succès, obtenez un jeton d’authentification à partir du compte lié ou de l’identité en ligne.
• Initialisez le plugin mod.io avec les paramètres d’environnement requis pour la plate-forme actuelle.
• Affichez les conditions d’utilisation de mod.io. Assurez-vous qu’ils sont acceptés par l’utilisateur.
• Authentifiez l’utilisateur à l’aide de SSO.

Conditions et consentement des utilisateurs

Les utilisateurs doivent accepter les conditions d’utilisation de Mod.io avant d’utiliser tous les services mod.io. Les conditions d’utilisation peuvent être récupérées à partir de mod.io en utilisant GetTermsOfUseAsync. Avant d’essayer l’authentification, assurez-vous que ces termes sont affichés et acceptés par l’utilisateur.

Consultez notre documentation complète des termes et consentements des utilisateurs pour plus de détails.

Lors de l’authentification via SSO, le bUserHasAcceptedTerms Le paramètre doit être défini sur FAUX par défaut. Si l’utilisateur a déjà accepté les derniers termes, il sera authentifié automatiquement. S’ils n’ont pas accepté les derniers termes, une erreur 403 Forbidden (error_ref 11074) sera retourné. Lorsque vous recevez cette erreur, vous devez afficher la boîte de dialogue des termes à l’utilisateur, et s’ils acceptent, soumettre à nouveau le flux d’authentification avec bUserHasAcceptedTerms se mettre à vrai pour cette demande spécifique uniquement. Toutes les tentatives d’authentification ultérieures devraient revenir à l’utilisation FAUX pour ce paramètre.

Méthodes d’authentification

Le plugin moteur Mod.io Unreal fournit deux façons aux utilisateurs de créer un compte pour utiliser le service: l’authentification par e-mail et la connexion unique (SSO) via un partenaire d’authentification externe.

Authentification par e-mail

Les utilisateurs peuvent s’authentifier avec mod.io avec juste une adresse e-mail. Cela implique:

• Demander un code d’authentification unique est envoyé à partir de mod.io à une adresse e-mail fournie par l’utilisateur.
• Soumettre le code reçu à mod.io.

Demander un code d’authentification

Demandez un code d’authentification unique en appelant RequestEmailAuthCodeAsync. Passez une adresse e-mail fournie par l’utilisateur comme premier argument.

void UModioManagerSubsystem::RequestEmailAuthCode(const FString &EmailAddress)
{
   if (UModioSubsystem* Subsystem = GEngine->GetEngineSubsystem<UModioSubsystem>())
   {
   	Subsystem->RequestEmailAuthCodeAsync(FModioEmailAddress(*EmailAddress), FOnErrorOnlyDelegateFast::CreateUObject(this, &UModioManagerSubsystem::OnRequestEmailAuthCodeComplete));
   }
}

void UModioManagerSubsystem::OnRequestEmailAuthCodeComplete(FModioErrorCode ErrorCode)
{
   UE_LOG(LogModioGame, Log, TEXT("Email auth code request complete with result: %s"), *ErrorCode.GetErrorMessage());
}

Lorsque votre rappel est invoqué, inspectez le ModioErrorCode pour un résultat réussi. Au cours du succès, invitez l’utilisateur à vérifier ses e-mails et à saisir le code d’authentification qu’il a reçu dans votre jeu.

Soumettre un code d’authentification

Pour finaliser l’authentification de l’utilisateur, soumettez le code qu’il a entré à mod.io en appelant AuthenticateUserEmailAsync. Passez le code de l’utilisateur comme le premier argument.

void UModioManagerSubsystem::AuthenticateUserEmail(const FString& AuthCode)
{
   if (UModioSubsystem* Subsystem = GEngine->GetEngineSubsystem<UModioSubsystem>())
   {
   	Subsystem->AuthenticateUserEmailAsync(FModioEmailAuthCode(*AuthCode), FOnErrorOnlyDelegateFast::CreateUObject(this, &UModioManagerSubsystem::OnAuthenticateUserEmailComplete));
   }
}

void UModioManagerSubsystem::OnAuthenticateUserEmailComplete(FModioErrorCode ErrorCode)
{
   UE_LOG(LogModioGame, Log, TEXT("Email auth code submission complete with result: %s"), *ErrorCode.GetErrorMessage());
}

Lorsque votre rappel est invoqué, inspectez le ModioErrorCode pour un résultat réussi. Au cours du succès, l’authentification des utilisateurs est terminée.

Authentification unique

Le plugin de moteur Mod.io Unreal dispose d’authentification SEPS (SECTO-ON (SSO) à partir d’un certain nombre de fournisseurs externes. Ceux-ci incluent:

Chaque plate-forme a ses propres exigences et prérequis pour effectuer des SSO. L’authentification spécifique à la plate-forme peut être trouvée dans la documentation de plate-forme respective. SSO est effectué en appelant AuthenticateUserExternalAsync. Cette fonction prend un ModioAuthenticationParams contenant des paramètres spécifiques au fournisseur et un ModioAuthenticationProvider indiquant le fournisseur que vous utilisez.

Le sous-système en ligne d’Unreal Engine offre un moyen pratique d’obtenir un jeton pour ModioAuthenticationParams.AuthToken. GetDefaultAuthProviderForCurrentPlatform Peut être utilisé pour obtenir le fournisseur par défaut pour la plate-forme actuelle.

void UModioManagerSubsystem::AuthenticateWithSSO(const FModioAuthenticationParams& AuthParams)
{
   if (UModioSubsystem* Subsystem = GEngine->GetEngineSubsystem<UModioSubsystem>())
   {
   	Subsystem->AuthenticateUserExternalAsync(AuthParams, UModioPlatformHelpersLibrary::GetDefaultAuthProviderForCurrentPlatform(), FOnErrorOnlyDelegateFast::CreateUObject(this, &UModioManagerSubsystem::AuthenticateUserExternalComplete));
   }
}

void UModioManagerSubsystem::AuthenticateUserExternalComplete(FModioErrorCode ErrorCode)
{
   UE_LOG(LogModioGame, Log, TEXT("SSO complete with result: %s"), *ErrorCode.GetErrorMessage());
}

Utilisation du sous-système en ligne Unreal

Depuis Unreal Engine 5.2, la plupart des méthodes d’authentification prises en charge par MOD.IO sont abstraites par le sous-système en ligne d’Unreal. Vous trouverez ci-dessous quelques extraits de code présentant le flux pour obtenir un jeton de compte lié du sous-système en ligne d’Unreal.

• Créez un sous-système pour gérer l’initialisation et l’authentification mod.io qui dépend du ModioSubsystem. Pendant l’initialisation de votre sous-système, effectuez une connexion en ligne du sous-système (OSS). Cela garantit que vous aurez un jeton Auth à plate-forme valide prêt en cas de besoin pour l’authentification MOD.IO SSO.

const IOnlineSubsystem* OnlineSubsystem = IOnlineSubsystem::GetByPlatform();
if (OnlineSubsystem != nullptr && OnlineSubsystem->GetIdentityInterface() != nullptr)
{
   // Get the Identity interface from our OnlineSubsystem and perform login
   const IOnlineIdentityPtr OnlineIdentity = OnlineSubsystem->GetIdentityInterface();
   OnlineIdentity->AddOnLoginCompleteDelegate_Handle(
   	0, FOnLoginCompleteDelegate::CreateLambda(
   		   [this](int32 LocalUserNum, bool bWasSuccessful, const FUniqueNetId& UserId, const FString& Error) {
   			   this->OnSubsystemLoginComplete(LocalUserNum, bWasSuccessful, UserId, Error);
   		   }));
   OnlineIdentity->Login(0, FOnlineAccountCredentials());
}
else
{
   // If we don't have a valid OnlineSubsystem, just initialize the mod.io plugin
   InitializeModio();
}

• Après une connexion OSS réussie, demandez le jeton de compte lié.

void UModioManagerSubsystem::OnSubsystemLoginComplete(int32 LocalUserNum, bool bWasSuccessful, const FUniqueNetId& UserId, const FString& Error)
{
   if (bWasSuccessful)
   {
   	auto OnlineIdentity = IOnlineSubsystem::GetByPlatform()->GetIdentityInterface();
   	OnlineIdentity->GetLinkedAccountAuthToken(0, FString(), IOnlineIdentity::FOnGetLinkedAccountAuthTokenCompleteDelegate::CreateUObject(this, &UModioManagerSubsystem::OnGetLinkedAccountTokenComplete)); 
   }
}

• Sur le succès, le rappel a reçu GetLinkedAccountAuthToken contiendra un jeton que vous pouvez utiliser pour effectuer SSO. Cela contiendra soit un tableau d’octets TokenData (par exemple pour la vapeur SSO) ou TokenString pour une chaîne en texte clair. Ceux-ci doivent être gérés de manière appropriée.

void UModioManagerSubsystem::OnGetLinkedAccountTokenComplete(int LocalUserNum, bool bWasSuccessful, const FExternalAuthToken& AuthToken)
{
   if (AuthToken.IsValid())
   {
   	if (AuthToken.HasTokenData())
   	{
   		AuthTokenString = FBase64::Encode(AuthToken.TokenData);		
   	} 
   	else if (AuthToken.HasTokenString())
   	{
   		AuthTokenString = AuthToken.TokenString;
   	}
   }
}

Vie à la vie et ré-authentification

Par défaut, les jetons émis par e-mail token échange ont une durée de vie de 1 an. Vous pouvez vérifier qu’un utilisateur a été authentifié avec succès avec VerifyUserAuthenticationAsync.

Si un utilisateur n’est pas authentifié pour une raison quelconque (par exemple, son jeton a été invalidé en modifiant son mot de passe ou si ses données de profil ont été supprimées de son appareil), vous devez les inciter à réapparaître.