project-real-resurrection-3/rr3-apk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Add decompiled APK source code (JADX)

Browse Source 
- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
Daniel Elliott
2026-02-18 14:52:23 -08:00
parent cc210a65ea
commit f9d20bb3fc
26991 changed files with 2541449 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
decompiled/sources/com/ea/nimble/tracking/ITracking.java Normal file
View File

@@ -0,0 +1,26 @@
package com.ea.nimble.tracking;
import java.util.Map;
/* loaded from: classes2.dex */
public interface ITracking {
void addCustomSessionData(String str, String str2);
void clearCustomSessionData();
boolean getEnable();
boolean getPostEnable();
String getSessionId();
void logEvent(String str, Map<String, String> map);
void removeCustomSessionData(String str);
void setEnable(boolean z);
void setPostEnable(boolean z);
void setTrackingAttribute(String str, String str2);
}

814
decompiled/sources/com/ea/nimble/tracking/NimbleTrackingImplBase.java Normal file
View File

@@ -0,0 +1,814 @@
package com.ea.nimble.tracking;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import com.ea.nimble.ApplicationEnvironment;
import com.ea.nimble.Component;
import com.ea.nimble.Global;
import com.ea.nimble.Log;
import com.ea.nimble.LogSource;
import com.ea.nimble.Network;
import com.ea.nimble.NimbleApplicationConfiguration;
import com.ea.nimble.Persistence;
import com.ea.nimble.PersistenceService;
import com.ea.nimble.SynergyEnvironment;
import com.ea.nimble.Utility;
import com.ea.nimble.mtx.catalog.synergy.SynergyCatalog;
import com.ea.nimble.tracking.Tracking;
import com.ironsource.mediationsdk.metadata.a;
import java.io.Serializable;
import java.util.ArrayList;
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.concurrent.ScheduledFuture;
/* loaded from: classes2.dex */
abstract class NimbleTrackingImplBase extends Component implements ITracking, LogSource {
private static final int DATA_VERSION_CURRENT = 3;
private static final int DEFAULT_MAX_QUEUE_LENGTH = 3;
protected static final double DEFAULT_POST_INTERVAL = 1.0d;
protected static final double DEFAULT_REPOST_MULTIPLIER = 2.0d;
protected static final double DEFAULT_RETRY_DELAY = 1.0d;
protected static final double MAX_POST_RETRY_DELAY = 300.0d;
private static final int MAX_QUEUED_EVENTS = 50;
private static final int MAX_QUEUED_SESSIONS = 50;
public static final String NIMBLE_TRACKING_DEFAULT_POST_ENABLE = "NimbleDefaultTrackingPostFlag";
protected static final double NOW_POST_INTERVAL = 0.0d;
private static final String ORIGIN_LOGIN_STATUS_STRING_AUTO_LOGGING_IN = "autoLogin";
private static final String ORIGIN_LOGIN_STATUS_STRING_LIVE_USER = "live";
private static final String ORIGIN_NOTIFICATION_LOGIN_STATUS_UPDATE_KEY_STATUS = "STATUS";
private static final String PERSISTENCE_CURRENT_SESSION_ID = "currentSessionObject";
private static final String PERSISTENCE_ENABLE_FLAG = "trackingEnabledFlag";
private static final String PERSISTENCE_EVENT_QUEUE_ID = "eventQueue";
private static final String PERSISTENCE_FIRST_SESSION_ID_NUMBER = "firstSessionIDNumber";
private static final String PERSISTENCE_LAST_SESSION_ID_NUMBER = "lastSessionIDNumber";
private static final String PERSISTENCE_LOGGED_IN_TO_ORIGIN_ID = "loggedInToOrigin";
private static final String PERSISTENCE_POST_ENABLE_FLAG = "trackingPostEnabledFlag";
private static final String PERSISTENCE_QUEUED_SESSIONS_ID = "queuedSessionObjects";
private static final String PERSISTENCE_SAVED_SESSION_ID_NUMBER = "savedSession";
private static final String PERSISTENCE_SESSION_DATA_ID = "sessionData";
private static final String PERSISTENCE_TOTAL_SESSION_COUNT = "totalSessionCount";
private static final String PERSISTENCE_TRACKING_ATTRIBUTES = "trackingAttributes";
private static final String PERSISTENCE_VERSION_ID = "dataVersion";
private static final String SESSION_FILE_FORMAT = "%sSession%d";
protected double m_postRetryDelay;
private ScheduledFuture<?> m_postTimer;
protected NimbleTrackingThreadManager m_threadManager;
protected ArrayList<TrackingBaseSessionObject> m_sessionsToPost = new ArrayList<>();
private boolean m_enable = true;
private boolean m_isFeatureDisabledFromServer = false;
protected ArrayList<SessionData> m_customSessionData = new ArrayList<>();
private StartupRequestsFinishedReceiver m_receiver = null;
private BroadcastReceiver m_networkStatusChangedReceiver = null;
protected boolean m_loggedInToOrigin = false;
private OriginLoginStatusChangedReceiver m_originLoginStatusChangedReceiver = null;
protected TrackingBaseSessionObject m_currentSessionObject = new TrackingBaseSessionObject();
protected double m_postInterval = 1.0d;
private boolean m_isPostPending = false;
protected boolean m_isRequestInProgress = false;
private long m_lastSessionIDNumber = -1;
private long m_firstSessionIDNumber = 0;
private long m_totalSessions = 0;
protected HashMap<String, String> m_trackingAttributes = new HashMap<>();
private boolean m_postEnable = true;
private final int m_maxQueueLength = 3;
public static class SessionData implements Serializable {
private static final long serialVersionUID = 465486;
String key;
String value;
}
public abstract List<Map<String, String>> convertEvent(Tracking.Event event);
public abstract String getFeatureTag();
@Override // com.ea.nimble.LogSource
public String getLogSourceTitle() {
return "TrackingBase";
}
public abstract String getPersistenceIdentifier();
public abstract void packageCurrentSession();
public abstract void postPendingEvents(boolean z);
public class PostTask implements Runnable {
private boolean m_packageEventsOnExpiry;
public PostTask(boolean z) {
this.m_packageEventsOnExpiry = false;
Log.Helper.LOGPUBLICFUNC(this);
this.m_packageEventsOnExpiry = z;
}
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingImplBase.this.postIntervalTimerExpired(this.m_packageEventsOnExpiry);
}
}
@Override // com.ea.nimble.tracking.ITracking
public boolean getEnable() {
Log.Helper.LOGPUBLICFUNC(this);
return this.m_enable;
}
@Override // com.ea.nimble.tracking.ITracking
public void setEnable(boolean z) {
Log.Helper.LOGPUBLICFUNC(this);
Object[] objArr = new Object[1];
objArr[0] = z ? "ENABLED" : "DISABLED";
Log.Helper.LOGI(this, "setEnable called. enable = %s", objArr);
if (this.m_enable == z) {
return;
}
if (!z) {
HashMap hashMap = new HashMap();
hashMap.put("eventType", Tracking.EVENT_USER_TRACKING_OPTOUT);
logEvent(Tracking.EVENT_USER_TRACKING_OPTOUT, hashMap);
packageCurrentSession();
postPendingEvents(false);
if (this.m_currentSessionObject.countOfEvents() > 0) {
Log.Helper.LOGI(this, "Removing %d remaining events that couldn't be sent from queue.", Integer.valueOf(this.m_currentSessionObject.countOfEvents()));
}
this.m_currentSessionObject = new TrackingBaseSessionObject();
ArrayList<TrackingBaseSessionObject> arrayList = this.m_sessionsToPost;
if (arrayList != null && arrayList.size() > 0) {
Log.Helper.LOGI(this, "Removing unposted sessions.", new Object[0]);
this.m_sessionsToPost.clear();
}
killPostTimer();
} else {
resetPostTimer();
}
this.m_enable = z;
saveToPersistence();
}
private void logEvent(Tracking.Event event, boolean z) {
ScheduledFuture<?> scheduledFuture;
Log.Helper.LOGFUNC(this);
List<Map<String, String>> convertEvent = convertEvent(event);
if (convertEvent != null && !convertEvent.isEmpty()) {
for (Map<String, String> map : convertEvent) {
this.m_currentSessionObject.events.add(map);
Log.Helper.LOGD(this, "Logged event, %s: \n", map);
}
saveToPersistence();
if (!z && (((scheduledFuture = this.m_postTimer) == null || (scheduledFuture.isDone() && !this.m_isRequestInProgress)) && isAbleToPostEvent(false))) {
resetPostTimer();
}
}
if (this.m_currentSessionObject.events.size() >= 50) {
Log.Helper.LOGD(this, "Current number of events (%d) has reached maximum (%d). Posting event queue now.", Integer.valueOf(this.m_currentSessionObject.events.size()), 50);
} else if (!z) {
return;
}
killPostTimer();
packageCurrentSession();
postPendingEvents(z);
}
@Override // com.ea.nimble.tracking.ITracking
public void logEvent(String str, Map<String, String> map) {
Log.Helper.LOGPUBLICFUNC(this);
if (!this.m_enable || this.m_isFeatureDisabledFromServer) {
return;
}
boolean z = false;
if (str.equals(Tracking.EVENT_SESSION_END)) {
Log.Helper.LOGD(this, "Logging session end event, " + str + ". Posting event queue now.", new Object[0]);
z = true;
}
Tracking.Event event = new Tracking.Event();
event.type = str;
event.parameters = map;
event.timestamp = new Date();
logEvent(event, z);
}
public void resetPostTimer() {
Log.Helper.LOGFUNC(this);
resetPostTimer(this.m_postInterval);
}
public void resetPostTimer(double d) {
Log.Helper.LOGFUNC(this);
resetPostTimer(d, true);
}
public void resetPostTimer(double d, boolean z) {
Log.Helper.LOGFUNC(this);
double d2 = NOW_POST_INTERVAL;
if (d < NOW_POST_INTERVAL) {
Log.Helper.LOGE(this, "resetPostTimer called with an invalid period: period < 0.0. Timer reset with period 0.0 instead", new Object[0]);
} else {
d2 = d;
}
Log.Helper.LOGI(this, "Resetting event post timer for %s seconds.", Double.valueOf(d));
killPostTimer();
this.m_postTimer = this.m_threadManager.createTimer(d2, new PostTask(z));
}
private void killPostTimer() {
Log.Helper.LOGFUNC(this);
ScheduledFuture<?> scheduledFuture = this.m_postTimer;
if (scheduledFuture != null) {
scheduledFuture.cancel(false);
this.m_postTimer = null;
}
}
@Override // com.ea.nimble.Component
public void setup() {
Log.Helper.LOGFUNC(this);
this.m_postRetryDelay = 1.0d;
this.m_threadManager = NimbleTrackingThreadManager.acquireInstance();
}
/* JADX WARN: Removed duplicated region for block: B:78:0x019f */
/* JADX WARN: Removed duplicated region for block: B:79:0x01a7 */
/* JADX WARN: Removed duplicated region for block: B:82:0x01ba */
@Override // com.ea.nimble.Component
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct add '--show-bad-code' argument
*/
public void restore() {
/*
Method dump skipped, instructions count: 576
To view this dump add '--comments-level debug' option
*/
throw new UnsupportedOperationException("Method not decompiled: com.ea.nimble.tracking.NimbleTrackingImplBase.restore():void");
}
@Override // com.ea.nimble.Component
public void suspend() {
Log.Helper.LOGFUNC(this);
BroadcastReceiver broadcastReceiver = this.m_networkStatusChangedReceiver;
if (broadcastReceiver != null) {
Utility.unregisterReceiver(broadcastReceiver);
this.m_networkStatusChangedReceiver = null;
}
OriginLoginStatusChangedReceiver originLoginStatusChangedReceiver = this.m_originLoginStatusChangedReceiver;
if (originLoginStatusChangedReceiver != null) {
Utility.unregisterReceiver(originLoginStatusChangedReceiver);
this.m_originLoginStatusChangedReceiver = null;
}
killPostTimer();
saveToPersistence();
}
@Override // com.ea.nimble.Component
public void resume() {
Log.Helper.LOGFUNC(this);
updateFeatureDisableState();
if (getEnable()) {
resetPostTimer();
}
if (this.m_originLoginStatusChangedReceiver == null) {
OriginLoginStatusChangedReceiver originLoginStatusChangedReceiver = new OriginLoginStatusChangedReceiver();
this.m_originLoginStatusChangedReceiver = originLoginStatusChangedReceiver;
Utility.registerReceiver(Global.NOTIFICATION_LOGIN_STATUS_CHANGE, originLoginStatusChangedReceiver);
}
this.m_postRetryDelay = 1.0d;
}
@Override // com.ea.nimble.Component
public void cleanup() {
Log.Helper.LOGFUNC(this);
killPostTimer();
}
@Override // com.ea.nimble.Component
public void teardown() {
Log.Helper.LOGFUNC(this);
NimbleTrackingThreadManager.releaseInstance();
this.m_threadManager = null;
}
private void saveToPersistence() {
Log.Helper.LOGFUNC(this);
Persistence persistenceForNimbleComponent = PersistenceService.getPersistenceForNimbleComponent(getComponentId(), Persistence.Storage.CACHE);
Log.Helper.LOGD(this, "Saving event queue to persistence (cache storage).", new Object[0]);
try {
try {
persistenceForNimbleComponent.setValue(PERSISTENCE_VERSION_ID, String.valueOf(3));
persistenceForNimbleComponent.setValue(PERSISTENCE_CURRENT_SESSION_ID, this.m_currentSessionObject);
persistenceForNimbleComponent.setValue(PERSISTENCE_SESSION_DATA_ID, this.m_customSessionData);
persistenceForNimbleComponent.setValue(PERSISTENCE_LOGGED_IN_TO_ORIGIN_ID, Boolean.valueOf(this.m_loggedInToOrigin));
persistenceForNimbleComponent.setValue(PERSISTENCE_FIRST_SESSION_ID_NUMBER, Long.valueOf(this.m_firstSessionIDNumber));
persistenceForNimbleComponent.setValue(PERSISTENCE_LAST_SESSION_ID_NUMBER, Long.valueOf(this.m_lastSessionIDNumber));
persistenceForNimbleComponent.setValue(PERSISTENCE_TOTAL_SESSION_COUNT, Long.valueOf(this.m_totalSessions));
persistenceForNimbleComponent.setValue(PERSISTENCE_QUEUED_SESSIONS_ID, this.m_sessionsToPost);
persistenceForNimbleComponent.setValue(PERSISTENCE_TRACKING_ATTRIBUTES, this.m_trackingAttributes);
} catch (OutOfMemoryError e) {
Log.Helper.LOGE(this, "OutOfMemoryError in saving m_sessionsToPost to persistence! MaxQueueLength is %s. Exception: %s", Integer.valueOf(this.m_maxQueueLength), e.getLocalizedMessage());
}
persistenceForNimbleComponent.lambda$new$0();
Persistence persistenceForNimbleComponent2 = PersistenceService.getPersistenceForNimbleComponent(getComponentId(), Persistence.Storage.DOCUMENT);
Log.Helper.LOGD(this, "Saving tracking enable/disable flag to persistence (document storage).", new Object[0]);
if (!persistenceForNimbleComponent2.getBackUp()) {
persistenceForNimbleComponent2.setBackUp(true);
}
persistenceForNimbleComponent2.setValue(PERSISTENCE_ENABLE_FLAG, Boolean.valueOf(this.m_enable));
persistenceForNimbleComponent2.lambda$new$0();
} catch (Throwable th) {
Log.Helper.LOGE(this, "Caught generic throwable while saving to persistence! Discarding attempt to save. Exception: %s", th.getLocalizedMessage());
}
}
private void configureTrackingOnFirstInstall() {
Log.Helper.LOGFUNC(this);
Log.Helper.LOGD(this, "First Install. Look for App Settings to enable/disable tracking", new Object[0]);
String configValueAsString = NimbleApplicationConfiguration.getConfigValueAsString(Tracking.NIMBLE_TRACKING_DEFAULTENABLE);
if (Utility.validString(configValueAsString)) {
if (configValueAsString.equalsIgnoreCase(a.j)) {
Log.Helper.LOGD(this, "Default App Setting : Enable Tracking", new Object[0]);
this.m_enable = true;
return;
} else {
if (configValueAsString.equalsIgnoreCase("disable")) {
Log.Helper.LOGD(this, "Default App Setting : Disable Tracking", new Object[0]);
this.m_enable = false;
return;
}
return;
}
}
android.util.Log.e(Global.NIMBLE_ID, "WARNING! Cannot find valid TrackingEnable from AndroidManifest.xml");
}
public void addObserverForSynergyEnvironmentUpdateFinished() {
Log.Helper.LOGFUNC(this);
if (this.m_receiver == null) {
StartupRequestsFinishedReceiver startupRequestsFinishedReceiver = new StartupRequestsFinishedReceiver();
this.m_receiver = startupRequestsFinishedReceiver;
Utility.registerReceiver(SynergyEnvironment.NOTIFICATION_STARTUP_REQUESTS_FINISHED, startupRequestsFinishedReceiver);
}
}
/* JADX INFO: Access modifiers changed from: private */
public void onStartupRequestsFinished(Intent intent) {
Map<String, Object> map;
Log.Helper.LOGFUNC(this);
if (intent.getExtras() == null || !intent.getExtras().getString("result").equals("1")) {
return;
}
int trackingPostInterval = SynergyEnvironment.getComponent().getTrackingPostInterval();
if (trackingPostInterval < 0 || trackingPostInterval == -1) {
this.m_postInterval = 1.0d;
} else {
this.m_postInterval = trackingPostInterval;
}
ArrayList<TrackingBaseSessionObject> arrayList = this.m_sessionsToPost;
if (arrayList != null) {
Iterator<TrackingBaseSessionObject> it = arrayList.iterator();
while (it.hasNext()) {
TrackingBaseSessionObject next = it.next();
if (next != null && (map = next.sessionData) != null) {
Object obj = map.get(SynergyCatalog.MTX_INFO_KEY_SELLID);
if (obj instanceof String) {
String str = (String) obj;
if (Utility.validString(str) && !str.equals("0")) {
String sellId = SynergyEnvironment.getComponent().getSellId();
next.sessionData.put(SynergyCatalog.MTX_INFO_KEY_SELLID, Utility.safeString(sellId));
if (sellId == null || sellId.equals("") || sellId.equals("0")) {
Log.Helper.LOGE(this, "Sell Id was still null after synergy update", new Object[0]);
}
}
}
Object obj2 = next.sessionData.get("hwId");
if ((obj2 instanceof String) && Utility.validString((String) obj2)) {
String eAHardwareId = SynergyEnvironment.getComponent().getEAHardwareId();
next.sessionData.put("hwId", Utility.safeString(eAHardwareId));
if (eAHardwareId == null || eAHardwareId.equals("")) {
Log.Helper.LOGE(this, "Hardware Id was still null after synergy update", new Object[0]);
}
}
Object obj3 = next.sessionData.get("deviceId");
if (obj3 instanceof String) {
String str2 = (String) obj3;
if (Utility.validString(str2) && !str2.equals("0")) {
String eADeviceId = SynergyEnvironment.getComponent().getEADeviceId();
next.sessionData.put("deviceId", Utility.safeString(eADeviceId));
if (eADeviceId == null || eADeviceId.equals("") || eADeviceId.equals("0")) {
Log.Helper.LOGE(this, "Device Id was still null after synergy update", new Object[0]);
}
}
}
Object obj4 = next.sessionData.get("synergyId");
if (obj4 instanceof String) {
String str3 = (String) obj4;
if (Utility.validString(str3) && !str3.equals("0")) {
String synergyId = SynergyEnvironment.getComponent().getSynergyId();
next.sessionData.put("synergyId", Utility.safeString(synergyId));
if (synergyId == null || synergyId.equals("") || synergyId.equals("0")) {
Log.Helper.LOGE(this, "Synergy Id was still null after synergy update", new Object[0]);
}
}
}
}
}
}
Log.Helper.LOGI(this, "Synergy environment update successful. Removing observer and re-attempting event post.", new Object[0]);
StartupRequestsFinishedReceiver startupRequestsFinishedReceiver = this.m_receiver;
if (startupRequestsFinishedReceiver != null) {
Utility.unregisterReceiver(startupRequestsFinishedReceiver);
this.m_receiver = null;
}
if (this.m_isPostPending) {
this.m_isPostPending = false;
resetPostTimer(NOW_POST_INTERVAL);
}
}
public class StartupRequestsFinishedReceiver extends BroadcastReceiver {
private StartupRequestsFinishedReceiver() {
}
@Override // android.content.BroadcastReceiver
public void onReceive(Context context, final Intent intent) {
Log.Helper.LOGPUBLICFUNC(this);
if (intent.getAction().equals(SynergyEnvironment.NOTIFICATION_STARTUP_REQUESTS_FINISHED)) {
NimbleTrackingImplBase.this.updateFeatureDisableState();
NimbleTrackingImplBase.this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingImplBase.StartupRequestsFinishedReceiver.1
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingImplBase.this.onStartupRequestsFinished(intent);
}
});
}
}
}
/* JADX INFO: Access modifiers changed from: private */
public void onOriginLoginStatusChanged(Intent intent) {
Log.Helper.LOGFUNC(this);
if (intent.getExtras() != null) {
String string = intent.getExtras().getString(ORIGIN_NOTIFICATION_LOGIN_STATUS_UPDATE_KEY_STATUS);
if (string.equals(ORIGIN_LOGIN_STATUS_STRING_LIVE_USER) || string.equals(ORIGIN_LOGIN_STATUS_STRING_AUTO_LOGGING_IN)) {
Log.Helper.LOGI(this, "Login status update, TRUE", new Object[0]);
this.m_loggedInToOrigin = true;
return;
} else {
Log.Helper.LOGI(this, "Login status update, FALSE", new Object[0]);
this.m_loggedInToOrigin = false;
return;
}
}
Log.Helper.LOGI(this, "Login status updated event received without extras bundle. Marking NOT logged in to Origin.", new Object[0]);
this.m_loggedInToOrigin = false;
}
public class OriginLoginStatusChangedReceiver extends BroadcastReceiver {
private OriginLoginStatusChangedReceiver() {
}
@Override // android.content.BroadcastReceiver
public void onReceive(Context context, final Intent intent) {
Log.Helper.LOGPUBLICFUNC(this);
if (intent.getAction().equals(Global.NOTIFICATION_LOGIN_STATUS_CHANGE)) {
NimbleTrackingImplBase.this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingImplBase.OriginLoginStatusChangedReceiver.1
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingImplBase.this.onOriginLoginStatusChanged(intent);
}
});
}
}
}
@Override // com.ea.nimble.tracking.ITracking
public void addCustomSessionData(String str, String str2) {
Log.Helper.LOGPUBLICFUNC(this);
if (Utility.validString(str) && Utility.validString(str2)) {
SessionData sessionData = new SessionData();
sessionData.key = str;
sessionData.value = str2;
this.m_customSessionData.add(sessionData);
saveSessionDataToPersistent();
}
}
@Override // com.ea.nimble.tracking.ITracking
public void removeCustomSessionData(String str) {
Log.Helper.LOGPUBLICFUNC(this);
if (Utility.validString(str)) {
Iterator<SessionData> it = this.m_customSessionData.iterator();
while (true) {
if (!it.hasNext()) {
break;
}
SessionData next = it.next();
if (next.key.equals(str)) {
this.m_customSessionData.remove(next);
break;
}
}
saveSessionDataToPersistent();
}
}
@Override // com.ea.nimble.tracking.ITracking
public void clearCustomSessionData() {
Log.Helper.LOGPUBLICFUNC(this);
}
@Override // com.ea.nimble.tracking.ITracking
public String getSessionId() {
Log.Helper.LOGPUBLICFUNC(this);
return "";
}
private void saveSessionDataToPersistent() {
Log.Helper.LOGFUNC(this);
Persistence persistenceForNimbleComponent = PersistenceService.getPersistenceForNimbleComponent(getComponentId(), Persistence.Storage.CACHE);
Log.Helper.LOGI(this, "Saving event queue to persistence.", new Object[0]);
persistenceForNimbleComponent.setValue(PERSISTENCE_SESSION_DATA_ID, this.m_customSessionData);
persistenceForNimbleComponent.lambda$new$0();
}
public boolean isAbleToPostEvent(boolean z) {
Log.Helper.LOGFUNC(this);
if (!this.m_enable || this.m_isFeatureDisabledFromServer || !this.m_postEnable) {
return false;
}
if (!z && !ApplicationEnvironment.isMainApplicationActive()) {
Log.Helper.LOGD(this, "isAbleToPostEvent - return because the app is in background", new Object[0]);
return false;
}
if (Network.getComponent().getStatus() == Network.Status.OK) {
if (SynergyEnvironment.getComponent().isDataAvailable()) {
return true;
}
this.m_isPostPending = true;
addObserverForSynergyEnvironmentUpdateFinished();
return false;
}
if (this.m_networkStatusChangedReceiver == null) {
Log.Helper.LOGD(this, "Network status not OK for event post. Adding receiver for network status change.", new Object[0]);
killPostTimer();
BroadcastReceiver broadcastReceiver = new BroadcastReceiver() { // from class: com.ea.nimble.tracking.NimbleTrackingImplBase.1
@Override // android.content.BroadcastReceiver
public void onReceive(Context context, Intent intent) {
Log.Helper.LOGPUBLICFUNC(this);
if (intent.getAction().equals(Global.NOTIFICATION_NETWORK_STATUS_CHANGE)) {
NimbleTrackingImplBase.this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingImplBase.1.1
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingImplBase.this.onNetworkStatusChange();
}
});
}
}
};
this.m_networkStatusChangedReceiver = broadcastReceiver;
Utility.registerReceiver(Global.NOTIFICATION_NETWORK_STATUS_CHANGE, broadcastReceiver);
}
return false;
}
@Override // com.ea.nimble.tracking.ITracking
public void setPostEnable(boolean z) {
Log.Helper.LOGPUBLICFUNC(this);
if (this.m_postEnable != z) {
this.m_postEnable = z;
Persistence persistenceForNimbleComponent = PersistenceService.getPersistenceForNimbleComponent(getComponentId(), Persistence.Storage.DOCUMENT);
persistenceForNimbleComponent.setValue(PERSISTENCE_POST_ENABLE_FLAG, Boolean.valueOf(this.m_postEnable));
persistenceForNimbleComponent.lambda$new$0();
if (isAbleToPostEvent(false)) {
resetPostTimer();
}
}
}
@Override // com.ea.nimble.tracking.ITracking
public boolean getPostEnable() {
Log.Helper.LOGPUBLICFUNC(this);
return this.m_postEnable;
}
/* JADX INFO: Access modifiers changed from: private */
public void onNetworkStatusChange() {
Log.Helper.LOGFUNC(this);
if (Network.getComponent().getStatus() == Network.Status.OK) {
Log.Helper.LOGD(this, "Network status restored, kicking off event post.", new Object[0]);
Utility.unregisterReceiver(this.m_networkStatusChangedReceiver);
this.m_networkStatusChangedReceiver = null;
resetPostTimer(NOW_POST_INTERVAL);
}
}
/* JADX INFO: Access modifiers changed from: private */
public void postIntervalTimerExpired(boolean z) {
Log.Helper.LOGFUNC(this);
if (z) {
packageCurrentSession();
}
postPendingEvents(false);
}
@Override // com.ea.nimble.tracking.ITracking
public void setTrackingAttribute(String str, String str2) {
Log.Helper.LOGPUBLICFUNC(this);
if (Utility.validString(str) && Utility.validString(str2)) {
this.m_trackingAttributes.put(str, str2);
}
}
public void queueCurrentEventsForPost() {
Log.Helper.LOGFUNC(this);
Log.Helper.LOGI(this, "queueCurrentEventsForPost called. Starting queue size: %d", Integer.valueOf(this.m_sessionsToPost.size()));
if (this.m_sessionsToPost == null) {
this.m_sessionsToPost = new ArrayList<>();
}
TrackingBaseSessionObject trackingBaseSessionObject = this.m_currentSessionObject;
if (trackingBaseSessionObject == null) {
Log.Helper.LOGE(this, "Unexpected state, currentSessionObject is null.", new Object[0]);
} else if (trackingBaseSessionObject.countOfEvents() == 0) {
Log.Helper.LOGE(this, "Unexpected state, currentSessionObject events list is null or empty.", new Object[0]);
} else {
addCurrentSessionObjectToBackOfQueue();
dropExtraSessions();
}
this.m_currentSessionObject = new TrackingBaseSessionObject(new HashMap(this.m_currentSessionObject.sessionData));
saveToPersistence();
}
private void saveSessionToFile(TrackingBaseSessionObject trackingBaseSessionObject, long j) {
Log.Helper.LOGFUNC(this);
String filenameForSessionID = getFilenameForSessionID(j);
Persistence persistenceForNimbleComponent = PersistenceService.getPersistenceForNimbleComponent(filenameForSessionID, Persistence.Storage.DOCUMENT);
if (persistenceForNimbleComponent.getBackUp()) {
persistenceForNimbleComponent.setBackUp(false);
}
try {
persistenceForNimbleComponent.setValue(PERSISTENCE_SAVED_SESSION_ID_NUMBER, trackingBaseSessionObject);
} catch (OutOfMemoryError e) {
Log.Helper.LOGE(this, "OutOfMemoryError occurred while saving a session object to file. Exception: %s", e.getLocalizedMessage());
}
persistenceForNimbleComponent.lambda$new$0();
PersistenceService.cleanReferenceToPersistence(filenameForSessionID, Persistence.Storage.DOCUMENT);
}
private TrackingBaseSessionObject loadSessionFromFile(long j) {
Serializable value;
Log.Helper.LOGFUNC(this);
Persistence persistenceForNimbleComponent = PersistenceService.getPersistenceForNimbleComponent(getFilenameForSessionID(j), Persistence.Storage.DOCUMENT);
if (persistenceForNimbleComponent == null || (value = persistenceForNimbleComponent.getValue(PERSISTENCE_SAVED_SESSION_ID_NUMBER)) == null || value.getClass() != TrackingBaseSessionObject.class) {
return null;
}
return (TrackingBaseSessionObject) value;
}
private String getFilenameForSessionID(long j) {
Log.Helper.LOGFUNC(this);
if (j < 0) {
Log.Helper.LOGE(this, "Trying to find the filename for an invalid sessionID!", new Object[0]);
return null;
}
return String.format(Locale.US, SESSION_FILE_FORMAT, getComponentId(), Long.valueOf(j));
}
public void removeSessionAndFillQueue(TrackingBaseSessionObject trackingBaseSessionObject) {
Log.Helper.LOGFUNC(this);
this.m_sessionsToPost.remove(trackingBaseSessionObject);
this.m_firstSessionIDNumber++;
this.m_totalSessions--;
fillSessionsToPost();
saveToPersistence();
}
private void addCurrentSessionObjectToBackOfQueue() {
Log.Helper.LOGFUNC(this);
this.m_lastSessionIDNumber++;
this.m_totalSessions++;
if (this.m_sessionsToPost.size() >= this.m_maxQueueLength) {
saveSessionToFile(this.m_currentSessionObject, this.m_lastSessionIDNumber);
} else {
this.m_sessionsToPost.add(this.m_currentSessionObject);
}
saveToPersistence();
}
private void fillSessionsToPost() {
Log.Helper.LOGFUNC(this);
for (int size = this.m_sessionsToPost.size(); size < this.m_maxQueueLength; size++) {
long j = this.m_firstSessionIDNumber + size;
if (j > this.m_lastSessionIDNumber) {
return;
}
TrackingBaseSessionObject loadSessionFromFile = loadSessionFromFile(j);
if (loadSessionFromFile != null) {
this.m_sessionsToPost.add(loadSessionFromFile);
PersistenceService.removePersistenceForNimbleComponent(getFilenameForSessionID(j), Persistence.Storage.DOCUMENT);
} else {
this.m_firstSessionIDNumber++;
}
}
}
private void dropExtraSessions() {
Log.Helper.LOGFUNC(this);
if (dropExtraSessions(true)) {
return;
}
Log.Helper.LOGD(this, "Failed to drop enough sessions. Dropping sessions without checking canDropSession.", new Object[0]);
if (dropExtraSessions(false)) {
return;
}
Log.Helper.LOGE(this, "Still unable to drop enough sessions. Remaining number: " + ((this.m_lastSessionIDNumber - this.m_firstSessionIDNumber) + 1), new Object[0]);
}
private void dropSessions(ArrayList<TrackingBaseSessionObject> arrayList, long j) {
Log.Helper.LOGFUNC(this);
for (int i = 0; i < arrayList.size(); i++) {
this.m_sessionsToPost.remove(arrayList.get(i));
PersistenceService.removePersistenceForNimbleComponent(getFilenameForSessionID(j - i), Persistence.Storage.DOCUMENT);
}
long size = (j - arrayList.size()) + 1;
long j2 = this.m_firstSessionIDNumber;
if (size == j2) {
this.m_firstSessionIDNumber = j2 + arrayList.size();
}
this.m_totalSessions -= arrayList.size();
saveToPersistence();
}
private boolean dropExtraSessions(boolean z) {
TrackingBaseSessionObject loadSessionFromFile;
Log.Helper.LOGFUNC(this);
long j = this.m_totalSessions;
if (j < 50) {
return true;
}
Log.Helper.LOGD(this, "Current number of sessions (%d) has reached maximum (%d). Removing old sessions.", Long.valueOf(j), 50);
ArrayList<TrackingBaseSessionObject> arrayList = new ArrayList<>();
long j2 = this.m_firstSessionIDNumber;
while (j2 <= this.m_lastSessionIDNumber) {
long j3 = j2 - this.m_firstSessionIDNumber;
if (j3 < this.m_sessionsToPost.size()) {
loadSessionFromFile = this.m_sessionsToPost.get((int) j3);
} else {
loadSessionFromFile = loadSessionFromFile(j2);
if (loadSessionFromFile == null) {
continue;
j2++;
}
}
if (arrayList.size() == 0 || isSameSession(arrayList.get(arrayList.size() - 1), loadSessionFromFile)) {
arrayList.add(loadSessionFromFile);
} else {
if (!z || canDropSession(arrayList)) {
dropSessions(arrayList, j2 - 1);
}
arrayList.clear();
if (this.m_totalSessions < 50) {
fillSessionsToPost();
return true;
}
arrayList.add(loadSessionFromFile);
}
j2++;
}
if (arrayList.size() > 0 && (!z || canDropSession(arrayList))) {
dropSessions(arrayList, j2 - 1);
}
fillSessionsToPost();
return this.m_totalSessions < 50;
}
public boolean isSameSession(TrackingBaseSessionObject trackingBaseSessionObject, TrackingBaseSessionObject trackingBaseSessionObject2) {
Log.Helper.LOGFUNC(this);
return false;
}
public boolean canDropSession(List<TrackingBaseSessionObject> list) {
Log.Helper.LOGFUNC(this);
return true;
}
/* JADX INFO: Access modifiers changed from: private */
public void updateFeatureDisableState() {
Log.Helper.LOGFUNC(this);
if (SynergyEnvironment.getComponent().isDataAvailable()) {
boolean isFeatureDisabled = SynergyEnvironment.getComponent().isFeatureDisabled(getFeatureTag());
this.m_isFeatureDisabledFromServer = isFeatureDisabled;
if (isFeatureDisabled) {
Log.Helper.LOGI(this, "*** FEATURE DISABLED FROM SERVER ***", new Object[0]);
}
}
}
}

16
decompiled/sources/com/ea/nimble/tracking/NimbleTrackingSynergyComponent.java Normal file
View File

@@ -0,0 +1,16 @@
package com.ea.nimble.tracking;
import com.ea.nimble.Base;
/* loaded from: classes2.dex */
class NimbleTrackingSynergyComponent extends NimbleTrackingThreadProxy {
static final String COMPONENT_ID = "com.ea.nimble.trackingimpl.synergy";
public static void initialize() {
Base.registerComponent(new NimbleTrackingSynergyComponent(), "com.ea.nimble.trackingimpl.synergy");
}
private NimbleTrackingSynergyComponent() {
super(new NimbleTrackingSynergyImpl());
}
}

5
decompiled/sources/com/ea/nimble/tracking/NimbleTrackingSynergyImpl$$ExternalSyntheticApiModelOutline0.java Normal file
View File

@@ -0,0 +1,5 @@
package com.ea.nimble.tracking;
/* loaded from: classes2.dex */
public abstract /* synthetic */ class NimbleTrackingSynergyImpl$$ExternalSyntheticApiModelOutline0 {
}

718
decompiled/sources/com/ea/nimble/tracking/NimbleTrackingSynergyImpl.java Normal file
View File

@@ -0,0 +1,718 @@
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) {
}
}
}

124
decompiled/sources/com/ea/nimble/tracking/NimbleTrackingThreadManager.java Normal file
View File

@@ -0,0 +1,124 @@
package com.ea.nimble.tracking;
import com.ea.nimble.Log;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/* loaded from: classes2.dex */
class NimbleTrackingThreadManager {
private static NimbleTrackingThreadManager s_instance;
private static int s_instanceRefs;
private final ScheduledExecutorService m_executor = new ScheduledThreadPoolExecutor(1) { // from class: com.ea.nimble.tracking.NimbleTrackingThreadManager.1
@Override // java.util.concurrent.ThreadPoolExecutor
public void afterExecute(Runnable runnable, Throwable th) {
Log.Helper.LOGFUNC(this);
super.afterExecute(runnable, th);
if (th == null && (runnable instanceof Future)) {
Future future = (Future) runnable;
if (!future.isCancelled()) {
try {
future.get();
} catch (InterruptedException unused) {
Thread.currentThread().interrupt();
} catch (ExecutionException e) {
th = e.getCause();
}
}
}
if (th != null) {
if (th instanceof Error) {
throw ((Error) th);
}
if (th instanceof RuntimeException) {
throw ((RuntimeException) th);
}
Log.Helper.LOGES("TrackingThreadManager", "Checked exception thrown from Tracking thread:", new Object[0]);
th.printStackTrace();
}
}
};
public static abstract class BlockingRunner {
private boolean m_done = false;
public abstract void run();
public BlockingRunner() {
Log.Helper.LOGPUBLICFUNC(this);
run();
waitUntilDone();
}
public void setDone() {
Log.Helper.LOGFUNC(this);
synchronized (this) {
this.m_done = true;
notifyAll();
}
}
private void waitUntilDone() {
Log.Helper.LOGFUNC(this);
if (this.m_done) {
return;
}
synchronized (this) {
while (!this.m_done) {
try {
wait();
} catch (InterruptedException unused) {
}
}
}
}
}
public static NimbleTrackingThreadManager acquireInstance() {
if (s_instance == null) {
s_instance = new NimbleTrackingThreadManager();
}
s_instanceRefs++;
return s_instance;
}
public static void releaseInstance() {
int i = s_instanceRefs - 1;
s_instanceRefs = i;
if (i == 0) {
s_instance.shutdown();
s_instance = null;
}
}
public ScheduledFuture<?> createTimer(double d, Runnable runnable) {
return this.m_executor.schedule(runnable, (long) (d * 1000.0d), TimeUnit.MILLISECONDS);
}
public void runInWorkerThread(Runnable runnable) {
runInWorkerThread(false, runnable);
}
public void runInWorkerThread(boolean z, Runnable runnable) {
if (z) {
try {
this.m_executor.submit(runnable).get();
return;
} catch (InterruptedException unused) {
Thread.currentThread().interrupt();
return;
} catch (ExecutionException unused2) {
return;
}
}
this.m_executor.execute(runnable);
}
private void shutdown() {
Log.Helper.LOGFUNC(this);
this.m_executor.shutdown();
}
}

191
decompiled/sources/com/ea/nimble/tracking/NimbleTrackingThreadProxy.java Normal file
View File

@@ -0,0 +1,191 @@
package com.ea.nimble.tracking;
import com.ea.nimble.Component;
import com.ea.nimble.Log;
import java.util.Map;
/* loaded from: classes2.dex */
public abstract class NimbleTrackingThreadProxy extends Component implements ITracking {
private final NimbleTrackingImplBase m_impl;
private NimbleTrackingThreadManager m_threadManager;
public NimbleTrackingThreadProxy(NimbleTrackingImplBase nimbleTrackingImplBase) {
Log.Helper.LOGFUNC(this);
this.m_impl = nimbleTrackingImplBase;
}
@Override // com.ea.nimble.Component
public void setup() {
Log.Helper.LOGFUNC(this);
NimbleTrackingThreadManager acquireInstance = NimbleTrackingThreadManager.acquireInstance();
this.m_threadManager = acquireInstance;
acquireInstance.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.1
@Override // java.lang.Runnable
public void run() {
NimbleTrackingThreadProxy.this.m_impl.setup();
}
});
}
@Override // com.ea.nimble.Component
public void restore() {
Log.Helper.LOGFUNC(this);
this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.2
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.restore();
}
});
}
@Override // com.ea.nimble.Component
public void suspend() {
Log.Helper.LOGFUNC(this);
this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.3
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.suspend();
}
});
}
@Override // com.ea.nimble.Component
public void resume() {
Log.Helper.LOGFUNC(this);
this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.4
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.resume();
}
});
}
@Override // com.ea.nimble.Component
public void cleanup() {
Log.Helper.LOGFUNC(this);
this.m_threadManager.runInWorkerThread(true, new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.5
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.cleanup();
}
});
}
@Override // com.ea.nimble.Component
public void teardown() {
Log.Helper.LOGFUNC(this);
this.m_threadManager.runInWorkerThread(true, new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.6
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.teardown();
}
});
NimbleTrackingThreadManager.releaseInstance();
this.m_threadManager = null;
}
@Override // com.ea.nimble.tracking.ITracking
public void setEnable(final boolean z) {
Log.Helper.LOGPUBLICFUNC(this);
this.m_threadManager.runInWorkerThread(true, new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.7
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.setEnable(z);
}
});
}
@Override // com.ea.nimble.tracking.ITracking
public boolean getEnable() {
Log.Helper.LOGPUBLICFUNC(this);
return this.m_impl.getEnable();
}
@Override // com.ea.nimble.tracking.ITracking
public boolean getPostEnable() {
Log.Helper.LOGPUBLICFUNC(this);
return this.m_impl.getPostEnable();
}
@Override // com.ea.nimble.tracking.ITracking
public void setPostEnable(final boolean z) {
Log.Helper.LOGPUBLICFUNC(this);
this.m_threadManager.runInWorkerThread(true, new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.8
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.setPostEnable(z);
}
});
}
@Override // com.ea.nimble.tracking.ITracking
public void logEvent(final String str, final Map<String, String> map) {
Log.Helper.LOGPUBLICFUNC(this);
this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.9
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.logEvent(str, map);
}
});
}
@Override // com.ea.nimble.tracking.ITracking
public void addCustomSessionData(final String str, final String str2) {
Log.Helper.LOGPUBLICFUNC(this);
this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.10
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.addCustomSessionData(str, str2);
}
});
}
@Override // com.ea.nimble.tracking.ITracking
public void removeCustomSessionData(final String str) {
Log.Helper.LOGPUBLICFUNC(this);
this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.11
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.removeCustomSessionData(str);
}
});
}
@Override // com.ea.nimble.tracking.ITracking
public void clearCustomSessionData() {
Log.Helper.LOGPUBLICFUNC(this);
}
@Override // com.ea.nimble.tracking.ITracking
public String getSessionId() {
Log.Helper.LOGPUBLICFUNC(this);
return this.m_impl.getSessionId();
}
@Override // com.ea.nimble.tracking.ITracking
public void setTrackingAttribute(final String str, final String str2) {
Log.Helper.LOGPUBLICFUNC(this);
this.m_threadManager.runInWorkerThread(new Runnable() { // from class: com.ea.nimble.tracking.NimbleTrackingThreadProxy.12
@Override // java.lang.Runnable
public void run() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingThreadProxy.this.m_impl.setTrackingAttribute(str, str2);
}
});
}
@Override // com.ea.nimble.Component
public String getComponentId() {
return this.m_impl.getComponentId();
}
}

7
decompiled/sources/com/ea/nimble/tracking/R.java Normal file
View File

@@ -0,0 +1,7 @@
package com.ea.nimble.tracking;
/* loaded from: classes2.dex */
public final class R {
private R() {
}
}

321
decompiled/sources/com/ea/nimble/tracking/SynergyConstants.java Normal file
View File

@@ -0,0 +1,321 @@
package com.ea.nimble.tracking;
import com.google.android.gms.auth.blockstore.BlockstoreStatusCodes;
import com.google.android.gms.games.GamesActivityResultCodes;
import com.ironsource.mediationsdk.utils.IronSourceConstants;
import com.vungle.ads.VungleError;
import com.vungle.ads.internal.protos.Sdk;
/* loaded from: classes2.dex */
public enum SynergyConstants {
EVT_UNDEFINED(-1),
EVT_APP_START_NORMALLY(10000),
EVT_APP_START_FROMPUSH(10001),
EVT_APP_START_AFTERINSTALL(10002),
EVT_APP_START_AFTERUPGRADE(10003),
EVT_APP_RESUME_NORMAL(GamesActivityResultCodes.RESULT_APP_MISCONFIGURED),
EVT_APP_SESSION_TIME(10005),
EVT_APP_RESUME_FROM_PUSH(10007),
EVT_APP_START_FROM_URL(10009),
EVT_APP_RESUME_FROM_URL(VungleError.AD_UNABLE_TO_PLAY),
EVT_NEW_SESSION_START_SYNERGYID_CHANGE(10012),
EVT_IDENTITY_MIGRATION(12000),
EVT_IDENTITY_LOGIN(12001),
EVT_IDENTITY_LOGOUT(12002),
EVT_IDENTITY_MIGRATION_STARTED(12003),
EVT_APP_END_NORMALLY(20000),
EVT_APP_END_ABNORMALLY(Sdk.SDKError.Reason.AD_SERVER_ERROR_VALUE),
EVT_APP_INTERRUPTED(20002),
EVT_APP_SESSION_END(20003),
EVT_APP_RESUME_FROM_EBISU(20004),
EVT_APP_SESSION_START_EMBED(20005),
EVT_EMBED_OTD_UPGRADE(20006),
EVT_SESSION_END_SYNERGYID_CHANGE(20007),
EVT_USER_SHOWN_PN_OPTIN_PROMPT(20008),
EVT_PN_SHOWN_TO_USER(20009),
EVT_PN_RECEIVED(20015),
EVT_PN_DEVICE_REGISTERED(20016),
EVT_OPT_FULL_PURCHASE(30000),
EVT_MOREGAMES_ENTER(Sdk.SDKError.Reason.AD_PUBLISHER_MISMATCH_VALUE),
EVT_MOREGAMES_CLICKTHROUGH(Sdk.SDKError.Reason.AD_INTERNAL_INTEGRATION_ERROR_VALUE),
EVT_MOREGAMES_GAMESELECT(30004),
EVT_MOREGAMES_CATEGORYSELECT(30005),
EVT_MOREGAMES_OVERLAY_APPEARS(30006),
EVT_MOREGAMES_OVERLAY_BUYCLICK(30007),
EVT_ENTER_FULL_GAME_OVERVIEW_SCREEN(30008),
EVT_LITE_ED_GAME_DEMO_START(30009),
EVT_LITE_ED_GAME_DEMO_END(30010),
EVT_MAINMENU_BANNER_CLICK(30011),
EVT_MAINMENU_TICKER_CLICK(30012),
EVT_INSTORE_BANNER_CLICK(30013),
EVT_INSTORE_TICKER_CLICK(30014),
EVT_FEATURED_BANNER_CLICK(30015),
EVT_MOREGAMES_CLICKTHROUGH_FEATURED(30017),
EVT_MOREGAMES_CLICKTHROUGH_SIDEBANNER(30018),
EVT_IPAD_UPSELL_MESSAGE_DISPLAYED(30019),
EVT_IPAD_UPSELL_MESSAGE_NOTHANKS_CLICKED(30020),
EVT_IPAD_UPSELL_MESSAGE_OK_CLICKED(30021),
EVT_IPAD_UPSELL_MESSAGE_LATER_CLICKED(30022),
EVT_UPSELL_VIDEO_CLICKED(30023),
EVT_USER_TRACKING_OPTOUT(30024),
EVT_GAMEPLAY_PROGRESSION_SPGAME_START(30025),
EVT_GAMEPLAY_PROGRESSION_SPGAME_RESTART(30026),
EVT_GAMEPLAY_PROGRESSION_SPGAME_SAVE(30027),
EVT_GAMEPLAY_PROGRESSION_SPGAME_CONTINUE(30028),
EVT_GAMEPLAY_PROGRESSION_SPGAME_QUIT(30029),
EVT_GAMEPLAY_PROGRESSION_SPGAME_COMPLETE(30030),
EVT_GAMEPLAY_PROGRESSION_SPGAME_TIME_SPENT(30031),
EVT_GAMEPLAY_PROGRESSION_SPGAME_SCORE(30032),
EVT_GAMEPLAY_PROGRESSION_TUTORIAL_SKIP(30033),
EVT_GAMEPLAY_PROGRESSION_TUTORIAL_COMPLETE(30034),
EVT_GAMEPLAY_PROGRESSION_CUTSCENE_SKIP(30035),
EVT_GAMEPLAY_PROGRESSION_CONTROLSCHEME_USED(30036),
EVT_GAMEPLAY_PROGRESSION_CHARACTER(30037),
EVT_GAMEPLAY_PROGRESSION_MPGAME_START(30038),
EVT_GAMEPLAY_PROGRESSION_MPGAME_QUIT(30039),
EVT_GAMEPLAY_PROGRESSION_MPGAME_DISCONNECT(30040),
EVT_GAMEPLAY_PROGRESSION_MPGAME_COMPLETE(30041),
EVT_GAMEPLAY_PROGRESSION_MPGAME_TIME_SPENT(30042),
EVT_MULTITASKING_USER_APP_MINIMIZED(30043),
EVT_MULTITASKING_USER_APP_RESUMED(30044),
EVT_MULTITASKING_USER_START_TUTORIAL(30045),
EVT_MTXVIEW_ENTER(BlockstoreStatusCodes.MAX_SIZE_EXCEEDED),
EVT_MTXVIEW_GAMECATEGORY(BlockstoreStatusCodes.TOO_MANY_ENTRIES),
EVT_MTXVIEW_ITEMSELECT(BlockstoreStatusCodes.FEATURE_NOT_SUPPORTED),
EVT_MTXVIEW_ITEMPURCHASE(40003),
EVT_MTXVIEW_ENTER_FROMCTX(40004),
EVT_MTXVIEW_FREEITEM_DOWNLOADED(40005),
EVT_MTXVIEW_ITEM_PURCHASED(40006),
EVT_IAC_MTX_ITEM_USED(40007),
EVT_MTXVIEW_ITEM_PURCHASED_REFERRERDATA(40008),
EVT_MTXVIEW_ITEMPURCHASE_SLOTDATA(40009),
EVT_MTXVIEW_ITEDISPLAYED(40010),
EVT_IGE_FREE_CREDITS_EARNED(40011),
EVT_IGE_PAID_CREDITS_EARNED(40012),
EVT_IGE_GIFT_RECEIVED(40013),
EVT_IGE_GIFT_SENT(40014),
EVT_IGE_FREE_CREDITS_ITEMS_CLICK(40015),
EVT_IGE_PAID_CREDITS_ITEMS_CLICK(40016),
EVT_IGE_STORE_VISIT(40017),
EVT_IGE_PAID_CREDITS_PURCHASE_REVENUE(40018),
EVT_IGE_PAID_CREDITS_PURCHASE_LEVEL(40019),
EVT_IGE_FREE_CREDITS_PURCHASE_REVENUE(40020),
EVT_IGE_FREE_CREDITS_PURCHASE_LEVEL(40021),
EVT_IGE_GAME_START_CASH_DETAIL(40022),
EVT_OFFERWALL_ITEM_REDEEMED_STORE_EAL(40023),
EVT_OFFERWALL_ITEM_REDEEMED_USER_LEVEL_EAL(40024),
EVT_OFFERWALL_ITEM_CLICK_EAL(40025),
EVT_OFFERWALL_STORE_VISIT_EAL(40026),
EVT_INGAME_AD_CLICK(40027),
EVT_INGAME_LEVEL_FREE_CREDITS_COUNT(40028),
EVT_INGAME_LEVEL_PAID_CREDITS_COUNT(40029),
EVT_USER_LEVEL_MTX_ITEM_PURCHASED(40030),
EVT_IGE_GAME_START_FREE_CREDIT(40031),
EVT_IGE_GAME_START_PAID_CREDIT(40032),
EVT_INGAME_EMAIL_OPEN(50001),
EVT_INGAME_EMAIL_SEND(50002),
EVT_INGAME_EMAIL_RECEIEVE(50003),
EVT_MEDIAPICKER_OPEN(50004),
EVT_ACCESS_BT_MENU(50005),
EVT_BEGIN_BT_SESSION(50006),
EVT_COMPLETE_BT_SESSION(50007),
EVT_ACCESS_WIFI_MENU(50008),
EVT_BEGIN_WIFI_SESSION(50009),
EVT_COMPLETE_WIFI_SESSION(50010),
EVT_USR_ISSUE_PUSH_NOTIFICATION_CHALLENGE(50011),
EVT_LANGUAGE_SELECTED(50012),
EVT_MENU_PROGRESSION_MAINMENU_SELECTED(50013),
EVT_MENU_PROGRESSION_MAINMENU_SUBMENU_SELECTED(50014),
EVT_MENU_PROGRESSION_GAMEMENU_SELECTED(50015),
EVT_MENU_PROGRESSION_GAMEMENU_SUBMENU_SELECTED(50016),
EVT_DEVICE_ORIENTATION_CHANGED(50017),
EVT_ERROR_BLUETOOTH_WIFI_BOTH_ACTIVE(50018),
EVT_ACCESS_INGAME_SCREEN(60001),
EVT_LEAVE_INGAME_SCREEN(60002),
EVT_USER_GAMEPLAY_FUNNEL_EAL(60003),
EVT_USER_TUTORIAL_FUNNEL_EAL(60004),
EVT_USER_TRANSACTION_FUNNEL(60005),
EVT_USER_MESSAGING_FUNNEL(60006),
EVT_USER_SIGNUP_FUNNEL(60007),
EVT_USER_GAME_LOAD_FUNNEL(60008),
EVT_USER_GAME_DOWNLOAD_FUNNEL(60009),
EVT_EVENTS_PURGED(70000),
EVT_GP_LEVEL_PROMOTION(70005),
EVT_GP_LEVEL_PROMOTION_GAMEPLAY_TIME_TOTAL_EAL(70006),
EVT_GP_ACHIEVEMENTS_CHECKPOINTS_EAL(70007),
EVT_GP_XPGAIN_EVENT_EAL(70008),
EVT_GP_EVENT_USER_EAL(70009),
EVT_GP_APP_START_USER_LEVEL_EAL(70010),
EVT_EBISU_EMAIL_PROMPT(80032),
EVT_EBISU_PROMPT_INPUT(80033),
EVT_EBISU_REGISTRATION_FUNNEL(80034),
EVT_EBISU_OPTIONAL_REGISTRATION_FIELDS(80035),
EVT_EBISU_REGISTRATION_ERROR(80036),
EVT_EBISU_SIGNIN_FUNNEL(80037),
EVT_EBISU_SIGNIN_ERROR(80038),
EVT_EBISU_USER_SIGNIN(80039),
EVT_EBISU_USER_FRIENDS_COUNT(80040),
EVT_EBISU_ENTER_EBISUUI(80041),
EVT_EBISU_FRIENDS_VISIT(80042),
EVT_EBISU_FRIEND_SEARCH(80043),
EVT_EBISU_FRIEND_INVITE_SENT(80044),
EVT_EBISU_FRIEND_INVITE_ACCPTED(80045),
EVT_EBISU_NEWSFEED_VISIT(80046),
EVT_EBISU_NEWSFEED_TILE_BUTTON_CLICK(80047),
EVT_EBISU_NEWSFEED_BANNER_CLICK(80048),
EVT_EBISU_NEWSFEED_UPDATES(80049),
EVT_EBISU_PROFILE_VISIT(80050),
EVT_EBISU_LOGO_YES_CLICK(80051),
EVT_EBISU_LOGO_NO_CLICK(80052),
EVT_EBISU_RECOVER_PASSWORD_FUNNEL(80053),
EVT_EBISU_USER_SIGNOUT(80054),
EVT_EBISU_LOAD_FAIL(80055),
EVT_EBISU_FRIEND_PROFILE_BANNER_CLICK(80056),
EVT_EBISU_FRIEND_PROFILE_GAME_ICON_CLICK(80057),
EVT_EBISU_FRIEND_INVITE_REJECTED(80058),
EVT_EBISU_PROFILE_BANNER_CLICK(80059),
EVT_EBISU_PROFILE_GAME_ICON_CLICK(80060),
EVT_ANTELOPE_SOCIAL_GROUP_CREATED(80070),
EVT_ANTELOPE_SOCIAL_GROUP_DELETED(80071),
EVT_ANTELOPE_MEMBER_ADDED_TO_GROUP(IronSourceConstants.TROUBLESHOOTING_SDK_INTERNAL_ERROR),
EVT_ANTELOPE_MEMBER_REMOVED_FROM_GROUP(80073),
EVT_ANTELOPE_MEMBER_REQUEST_TO_GROUP(80074),
EVT_ANTELOPE_MEMBER_DENIED_FROM_GROUP(80089),
EVT_ANTELOPE_MESSAGE_SENT_TO_GROUP_CHAT(80075),
EVT_ANTELOPE_MESSAGE_SENT_TO_INBOX(80076),
EVT_ANTELOPE_MESSAGE_SENT_TO_WORLD_CHAT(80077),
EVT_ANTELOPE_MESSAGE_SENT_TO_P2P_CHAT(80078),
EVT_NEXUS_AUTHENTICATOR_LOGIN(80083),
EVT_NEXUS_AUTHENTICATOR_LOGOUT(80084),
EVT_GAME_ERROR_CONNECTIVITY(90000),
EVT_GAME_ERROR_GAMEPLAY(90001),
EVT_APPSTART_NORMALLY(10000),
EVT_APPSTART_FROMPUSH(10001),
EVT_APPSTART_AFTERINSTALL(10002),
EVT_APPSTART_AFTERUPGRADE(10003),
EVT_APP_SESSION_START(GamesActivityResultCodes.RESULT_APP_MISCONFIGURED),
EVT_APPSTART_FROM_URL(10009),
EVT_APP_ENTER_FOREGROUND_FROM_URL(VungleError.AD_UNABLE_TO_PLAY),
EVT_APPEND_NORMALLY(20000),
EVT_APPEND_ABNORMALLY(Sdk.SDKError.Reason.AD_SERVER_ERROR_VALUE),
EVT_APP_ENTER_FOREGROUND_FROM_EBISU(20004),
EVT_KEYTYPE_NONE(0),
EVT_KEYTYPE_GAME_SELLID(1),
EVT_KEYTYPE_MTX_SELLID(2),
EVT_KEYTYPE_MTX_CATEGORY(3),
EVT_KEYTYPE_SCREEN_NAME(4),
EVT_KEYTYPE_EVENT_COUNT(5),
EVT_KEYTYPE_DURATION(7),
EVT_KEYTYPE_FREQUENCY(8),
EVT_KEYTYPE_FEATURED(10),
EVT_KEYTYPE_DMG_SECTION(11),
EVT_KEYTYPE_GAME_PRODUCTID(12),
EVT_KEYTYPE_DMG_CATEGORY(13),
EVT_KEYTYPE_SCORE(14),
EVT_KEYTYPE_ENUMERATION(15),
EVT_KEYTYPE_TICKERID(16),
EVT_KEYTYPE_BANNERID(17),
EVT_KEYTYPE_MESSAGEID(18),
EVT_KEYTYPE_BANNER_POSITION(19),
EVT_KEYTYPE_LANGUAGE(20),
EVT_KEYTYPE_USER_LEVEL_DATA(21),
EVT_KEYTYPE_FIELD_ID(22),
EVT_KEYTYPE_LOGO_MESSAGE_ID(23),
EVT_KEYTYPE_FIELD_TYPE(24),
EVT_KEYTYPE_SYNERGYID(25),
EVT_KEYTYPE_JSON_MAP(26),
EVT_KEYTYPE_LAST_ENUM(27);
public static final int EVENT_SYNERGY_CUSTOM = 4;
public static final String NIMBLE_NOTIFICATION_TRACKING_SYNERGY_POSTING_TO_SERVER = "nimble.notification.trackingimpl.synergy.postingToServer";
public final int value;
SynergyConstants(int i) {
this.value = i;
}
public static SynergyConstants fromInt(int i) {
for (SynergyConstants synergyConstants : values()) {
if (synergyConstants.value == i) {
return synergyConstants;
}
}
return EVT_UNDEFINED;
}
/* renamed from: com.ea.nimble.tracking.SynergyConstants$1, reason: invalid class name */
public static /* synthetic */ class AnonymousClass1 {
static final /* synthetic */ int[] $SwitchMap$com$ea$nimble$tracking$SynergyConstants;
static {
int[] iArr = new int[SynergyConstants.values().length];
$SwitchMap$com$ea$nimble$tracking$SynergyConstants = iArr;
try {
iArr[SynergyConstants.EVT_APP_START_NORMALLY.ordinal()] = 1;
} catch (NoSuchFieldError unused) {
}
try {
$SwitchMap$com$ea$nimble$tracking$SynergyConstants[SynergyConstants.EVT_APP_START_FROMPUSH.ordinal()] = 2;
} catch (NoSuchFieldError unused2) {
}
try {
$SwitchMap$com$ea$nimble$tracking$SynergyConstants[SynergyConstants.EVT_APP_START_AFTERINSTALL.ordinal()] = 3;
} catch (NoSuchFieldError unused3) {
}
try {
$SwitchMap$com$ea$nimble$tracking$SynergyConstants[SynergyConstants.EVT_APP_START_AFTERUPGRADE.ordinal()] = 4;
} catch (NoSuchFieldError unused4) {
}
try {
$SwitchMap$com$ea$nimble$tracking$SynergyConstants[SynergyConstants.EVT_APP_RESUME_NORMAL.ordinal()] = 5;
} catch (NoSuchFieldError unused5) {
}
try {
$SwitchMap$com$ea$nimble$tracking$SynergyConstants[SynergyConstants.EVT_APP_RESUME_FROM_PUSH.ordinal()] = 6;
} catch (NoSuchFieldError unused6) {
}
try {
$SwitchMap$com$ea$nimble$tracking$SynergyConstants[SynergyConstants.EVT_APP_START_FROM_URL.ordinal()] = 7;
} catch (NoSuchFieldError unused7) {
}
try {
$SwitchMap$com$ea$nimble$tracking$SynergyConstants[SynergyConstants.EVT_APP_RESUME_FROM_URL.ordinal()] = 8;
} catch (NoSuchFieldError unused8) {
}
try {
$SwitchMap$com$ea$nimble$tracking$SynergyConstants[SynergyConstants.EVT_NEW_SESSION_START_SYNERGYID_CHANGE.ordinal()] = 9;
} catch (NoSuchFieldError unused9) {
}
try {
$SwitchMap$com$ea$nimble$tracking$SynergyConstants[SynergyConstants.EVT_APP_SESSION_END.ordinal()] = 10;
} catch (NoSuchFieldError unused10) {
}
try {
$SwitchMap$com$ea$nimble$tracking$SynergyConstants[SynergyConstants.EVT_APP_SESSION_TIME.ordinal()] = 11;
} catch (NoSuchFieldError unused11) {
}
}
}
public boolean isSessionStartEventType() {
switch (AnonymousClass1.$SwitchMap$com$ea$nimble$tracking$SynergyConstants[ordinal()]) {
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
return true;
default:
return false;
}
}
public boolean isSessionEndEventType() {
int i = AnonymousClass1.$SwitchMap$com$ea$nimble$tracking$SynergyConstants[ordinal()];
return i == 10 || i == 11;
}
}

124
decompiled/sources/com/ea/nimble/tracking/Tracking.java Normal file
View File

@@ -0,0 +1,124 @@
package com.ea.nimble.tracking;
import com.ea.nimble.Base;
import com.ea.nimble.Log;
import java.util.Date;
import java.util.Map;
/* loaded from: classes2.dex */
public class Tracking {
private static final String APP_RESUME_EVENT_PREFIX = "APPRESUME_";
private static final String APP_START_EVENT_PREFIX = "APPSTART_";
public static final String COMPONENT_ID = "com.ea.nimble.tracking";
public static final String EVENT_ANTELOPE_MEMBER_ADDED_TO_GROUP = "NIMBLESTANDARD::ANTELOPE_MEMBER_ADDED_TO_GROUP";
public static final String EVENT_ANTELOPE_MEMBER_DENIED_FROM_GROUP = "NIMBLESTANDARD::ANTELOPE_MEMBER_DENIED_FROM_GROUP";
public static final String EVENT_ANTELOPE_MEMBER_REMOVED_FROM_GROUP = "NIMBLESTANDARD::ANTELOPE_MEMBER_REMOVED_FROM_GROUP";
public static final String EVENT_ANTELOPE_MEMBER_REQUEST_TO_GROUP = "NIMBLESTANDARD::ANTELOPE_MEMBER_REQUEST_TO_GROUP";
public static final String EVENT_ANTELOPE_MESSAGE_SENT_TO_GROUP_CHAT = "NIMBLESTANDARD::ANTELOPE_MESSAGE_SENT_TO_GROUP_CHAT";
public static final String EVENT_ANTELOPE_MESSAGE_SENT_TO_INBOX = "NIMBLESTANDARD::ANTELOPE_MESSAGE_SENT_TO_INBOX";
public static final String EVENT_ANTELOPE_MESSAGE_SENT_TO_P2P_CHAT = "NIMBLESTANDARD::ANTELOPE_MESSAGE_SENT_TO_P2P_CHAT";
public static final String EVENT_ANTELOPE_MESSAGE_SENT_TO_WORLD_CHAT = "NIMBLESTANDARD::ANTELOPE_MESSAGE_SENT_TO_WORLD_CHAT";
public static final String EVENT_ANTELOPE_SOCIAL_GROUP_CREATED = "NIMBLESTANDARD::ANTELOPE_SOCIAL_GROUP_CREATED";
public static final String EVENT_ANTELOPE_SOCIAL_GROUP_DELETED = "NIMBLESTANDARD::ANTELOPE_SOCIAL_GROUP_DELETED";
public static final String EVENT_APPRESUME_FROMEBISU = "NIMBLESTANDARD::APPRESUME_FROMEBISU";
public static final String EVENT_APPRESUME_FROMPUSH = "NIMBLESTANDARD::APPRESUME_FROMPUSH";
public static final String EVENT_APPRESUME_FROMURL = "NIMBLESTANDARD::APPRESUME_FROMURL";
public static final String EVENT_APPRESUME_NORMAL = "NIMBLESTANDARD::APPRESUME_NORMAL";
public static final String EVENT_APPSTART_AFTERINSTALL = "NIMBLESTANDARD::APPSTART_AFTERINSTALL";
public static final String EVENT_APPSTART_AFTERUPGRADE = "NIMBLESTANDARD::APPSTART_AFTERUPGRADE";
public static final String EVENT_APPSTART_FROMPUSH = "NIMBLESTANDARD::APPSTART_FROMPUSH";
public static final String EVENT_APPSTART_FROMURL = "NIMBLESTANDARD::APPSTART_FROMURL";
public static final String EVENT_APPSTART_NORMAL = "NIMBLESTANDARD::APPSTART_NORMAL";
public static final String EVENT_LEVEL_UP = "NIMBLESTANDARD::LEVEL_UP";
public static final String EVENT_MTX_FREEITEM_DOWNLOADED = "NIMBLESTANDARD::MTX_FREEITEM_DOWNLOADED";
public static final String EVENT_MTX_ITEM_BEGIN_PURCHASE = "NIMBLESTANDARD::MTX_ITEM_BEGIN_PURCHASE";
public static final String EVENT_MTX_ITEM_PURCHASED = "NIMBLESTANDARD::MTX_ITEM_PURCHASED";
public static final String EVENT_PN_DEVICE_REGISTERED = "NIMBLESTANDARD::PN_DEVICE_REGISTERED";
public static final String EVENT_PN_DISPLAY_OPT_IN = "NIMBLESTANDARD::PN_DISPLAY_OPT_IN";
public static final String EVENT_PN_RECEIVED = "NIMBLESTANDARD::PN_RECEIVED";
public static final String EVENT_PN_SHOWN_TO_USER = "NIMBLESTANDARD::PN_SHOWN_TO_USER";
public static final String EVENT_PN_USER_CLICKED_OK = "NIMBLESTANDARD::PN_USER_CLICKED_OK";
public static final String EVENT_PN_USER_OPT_IN = "NIMBLESTANDARD::PN_USER_OPT_IN";
public static final String EVENT_REFERRERID_RECEIVED = "NIMBLESTANDARD::REFERRER_ID_RECEIVED";
public static final String EVENT_SESSION_END = "NIMBLESTANDARD::SESSION_END";
public static final String EVENT_SESSION_START = "NIMBLESTANDARD::SESSION_START";
public static final String EVENT_SESSION_TIME = "NIMBLESTANDARD::SESSION_TIME";
public static final String EVENT_TUTORIAL_COMPLETE = "NIMBLESTANDARD::TUTORIAL_COMPLETE";
public static final String EVENT_USER_REGISTERED = "NIMBLESTANDARD::USER_REGISTERED";
public static final String EVENT_USER_TRACKING_OPTOUT = "NIMBLESTANDARD::USER_TRACKING_OPTOUT";
public static final String KEY_ANTELOPE_GROUP_ID = "NIMBLESTANDARD::KEY_ANTELOPE_GROUP_ID";
public static final String KEY_ANTELOPE_GROUP_TYPE = "NIMBLESTANDARD::KEY_ANTELOPE_GROUP_TYPE";
public static final String KEY_ANTELOPE_INVITE_TYPE = "NIMBLESTANDARD::KEY_ANTELOPE_INVITE_TYPE";
public static final String KEY_ANTELOPE_MEMBER_ID = "NIMBLESTANDARD::KEY_ANTELOPE_MEMBER_ID";
public static final String KEY_ANTELOPE_MESSAGE_TYPE = "NIMBLESTANDARD::KEY_ANTELOPE_MESSAGE_TYPE";
public static final String KEY_ANTELOPE_PROGRESSION = "NIMBLESTANDARD::KEY_ANTELOPE_PROGRESSION";
public static final String KEY_ANTELOPE_RECIPIENT_ID = "NIMBLESTANDARD::KEY_ANTELOPE_RECIPIENT_ID";
public static final String KEY_ANTELOPE_RECIPIENT_TYPE = "NIMBLESTANDARD::KEY_ANTELOPE_RECIPIENT_TYPE";
public static final String KEY_DURATION = "NIMBLESTANDARD::KEY_DURATION";
public static final String KEY_GAMEPLAY_DURATION = "NIMBLESTANDARD::KEY_GAMEPLAY_DURATION";
public static final String KEY_MTX_CURRENCY = "NIMBLESTANDARD::KEY_MTX_CURRENCY";
public static final String KEY_MTX_PRICE = "NIMBLESTANDARD::KEY_MTX_PRICE";
public static final String KEY_MTX_SELLID = "NIMBLESTANDARD::KEY_MTX_SELLID";
public static final String KEY_PN_DATE_OF_BIRTH = "NIMBLESTANDARD::KEY_PN_DATE_OF_BIRTH";
public static final String KEY_PN_DEVICE_ID = "NIMBLESTANDARD::KEY_PN_DEVICE_ID";
public static final String KEY_PN_DISABLED_FLAG = "NIMBLESTANDARD::KEY_PN_DISABLED_FLAG";
public static final String KEY_PN_MESSAGE_ID = "NIMBLESTANDARD::KEY_PN_MESSAGE_ID";
public static final String KEY_PN_MESSAGE_TYPE = "NIMBLESTANDARD::KEY_PN_MESSAGE_TYPE";
public static final String KEY_REFERRER_ID = "NIMBLESTANDARD::KEY_REFERRER_ID";
public static final String KEY_USERNAME = "NIMBLESTANDARD::KEY_USERNAME";
public static final String KEY_USER_LEVEL = "NIMBLESTANDARD::KEY_USER_LEVEL";
public static final String NIMBLE_TRACKING_ATTRIBUTE_PROGRESSION_LEVEL = "NIMBLESTANDARD::ATTRIBUTE_PROGRESSION_LEVEL";
public static final String NIMBLE_TRACKING_DEFAULTENABLE = "com.ea.nimble.tracking.defaultEnable";
public static final String NIMBLE_TRACKING_EVENT_IDENTITY_LOGIN = "NIMBLESTANDARD::IDENTITY_LOGIN";
public static final String NIMBLE_TRACKING_EVENT_IDENTITY_LOGOUT = "NIMBLESTANDARD::IDENTITY_LOGOUT";
public static final String NIMBLE_TRACKING_EVENT_IDENTITY_MIGRATION = "NIMBLESTANDARD::IDENTITY_MIGRATION";
public static final String NIMBLE_TRACKING_EVENT_IDENTITY_MIGRATION_STARTED = "NIMBLESTANDARD::IDENTITY_MIGRATION_STARTED";
public static final String NIMBLE_TRACKING_KEY_IDENTITY_MAP_SOURCE = "NIMBLESTANDARD::KEY_IDENTITY_SOURCE";
public static final String NIMBLE_TRACKING_KEY_IDENTITY_MAP_TARGET = "NIMBLESTANDARD::KEY_IDENTITY_TARGET";
public static final String NIMBLE_TRACKING_KEY_IDENTITY_PIDMAP_LOGIN = "NIMBLESTANDARD::KEY_IDENTITY_PIDMAP_LOGIN";
public static final String NIMBLE_TRACKING_KEY_IDENTITY_PIDMAP_LOGOUT = "NIMBLESTANDARD::KEY_IDENTITY_PIDMAP_LOGOUT";
public static final String NIMBLE_TRACKING_KEY_MIGRATION_GAME_TRIGGERED = "NIMBLESTANDARD::KEY_MIGRATION_GAME_TRIGGERED";
public static final String NIMBLE_TRACKING_KEY_PN_MESSAGEID = "NIMBLESTANDARD::KEY_PN_MESSAGE_ID";
private static final String SESSION_END_EVENT_PREFIX = "SESSION_END";
private static final String SESSION_START_EVENT_PREFIX = "SESSION_START";
private static final String STANDARD_EVENT_PREFIX = "NIMBLESTANDARD::";
public static class Event {
Map<String, String> parameters;
Date timestamp;
String type;
}
public static ITracking getComponent() {
return (ITracking) Base.getComponent(COMPONENT_ID);
}
private static void initialize() {
Log.Helper.LOGFUNCS("Tracking");
Base.registerComponent(new TrackingWrangler(), COMPONENT_ID);
}
public static boolean isNimbleStandardEvent(String str) {
Log.Helper.LOGPUBLICFUNCS("Tracking");
if (str == null) {
return false;
}
return str.startsWith(STANDARD_EVENT_PREFIX);
}
public static boolean isSessionStartEvent(String str) {
Log.Helper.LOGPUBLICFUNCS("Tracking");
if (str == null) {
return false;
}
return str.startsWith(APP_START_EVENT_PREFIX, 16) || str.startsWith(APP_RESUME_EVENT_PREFIX, 16) || str.startsWith(SESSION_START_EVENT_PREFIX, 16);
}
public static boolean isSessionEndEvent(String str) {
Log.Helper.LOGPUBLICFUNCS("Tracking");
if (str == null) {
return false;
}
return str.startsWith(SESSION_END_EVENT_PREFIX, 16);
}
}

52
decompiled/sources/com/ea/nimble/tracking/TrackingBaseSessionObject.java Normal file
View File

@@ -0,0 +1,52 @@
package com.ea.nimble.tracking;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/* loaded from: classes2.dex */
public class TrackingBaseSessionObject implements Externalizable {
private static final long serialVersionUID = 1;
public List<Map<String, String>> events;
public int repostCount;
public Map<String, Object> sessionData;
public TrackingBaseSessionObject() {
this.events = new ArrayList();
this.sessionData = new HashMap();
this.repostCount = 0;
}
public TrackingBaseSessionObject(Map<String, Object> map) {
this.events = new ArrayList();
this.sessionData = map;
this.repostCount = 0;
}
public int countOfEvents() {
List<Map<String, String>> list = this.events;
if (list == null) {
return 0;
}
return list.size();
}
@Override // java.io.Externalizable
public void writeExternal(ObjectOutput objectOutput) throws IOException {
objectOutput.writeObject(this.events);
objectOutput.writeObject(this.sessionData);
objectOutput.writeInt(this.repostCount);
}
@Override // java.io.Externalizable
public void readExternal(ObjectInput objectInput) throws IOException, ClassNotFoundException {
this.events = (List) objectInput.readObject();
this.sessionData = (Map) objectInput.readObject();
this.repostCount = objectInput.readInt();
}
}

251
decompiled/sources/com/ea/nimble/tracking/TrackingEventWrangler.java Normal file
View File

@@ -0,0 +1,251 @@
package com.ea.nimble.tracking;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import com.ea.eadp.pushnotification.forwarding.FCMMessageService;
import com.ea.nimble.ApplicationEnvironment;
import com.ea.nimble.ApplicationLifecycle;
import com.ea.nimble.Base;
import com.ea.nimble.Component;
import com.ea.nimble.IApplicationLifecycle;
import com.ea.nimble.Log;
import com.ea.nimble.LogSource;
import com.ea.nimble.Persistence;
import com.ea.nimble.PersistenceService;
import com.ea.nimble.SynergyEnvironment;
import java.util.HashMap;
import java.util.Map;
/* loaded from: classes2.dex */
class TrackingEventWrangler extends Component implements IApplicationLifecycle.ApplicationLifecycleCallbacks, LogSource, IApplicationLifecycle.ActivityEventCallbacks {
private static final String APP_VERSION_PERSISTENCE_ID = "applicationBundleVersion";
public static final String COMPONENT_ID = "com.ea.nimble.tracking.eventwrangler";
private Intent m_newIntent;
private Long m_sessionStartTimestamp;
@Override // com.ea.nimble.Component
public String getComponentId() {
return COMPONENT_ID;
}
@Override // com.ea.nimble.LogSource
public String getLogSourceTitle() {
return "Tracking";
}
@Override // com.ea.nimble.IApplicationLifecycle.ActivityEventCallbacks
public void onActivityResult(Activity activity, int i, int i2, Intent intent) {
}
@Override // com.ea.nimble.IApplicationLifecycle.ActivityEventCallbacks
public boolean onBackPressed() {
return true;
}
@Override // com.ea.nimble.IApplicationLifecycle.ActivityEventCallbacks
public void onNewIntent(Activity activity, Intent intent) {
this.m_newIntent = intent;
}
@Override // com.ea.nimble.IApplicationLifecycle.ActivityEventCallbacks
public void onWindowFocusChanged(boolean z) {
}
private TrackingEventWrangler() {
}
private static void initialize() {
Log.Helper.LOGFUNCS("TrackingEventWrangler");
Base.registerComponent(new TrackingEventWrangler(), COMPONENT_ID);
}
@Override // com.ea.nimble.Component
public void restore() {
Log.Helper.LOGPUBLICFUNC(this);
ApplicationLifecycle.getComponent().registerApplicationLifecycleCallbacks(this);
ApplicationLifecycle.getComponent().registerActivityEventCallbacks(this);
}
@Override // com.ea.nimble.Component
public void cleanup() {
Log.Helper.LOGPUBLICFUNC(this);
ApplicationLifecycle.getComponent().unregisterApplicationLifecycleCallbacks(this);
ApplicationLifecycle.getComponent().unregisterActivityEventCallbacks(this);
}
@Override // com.ea.nimble.IApplicationLifecycle.ApplicationLifecycleCallbacks
public void onApplicationLaunch(Intent intent) {
if (intent.getData() != null) {
logAndCheckEvent(Tracking.EVENT_APPSTART_FROMURL);
return;
}
if (intent.getStringExtra("PushNotification") != null) {
Log.Helper.LOGI(this, "Awesome. PN launched me", new Object[0]);
HashMap hashMap = new HashMap();
addPushTNGTrackingParams(intent.getExtras(), hashMap);
if (hashMap.isEmpty()) {
logAndCheckEvent(Tracking.EVENT_APPSTART_FROMPUSH);
return;
} else {
logAndCheckEvent(Tracking.EVENT_APPSTART_FROMPUSH, hashMap);
return;
}
}
Persistence persistenceForNimbleComponent = PersistenceService.getPersistenceForNimbleComponent(COMPONENT_ID, Persistence.Storage.DOCUMENT);
String stringValue = persistenceForNimbleComponent.getStringValue(APP_VERSION_PERSISTENCE_ID);
if (stringValue == null) {
stringValue = PersistenceService.getPersistenceForNimbleComponent(COMPONENT_ID, Persistence.Storage.CACHE).getStringValue(APP_VERSION_PERSISTENCE_ID);
}
String applicationVersion = ApplicationEnvironment.getComponent().getApplicationVersion();
Log.Helper.LOGD(this, "Current app version, %s. Cached app version, %s", applicationVersion, stringValue);
if (stringValue == null) {
persistenceForNimbleComponent.setValue(APP_VERSION_PERSISTENCE_ID, applicationVersion);
logAndCheckEvent(Tracking.EVENT_APPSTART_AFTERINSTALL);
} else if (!stringValue.equals(applicationVersion)) {
persistenceForNimbleComponent.setValue(APP_VERSION_PERSISTENCE_ID, applicationVersion);
logAndCheckEvent(Tracking.EVENT_APPSTART_AFTERUPGRADE);
} else {
logAndCheckEvent(Tracking.EVENT_APPSTART_NORMAL);
}
}
@Override // com.ea.nimble.IApplicationLifecycle.ApplicationLifecycleCallbacks
public void onApplicationSuspend() {
logAndCheckEvent(Tracking.EVENT_SESSION_END);
}
@Override // com.ea.nimble.IApplicationLifecycle.ApplicationLifecycleCallbacks
public void onApplicationResume() {
if (ApplicationEnvironment.getCurrentActivity().getIntent().getData() != null) {
logAndCheckEvent(Tracking.EVENT_APPRESUME_FROMURL);
return;
}
Intent intent = this.m_newIntent;
if (intent != null) {
if (intent.getData() != null) {
logAndCheckEvent(Tracking.EVENT_APPRESUME_FROMURL);
} else if (this.m_newIntent.getStringExtra("PushNotification") != null) {
HashMap hashMap = new HashMap();
addPushTNGTrackingParams(this.m_newIntent.getExtras(), hashMap);
if (hashMap.isEmpty()) {
logAndCheckEvent(Tracking.EVENT_APPRESUME_FROMPUSH);
} else {
logAndCheckEvent(Tracking.EVENT_APPRESUME_FROMPUSH, hashMap);
}
} else {
logAndCheckEvent(Tracking.EVENT_APPRESUME_NORMAL);
}
this.m_newIntent = null;
return;
}
logAndCheckEvent(Tracking.EVENT_APPRESUME_NORMAL);
}
@Override // com.ea.nimble.IApplicationLifecycle.ApplicationLifecycleCallbacks
public void onApplicationQuit() {
logAndCheckEvent(Tracking.EVENT_SESSION_END);
}
public void logAndCheckEvent(String str) {
Log.Helper.LOGPUBLICFUNC(this);
logAndCheckEvent(str, null);
}
/* JADX WARN: Removed duplicated region for block: B:15:? A[RETURN, SYNTHETIC] */
/* JADX WARN: Removed duplicated region for block: B:9:0x0089 */
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct add '--show-bad-code' argument
*/
private void logAndCheckEvent(java.lang.String r9, java.util.Map<java.lang.String, java.lang.String> r10) {
/*
r8 = this;
com.ea.nimble.Log.Helper.LOGFUNC(r8)
java.lang.String r0 = "com.ea.nimble.tracking"
com.ea.nimble.Component r0 = com.ea.nimble.Base.getComponent(r0)
com.ea.nimble.tracking.TrackingWrangler r0 = (com.ea.nimble.tracking.TrackingWrangler) r0
boolean r1 = com.ea.nimble.tracking.Tracking.isSessionStartEvent(r9)
r2 = 1
r3 = 0
if (r1 == 0) goto L34
java.lang.Long r1 = r8.m_sessionStartTimestamp
if (r1 == 0) goto L1f
java.lang.String r1 = "Pre-existing session start timestamp found while logging new session start! Overwriting previous session start timestamp."
java.lang.Object[] r4 = new java.lang.Object[r3]
com.ea.nimble.Log.Helper.LOGE(r8, r1, r4)
goto L26
L1f:
java.lang.String r1 = "Marking session start time."
java.lang.Object[] r4 = new java.lang.Object[r3]
com.ea.nimble.Log.Helper.LOGD(r8, r1, r4)
L26:
long r4 = java.lang.System.currentTimeMillis()
java.lang.Long r1 = java.lang.Long.valueOf(r4)
r8.m_sessionStartTimestamp = r1
r0.setSessionState(r2)
goto L86
L34:
java.lang.Long r1 = r8.m_sessionStartTimestamp
if (r1 != 0) goto L42
java.lang.String r10 = "No current session. %s will not be logged."
java.lang.Object[] r9 = new java.lang.Object[]{r9}
com.ea.nimble.Log.Helper.LOGE(r8, r10, r9)
return
L42:
boolean r1 = com.ea.nimble.tracking.Tracking.isSessionEndEvent(r9)
if (r1 == 0) goto L86
long r4 = java.lang.System.currentTimeMillis()
java.lang.Long r1 = r8.m_sessionStartTimestamp
long r6 = r1.longValue()
long r4 = r4 - r6
double r4 = (double) r4
r6 = 4652007308841189376(0x408f400000000000, double:1000.0)
double r4 = r4 / r6
java.util.Locale r1 = java.util.Locale.US
java.lang.Double r4 = java.lang.Double.valueOf(r4)
java.lang.Object[] r4 = new java.lang.Object[]{r4}
java.lang.String r5 = "%.0f"
java.lang.String r1 = java.lang.String.format(r1, r5, r4)
java.lang.String r4 = "Logging session time, %s seconds."
java.lang.Object[] r5 = new java.lang.Object[]{r1}
com.ea.nimble.Log.Helper.LOGD(r8, r4, r5)
java.util.HashMap r4 = new java.util.HashMap
r4.<init>()
java.lang.String r5 = "NIMBLESTANDARD::KEY_DURATION"
r4.put(r5, r1)
java.lang.String r1 = "NIMBLESTANDARD::SESSION_TIME"
r8.logAndCheckEvent(r1, r4)
r1 = 0
r8.m_sessionStartTimestamp = r1
goto L87
L86:
r2 = r3
L87:
if (r0 == 0) goto L91
r0.logEvent(r9, r10)
if (r2 == 0) goto L91
r0.setSessionState(r3)
L91:
return
*/
throw new UnsupportedOperationException("Method not decompiled: com.ea.nimble.tracking.TrackingEventWrangler.logAndCheckEvent(java.lang.String, java.util.Map):void");
}
private void addPushTNGTrackingParams(Bundle bundle, Map<String, String> map) {
Log.Helper.LOGFUNC(this);
if (bundle == null || bundle.isEmpty()) {
return;
}
if (bundle.containsKey(FCMMessageService.PushIntentExtraKeys.PUSH_ID)) {
map.put("NIMBLESTANDARD::KEY_PN_MESSAGE_ID", bundle.getString(FCMMessageService.PushIntentExtraKeys.PUSH_ID));
}
if (bundle.containsKey(FCMMessageService.PushIntentExtraKeys.PN_TYPE)) {
map.put(Tracking.KEY_PN_MESSAGE_TYPE, bundle.getString(FCMMessageService.PushIntentExtraKeys.PN_TYPE));
}
if (map == null || map.isEmpty()) {
return;
}
map.put(Tracking.KEY_PN_DEVICE_ID, SynergyEnvironment.getComponent().getEADeviceId());
}
}

10
decompiled/sources/com/ea/nimble/tracking/TrackingSynergy.java Normal file
View File

@@ -0,0 +1,10 @@
package com.ea.nimble.tracking;
/* loaded from: classes2.dex */
public class TrackingSynergy {
public static final String EVENT_CUSTOM = "SYNERGYTRACKING::CUSTOM";
private static void initialize() {
NimbleTrackingSynergyComponent.initialize();
}
}

140
decompiled/sources/com/ea/nimble/tracking/TrackingWrangler.java Normal file
View File

@@ -0,0 +1,140 @@
package com.ea.nimble.tracking;
import com.ea.nimble.Base;
import com.ea.nimble.Component;
import com.ea.nimble.IOperationalTelemetryDispatch;
import com.ea.nimble.Log;
import com.ea.nimble.LogSource;
import com.ea.nimble.Utility;
import java.util.Map;
/* loaded from: classes2.dex */
public class TrackingWrangler extends Component implements ITracking, LogSource {
private boolean m_sessionIsActive = false;
private ITracking[] m_trackingComponents;
@Override // com.ea.nimble.Component
public String getComponentId() {
return Tracking.COMPONENT_ID;
}
@Override // com.ea.nimble.LogSource
public String getLogSourceTitle() {
return "Tracking";
}
@Override // com.ea.nimble.Component
public void restore() {
Log.Helper.LOGPUBLICFUNC(this);
Object[] componentList = Base.getComponentList("com.ea.nimble.trackingimpl");
this.m_trackingComponents = new ITracking[componentList.length];
for (int i = 0; i < componentList.length; i++) {
this.m_trackingComponents[i] = (ITracking) componentList[i];
}
}
@Override // com.ea.nimble.tracking.ITracking
public void setEnable(boolean z) {
Log.Helper.LOGPUBLICFUNC(this);
StringBuilder sb = new StringBuilder();
sb.append(z ? "ENABLE" : "DISABLE");
sb.append(" tracking");
Log.Helper.LOGD(this, sb.toString(), new Object[0]);
for (ITracking iTracking : this.m_trackingComponents) {
iTracking.setEnable(z);
}
if (z) {
((TrackingEventWrangler) Base.getComponent(TrackingEventWrangler.COMPONENT_ID)).logAndCheckEvent(Tracking.EVENT_SESSION_START);
}
}
public void setSessionState(boolean z) {
Log.Helper.LOGPUBLICFUNC(this);
this.m_sessionIsActive = z;
}
@Override // com.ea.nimble.tracking.ITracking
public boolean getEnable() {
Log.Helper.LOGPUBLICFUNC(this);
boolean z = false;
for (ITracking iTracking : this.m_trackingComponents) {
z = z || iTracking.getEnable();
}
return z;
}
@Override // com.ea.nimble.tracking.ITracking
public boolean getPostEnable() {
Log.Helper.LOGPUBLICFUNC(this);
boolean z = false;
for (ITracking iTracking : this.m_trackingComponents) {
z = z || iTracking.getPostEnable();
}
return z;
}
@Override // com.ea.nimble.tracking.ITracking
public void setPostEnable(boolean z) {
Log.Helper.LOGPUBLICFUNC(this);
for (ITracking iTracking : this.m_trackingComponents) {
iTracking.setPostEnable(z);
}
}
@Override // com.ea.nimble.tracking.ITracking
public void logEvent(String str, Map<String, String> map) {
Log.Helper.LOGPUBLICFUNC(this);
if (!this.m_sessionIsActive) {
Log.Helper.LOGD(this, "Ignoring event %s because there is not an active session", str);
return;
}
Log.Helper.LOGD(this, "LogEvent type(%s) parameters(%s)", str, Utility.convertLiteralMapToString(map));
for (ITracking iTracking : this.m_trackingComponents) {
iTracking.logEvent(str, map);
}
}
@Override // com.ea.nimble.tracking.ITracking
public void addCustomSessionData(String str, String str2) {
Log.Helper.LOGPUBLICFUNC(this);
for (ITracking iTracking : this.m_trackingComponents) {
iTracking.addCustomSessionData(str, str2);
}
}
@Override // com.ea.nimble.tracking.ITracking
public void removeCustomSessionData(String str) {
Log.Helper.LOGPUBLICFUNC(this);
for (ITracking iTracking : this.m_trackingComponents) {
iTracking.removeCustomSessionData(str);
}
}
@Override // com.ea.nimble.tracking.ITracking
public void setTrackingAttribute(String str, String str2) {
Log.Helper.LOGPUBLICFUNC(this);
for (ITracking iTracking : this.m_trackingComponents) {
iTracking.setTrackingAttribute(str, str2);
}
}
@Override // com.ea.nimble.tracking.ITracking
public void clearCustomSessionData() {
Log.Helper.LOGPUBLICFUNC(this);
}
@Override // com.ea.nimble.tracking.ITracking
public String getSessionId() {
Log.Helper.LOGPUBLICFUNC(this);
NimbleTrackingSynergyComponent nimbleTrackingSynergyComponent = (NimbleTrackingSynergyComponent) Base.getComponent(IOperationalTelemetryDispatch.EVENTTYPE_TRACKING_SYNERGY_PAYLOADS);
if (nimbleTrackingSynergyComponent == null) {
return "";
}
String sessionId = nimbleTrackingSynergyComponent.getSessionId();
return Utility.validString(sessionId) ? sessionId : "";
}
public static TrackingWrangler getComponent() {
return (TrackingWrangler) Tracking.getComponent();
}
}