package com.ea.nimble.tracking;

import android.app.Activity;
import android.app.ActivityManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.support.v4.media.session.PlaybackStateCompat;
import com.ea.nimble.ApplicationEnvironment;
import com.ea.nimble.Global;
import com.ea.nimble.IApplicationEnvironment;
import com.ea.nimble.IHttpRequest;
import com.ea.nimble.INetwork;
import com.ea.nimble.IOperationalTelemetryDispatch;
import com.ea.nimble.ISynergyEnvironment;
import com.ea.nimble.ISynergyIdManager;
import com.ea.nimble.ISynergyRequest;
import com.ea.nimble.Log;
import com.ea.nimble.LogSource;
import com.ea.nimble.Network;
import com.ea.nimble.OperationalTelemetryDispatch;
import com.ea.nimble.SynergyEnvironment;
import com.ea.nimble.SynergyIdManager;
import com.ea.nimble.SynergyNetwork;
import com.ea.nimble.SynergyNetworkConnectionCallback;
import com.ea.nimble.SynergyNetworkConnectionHandle;
import com.ea.nimble.SynergyRequest;
import com.ea.nimble.Utility;
import com.ea.nimble.mtx.catalog.synergy.SynergyCatalog;
import com.ea.nimble.tracking.NimbleTrackingThreadManager;
import com.ea.nimble.tracking.Tracking;
import com.google.android.gms.ads.RequestConfiguration;
import com.ironsource.ad;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Random;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

/* loaded from: classes2.dex */
class NimbleTrackingSynergyImpl extends NimbleTrackingImplBase implements LogSource {
    private static final String EVENT_PREFIX = "SYNERGYTRACKING::";
    private static final int MAX_CUSTOM_EVENT_PARAMETERS = 20;
    private int m_eventNumber;
    private Map<String, String> m_pidMap;
    private String m_sessionId;
    private final BroadcastReceiver m_pidInfoUpdateReceiver = new BroadcastReceiver() { // from class: com.ea.nimble.tracking.NimbleTrackingSynergyImpl.1
        @Override // android.content.BroadcastReceiver
        public void onReceive(Context context, final Intent intent) {
            Log.Helper.LOGPUBLICFUNC(this);
            NimbleTrackingSynergyImpl.this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingSynergyImpl.1.1
                @Override // java.lang.Runnable
                public void run() {
                    Log.Helper.LOGPUBLICFUNC(this);
                    NimbleTrackingSynergyImpl.this.onPidInfoUpdate(intent);
                }
            });
        }
    };
    private final SynergyIdChangedReceiver m_synergyIdChangedReceiver = new SynergyIdChangedReceiver();
    private final List<Map<String, String>> m_pendingEvents = new ArrayList();

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

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase, com.ea.nimble.LogSource
    public String getLogSourceTitle() {
        return "TrackingSynergy";
    }

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase
    public String getPersistenceIdentifier() {
        return "Synergy";
    }

    public class JsonData implements ISynergyRequest.IJsonData {
        private final ArrayList<Map<String, Object>> data;

        @Override // com.ea.nimble.ISynergyRequest.IJsonData
        public Object getData() {
            return this.data;
        }

        public JsonData(ArrayList<Map<String, Object>> arrayList) {
            this.data = arrayList;
        }

        @Override // com.ea.nimble.ISynergyRequest.IJsonData
        public int size() {
            return this.data.size();
        }
    }

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

        @Override // android.content.BroadcastReceiver
        public void onReceive(Context context, final Intent intent) {
            Log.Helper.LOGPUBLICFUNC(this);
            NimbleTrackingSynergyImpl.this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingSynergyImpl.SynergyIdChangedReceiver.1
                @Override // java.lang.Runnable
                public void run() {
                    Log.Helper.LOGPUBLICFUNC(this);
                    NimbleTrackingSynergyImpl.this.onSynergyIdChanged(intent);
                }
            });
        }
    }

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase
    public String getFeatureTag() {
        Log.Helper.LOGFUNC(this);
        return "SynergyTracker";
    }

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase, com.ea.nimble.Component
    public void restore() {
        Log.Helper.LOGFUNC(this);
        super.restore();
        Utility.registerReceiver(Global.NIMBLE_NOTIFICATION_IDENTITY_PID_INFO_UPDATE, this.m_pidInfoUpdateReceiver);
        wakeup();
    }

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase, com.ea.nimble.Component
    public void cleanup() {
        Log.Helper.LOGFUNC(this);
        sleep();
        super.cleanup();
    }

    private String generateSynergySessionId() {
        Log.Helper.LOGFUNC(this);
        String replace = Utility.getUTCDateStringFormat(new Date()).replace("_", "");
        StringBuilder sb = new StringBuilder(24);
        sb.append(replace);
        int length = 24 - sb.length();
        Random random = new Random();
        for (int i = 0; i < length; i++) {
            sb.append(random.nextInt(10));
        }
        return sb.toString();
    }

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase, com.ea.nimble.tracking.ITracking
    public void setEnable(boolean z) {
        Log.Helper.LOGPUBLICFUNC(this);
        super.setEnable(z);
        if (z) {
            return;
        }
        this.m_sessionId = null;
    }

    private void resetSession() {
        Log.Helper.LOGFUNC(this);
        this.m_sessionId = generateSynergySessionId();
        this.m_eventNumber = 1;
    }

    /* JADX WARN: Removed duplicated region for block: B:15:0x08af  */
    /* JADX WARN: Removed duplicated region for block: B:36:0x08ff  */
    /* JADX WARN: Removed duplicated region for block: B:39:0x091b  */
    /* JADX WARN: Removed duplicated region for block: B:50:0x0986  */
    /* JADX WARN: Removed duplicated region for block: B:53:0x0998  */
    /* JADX WARN: Removed duplicated region for block: B:56:0x095d  */
    /* JADX WARN: Removed duplicated region for block: B:60:0x0907  */
    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public java.util.List<java.util.Map<java.lang.String, java.lang.String>> convertEvent(com.ea.nimble.tracking.Tracking.Event r20) {
        /*
            Method dump skipped, instructions count: 2492
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: com.ea.nimble.tracking.NimbleTrackingSynergyImpl.convertEvent(com.ea.nimble.tracking.Tracking$Event):java.util.List");
    }

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase
    public void postPendingEvents(boolean z) {
        Log.Helper.LOGFUNC(this);
        if (isAbleToPostEvent(z)) {
            ArrayList<TrackingBaseSessionObject> arrayList = this.m_sessionsToPost;
            if (arrayList == null || arrayList.size() <= 0) {
                Log.Helper.LOGD(this, "No tracking sessions to post.", new Object[0]);
                return;
            }
            SynergyRequest createPostRequest = createPostRequest();
            if (createPostRequest == null) {
                return;
            }
            createPostRequest.httpRequest.runInBackground = z;
            this.m_isRequestInProgress = true;
            final NimbleTrackingThreadManager acquireInstance = NimbleTrackingThreadManager.acquireInstance();
            try {
                SynergyNetwork.getComponent().sendRequest(createPostRequest, new SynergyNetworkConnectionCallback() { // from class: com.ea.nimble.tracking.NimbleTrackingSynergyImpl.2
                    @Override // com.ea.nimble.SynergyNetworkConnectionCallback
                    public void callback(final SynergyNetworkConnectionHandle synergyNetworkConnectionHandle) {
                        Log.Helper.LOGPUBLICFUNC(this);
                        acquireInstance.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingSynergyImpl.2.1
                            @Override // java.lang.Runnable
                            public void run() {
                                Log.Helper.LOGPUBLICFUNC(this);
                                NimbleTrackingSynergyImpl.this.onPostComplete(synergyNetworkConnectionHandle);
                            }
                        });
                        NimbleTrackingThreadManager.releaseInstance();
                    }
                });
            } catch (OutOfMemoryError unused) {
                Activity currentActivity = ApplicationEnvironment.getCurrentActivity();
                if (currentActivity != null) {
                    ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
                    ((ActivityManager) currentActivity.getSystemService("activity")).getMemoryInfo(memoryInfo);
                    Log.Helper.LOGI(this, "OutOfMemoryError with " + (memoryInfo.availMem / PlaybackStateCompat.ACTION_SET_CAPTIONING_ENABLED) + " MB left. Dropping current session", new Object[0]);
                } else {
                    Log.Helper.LOGI(this, "Out of memory. Dropping current session", new Object[0]);
                }
                NimbleTrackingThreadManager.releaseInstance();
                double d = this.m_postInterval;
                this.m_postRetryDelay = 1.0d;
                this.m_isRequestInProgress = false;
                ArrayList<TrackingBaseSessionObject> arrayList2 = this.m_sessionsToPost;
                if (arrayList2 != null && !arrayList2.isEmpty()) {
                    Log.Helper.LOGI(this, "More items found in the queue. Post the next one now. Queue size: %d", Integer.valueOf(this.m_sessionsToPost.size()));
                    resetPostTimer(0.0d, false);
                } else {
                    Log.Helper.LOGI(this, "No more items found in the queue. Wait on the timer. Queue size: %d", Integer.valueOf(this.m_sessionsToPost.size()));
                    resetPostTimer(d, true);
                }
            }
        }
    }

    private void clearAndRefillSessionsToPost() {
        Iterator it = ((ArrayList) this.m_sessionsToPost.clone()).iterator();
        while (it.hasNext()) {
            removeSessionAndFillQueue((TrackingBaseSessionObject) it.next());
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Removed duplicated region for block: B:11:0x0078  */
    /* JADX WARN: Removed duplicated region for block: B:17:0x00a5  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public void onPostComplete(com.ea.nimble.SynergyNetworkConnectionHandle r8) {
        /*
            r7 = this;
            com.ea.nimble.Log.Helper.LOGFUNC(r7)
            r0 = 0
            if (r8 == 0) goto Ldf
            com.ea.nimble.ISynergyResponse r1 = r8.getResponse()
            if (r1 != 0) goto Le
            goto Ldf
        Le:
            com.ea.nimble.ISynergyResponse r1 = r8.getResponse()
            java.lang.Exception r1 = r1.getError()
            r2 = 1
            r3 = 4607182418800017408(0x3ff0000000000000, double:1.0)
            if (r1 != 0) goto L24
            r7.clearAndRefillSessionsToPost()
            r7.m_postRetryDelay = r3
            double r3 = r7.m_postInterval
        L22:
            r8 = r0
            goto L6d
        L24:
            com.ea.nimble.ISynergyResponse r1 = r8.getResponse()
            com.ea.nimble.IHttpResponse r1 = r1.getHttpResponse()
            if (r1 == 0) goto L57
            int r5 = r1.getStatusCode()
            r6 = 400(0x190, float:5.6E-43)
            if (r5 == r6) goto L3e
            int r5 = r1.getStatusCode()
            r6 = 415(0x19f, float:5.82E-43)
            if (r5 != r6) goto L57
        L3e:
            int r8 = r1.getStatusCode()
            java.lang.Integer r8 = java.lang.Integer.valueOf(r8)
            java.lang.Object[] r8 = new java.lang.Object[]{r8}
            java.lang.String r1 = "Received HTTP status %d. Discarding post."
            com.ea.nimble.Log.Helper.LOGE(r7, r1, r8)
            r7.clearAndRefillSessionsToPost()
            r7.m_postRetryDelay = r3
            double r3 = r7.m_postInterval
            goto L22
        L57:
            com.ea.nimble.ISynergyResponse r8 = r8.getResponse()
            java.lang.Exception r8 = r8.getError()
            java.lang.String r8 = r8.getLocalizedMessage()
            java.lang.Object[] r8 = new java.lang.Object[]{r8}
            java.lang.String r1 = "Failed to send tracking events. Error: %s"
            com.ea.nimble.Log.Helper.LOGE(r7, r1, r8)
            r8 = r2
        L6d:
            java.lang.String r1 = "Telemetry post request finished, resetting isRequestInProgress flag to false."
            java.lang.Object[] r5 = new java.lang.Object[r0]
            com.ea.nimble.Log.Helper.LOGI(r7, r1, r5)
            r7.m_isRequestInProgress = r0
            if (r8 == 0) goto La5
            double r1 = r7.m_postRetryDelay
            r3 = 4611686018427387904(0x4000000000000000, double:2.0)
            double r3 = r3 * r1
            r7.m_postRetryDelay = r3
            r5 = 4643985272004935680(0x4072c00000000000, double:300.0)
            int r8 = (r3 > r5 ? 1 : (r3 == r5 ? 0 : -1))
            if (r8 <= 0) goto L8a
            r7.m_postRetryDelay = r5
        L8a:
            java.lang.Double r8 = java.lang.Double.valueOf(r1)
            java.util.ArrayList<com.ea.nimble.tracking.TrackingBaseSessionObject> r3 = r7.m_sessionsToPost
            int r3 = r3.size()
            java.lang.Integer r3 = java.lang.Integer.valueOf(r3)
            java.lang.Object[] r8 = new java.lang.Object[]{r8, r3}
            java.lang.String r3 = "Posting a retry with delay of %s due to failed send. Queue size: %d"
            com.ea.nimble.Log.Helper.LOGI(r7, r3, r8)
            r7.resetPostTimer(r1, r0)
            goto Lde
        La5:
            java.util.ArrayList<com.ea.nimble.tracking.TrackingBaseSessionObject> r8 = r7.m_sessionsToPost
            if (r8 == 0) goto Lc8
            boolean r8 = r8.isEmpty()
            if (r8 != 0) goto Lc8
            java.util.ArrayList<com.ea.nimble.tracking.TrackingBaseSessionObject> r8 = r7.m_sessionsToPost
            int r8 = r8.size()
            java.lang.Integer r8 = java.lang.Integer.valueOf(r8)
            java.lang.Object[] r8 = new java.lang.Object[]{r8}
            java.lang.String r1 = "More items found in the queue. Post the next one now. Queue size: %d"
            com.ea.nimble.Log.Helper.LOGI(r7, r1, r8)
            r1 = 0
            r7.resetPostTimer(r1, r0)
            goto Lde
        Lc8:
            java.util.ArrayList<com.ea.nimble.tracking.TrackingBaseSessionObject> r8 = r7.m_sessionsToPost
            int r8 = r8.size()
            java.lang.Integer r8 = java.lang.Integer.valueOf(r8)
            java.lang.Object[] r8 = new java.lang.Object[]{r8}
            java.lang.String r0 = "No more items found in the queue. Wait on the timer. Queue size: %d"
            com.ea.nimble.Log.Helper.LOGI(r7, r0, r8)
            r7.resetPostTimer(r3, r2)
        Lde:
            return
        Ldf:
            java.lang.String r8 = "No response exists in this post!"
            java.lang.Object[] r0 = new java.lang.Object[r0]
            com.ea.nimble.Log.Helper.LOGE(r7, r8, r0)
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: com.ea.nimble.tracking.NimbleTrackingSynergyImpl.onPostComplete(com.ea.nimble.SynergyNetworkConnectionHandle):void");
    }

    /* JADX WARN: Unreachable blocks removed: 1, instructions: 1 */
    public SynergyRequest createPostRequest() {
        Log.Helper.LOGFUNC(this);
        String serverUrlWithKey = SynergyEnvironment.getComponent().getServerUrlWithKey(SynergyEnvironment.SERVER_URL_KEY_SYNERGY_TRACKING);
        if (serverUrlWithKey == null) {
            Log.Helper.LOGI(this, "Tracking server URL from NimbleEnvironment is nil. Adding observer for environment update finish.", new Object[0]);
            addObserverForSynergyEnvironmentUpdateFinished();
            return null;
        }
        ISynergyEnvironment component = SynergyEnvironment.getComponent();
        ArrayList arrayList = new ArrayList();
        Iterator<TrackingBaseSessionObject> it = this.m_sessionsToPost.iterator();
        while (it.hasNext()) {
            TrackingBaseSessionObject next = it.next();
            if (next == null) {
                removeSessionAndFillQueue(null);
            } else {
                HashMap hashMap = new HashMap();
                hashMap.putAll(next.sessionData);
                hashMap.put("now_timestamp", Utility.getUTCDateStringFormat(new Date()));
                ArrayList arrayList2 = new ArrayList(next.events);
                for (int i = 0; i < arrayList2.size(); i++) {
                    ((Map) arrayList2.get(i)).put("repostCount", String.valueOf(next.repostCount));
                }
                Log.Helper.LOGD(this, "Event queue marshalled. Incrementing repost count from %d to %d", Integer.valueOf(next.repostCount), Integer.valueOf(next.repostCount + 1));
                next.repostCount++;
                hashMap.put("events", arrayList2);
                if (!Utility.validStringObject(hashMap.get("uid"))) {
                    String synergyId = SynergyIdManager.getComponent().getSynergyId();
                    if (Utility.validString(synergyId)) {
                        Log.Helper.LOGV(this, "Creating post request. No uid in session info dictionary, inserting uid value %s now.", synergyId);
                        hashMap.put("uid", synergyId);
                    } else {
                        Log.Helper.LOGV(this, "Creating post request. No uid in session info dictionary, still no uid available now.", new Object[0]);
                    }
                }
                if (!Utility.validStringObject(hashMap.get(SynergyCatalog.MTX_INFO_KEY_SELLID))) {
                    String safeString = Utility.safeString(component.getSellId());
                    if (!Utility.validString(safeString)) {
                        Log.Helper.LOGE(this, "Creating POST request. Missing sell id.", new Object[0]);
                    } else {
                        hashMap.put(SynergyCatalog.MTX_INFO_KEY_SELLID, safeString);
                    }
                }
                if (!Utility.validStringObject(hashMap.get("hwId"))) {
                    String safeString2 = Utility.safeString(component.getEAHardwareId());
                    if (!Utility.validString(safeString2)) {
                        Log.Helper.LOGE(this, "Creating POST request. Missing hw id.", new Object[0]);
                    } else {
                        hashMap.put("hwId", safeString2);
                    }
                }
                if (!Utility.validStringObject(hashMap.get("deviceId"))) {
                    String safeString3 = Utility.safeString(component.getEADeviceId());
                    if (!Utility.validString(safeString3)) {
                        Log.Helper.LOGE(this, "Creating POST request. Missing device id.", new Object[0]);
                    } else {
                        hashMap.put("deviceId", safeString3);
                    }
                }
                arrayList.add(hashMap);
            }
        }
        SynergyRequest synergyRequest = new SynergyRequest("/tracking/api/core/logEvent", IHttpRequest.Method.POST, null);
        synergyRequest.baseUrl = serverUrlWithKey;
        synergyRequest.jsonData = new JsonData(arrayList);
        IOperationalTelemetryDispatch component2 = OperationalTelemetryDispatch.getComponent();
        if (component2 != null) {
            JSONObject jSONObject = new JSONObject();
            String str = "BASEURL";
            try {
                jSONObject.put("BASEURL", synergyRequest.baseUrl);
                jSONObject.put("API", synergyRequest.api);
                str = "POSTDATA";
                jSONObject.put("POSTDATA", new JSONArray((Collection) arrayList));
            } catch (JSONException unused) {
                Log.Helper.LOGE(this, "Failed to add " + str + " to eventDict.", new Object[0]);
            }
            component2.logEvent(IOperationalTelemetryDispatch.EVENTTYPE_TRACKING_SYNERGY_PAYLOADS, jSONObject.toString());
        }
        Utility.sendBroadcast(SynergyConstants.NIMBLE_NOTIFICATION_TRACKING_SYNERGY_POSTING_TO_SERVER);
        return synergyRequest;
    }

    private Map<String, Object> generateSessionInfoDictionary(String str) {
        String str2;
        Log.Helper.LOGFUNC(this);
        ISynergyEnvironment component = SynergyEnvironment.getComponent();
        ISynergyIdManager component2 = SynergyIdManager.getComponent();
        IApplicationEnvironment component3 = ApplicationEnvironment.getComponent();
        final HashMap hashMap = new HashMap();
        new NimbleTrackingThreadManager.BlockingRunner() { // from class: com.ea.nimble.tracking.NimbleTrackingSynergyImpl.3
            @Override // com.ea.nimble.tracking.NimbleTrackingThreadManager.BlockingRunner
            public void run() {
                ApplicationEnvironment.getComponent().retrieveAdvertisingId(new IApplicationEnvironment.AdvertisingIdCalback() { // from class: com.ea.nimble.tracking.NimbleTrackingSynergyImpl.3.1
                    @Override // com.ea.nimble.IApplicationEnvironment.AdvertisingIdCalback
                    public void onCallback(String str3, boolean z) {
                        hashMap.put("advertiserID", str3);
                        hashMap.put(ApplicationEnvironment.NIMBLE_PARAMETER_LIMIT_AD_TRACKING, Boolean.valueOf(z));
                        setDone();
                    }
                });
            }
        };
        String sellId = component.getSellId();
        String eAHardwareId = component.getEAHardwareId();
        String eADeviceId = component.getEADeviceId();
        String str3 = Build.VERSION.RELEASE;
        String carrier = ApplicationEnvironment.getComponent().getCarrier();
        String applicationVersion = ApplicationEnvironment.getComponent().getApplicationVersion();
        try {
            hashMap.put("timezone", String.format(Locale.US, "%tZ", Calendar.getInstance()));
        } catch (Exception e) {
            Log.Helper.LOGW(this, "Failed to get timezone abbreviation with error: " + e.getMessage(), new Object[0]);
        }
        hashMap.put(ad.y0, carrier);
        hashMap.put("pflag", component3.isAppCracked() ? "1" : "0");
        hashMap.put("jflag", component3.isDeviceRooted() ? "1" : "0");
        hashMap.put("firmwareVer", str3);
        hashMap.put(SynergyCatalog.MTX_INFO_KEY_SELLID, Utility.safeString(sellId));
        hashMap.put("buildId", Utility.safeString(applicationVersion));
        hashMap.put("sdkVer", Global.NIMBLE_RELEASE_VERSION);
        hashMap.put("sdkCfg", "DL");
        hashMap.put("deviceId", Utility.safeString(eADeviceId));
        hashMap.put("hwId", Utility.safeString(eAHardwareId));
        hashMap.put("schemaVer", "2");
        hashMap.put("platform", "android");
        INetwork component4 = Network.getComponent();
        if (component4.getStatus() == Network.Status.OK) {
            str2 = component4.isNetworkWifi() ? "W" : RequestConfiguration.MAX_AD_CONTENT_RATING_G;
        } else {
            str2 = "N";
        }
        hashMap.put("networkAccess", str2);
        hashMap.put("originUser", this.m_loggedInToOrigin ? "Y" : "N");
        if (!Utility.validString(str)) {
            str = component2.getSynergyId();
        }
        if (str != null) {
            hashMap.put("uid", Utility.safeString(str));
        }
        hashMap.put(ApplicationEnvironment.NIMBLE_PARAMETER_ANDROID_ID, component3.getAndroidId());
        Map<String, String> map = this.m_pidMap;
        if (map != null && map.size() > 0) {
            hashMap.put("pidMap", this.m_pidMap);
        }
        String gameSpecifiedPlayerId = component3.getGameSpecifiedPlayerId();
        if (gameSpecifiedPlayerId != null && gameSpecifiedPlayerId.length() > 0) {
            hashMap.put("gamePlayerId", gameSpecifiedPlayerId);
        }
        int size = this.m_customSessionData.size();
        if (size > 0) {
            for (int i = 0; i < size; i++) {
                hashMap.put(this.m_customSessionData.get(i).key, this.m_customSessionData.get(i).value);
            }
        }
        return hashMap;
    }

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase
    public void packageCurrentSession() {
        Log.Helper.LOGFUNC(this);
        if (this.m_currentSessionObject.countOfEvents() > 0) {
            Log.Helper.LOGV(this, "Preparing for post, generating session info dictionary.", new Object[0]);
            this.m_currentSessionObject.sessionData = new HashMap(generateSessionInfoDictionary(null));
            queueCurrentEventsForPost();
        }
    }

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase
    public boolean isSameSession(TrackingBaseSessionObject trackingBaseSessionObject, TrackingBaseSessionObject trackingBaseSessionObject2) {
        Log.Helper.LOGFUNC(this);
        if (trackingBaseSessionObject.events.size() == 0 || trackingBaseSessionObject2.events.size() == 0) {
            Log.Helper.LOGE(this, "Trying to compare session with no events", new Object[0]);
            return true;
        }
        String str = trackingBaseSessionObject.events.get(0).get("session");
        String str2 = trackingBaseSessionObject2.events.get(0).get("session");
        if (str == null || str2 == null) {
            Log.Helper.LOGE(this, "Trying to compare event with no session", new Object[0]);
            return true;
        }
        return str.equals(str2);
    }

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase
    public boolean canDropSession(List<TrackingBaseSessionObject> list) {
        Log.Helper.LOGFUNC(this);
        TrackingBaseSessionObject trackingBaseSessionObject = list.get(0);
        if (trackingBaseSessionObject.events.size() == 0) {
            Log.Helper.LOGE(this, "Trying to drop session with no events", new Object[0]);
            return true;
        }
        Iterator<Map<String, String>> it = trackingBaseSessionObject.events.iterator();
        while (it.hasNext()) {
            String str = it.next().get("eventType");
            if (str != null && str.equals(String.valueOf(SynergyConstants.EVT_APP_START_AFTERINSTALL.value))) {
                return false;
            }
        }
        return true;
    }

    private void wakeup() {
        Log.Helper.LOGFUNC(this);
        Utility.registerReceiver(SynergyIdManager.NOTIFICATION_SYNERGY_ID_CHANGED, this.m_synergyIdChangedReceiver);
    }

    private void sleep() {
        Log.Helper.LOGFUNC(this);
        Utility.unregisterReceiver(this.m_synergyIdChangedReceiver);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void onSynergyIdChanged(Intent intent) {
        Log.Helper.LOGFUNC(this);
        String stringExtra = intent.getStringExtra("previousSynergyId");
        String stringExtra2 = intent.getStringExtra("currentSynergyId");
        HashMap hashMap = new HashMap();
        hashMap.put("eventType", String.valueOf(SynergyConstants.EVT_SESSION_END_SYNERGYID_CHANGE.value));
        SynergyConstants synergyConstants = SynergyConstants.EVT_KEYTYPE_SYNERGYID;
        hashMap.put("keyType01", String.valueOf(synergyConstants.value));
        hashMap.put("keyValue01", Utility.safeString(stringExtra));
        hashMap.put("keyType02", String.valueOf(synergyConstants.value));
        hashMap.put("keyValue02", Utility.safeString(stringExtra2));
        logEvent(TrackingSynergy.EVENT_CUSTOM, hashMap);
        this.m_currentSessionObject.sessionData = new HashMap(generateSessionInfoDictionary(stringExtra));
        queueCurrentEventsForPost();
        hashMap.put("eventType", String.valueOf(SynergyConstants.EVT_NEW_SESSION_START_SYNERGYID_CHANGE.value));
        logEvent(TrackingSynergy.EVENT_CUSTOM, hashMap);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void onPidInfoUpdate(Intent intent) {
        HashMap hashMap;
        Serializable serializableExtra;
        Log.Helper.LOGFUNC(this);
        if (Build.VERSION.SDK_INT >= 33) {
            serializableExtra = intent.getSerializableExtra(Global.NIMBLE_IDENTITY_DICTIONARY_KEY_PIDMAP_ID, HashMap.class);
            hashMap = (HashMap) serializableExtra;
        } else {
            hashMap = (HashMap) intent.getSerializableExtra(Global.NIMBLE_IDENTITY_DICTIONARY_KEY_PIDMAP_ID);
        }
        if (hashMap == null || hashMap.size() <= 0) {
            return;
        }
        this.m_pidMap = hashMap;
        this.m_currentSessionObject.sessionData.put("pidMap", hashMap);
    }

    @Override // com.ea.nimble.tracking.NimbleTrackingImplBase, com.ea.nimble.tracking.ITracking
    public String getSessionId() {
        Log.Helper.LOGPUBLICFUNC(this);
        return this.m_sessionId;
    }

    private static boolean isSynergyEvent(String str) {
        Log.Helper.LOGFUNCS("NimbleTrackingSynergyImpl");
        if (str == null) {
            return false;
        }
        return str.startsWith(EVENT_PREFIX);
    }

    private void parseCustomParameters(Map<String, String> map, Map<String, String> map2) {
        int i;
        Log.Helper.LOGFUNC(this);
        ArrayList arrayList = new ArrayList(20);
        ArrayList arrayList2 = new ArrayList(20);
        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
        while (true) {
            i = 0;
            if (!it.hasNext()) {
                break;
            }
            Map.Entry<String, String> next = it.next();
            String key = next.getKey();
            if (key.startsWith("keyType")) {
                try {
                    int parseInt = Integer.parseInt(key.substring(7));
                    if (parseInt <= 0 || parseInt > 20) {
                        Log.Helper.LOGE(this, "Error: Custom parameter number %d is out of range of 1-%d", Integer.valueOf(parseInt), 20);
                    } else {
                        int i2 = parseInt - 1;
                        if (i2 < arrayList.size()) {
                            arrayList.set(i2, next.getValue());
                        } else {
                            for (int size = arrayList.size(); size < i2; size++) {
                                arrayList.add(null);
                            }
                            arrayList.add(next.getValue());
                        }
                    }
                } catch (NumberFormatException unused) {
                    Log.Helper.LOGE(this, "Error: Invalid format for keyType parameter. Expected keyType##, got " + key, new Object[0]);
                }
            } else if (key.startsWith("keyValue")) {
                try {
                    int parseInt2 = Integer.parseInt(key.substring(8));
                    if (parseInt2 <= 0 || parseInt2 > 20) {
                        Log.Helper.LOGE(this, "Error: Custom parameter number %d is out of range of 1-%d", Integer.valueOf(parseInt2), 20);
                    } else {
                        int i3 = parseInt2 - 1;
                        if (i3 < arrayList2.size()) {
                            arrayList2.set(i3, next.getValue());
                        } else {
                            for (int size2 = arrayList2.size(); size2 < i3; size2++) {
                                arrayList2.add(null);
                            }
                            arrayList2.add(next.getValue());
                        }
                    }
                } catch (NumberFormatException unused2) {
                    Log.Helper.LOGE(this, "Error: Invalid format for keyValue parameter. Expected keyValue##, got " + key, new Object[0]);
                }
            }
        }
        int max = Math.max(arrayList.size(), arrayList2.size());
        while (i < max) {
            String str = i < arrayList.size() ? (String) arrayList.get(i) : null;
            if (str == null) {
                Log.Helper.LOGE(this, "Error: No corresponding keyType entry for parameter number %d", Integer.valueOf(i + 1));
                str = "0";
            }
            String str2 = i < arrayList2.size() ? (String) arrayList2.get(i) : null;
            if (str2 == null) {
                Log.Helper.LOGE(this, "Error: No corresponding keyValue entry for parameter number %d", Integer.valueOf(i + 1));
                str2 = "";
            }
            Locale locale = Locale.US;
            i++;
            map2.put(String.format(locale, "eventKeyType%02d", Integer.valueOf(i)), str);
            map2.put(String.format(locale, "eventValue%02d", Integer.valueOf(i)), str2);
        }
    }

    private void addPushTNGTrackingParams(Tracking.Event event, Map<String, String> map) {
        Log.Helper.LOGFUNC(this);
        try {
            map.put("eventKeyType01", String.valueOf(SynergyConstants.EVT_KEYTYPE_MESSAGEID.value));
            map.put("eventValue01", event.parameters.get("NIMBLESTANDARD::KEY_PN_MESSAGE_ID"));
            SynergyConstants synergyConstants = SynergyConstants.EVT_KEYTYPE_ENUMERATION;
            map.put("eventKeyType02", String.valueOf(synergyConstants.value));
            map.put("eventValue02", event.parameters.get(Tracking.KEY_PN_MESSAGE_TYPE));
            map.put("eventKeyType03", String.valueOf(synergyConstants.value));
            map.put("eventValue03", event.parameters.get(Tracking.KEY_PN_DEVICE_ID));
        } catch (Exception unused) {
        }
    }
}