ArgumentOutOfRangeException when calling achievementManager.UnlockAchievementManually()

[Schu-Box]

I've integrated the plugin for an upcoming game and am able to successfully login to EOS. For some reason, I get an ArgumentOutOfRangeException anytime I attempt to interface with achievements (unlocking or checking for their existence). The below is the code I'm using to unlock the achievement and the error that it spits out.

I've confirmed that the achievements are properly setup in the Epic Dev Portal and that the string argument matches the id of the achievement. I can't figure out why I keep getting this error and haven't been able to find an answer yet so I would greatly appreciate if anyone happens to have ideas for how to resolve.

EOSAchievementManager achievementManager = EOSManager.Instance.GetOrCreateManager<EOSAchievementManager>();
Debug.Log("ID of achievement according to Epic is : " + achievementManager.GetAchievementDefinitionAtIndex(achievementIndex).AchievementId);
achievementManager.UnlockAchievementManually(achievementIndex.ToString());

System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection.
Parameter name: index
  at System.Collections.Generic.List1[T].get_Item (System.Int32 index) [0x00000] in <00000000000000000000000000000000>:0 
  at PlayEveryWare.EpicOnlineServices.Samples.EOSAchievementManager.GetAchievementDefinitionAtIndex (System.Int32 idx) [0x00000] in <00000000000000000000000000000000>:0 
  at Common.AchievementManager.TriggerAchievement (Common.Achievements achievement) [0x00000] in <00000000000000000000000000000000>:0 
  at Common.AchievementManager.CheckForMissingAchievements () [0x00000] in <00000000000000000000000000000000>:0 
  at MainMenuController.OnClickContinueMission () [0x00000] in <00000000000000000000000000000000>:0 
  at UnityEngine.Events.UnityEvent.Invoke () [0x00000] in <00000000000000000000000000000000>:0 
  at UIButton.OnClick (System.Boolean in_playClickAudioOnce) [0x00000] in <00000000000000000000000000000000>:0 
  at MasterInput.CheckConfirmInput () [0x00000] in <00000000000000000000000000000000>:0 
  at MasterInput.Update () [0x00000] in <00000000000000000000000000000000>:0 
UnityEngine.Logger:Log(LogType, Object)
UnityEngine.Debug:LogError(Object)
Common.AchievementManager:TriggerAchievement(Achievements)
Common.AchievementManager:CheckForMissingAchievements()
MainMenuController:OnClickContinueMission()
UnityEngine.Events.UnityEvent:Invoke()
UIButton:OnClick(Boolean)
MasterInput:CheckConfirmInput()
MasterInput:Update()

[andrew-hirata-playeveryware]

Hello @Schu-Box !

My first guess on this is that the achievements aren't being cached. Are you able to confirm the following:

• Connect login is working (This is different than Auth login)
• The Achievement Manager was created before Connect login.

If connect login is working, but it is being created after connect login, you might need to call the RefreshData method.

[Schu-Box]

Hey thanks for the reply. Could you explain what you mean that the Connect Login is different from the Auth Login? I'm currently calling "StartLoginWithLoginTypeAndToken". Is there an additional login function I need to call after that?

The code I'm currently using is below.

private IEnumerator Start()
{
    yield return new WaitForSeconds(2f);
#if EPIC
    
    Debug.Log("Creating EOSAchievementManager");
    EOSManager.Instance.GetOrCreateManager<EOSAchievementManager>();

    Debug.Log("Logging into Epic Online Services");

    EOSManager.EOSSingleton.EpicLauncherArgs argsEpic = EOSManager.Instance.GetCommandLineArgsFromEpicLauncher();

    EOSManager.Instance.StartLoginWithLoginTypeAndToken(LoginCredentialType.ExchangeCode,
        argsEpic.epicUserID,
        argsEpic.authPassword,
        (Epic.OnlineServices.Auth.LoginCallbackInfo callbackInfo) =>
        {
            if (callbackInfo.ResultCode != Epic.OnlineServices.Result.Success)
                CreateAndConnectWithContinuanceToken(callbackInfo);
            else
                HandleOnAuthSucceeded(callbackInfo);
        }
    );
    
#endif
}

private void HandleOnAuthSucceeded(Epic.OnlineServices.Auth.LoginCallbackInfo callbackInfo)
{
    Debug.Log("EOS LOGGED with token [" + callbackInfo.ResultCode + "]");
    
    StartLoginWithLoginTypeAndTokenCallback(callbackInfo);

    Debug.Log("Experimental");

    // init achievements - not sure any of this is necessary
        EOSAchievementManager achievementManager = EOSManager.Instance.GetOrCreateManager<EOSAchievementManager>();
        achievementManager.GetAchievementDefinitionCount();
        achievementManager.EnumerateCachedAchievementDefinitions();
        var userId = EOSManager.Instance.GetProductUserId();
        if (userId.IsValid())
            achievementManager.EnumerateCachedPlayerAchievement(userId);
}


private void CreateAndConnectWithContinuanceToken(Epic.OnlineServices.Auth.LoginCallbackInfo callbackInfo) 
{
    Debug.Log("Create and Connect Called");
    
    if (callbackInfo.ResultCode != Epic.OnlineServices.Result.Success)
    {
        EOSManager.Instance.CreateConnectUserWithContinuanceToken(callbackInfo.ContinuanceToken, (Epic.OnlineServices.Connect.CreateUserCallbackInfo createUserCallbackInfo) =>
        {
            EOSManager.Instance.StartConnectLoginWithEpicAccount(callbackInfo.LocalUserId, (Epic.OnlineServices.Connect.LoginCallbackInfo retryConnectLoginCallbackInfo) =>
            {
            });
        });

    }
    else
    {
        StartLoginWithLoginTypeAndTokenCallback(callbackInfo);
    }
}

public void StartLoginWithLoginTypeAndTokenCallback(Epic.OnlineServices.Auth.LoginCallbackInfo loginCallbackInfo) 
{
    Debug.Log("Start Login With Login Type And Token Callback Called");
    
    if (loginCallbackInfo.ResultCode == Epic.OnlineServices.Result.Success)
    {
        StartConnectLoginWithLoginCallbackInfo(loginCallbackInfo);
    }
    else if (loginCallbackInfo.ResultCode == Epic.OnlineServices.Result.InvalidUser) {

        EOSManager.Instance.AuthLinkExternalAccountWithContinuanceToken(loginCallbackInfo.ContinuanceToken,
            LinkAccountFlags.NoFlags,
            (Epic.OnlineServices.Auth.LinkAccountCallbackInfo linkAccountCallbackInfo) => {
                StartConnectLoginWithLoginCallbackInfo(loginCallbackInfo);
            });
    }
}

private void StartConnectLoginWithLoginCallbackInfo(Epic.OnlineServices.Auth.LoginCallbackInfo loginCallbackInfo)
{
    EOSManager.Instance.StartConnectLoginWithEpicAccount(loginCallbackInfo.LocalUserId, (Epic.OnlineServices.Connect.LoginCallbackInfo connectLoginCallbackInfo) =>
    {
        if (connectLoginCallbackInfo.ResultCode == Epic.OnlineServices.Result.Success)
        {
            var eosConnectInterface = GetEOSConnectInterface();
            var addNotifyAuthExpirationOptions = new AddNotifyAuthExpirationOptions { };

            eosConnectInterface.AddNotifyAuthExpiration(ref addNotifyAuthExpirationOptions, null, (ref AuthExpirationCallbackInfo resultCallback) =>
            {
                StartConnectLoginWithLoginCallbackInfo(loginCallbackInfo);
            });
        }
        else if (connectLoginCallbackInfo.ResultCode == Epic.OnlineServices.Result.InvalidUser)
        {
            EOSManager.Instance.CreateConnectUserWithContinuanceToken(connectLoginCallbackInfo.ContinuanceToken, (CreateUserCallbackInfo createUserCallbackInfo) =>
            {
                EOSManager.Instance.StartConnectLoginWithEpicAccount(loginCallbackInfo.LocalUserId, (Epic.OnlineServices.Connect.LoginCallbackInfo retryConnectLoginCallbackInfo) =>
                {
                });
            });
        }
    });
}

private ConnectInterface GetEOSConnectInterface()
{
    if (eosConnectInterface == null)
    {
        var eosPlatformInterface = EOSManager.Instance.GetEOSPlatformInterface();
        eosConnectInterface = eosPlatformInterface.GetConnectInterface();
    }

    return eosConnectInterface;
}

[WispyMouse]

@Schu-Box Ahoy! Apologies for the delay, let's try n' tackle this! It's understandable how the relationship between Auth and Connect can be confusing, and their names and descriptions alone don't carry things through end-to-end with total clarity. This post will first explain the intended login flow, then how to relate that to your code and situation.

Auth Login, then Connect Login

Could you explain what you mean that the Connect Login is different from the Auth Login?

Over at the documentation for Authenticating Players, there is a link over to an explanation by Epic of how Auth Login supports Connect Login.

In the Epic Online Services Plugin for Unity, we expose Auth Interface login methods; Persistent Auth, Account Portal, Dev Auth, Exchange Code, and External Auth. First, perform one of these Auth logins successfully. If one doesn't work, your code is free to try another method. These are all either managed through AuthInterface.Login and LoginOptions, or through EOSManager and functions like StartLoginWithLoginOptions or StartLoginWithLoginTypeAndToken. In our samples the UILoginMenu performs an associated login when OnLoginButtonClick is pressed. Every one of the login operations in this function is an Auth Login.

That makes Auth Login our first step. You need to finish an Auth Login correctly and successfully first.

To make use of the plugin's features, the next step after a successful Auth Login is a Connect Login. A Connect Login will use the information from a successful Auth Login to get an associated Product User ID, so that you can utilize Epic Online Game Services features. Looking at the UILoginMenu sample code, all of the above login operations follow-up with the StartLoginWithTypeAndTokenCallback method after a successful Auth login. Inside here, the Connect Interface is used to try and log in the existing user, or to create an account link if one is needed. It calls out to EOSManager.Instance.StartConnectLoginWithEpicAccount. If that succeeds, we're done and fully connected. If that returns InvalidUser, then it attempts EOSManager.Instance.CreateConnectUserWithContinuanceToken, which will then do the above StartConnectLoginWithEpicAccount if that is successful.

And with that, we have a Connect Login. With this done, we're truly logged in, and can make the most of Epic Online Game Services functionality.

Relating To Schu-Box's Game's Code

Let's look at the code you included! In Start, it calls out to EOSManager.Instance.StartLoginWithTypeAndToken in ExchangeCode mode. If it doesn't succeed you're then calling CreateAndConnectWithContinuanceToken. Instead of using a Connect Login after an unsuccessful Auth Login, you should try a different Auth Login method, such as Account Portal. With that change, I believe you can delete the function in your provided code named CreateAndConnectWithContinuanceToken, and let StartConnectLoginWithLoginCallbackInfo handle it all.

Inside that StartConnectLoginWithLoginCallbackInfo, you correctly go through a flow of trying to create a new connect user when the result code is InvalidUser. However, you only have the AddNotifyAuthExpiration inside the first block of logic. Make sure that you're calling this in the InvalidUser scenario, too, or else your user's authentication will expire without renewing!

When it succeeds, you're running HandleOnAuthSucceeded into StartLoginWithLoginTypeAndTokenCallback, which will call out to StartConnectLoginWithLoginCallbackInfo. That flow is mostly right. But inside HandleOnAuthSucceeded, you're initializing and utilizing the EOSAchievementManager before the Connect Login part is actually done. Instead, you should call these achievement code pieces after the success is read in on during StartConnectLoginWithLoginCallbackInfo. Perhaps you could add a function that is called after that successful login.

Hope this helps! Let me know if you have any questions. We'll reflect on the teachings here and contemplate how to improve this plugin's documentation.