package com.ea.nimble;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import com.ea.nimble.Log;
import com.ea.nimble.Persistence;
import com.ea.nimble.SynergyIdManagerError;
import java.util.HashMap;

/* loaded from: classes2.dex */
class SynergyIdManagerImpl extends Component implements ISynergyIdManager, LogSource {
    private static final String ANONYMOUS_ID_PERSISTENCE_DATA_ID = "anonymousId";
    private static final String AUTHENTICATOR_PERSISTENCE_DATA_ID = "authenticator";
    private static final String CURRENT_ID_PERSISTENCE_DATA_ID = "currentId";
    private static final String SYNERGY_ID_MANAGER_ANONYMOUS_ID_PERSISTENCE_ID = "com.ea.nimble.synergyidmanager.anonymousId";
    private static final String VERSION_PERSISTENCE_DATA_ID = "dataVersion";
    private String m_anonymousSynergyId;
    private String m_authenticatorIdentifier;
    private String m_currentSynergyId;
    private BroadcastReceiver m_receiver = new SynergyIdManagerReceiver();

    @Override // com.ea.nimble.Component
    public String getComponentId() {
        return SynergyIdManager.COMPONENT_ID;
    }

    @Override // com.ea.nimble.LogSource
    public String getLogSourceTitle() {
        return "SynergyId";
    }

    public class SynergyIdManagerReceiver extends BroadcastReceiver {
        private SynergyIdManagerReceiver() {
        }

        @Override // android.content.BroadcastReceiver
        public void onReceive(Context context, Intent intent) {
            if (ApplicationEnvironment.isMainApplicationActive()) {
                SynergyIdManagerImpl.this.onSynergyEnvironmentStartupRequestsFinished();
            }
        }
    }

    public static ISynergyIdManager getComponent() {
        return (ISynergyIdManager) Base.getComponent(SynergyIdManager.COMPONENT_ID);
    }

    private void wakeup() {
        restoreFromPersistent();
        if (!Utility.validString(this.m_anonymousSynergyId)) {
            setAnonymousSynergyId(SynergyEnvironment.getComponent().getSynergyId());
        }
        if (!Utility.validString(this.m_currentSynergyId)) {
            setCurrentSynergyId(this.m_anonymousSynergyId);
        }
        Utility.registerReceiver(SynergyEnvironment.NOTIFICATION_STARTUP_REQUESTS_FINISHED, this.m_receiver);
    }

    private void sleep() {
        Utility.unregisterReceiver(this.m_receiver);
        saveDataToPersistent();
    }

    @Override // com.ea.nimble.Component
    public void restore() {
        wakeup();
    }

    @Override // com.ea.nimble.Component
    public void suspend() {
        sleep();
    }

    @Override // com.ea.nimble.Component
    public void resume() {
        wakeup();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void onSynergyEnvironmentStartupRequestsFinished() {
        Log.Helper.LOGFUNC(this);
        if (SynergyEnvironment.getComponent() != null) {
            Log.Helper.LOGD(this, "onSynergyEnvironmentStartupRequestsFinished - Process the notification, everything looks okay", new Object[0]);
            setAnonymousSynergyId(SynergyEnvironment.getComponent().getSynergyId());
            if (Utility.validString(this.m_currentSynergyId)) {
                return;
            }
            setCurrentSynergyId(this.m_anonymousSynergyId);
            return;
        }
        Log.Helper.LOGI(this, "onSynergyEnvironmentStartupRequestsFinished - Aborted because we were unable to get SynergyEnvironment", new Object[0]);
    }

    @Override // com.ea.nimble.Component
    public void cleanup() {
        sleep();
    }

    private void restoreFromPersistent() {
        Log.Helper.LOGFUNC(this);
        Persistence persistenceForNimbleComponent = PersistenceService.getPersistenceForNimbleComponent(SynergyIdManager.COMPONENT_ID, Persistence.Storage.CACHE);
        if (persistenceForNimbleComponent != null) {
            Log.Helper.LOGD("Loaded persistence data version,  %s.", persistenceForNimbleComponent.getStringValue(VERSION_PERSISTENCE_DATA_ID), new Object[0]);
            this.m_currentSynergyId = persistenceForNimbleComponent.getStringValue(CURRENT_ID_PERSISTENCE_DATA_ID);
            String stringValue = persistenceForNimbleComponent.getStringValue(AUTHENTICATOR_PERSISTENCE_DATA_ID);
            this.m_authenticatorIdentifier = stringValue;
            Log.Helper.LOGD(this, "Loaded Synergy ID, %s, with authenticator, %s.", this.m_currentSynergyId, stringValue);
        } else {
            Log.Helper.LOGE(this, "Could not get persistence object to load from.", new Object[0]);
        }
        Persistence persistenceForNimbleComponent2 = PersistenceService.getPersistenceForNimbleComponent(SYNERGY_ID_MANAGER_ANONYMOUS_ID_PERSISTENCE_ID, Persistence.Storage.DOCUMENT);
        if (persistenceForNimbleComponent2 != null) {
            Log.Helper.LOGD(this, "Loaded persistence data version, %s.", Utility.safeString(persistenceForNimbleComponent2.getStringValue(VERSION_PERSISTENCE_DATA_ID)));
            String stringValue2 = persistenceForNimbleComponent2.getStringValue(ANONYMOUS_ID_PERSISTENCE_DATA_ID);
            this.m_anonymousSynergyId = stringValue2;
            Log.Helper.LOGD(this, "Loaded anonymous Synergy ID, %s.", Utility.safeString(stringValue2));
            return;
        }
        Log.Helper.LOGE(this, "Could not get anonymous Synergy ID persistence object to load from.", new Object[0]);
    }

    private void saveDataToPersistent() {
        Log.Helper.LOGFUNC(this);
        Persistence persistenceForNimbleComponent = PersistenceService.getPersistenceForNimbleComponent(SYNERGY_ID_MANAGER_ANONYMOUS_ID_PERSISTENCE_ID, Persistence.Storage.DOCUMENT);
        if (persistenceForNimbleComponent != null) {
            Log.Helper.LOGD("Saving anonymous Synergy ID, %s, to persistent.", this.m_anonymousSynergyId, new Object[0]);
            persistenceForNimbleComponent.setValue(VERSION_PERSISTENCE_DATA_ID, "1.0.0");
            persistenceForNimbleComponent.setValue(ANONYMOUS_ID_PERSISTENCE_DATA_ID, this.m_anonymousSynergyId);
            persistenceForNimbleComponent.setBackUp(true);
            persistenceForNimbleComponent.lambda$new$0();
        } else {
            Log.Helper.LOGE(this, "Could not get anonymous Synergy ID persistence object to save to.", new Object[0]);
        }
        Persistence persistenceForNimbleComponent2 = PersistenceService.getPersistenceForNimbleComponent(SynergyIdManager.COMPONENT_ID, Persistence.Storage.CACHE);
        if (persistenceForNimbleComponent2 != null) {
            Log.Helper.LOGD(this, "Saving current Synergy ID, %s, and authenticator, %s, to persistent.", this.m_currentSynergyId, this.m_authenticatorIdentifier);
            persistenceForNimbleComponent2.setValue(VERSION_PERSISTENCE_DATA_ID, "1.0.0");
            persistenceForNimbleComponent2.setValue(CURRENT_ID_PERSISTENCE_DATA_ID, this.m_currentSynergyId);
            persistenceForNimbleComponent2.setValue(AUTHENTICATOR_PERSISTENCE_DATA_ID, this.m_authenticatorIdentifier);
            persistenceForNimbleComponent2.lambda$new$0();
            return;
        }
        Log.Helper.LOGE(this, "Could not get persistence object to save to.", new Object[0]);
    }

    private void setAnonymousSynergyId(String str) {
        Log.Helper.LOGFUNC(this);
        if (Utility.validString(this.m_anonymousSynergyId) && !Utility.validString(str)) {
            Log.Helper.LOGE(this, "Attempt to set invalid anonymous Synergy ID over existing ID, %s. Ignoring attempt.", this.m_anonymousSynergyId);
            return;
        }
        String str2 = this.m_anonymousSynergyId;
        this.m_anonymousSynergyId = str;
        saveDataToPersistent();
        if (Utility.validString(str2) && ((Utility.validString(str2) && !str2.equals(this.m_anonymousSynergyId)) || (Utility.validString(this.m_anonymousSynergyId) && !this.m_anonymousSynergyId.equals(str2)))) {
            HashMap hashMap = new HashMap();
            hashMap.put("previousSynergyId", Utility.safeString(str2));
            hashMap.put("currentSynergyId", Utility.safeString(this.m_anonymousSynergyId));
            Utility.sendBroadcast(SynergyIdManager.NOTIFICATION_ANONYMOUS_SYNERGY_ID_CHANGED, hashMap);
        }
        if (this.m_authenticatorIdentifier == null) {
            setCurrentSynergyId(this.m_anonymousSynergyId);
        }
    }

    private void setCurrentSynergyId(String str) {
        Log.Helper.LOGFUNC(this);
        if (Utility.validString(this.m_currentSynergyId) && !Utility.validString(str)) {
            Log.Helper.LOGE(this, "Attempt to set invalid current Synergy ID over existing ID, %s. Ignoring attempt.", this.m_currentSynergyId);
            return;
        }
        String str2 = this.m_currentSynergyId;
        this.m_currentSynergyId = str;
        saveDataToPersistent();
        if (Utility.validString(str2)) {
            if ((!Utility.validString(str2) || str2.equals(this.m_currentSynergyId)) && (!Utility.validString(this.m_currentSynergyId) || this.m_currentSynergyId.equals(str2))) {
                return;
            }
            HashMap hashMap = new HashMap();
            hashMap.put("previousSynergyId", Utility.safeString(str2));
            hashMap.put("currentSynergyId", Utility.safeString(this.m_currentSynergyId));
            Utility.sendBroadcast(SynergyIdManager.NOTIFICATION_SYNERGY_ID_CHANGED, hashMap);
        }
    }

    @Override // com.ea.nimble.ISynergyIdManager
    public String getSynergyId() {
        Log.Helper.LOGPUBLICFUNC(this);
        return Utility.validString(this.m_currentSynergyId) ? this.m_currentSynergyId : getAnonymousSynergyId();
    }

    @Override // com.ea.nimble.ISynergyIdManager
    public String getAnonymousSynergyId() {
        Log.Helper.LOGPUBLICFUNC(this);
        return Utility.validString(this.m_anonymousSynergyId) ? this.m_anonymousSynergyId : SynergyEnvironment.getComponent().getSynergyId();
    }

    @Override // com.ea.nimble.ISynergyIdManager
    public SynergyIdManagerError login(String str, String str2) {
        Log.Helper.LOGPUBLICFUNC(this);
        if (this.m_authenticatorIdentifier != null) {
            return new SynergyIdManagerError(SynergyIdManagerError.Code.UNEXPECTED_LOGIN_STATE, "Already logged in with authenticator, " + this.m_authenticatorIdentifier);
        }
        if (!Utility.validString(str) || !Utility.isOnlyDecimalCharacters(str)) {
            return new SynergyIdManagerError(SynergyIdManagerError.Code.INVALID_ID, "Synergy ID must be numeric digits.");
        }
        if (!Utility.validString(str2)) {
            return new SynergyIdManagerError(SynergyIdManagerError.Code.MISSING_AUTHENTICATOR, "Authenticator string required for login API.");
        }
        this.m_authenticatorIdentifier = str2;
        setCurrentSynergyId(str);
        return null;
    }

    @Override // com.ea.nimble.ISynergyIdManager
    public SynergyIdManagerError logout(String str) {
        Log.Helper.LOGPUBLICFUNC(this);
        if (this.m_authenticatorIdentifier == null) {
            return new SynergyIdManagerError(SynergyIdManagerError.Code.UNEXPECTED_LOGIN_STATE, "Already logged out.");
        }
        if (!Utility.validString(str)) {
            return new SynergyIdManagerError(SynergyIdManagerError.Code.MISSING_AUTHENTICATOR, "Authenticator string required for logout API.");
        }
        if (!this.m_authenticatorIdentifier.equals(str)) {
            return new SynergyIdManagerError(SynergyIdManagerError.Code.AUTHENTICATOR_CONFLICT, "Logout must be performed by the same authenticator that logged in, " + this.m_authenticatorIdentifier);
        }
        setCurrentSynergyId(this.m_anonymousSynergyId);
        this.m_authenticatorIdentifier = null;
        return null;
    }
}