package com.glu.plugins.gluanalytics;

import android.annotation.TargetApi;
import android.app.ActivityManager;
import android.content.Context;
import android.os.Process;
import android.os.SystemClock;
import android.view.Choreographer;
import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
import com.glu.plugins.gluanalytics.util.Common;
import com.glu.plugins.gluanalytics.util.YLogger;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/* loaded from: classes2.dex */
public class GluPerformance implements IPerformance {
    private static long preSDKLoadStartTimeStamp;
    private ActivityManager mActivityManager;
    private IAnalytics mAnalytics;
    private boolean mDevBuild;
    private ScheduledThreadPoolExecutor mExecutor;
    private boolean mHasVersionChanged;
    private boolean mIsFirstLaunch;
    private double mLatestFPS;
    PerfSample mPreInitSample;
    private boolean mRunning;
    private double mSampleInterval;
    private double mTargetFrameRate;
    private final Object lock = new Object();
    private final YLogger mLog = YLogger.create(getClass());
    final String LOG_NAME_PERFORMANCE = "PERFORMANCE";
    final String LOG_EVENT_SOURCE_SDK = "SDK_STANDARD";
    final String APP_PERFORMANCE = "APP_PERFORMANCE";
    private HashMap<String, PerfSample> mPerfSamples = new HashMap<>();
    private int mFrameCount = 0;
    private long mLastFrameTime = 0;
    private FrameTask mFrameTask = new FrameTask();

    @Override // com.glu.plugins.gluanalytics.IPerformance
    public void internal_SetAnalytics(IAnalytics iAnalytics) {
        this.mAnalytics = iAnalytics;
    }

    public static /* synthetic */ int access$408(GluPerformance gluPerformance) {
        int i = gluPerformance.mFrameCount;
        gluPerformance.mFrameCount = i + 1;
        return i;
    }

    public GluPerformance(Context context, double d, double d2, boolean z, double d3, boolean z2, boolean z3) {
        this.mSampleInterval = d;
        this.mTargetFrameRate = d2;
        this.mDevBuild = z;
        this.mIsFirstLaunch = z2;
        this.mHasVersionChanged = z3;
        this.mActivityManager = (ActivityManager) context.getSystemService("activity");
        this.mLatestFPS = d2;
        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
        this.mExecutor = scheduledThreadPoolExecutor;
        scheduledThreadPoolExecutor.scheduleAtFixedRate(new SampleTask(), 0L, (long) (d * 1000.0d), TimeUnit.MILLISECONDS);
        this.mRunning = true;
        this.mPreInitSample = null;
        logPreBootSample(d3);
        perfSampleStart("APP_PERFORMANCE", 7, null);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public double getUsedMemory() {
        return this.mActivityManager.getProcessMemoryInfo(new int[]{Process.myPid()})[0].getTotalPss() / 1024.0f;
    }

    @Override // com.glu.plugins.gluanalytics.IPerformance
    public void destroy() {
        if (this.mRunning) {
            perfSampleEnd("APP_PERFORMANCE", null);
            this.mRunning = false;
        }
    }

    @Override // com.glu.plugins.gluanalytics.IPerformance
    public void onResume() {
        this.mFrameCount = 0;
        this.mLastFrameTime = 0L;
        this.mFrameTask.start();
        if (!this.mRunning) {
            this.mRunning = true;
            perfSampleStart("APP_PERFORMANCE", 7, null);
        }
        for (String str : this.mPerfSamples.keySet()) {
            Map<String, ?> map = this.mPerfSamples.get(str).userData;
            if (map != null && map.containsKey("autoPause")) {
                perfSampleAction(str, 1);
            }
        }
    }

    @Override // com.glu.plugins.gluanalytics.IPerformance
    public void onPause() {
        if (this.mRunning) {
            perfSampleEnd("APP_PERFORMANCE", null);
            this.mRunning = false;
        }
        this.mFrameTask.end();
        synchronized (this.lock) {
            try {
                for (Map.Entry<String, PerfSample> entry : this.mPerfSamples.entrySet()) {
                    PerfSample value = entry.getValue();
                    value.isSuspended = true;
                    Map<String, ?> map = value.userData;
                    if (map != null && map.containsKey("autoPause")) {
                        perfSampleAction(entry.getKey(), 0);
                    }
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override // com.glu.plugins.gluanalytics.IPerformance
    public void internal_LogLaunchOverhead() {
        PerfSample perfSample = this.mPreInitSample;
        if (perfSample != null) {
            flush(perfSample);
            this.mPreInitSample = null;
        }
    }

    @Override // com.glu.plugins.gluanalytics.IPerformance
    public void perfSampleStart(String str, int i, Map<String, ?> map) {
        synchronized (this.lock) {
            try {
                if (this.mPerfSamples.containsKey(str)) {
                    this.mLog.e("PerfSampleStart", InneractiveMediationDefs.GENDER_MALE, "placement has already exist, ignored.", "placement", str);
                    return;
                }
                PerfSample perfSample = new PerfSample();
                perfSample.placement = str;
                perfSample.type = i;
                perfSample.userData = map;
                perfSample.maxMemory = 0.0d;
                perfSample.totalMemory = 0.0d;
                perfSample.startMemory = this.mDevBuild ? getUsedMemory() : 0.0d;
                perfSample.endMemory = 0.0d;
                perfSample.minFPS = this.mTargetFrameRate;
                perfSample.maxFPS = 0.0d;
                perfSample.totalFPS = 0.0d;
                perfSample.lastFPS = 0.0d;
                perfSample.sampleCount = 0L;
                perfSample.startTimeStamp = SystemClock.uptimeMillis();
                perfSample.isSuspended = false;
                perfSample.isPaused = false;
                perfSample.startPausedTimeStamp = 0.0d;
                perfSample.pausedTimeTotal = 0.0d;
                perfSample.preInitTime = 0.0d;
                synchronized (this.lock) {
                    this.mPerfSamples.put(str, perfSample);
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override // com.glu.plugins.gluanalytics.IPerformance
    public void perfSampleEnd(String str, Map<String, ?> map) {
        synchronized (this.lock) {
            try {
                if (!this.mPerfSamples.containsKey(str)) {
                    this.mLog.e("PerfSampleEnd", InneractiveMediationDefs.GENDER_MALE, "placement is not exist, ignored.", "placement", str);
                    return;
                }
                PerfSample perfSample = this.mPerfSamples.get(str);
                this.mPerfSamples.remove(str);
                if (map != null && map.size() != 0) {
                    perfSample.userData = map;
                }
                perfSample.endMemory = this.mDevBuild ? getUsedMemory() : 0.0d;
                flush(perfSample);
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override // com.glu.plugins.gluanalytics.IPerformance
    public PerfMeasure perfGetValues() {
        PerfMeasure perfMeasure = new PerfMeasure();
        boolean containsKey = this.mPerfSamples.containsKey("APP_PERFORMANCE");
        PerfSample perfSample = this.mPerfSamples.get("APP_PERFORMANCE");
        if (!containsKey || (perfSample.type & 4) == 0 || perfSample.isPaused) {
            perfMeasure.averageFPS = -1.0d;
            perfMeasure.lastFPS = -1.0d;
            perfMeasure.minFPS = -1.0d;
            perfMeasure.maxFPS = -1.0d;
        } else {
            perfMeasure.averageFPS = perfSample.totalFPS / perfSample.sampleCount;
            perfMeasure.lastFPS = perfSample.lastFPS;
            perfMeasure.minFPS = perfSample.minFPS;
            perfMeasure.maxFPS = perfSample.maxFPS;
        }
        if (!containsKey || (perfSample.type & 2) == 0 || perfSample.isPaused) {
            perfMeasure.startMem = -1.0d;
            perfMeasure.maxMem = -1.0d;
            perfMeasure.currentMem = -1.0d;
        } else {
            perfMeasure.startMem = perfSample.startMemory;
            perfMeasure.maxMem = perfSample.maxMemory;
            perfMeasure.currentMem = getUsedMemory();
        }
        if (!containsKey || (perfSample.type & 2) == 0 || perfSample.isPaused) {
            perfMeasure.time = -1.0d;
        } else {
            perfMeasure.time = (SystemClock.uptimeMillis() - perfSample.startTimeStamp) - perfSample.pausedTimeTotal;
        }
        return perfMeasure;
    }

    @Override // com.glu.plugins.gluanalytics.IPerformance
    public boolean perfSampleAction(String str, int i) {
        if (!this.mPerfSamples.containsKey(str)) {
            return false;
        }
        PerfSample perfSample = this.mPerfSamples.get(str);
        if (i != 0) {
            if (i != 1) {
                if (i == 2) {
                    synchronized (this.lock) {
                        this.mPerfSamples.remove(str);
                    }
                }
            } else {
                if (!perfSample.isPaused) {
                    return false;
                }
                perfSample.isPaused = false;
                perfSample.pausedTimeTotal += SystemClock.uptimeMillis() - perfSample.startPausedTimeStamp;
            }
        } else {
            if (perfSample.isPaused) {
                return false;
            }
            perfSample.isPaused = true;
            perfSample.startPausedTimeStamp = SystemClock.uptimeMillis();
        }
        return true;
    }

    public static void perfSampleLogLaunchOverhead() {
        preSDKLoadStartTimeStamp = SystemClock.uptimeMillis();
    }

    public void logPreBootSample(double d) {
        if (0 != preSDKLoadStartTimeStamp || d > 0.0d) {
            PerfSample perfSample = new PerfSample();
            this.mPreInitSample = perfSample;
            perfSample.placement = "LAUNCH_OVERHEAD";
            perfSample.userData = null;
            perfSample.type = 1;
            if (d > 0.0d) {
                perfSample.preInitTime = d * 1000.0d;
            } else {
                perfSample.startTimeStamp = preSDKLoadStartTimeStamp;
            }
            perfSample.isSuspended = false;
        }
    }

    private void flush(PerfSample perfSample) {
        HashMap hashMap;
        if (perfSample == null) {
            return;
        }
        if (perfSample.userData == null) {
            hashMap = new HashMap();
        } else {
            hashMap = new HashMap(perfSample.userData);
        }
        HashMap hashMap2 = hashMap;
        if (this.mIsFirstLaunch) {
            hashMap2.put("isFirstLaunch", "true");
        }
        if (this.mHasVersionChanged) {
            hashMap2.put("wasVersionUpdated", "true");
        }
        if ((perfSample.type & 2) != 0) {
            if (this.mDevBuild) {
                hashMap2.put("start_mem", Double.valueOf(perfSample.startMemory));
                hashMap2.put("end_mem", Double.valueOf(perfSample.endMemory));
            }
            if (perfSample.sampleCount != 0) {
                hashMap2.put("max_mem", Double.valueOf(perfSample.maxMemory));
                hashMap2.put("avg_mem", Double.valueOf(perfSample.totalMemory / perfSample.sampleCount));
            } else if (this.mDevBuild) {
                hashMap2.put("max_mem", Double.valueOf(Math.max(perfSample.startMemory, perfSample.endMemory)));
                hashMap2.put("avg_mem", Double.valueOf((perfSample.startMemory + perfSample.endMemory) * 0.5d));
            }
        }
        if ((perfSample.type & 4) != 0 && perfSample.sampleCount != 0) {
            hashMap2.put("min_fps", Double.valueOf(perfSample.minFPS));
            hashMap2.put("avg_fps", Double.valueOf(perfSample.totalFPS / perfSample.sampleCount));
            hashMap2.put("target_fps", Double.valueOf(this.mTargetFrameRate));
        }
        if ((perfSample.type & 1) != 0) {
            double d = perfSample.preInitTime;
            if (d > 0.0d) {
                hashMap2.put("time_ms", Double.valueOf(d));
            } else {
                hashMap2.put("time_ms", Double.valueOf((SystemClock.uptimeMillis() - perfSample.startTimeStamp) - perfSample.pausedTimeTotal));
            }
            if (perfSample.isSuspended) {
                hashMap2.put("is_suspended", Boolean.TRUE);
            }
        }
        this.mAnalytics.internal_perfEvent(perfSample.placement, "PERFORMANCE", String.valueOf(perfSample.type), null, "SDK_STANDARD", hashMap2);
    }

    @TargetApi(16)
    public class FrameTask implements Choreographer.FrameCallback {
        private Choreographer choreographer;

        public FrameTask() {
            try {
                this.choreographer = Choreographer.getInstance();
                start();
            } catch (Exception unused) {
                GluPerformance.this.mLog.e("PerfSample", InneractiveMediationDefs.GENDER_MALE, "GluPerformance is created in a thread without looper!");
                Common.runOnUIThread(new Runnable() { // from class: com.glu.plugins.gluanalytics.GluPerformance.FrameTask.1
                    @Override // java.lang.Runnable
                    public void run() {
                        FrameTask.this.choreographer = Choreographer.getInstance();
                        FrameTask.this.start();
                    }
                });
            }
        }

        public void start() {
            Choreographer choreographer = this.choreographer;
            if (choreographer != null) {
                choreographer.postFrameCallback(this);
            }
        }

        public void end() {
            Choreographer choreographer = this.choreographer;
            if (choreographer != null) {
                choreographer.removeFrameCallback(this);
            }
        }

        @Override // android.view.Choreographer.FrameCallback
        public void doFrame(long j) {
            if (GluPerformance.this.mLastFrameTime == 0) {
                GluPerformance.this.mLastFrameTime = j;
            } else {
                GluPerformance.access$408(GluPerformance.this);
                double d = (j - GluPerformance.this.mLastFrameTime) * 1.0E-9d;
                if (d >= GluPerformance.this.mSampleInterval) {
                    GluPerformance.this.mLastFrameTime = j;
                    GluPerformance.this.mLatestFPS = r5.mFrameCount / d;
                    GluPerformance.this.mFrameCount = 0;
                }
            }
            this.choreographer.postFrameCallback(this);
        }
    }

    public class SampleTask implements Runnable {
        public SampleTask() {
        }

        @Override // java.lang.Runnable
        public void run() {
            synchronized (GluPerformance.this.lock) {
                if (GluPerformance.this.mPerfSamples.size() != 0 && GluPerformance.this.mRunning) {
                    double usedMemory = GluPerformance.this.getUsedMemory();
                    double min = Math.min(GluPerformance.this.mLatestFPS, GluPerformance.this.mTargetFrameRate);
                    synchronized (GluPerformance.this.lock) {
                        try {
                            for (PerfSample perfSample : GluPerformance.this.mPerfSamples.values()) {
                                if (!perfSample.isPaused) {
                                    perfSample.sampleCount++;
                                    int i = perfSample.type;
                                    if ((i & 2) != 0) {
                                        perfSample.totalMemory += usedMemory;
                                        if (perfSample.maxMemory < usedMemory) {
                                            perfSample.maxMemory = usedMemory;
                                        }
                                    }
                                    if ((i & 4) != 0) {
                                        perfSample.totalFPS += min;
                                        perfSample.lastFPS = min;
                                        if (perfSample.minFPS > min) {
                                            perfSample.minFPS = min;
                                        }
                                        if (perfSample.maxFPS < min) {
                                            perfSample.maxFPS = min;
                                        }
                                    }
                                }
                            }
                        } finally {
                        }
                    }
                }
            }
        }
    }

    public class PerfSample {
        double endMemory;
        boolean isPaused;
        boolean isSuspended;
        double lastFPS;
        double maxFPS;
        double maxMemory;
        double minFPS;
        double pausedTimeTotal;
        String placement;
        double preInitTime;
        long sampleCount;
        double startMemory;
        double startPausedTimeStamp;
        double startTimeStamp;
        double totalFPS;
        double totalMemory;
        int type;
        Map<String, ?> userData;

        private PerfSample() {
        }
    }
}