package com.ea.nimble;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import com.ea.nimble.IApplicationLifecycle;
import com.ea.nimble.Log;
import java.util.ArrayList;
import java.util.Iterator;

/* loaded from: classes2.dex */
class ApplicationLifecycleImpl extends Component implements IApplicationLifecycle, LogSource {
    private final BaseCore m_core;
    private State m_state = State.INIT;
    private int m_createdActivityCount = 0;
    private int m_runningActivityCount = 0;
    private final ArrayList<IApplicationLifecycle.ActivityLifecycleCallbacks> m_activityLifecycleCallbacks = new ArrayList<>();
    private final ArrayList<IApplicationLifecycle.ActivityEventCallbacks> m_activityEventCallbacks = new ArrayList<>();
    private final ArrayList<IApplicationLifecycle.ApplicationLifecycleCallbacks> m_applicationLifecycleCallbacks = new ArrayList<>();

    public enum State {
        INIT,
        LAUNCH,
        RESUME,
        RUN,
        PAUSE,
        SUSPEND,
        QUIT,
        CONFIG_CHANGE
    }

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

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

    public ApplicationLifecycleImpl(BaseCore baseCore) {
        this.m_core = baseCore;
    }

    @Override // com.ea.nimble.Component
    public void teardown() {
        this.m_activityLifecycleCallbacks.clear();
        this.m_activityEventCallbacks.clear();
        this.m_applicationLifecycleCallbacks.clear();
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void registerActivityLifecycleCallbacks(IApplicationLifecycle.ActivityLifecycleCallbacks activityLifecycleCallbacks) {
        this.m_activityLifecycleCallbacks.add(activityLifecycleCallbacks);
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void unregisterActivityLifecycleCallbacks(IApplicationLifecycle.ActivityLifecycleCallbacks activityLifecycleCallbacks) {
        this.m_activityLifecycleCallbacks.remove(activityLifecycleCallbacks);
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void registerActivityEventCallbacks(IApplicationLifecycle.ActivityEventCallbacks activityEventCallbacks) {
        this.m_activityEventCallbacks.add(activityEventCallbacks);
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void unregisterActivityEventCallbacks(IApplicationLifecycle.ActivityEventCallbacks activityEventCallbacks) {
        this.m_activityEventCallbacks.remove(activityEventCallbacks);
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void registerApplicationLifecycleCallbacks(IApplicationLifecycle.ApplicationLifecycleCallbacks applicationLifecycleCallbacks) {
        this.m_applicationLifecycleCallbacks.add(applicationLifecycleCallbacks);
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void unregisterApplicationLifecycleCallbacks(IApplicationLifecycle.ApplicationLifecycleCallbacks applicationLifecycleCallbacks) {
        this.m_applicationLifecycleCallbacks.remove(applicationLifecycleCallbacks);
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityCreate(Bundle bundle, Activity activity) {
        Log.Helper.LOGV(this, "Activity %s CREATE", activity.getLocalClassName());
        State state = this.m_state;
        if (state == State.INIT || state == State.QUIT) {
            Log.Helper.LOGD(this, "Activity created clearly with state %s", state.toString());
            this.m_core.onApplicationLaunch(activity.getIntent());
            Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it = this.m_activityLifecycleCallbacks.iterator();
            while (it.hasNext()) {
                it.next().onActivityCreated(activity, bundle);
            }
            notifyApplicationLaunch(activity.getIntent());
            this.m_createdActivityCount = 1;
            this.m_state = State.LAUNCH;
            int i = this.m_runningActivityCount;
            if (i != 0) {
                Log.Helper.LOGE(this, "Invalid running activity count %d", Integer.valueOf(i));
                this.m_runningActivityCount = 0;
            }
        } else if (state == State.CONFIG_CHANGE) {
            if (ApplicationEnvironment.getCurrentActivity() != activity) {
                Log.Helper.LOGE(this, "Activity created with state CONFIG_CHANGE but different activity %s and %s", ApplicationEnvironment.getCurrentActivity().getLocalClassName(), activity.getLocalClassName());
            } else {
                Log.Helper.LOGD(this, "Activity created from CONFIG_CHANGE, activity configuration changed", new Object[0]);
            }
            Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it2 = this.m_activityLifecycleCallbacks.iterator();
            while (it2.hasNext()) {
                it2.next().onActivityCreated(activity, bundle);
            }
            int i2 = this.m_runningActivityCount;
            if (i2 != 0) {
                Log.Helper.LOGE(this, "Invalid running activity count %d", Integer.valueOf(i2));
                this.m_runningActivityCount = 0;
            }
        } else if (state == State.PAUSE) {
            Log.Helper.LOGD(this, "Activity created from PAUSE, normal activity switch", new Object[0]);
            Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it3 = this.m_activityLifecycleCallbacks.iterator();
            while (it3.hasNext()) {
                it3.next().onActivityCreated(activity, bundle);
            }
            this.m_createdActivityCount++;
        } else if (state == State.SUSPEND) {
            Log.Helper.LOGD(this, "Activity created from SUSPEND, external activity switch; (new) app restart", new Object[0]);
            this.m_core.onApplicationResume();
            this.m_state = State.RESUME;
            Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it4 = this.m_activityLifecycleCallbacks.iterator();
            while (it4.hasNext()) {
                it4.next().onActivityCreated(activity, bundle);
            }
            this.m_createdActivityCount++;
            int i3 = this.m_runningActivityCount;
            if (i3 != 0) {
                Log.Helper.LOGE(this, "Invalid running activity count %d", Integer.valueOf(i3));
                this.m_runningActivityCount = 0;
            }
        } else {
            Log.Helper.LOGE(this, "Activity created with %s state, shouldn't happen", state.toString());
        }
        Log.Helper.LOGV(this, "State after created %s (%d, %d)", this.m_state.toString(), Integer.valueOf(this.m_createdActivityCount), Integer.valueOf(this.m_runningActivityCount));
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityRestart(Activity activity) {
        Log.Helper.LOGV(this, "Activity %s RESTART", activity.getLocalClassName());
        ApplicationEnvironment.setCurrentActivity(activity);
        State state = this.m_state;
        if (state == State.PAUSE) {
            Log.Helper.LOGD(this, "Activity restart from PAUSE, normal activity switch", new Object[0]);
        } else if (state == State.SUSPEND) {
            this.m_core.onApplicationResume();
            this.m_state = State.RESUME;
            Log.Helper.LOGD(this, "Activity restart from SUSPEND, external activity switch; (new) app restart", new Object[0]);
        } else {
            Log.Helper.LOGE(this, "Activity restart with invalid state %s", state.toString());
        }
        Log.Helper.LOGV(this, "State after restart %s (%d, %d)", this.m_state.toString(), Integer.valueOf(this.m_createdActivityCount), Integer.valueOf(this.m_runningActivityCount));
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityStart(Activity activity) {
        Log.Helper.LOGV(this, "Activity %s START", activity.getLocalClassName());
        ApplicationEnvironment.setCurrentActivity(activity);
        State state = this.m_state;
        if (state == State.LAUNCH) {
            this.m_state = State.PAUSE;
            Log.Helper.LOGD(this, "Activity start with LAUNCH state, normal app start", new Object[0]);
        } else if (state == State.RESUME) {
            Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it = this.m_activityLifecycleCallbacks.iterator();
            while (it.hasNext()) {
                it.next().onActivityStarted(activity);
            }
            notifyApplicationResume(activity.getIntent());
            this.m_state = State.PAUSE;
            Log.Helper.LOGD(this, "Activity start with RESUME state, set to PAUSE", new Object[0]);
        } else if (state == State.CONFIG_CHANGE) {
            Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it2 = this.m_activityLifecycleCallbacks.iterator();
            while (it2.hasNext()) {
                it2.next().onActivityStarted(activity);
            }
            this.m_state = State.PAUSE;
            Log.Helper.LOGD(this, "Activity start with CONFIG_CHANGE state, set to PAUSE", new Object[0]);
        } else if (state == State.PAUSE) {
            Log.Helper.LOGD(this, "Activity start with PAUSE state, normal activity switch", new Object[0]);
        } else {
            Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it3 = this.m_activityLifecycleCallbacks.iterator();
            while (it3.hasNext()) {
                it3.next().onActivityStarted(activity);
            }
            Log.Helper.LOGE(this, "Activity start with invalid state %s", this.m_state.toString());
        }
        this.m_runningActivityCount++;
        Log.Helper.LOGV(this, "State after start %s (%d, %d)", this.m_state.toString(), Integer.valueOf(this.m_createdActivityCount), Integer.valueOf(this.m_runningActivityCount));
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityRestoreInstanceState(Bundle bundle, Activity activity) {
        Log.Helper.LOGV(this, "Activity %s RESTORE_STATE", activity.getLocalClassName());
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityResume(Activity activity) {
        Log.Helper.LOGV(this, "Activity %s RESUME", activity.getLocalClassName());
        ApplicationEnvironment.setCurrentActivity(activity);
        Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it = this.m_activityLifecycleCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onActivityResumed(activity);
        }
        State state = this.m_state;
        if (state != State.PAUSE) {
            Log.Helper.LOGE(this, "Activity resume on invalid state %s", state.toString());
            Log.Helper.LOGE(this, "<NOTE>Please double check if the game's activity hooks ApplicationLifecycle.onActivityRestart() correctly.", new Object[0]);
        }
        State state2 = State.RUN;
        this.m_state = state2;
        Log.Helper.LOGV(this, "State after resume %s (%d, %d)", state2.toString(), Integer.valueOf(this.m_createdActivityCount), Integer.valueOf(this.m_runningActivityCount));
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityPause(Activity activity) {
        Log.Helper.LOGV(this, "Activity %s PAUSE", activity.getLocalClassName());
        Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it = this.m_activityLifecycleCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onActivityPaused(activity);
        }
        if (this.m_state != State.RUN) {
            Log.Helper.LOGE(this, "Activity pause on invalid state %s", activity.getLocalClassName());
        }
        State state = State.PAUSE;
        this.m_state = state;
        Log.Helper.LOGV(this, "State after pause %s (%d, %d)", state.toString(), Integer.valueOf(this.m_createdActivityCount), Integer.valueOf(this.m_runningActivityCount));
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivitySaveInstanceState(Bundle bundle, Activity activity) {
        Log.Helper.LOGV(this, "Activity %s SAVE_STATE", activity.getLocalClassName());
        Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it = this.m_activityLifecycleCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onActivitySaveInstanceState(activity, bundle);
        }
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    @SuppressLint({"NewApi"})
    public void notifyActivityStop(Activity activity) {
        Log.Helper.LOGV(this, "Activity %s STOP", activity.getLocalClassName());
        Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it = this.m_activityLifecycleCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onActivityStopped(activity);
        }
        this.m_runningActivityCount--;
        if (activity.isChangingConfigurations()) {
            this.m_state = State.CONFIG_CHANGE;
        } else if (this.m_runningActivityCount == 0) {
            State state = this.m_state;
            if (state != State.PAUSE && state != State.SUSPEND) {
                Log.Helper.LOGW(this, "Interesting case %s, HIGHLIGHT!!", state);
            }
            this.m_state = State.SUSPEND;
            if (!activity.isFinishing()) {
                notifyApplicationSuspend();
                this.m_core.onApplicationSuspend();
            }
        } else {
            State state2 = this.m_state;
            if (state2 == State.PAUSE) {
                this.m_state = State.SUSPEND;
                if (!activity.isFinishing()) {
                    Log.Helper.LOGW(this, "running activity count may be messed", new Object[0]);
                    notifyApplicationSuspend();
                    this.m_core.onApplicationSuspend();
                }
            } else if (state2 != State.RUN) {
                Log.Helper.LOGE(this, "Activity stop on invalid state %s", state2.toString());
            }
        }
        Log.Helper.LOGV(this, "State after stop %s (%d, %d)", this.m_state.toString(), Integer.valueOf(this.m_createdActivityCount), Integer.valueOf(this.m_runningActivityCount));
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityDestroy(Activity activity) {
        Log.Helper.LOGV(this, "Activity %s DESTROY", activity.getLocalClassName());
        Iterator<IApplicationLifecycle.ActivityLifecycleCallbacks> it = this.m_activityLifecycleCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onActivityDestroyed(activity);
        }
        State state = this.m_state;
        if (state != State.CONFIG_CHANGE) {
            if (state != State.SUSPEND && state != State.RUN) {
                Log.Helper.LOGE(this, "Activity destroy on invalid state %s", state.toString());
            }
            int i = this.m_createdActivityCount - 1;
            this.m_createdActivityCount = i;
            if (i == 0) {
                this.m_state = State.QUIT;
                notifyApplicationQuit();
                this.m_core.onApplicationQuit();
                ApplicationEnvironment.setCurrentActivity(null);
            }
        }
        Log.Helper.LOGV(this, "State after destroy %s (%d, %d)", this.m_state.toString(), Integer.valueOf(this.m_createdActivityCount), Integer.valueOf(this.m_runningActivityCount));
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityResult(int i, int i2, Intent intent, Activity activity) {
        Iterator<IApplicationLifecycle.ActivityEventCallbacks> it = this.m_activityEventCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onActivityResult(activity, i, i2, intent);
        }
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityWindowFocusChanged(boolean z, Activity activity) {
        Iterator<IApplicationLifecycle.ActivityEventCallbacks> it = this.m_activityEventCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onWindowFocusChanged(z);
        }
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityOnNewIntent(Intent intent, Activity activity) {
        Iterator<IApplicationLifecycle.ActivityEventCallbacks> it = this.m_activityEventCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onNewIntent(activity, intent);
        }
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public boolean handleBackPressed() {
        Iterator<IApplicationLifecycle.ActivityEventCallbacks> it = this.m_activityEventCallbacks.iterator();
        boolean z = true;
        while (it.hasNext()) {
            if (!it.next().onBackPressed()) {
                z = false;
            }
        }
        return z;
    }

    @Override // com.ea.nimble.IApplicationLifecycle
    public void notifyActivityRetainNonConfigurationInstance() {
        Log.Helper.LOGFUNC(this);
    }

    private void deleteConsumedDataFromIntent(Intent intent) {
        if (intent != null) {
            if (intent.getData() != null && intent.getDataString().startsWith("ea://socialsharing")) {
                intent.removeExtra("key");
                intent.setData(null);
            }
            if (intent.getStringExtra("PushNotification") != null) {
                intent.removeExtra("PushNotification");
            }
        }
    }

    private void notifyApplicationLaunch(Intent intent) {
        Log.Helper.LOGFUNC(this);
        Iterator<IApplicationLifecycle.ApplicationLifecycleCallbacks> it = this.m_applicationLifecycleCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onApplicationLaunch(intent);
        }
        deleteConsumedDataFromIntent(intent);
    }

    private void notifyApplicationSuspend() {
        Log.Helper.LOGFUNC(this);
        Iterator<IApplicationLifecycle.ApplicationLifecycleCallbacks> it = this.m_applicationLifecycleCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onApplicationSuspend();
        }
    }

    private void notifyApplicationResume(Intent intent) {
        Log.Helper.LOGFUNC(this);
        Iterator<IApplicationLifecycle.ApplicationLifecycleCallbacks> it = this.m_applicationLifecycleCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onApplicationResume();
        }
        deleteConsumedDataFromIntent(intent);
    }

    private void notifyApplicationQuit() {
        Log.Helper.LOGFUNC(this);
        Iterator<IApplicationLifecycle.ApplicationLifecycleCallbacks> it = this.m_applicationLifecycleCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onApplicationQuit();
        }
    }
}