Add decompiled APK source code (JADX)

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

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/vungle/ads/internal/signals/SessionData$$serializer.java

@@ -0,0 +1,148 @@
+package com.vungle.ads.internal.signals;
+
+import com.mbridge.msdk.newreward.function.common.MBridgeCommon;
+import com.vungle.ads.internal.model.UnclosedAd$$serializer;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.serialization.KSerializer;
+import kotlinx.serialization.UnknownFieldException;
+import kotlinx.serialization.descriptors.SerialDescriptor;
+import kotlinx.serialization.encoding.CompositeDecoder;
+import kotlinx.serialization.encoding.CompositeEncoder;
+import kotlinx.serialization.encoding.Decoder;
+import kotlinx.serialization.encoding.Encoder;
+import kotlinx.serialization.internal.ArrayListSerializer;
+import kotlinx.serialization.internal.GeneratedSerializer;
+import kotlinx.serialization.internal.IntSerializer;
+import kotlinx.serialization.internal.LongSerializer;
+import kotlinx.serialization.internal.PluginGeneratedSerialDescriptor;
+import kotlinx.serialization.internal.StringSerializer;
+
+/* loaded from: classes4.dex */
+public final class SessionData$$serializer implements GeneratedSerializer<SessionData> {
+    public static final SessionData$$serializer INSTANCE;
+    public static final /* synthetic */ SerialDescriptor descriptor;
+
+    public SerialDescriptor getDescriptor() {
+        return descriptor;
+    }
+
+    static {
+        SessionData$$serializer sessionData$$serializer = new SessionData$$serializer();
+        INSTANCE = sessionData$$serializer;
+        SerialDescriptor pluginGeneratedSerialDescriptor = new PluginGeneratedSerialDescriptor("com.vungle.ads.internal.signals.SessionData", sessionData$$serializer, 7);
+        pluginGeneratedSerialDescriptor.addElement("103", false);
+        pluginGeneratedSerialDescriptor.addElement("101", true);
+        pluginGeneratedSerialDescriptor.addElement("100", true);
+        pluginGeneratedSerialDescriptor.addElement("106", true);
+        pluginGeneratedSerialDescriptor.addElement(MBridgeCommon.DYNAMIC_VIEW_TEMPLATE_VALUE, true);
+        pluginGeneratedSerialDescriptor.addElement("104", true);
+        pluginGeneratedSerialDescriptor.addElement("105", true);
+        descriptor = pluginGeneratedSerialDescriptor;
+    }
+
+    private SessionData$$serializer() {
+    }
+
+    public KSerializer<?>[] childSerializers() {
+        return new KSerializer[]{(KSerializer) IntSerializer.INSTANCE, (KSerializer) StringSerializer.INSTANCE, (KSerializer) LongSerializer.INSTANCE, (KSerializer) new ArrayListSerializer(SignaledAd$$serializer.INSTANCE), (KSerializer) LongSerializer.INSTANCE, (KSerializer) IntSerializer.INSTANCE, (KSerializer) new ArrayListSerializer(UnclosedAd$$serializer.INSTANCE)};
+    }
+
+    /* renamed from: deserialize, reason: merged with bridge method [inline-methods] */
+    public SessionData m3969deserialize(Decoder decoder) {
+        int i;
+        Object obj;
+        int i2;
+        long j;
+        int i3;
+        String str;
+        Object obj2;
+        long j2;
+        Intrinsics.checkNotNullParameter(decoder, "decoder");
+        SerialDescriptor descriptor2 = getDescriptor();
+        CompositeDecoder beginStructure = decoder.beginStructure(descriptor2);
+        int i4 = 2;
+        if (beginStructure.decodeSequentially()) {
+            int decodeIntElement = beginStructure.decodeIntElement(descriptor2, 0);
+            String decodeStringElement = beginStructure.decodeStringElement(descriptor2, 1);
+            long decodeLongElement = beginStructure.decodeLongElement(descriptor2, 2);
+            obj2 = beginStructure.decodeSerializableElement(descriptor2, 3, new ArrayListSerializer(SignaledAd$$serializer.INSTANCE), (Object) null);
+            long decodeLongElement2 = beginStructure.decodeLongElement(descriptor2, 4);
+            int decodeIntElement2 = beginStructure.decodeIntElement(descriptor2, 5);
+            obj = beginStructure.decodeSerializableElement(descriptor2, 6, new ArrayListSerializer(UnclosedAd$$serializer.INSTANCE), (Object) null);
+            i = decodeIntElement;
+            i2 = decodeIntElement2;
+            j = decodeLongElement2;
+            str = decodeStringElement;
+            i3 = 127;
+            j2 = decodeLongElement;
+        } else {
+            long j3 = 0;
+            boolean z = true;
+            int i5 = 0;
+            int i6 = 0;
+            String str2 = null;
+            Object obj3 = null;
+            long j4 = 0;
+            Object obj4 = null;
+            int i7 = 0;
+            while (z) {
+                int decodeElementIndex = beginStructure.decodeElementIndex(descriptor2);
+                switch (decodeElementIndex) {
+                    case -1:
+                        z = false;
+                    case 0:
+                        i6 |= 1;
+                        i5 = beginStructure.decodeIntElement(descriptor2, 0);
+                    case 1:
+                        str2 = beginStructure.decodeStringElement(descriptor2, 1);
+                        i6 |= 2;
+                    case 2:
+                        j4 = beginStructure.decodeLongElement(descriptor2, i4);
+                        i6 |= 4;
+                    case 3:
+                        obj3 = beginStructure.decodeSerializableElement(descriptor2, 3, new ArrayListSerializer(SignaledAd$$serializer.INSTANCE), obj3);
+                        i6 |= 8;
+                        i4 = 2;
+                    case 4:
+                        j3 = beginStructure.decodeLongElement(descriptor2, 4);
+                        i6 |= 16;
+                        i4 = 2;
+                    case 5:
+                        i7 = beginStructure.decodeIntElement(descriptor2, 5);
+                        i6 |= 32;
+                        i4 = 2;
+                    case 6:
+                        obj4 = beginStructure.decodeSerializableElement(descriptor2, 6, new ArrayListSerializer(UnclosedAd$$serializer.INSTANCE), obj4);
+                        i6 |= 64;
+                        i4 = 2;
+                    default:
+                        throw new UnknownFieldException(decodeElementIndex);
+                }
+            }
+            i = i5;
+            obj = obj4;
+            i2 = i7;
+            j = j3;
+            i3 = i6;
+            str = str2;
+            obj2 = obj3;
+            j2 = j4;
+        }
+        beginStructure.endStructure(descriptor2);
+        return new SessionData(i3, i, str, j2, (List) obj2, j, i2, (List) obj, null);
+    }
+
+    public void serialize(Encoder encoder, SessionData value) {
+        Intrinsics.checkNotNullParameter(encoder, "encoder");
+        Intrinsics.checkNotNullParameter(value, "value");
+        SerialDescriptor descriptor2 = getDescriptor();
+        CompositeEncoder beginStructure = encoder.beginStructure(descriptor2);
+        SessionData.write$Self(value, beginStructure, descriptor2);
+        beginStructure.endStructure(descriptor2);
+    }
+
+    public KSerializer<?>[] typeParametersSerializers() {
+        return GeneratedSerializer.DefaultImpls.typeParametersSerializers(this);
+    }
+}

decompiled/sources/com/vungle/ads/internal/signals/SessionData.java

@@ -0,0 +1,314 @@
+package com.vungle.ads.internal.signals;
+
+import com.mbridge.msdk.newreward.function.common.MBridgeCommon;
+import com.vungle.ads.internal.model.UnclosedAd;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.serialization.KSerializer;
+import kotlinx.serialization.SerialName;
+import kotlinx.serialization.Serializable;
+import kotlinx.serialization.internal.PluginExceptionsKt;
+import kotlinx.serialization.internal.SerializationConstructorMarker;
+
+@Serializable
+/* loaded from: classes4.dex */
+public final class SessionData {
+    public static final Companion Companion = new Companion(null);
+    private final int sessionCount;
+    private long sessionCreationTime;
+    private int sessionDepthCounter;
+    private long sessionDuration;
+    private final String sessionId;
+    private List<SignaledAd> signaledAd;
+    private List<UnclosedAd> unclosedAd;
+
+    public static /* synthetic */ SessionData copy$default(SessionData sessionData, int i, int i2, Object obj) {
+        if ((i2 & 1) != 0) {
+            i = sessionData.sessionCount;
+        }
+        return sessionData.copy(i);
+    }
+
+    @SerialName("103")
+    public static /* synthetic */ void getSessionCount$annotations() {
+    }
+
+    @SerialName("100")
+    public static /* synthetic */ void getSessionCreationTime$annotations() {
+    }
+
+    @SerialName("104")
+    public static /* synthetic */ void getSessionDepthCounter$annotations() {
+    }
+
+    @SerialName(MBridgeCommon.DYNAMIC_VIEW_TEMPLATE_VALUE)
+    public static /* synthetic */ void getSessionDuration$annotations() {
+    }
+
+    @SerialName("101")
+    public static /* synthetic */ void getSessionId$annotations() {
+    }
+
+    @SerialName("106")
+    public static /* synthetic */ void getSignaledAd$annotations() {
+    }
+
+    @SerialName("105")
+    public static /* synthetic */ void getUnclosedAd$annotations() {
+    }
+
+    public final int component1() {
+        return this.sessionCount;
+    }
+
+    public final SessionData copy(int i) {
+        return new SessionData(i);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        return (obj instanceof SessionData) && this.sessionCount == ((SessionData) obj).sessionCount;
+    }
+
+    public final int getSessionCount() {
+        return this.sessionCount;
+    }
+
+    public final long getSessionCreationTime() {
+        return this.sessionCreationTime;
+    }
+
+    public final int getSessionDepthCounter() {
+        return this.sessionDepthCounter;
+    }
+
+    public final long getSessionDuration() {
+        return this.sessionDuration;
+    }
+
+    public final String getSessionId() {
+        return this.sessionId;
+    }
+
+    public final List<SignaledAd> getSignaledAd() {
+        return this.signaledAd;
+    }
+
+    public final List<UnclosedAd> getUnclosedAd() {
+        return this.unclosedAd;
+    }
+
+    public int hashCode() {
+        return Integer.hashCode(this.sessionCount);
+    }
+
+    public final void setSessionCreationTime(long j) {
+        this.sessionCreationTime = j;
+    }
+
+    public final void setSessionDepthCounter(int i) {
+        this.sessionDepthCounter = i;
+    }
+
+    public final void setSessionDuration(long j) {
+        this.sessionDuration = j;
+    }
+
+    public final void setSignaledAd(List<SignaledAd> list) {
+        Intrinsics.checkNotNullParameter(list, "<set-?>");
+        this.signaledAd = list;
+    }
+
+    public final void setUnclosedAd(List<UnclosedAd> list) {
+        Intrinsics.checkNotNullParameter(list, "<set-?>");
+        this.unclosedAd = list;
+    }
+
+    public String toString() {
+        return "SessionData(sessionCount=" + this.sessionCount + ')';
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final KSerializer<SessionData> serializer() {
+            return SessionData$$serializer.INSTANCE;
+        }
+    }
+
+    public SessionData(int i) {
+        this.sessionCount = i;
+        String uuid = UUID.randomUUID().toString();
+        Intrinsics.checkNotNullExpressionValue(uuid, "randomUUID().toString()");
+        this.sessionId = uuid;
+        this.sessionCreationTime = System.currentTimeMillis() / 1000;
+        this.signaledAd = new ArrayList();
+        this.unclosedAd = new ArrayList();
+    }
+
+    public /* synthetic */ SessionData(int i, @SerialName("103") int i2, @SerialName("101") String str, @SerialName("100") long j, @SerialName("106") List list, @SerialName("102") long j2, @SerialName("104") int i3, @SerialName("105") List list2, SerializationConstructorMarker serializationConstructorMarker) {
+        if (1 != (i & 1)) {
+            PluginExceptionsKt.throwMissingFieldException(i, 1, SessionData$$serializer.INSTANCE.getDescriptor());
+        }
+        this.sessionCount = i2;
+        if ((i & 2) == 0) {
+            String uuid = UUID.randomUUID().toString();
+            Intrinsics.checkNotNullExpressionValue(uuid, "randomUUID().toString()");
+            this.sessionId = uuid;
+        } else {
+            this.sessionId = str;
+        }
+        if ((i & 4) == 0) {
+            this.sessionCreationTime = System.currentTimeMillis() / 1000;
+        } else {
+            this.sessionCreationTime = j;
+        }
+        if ((i & 8) == 0) {
+            this.signaledAd = new ArrayList();
+        } else {
+            this.signaledAd = list;
+        }
+        if ((i & 16) == 0) {
+            this.sessionDuration = 0L;
+        } else {
+            this.sessionDuration = j2;
+        }
+        if ((i & 32) == 0) {
+            this.sessionDepthCounter = 0;
+        } else {
+            this.sessionDepthCounter = i3;
+        }
+        if ((i & 64) == 0) {
+            this.unclosedAd = new ArrayList();
+        } else {
+            this.unclosedAd = list2;
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:4:0x0030, code lost:
+    
+        if (kotlin.jvm.internal.Intrinsics.areEqual(r1, r2) == false) goto L7;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final void write$Self(com.vungle.ads.internal.signals.SessionData r7, kotlinx.serialization.encoding.CompositeEncoder r8, kotlinx.serialization.descriptors.SerialDescriptor r9) {
+        /*
+            java.lang.String r0 = "self"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r7, r0)
+            java.lang.String r0 = "output"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r8, r0)
+            java.lang.String r0 = "serialDesc"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r9, r0)
+            int r0 = r7.sessionCount
+            r1 = 0
+            r8.encodeIntElement(r9, r1, r0)
+            r0 = 1
+            boolean r1 = r8.shouldEncodeElementDefault(r9, r0)
+            if (r1 == 0) goto L1d
+            goto L32
+        L1d:
+            java.lang.String r1 = r7.sessionId
+            java.util.UUID r2 = java.util.UUID.randomUUID()
+            java.lang.String r2 = r2.toString()
+            java.lang.String r3 = "randomUUID().toString()"
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r2, r3)
+            boolean r1 = kotlin.jvm.internal.Intrinsics.areEqual(r1, r2)
+            if (r1 != 0) goto L37
+        L32:
+            java.lang.String r1 = r7.sessionId
+            r8.encodeStringElement(r9, r0, r1)
+        L37:
+            r0 = 2
+            boolean r1 = r8.shouldEncodeElementDefault(r9, r0)
+            if (r1 == 0) goto L3f
+            goto L4c
+        L3f:
+            long r1 = r7.sessionCreationTime
+            long r3 = java.lang.System.currentTimeMillis()
+            r5 = 1000(0x3e8, double:4.94E-321)
+            long r3 = r3 / r5
+            int r1 = (r1 > r3 ? 1 : (r1 == r3 ? 0 : -1))
+            if (r1 == 0) goto L51
+        L4c:
+            long r1 = r7.sessionCreationTime
+            r8.encodeLongElement(r9, r0, r1)
+        L51:
+            r0 = 3
+            boolean r1 = r8.shouldEncodeElementDefault(r9, r0)
+            if (r1 == 0) goto L59
+            goto L66
+        L59:
+            java.util.List<com.vungle.ads.internal.signals.SignaledAd> r1 = r7.signaledAd
+            java.util.ArrayList r2 = new java.util.ArrayList
+            r2.<init>()
+            boolean r1 = kotlin.jvm.internal.Intrinsics.areEqual(r1, r2)
+            if (r1 != 0) goto L76
+        L66:
+            kotlinx.serialization.internal.ArrayListSerializer r1 = new kotlinx.serialization.internal.ArrayListSerializer
+            com.vungle.ads.internal.signals.SignaledAd$$serializer r2 = com.vungle.ads.internal.signals.SignaledAd$$serializer.INSTANCE
+            kotlinx.serialization.KSerializer r2 = (kotlinx.serialization.KSerializer) r2
+            r1.<init>(r2)
+            kotlinx.serialization.SerializationStrategy r1 = (kotlinx.serialization.SerializationStrategy) r1
+            java.util.List<com.vungle.ads.internal.signals.SignaledAd> r2 = r7.signaledAd
+            r8.encodeSerializableElement(r9, r0, r1, r2)
+        L76:
+            r0 = 4
+            boolean r1 = r8.shouldEncodeElementDefault(r9, r0)
+            if (r1 == 0) goto L7e
+            goto L86
+        L7e:
+            long r1 = r7.sessionDuration
+            r3 = 0
+            int r1 = (r1 > r3 ? 1 : (r1 == r3 ? 0 : -1))
+            if (r1 == 0) goto L8b
+        L86:
+            long r1 = r7.sessionDuration
+            r8.encodeLongElement(r9, r0, r1)
+        L8b:
+            r0 = 5
+            boolean r1 = r8.shouldEncodeElementDefault(r9, r0)
+            if (r1 == 0) goto L93
+            goto L97
+        L93:
+            int r1 = r7.sessionDepthCounter
+            if (r1 == 0) goto L9c
+        L97:
+            int r1 = r7.sessionDepthCounter
+            r8.encodeIntElement(r9, r0, r1)
+        L9c:
+            r0 = 6
+            boolean r1 = r8.shouldEncodeElementDefault(r9, r0)
+            if (r1 == 0) goto La4
+            goto Lb1
+        La4:
+            java.util.List<com.vungle.ads.internal.model.UnclosedAd> r1 = r7.unclosedAd
+            java.util.ArrayList r2 = new java.util.ArrayList
+            r2.<init>()
+            boolean r1 = kotlin.jvm.internal.Intrinsics.areEqual(r1, r2)
+            if (r1 != 0) goto Lc1
+        Lb1:
+            kotlinx.serialization.internal.ArrayListSerializer r1 = new kotlinx.serialization.internal.ArrayListSerializer
+            com.vungle.ads.internal.model.UnclosedAd$$serializer r2 = com.vungle.ads.internal.model.UnclosedAd$$serializer.INSTANCE
+            kotlinx.serialization.KSerializer r2 = (kotlinx.serialization.KSerializer) r2
+            r1.<init>(r2)
+            kotlinx.serialization.SerializationStrategy r1 = (kotlinx.serialization.SerializationStrategy) r1
+            java.util.List<com.vungle.ads.internal.model.UnclosedAd> r7 = r7.unclosedAd
+            r8.encodeSerializableElement(r9, r0, r1, r7)
+        Lc1:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.vungle.ads.internal.signals.SessionData.write$Self(com.vungle.ads.internal.signals.SessionData, kotlinx.serialization.encoding.CompositeEncoder, kotlinx.serialization.descriptors.SerialDescriptor):void");
+    }
+}

decompiled/sources/com/vungle/ads/internal/signals/SignalKey.java

@@ -0,0 +1,21 @@
+package com.vungle.ads.internal.signals;
+
+/* loaded from: classes4.dex */
+public final class SignalKey {
+    public static final int AD_LOADED_PLAYED_DURATION = 110;
+    public static final int AD_SIGNAL = 106;
+    public static final int DURATION_AFTER_PREVIOUS_LOAD = 109;
+    public static final int EVENT_ID = 107;
+    public static final SignalKey INSTANCE = new SignalKey();
+    public static final int SCREEN_ORIENTATION = 108;
+    public static final int SESSION_COUNT = 103;
+    public static final int SESSION_CREATION_TIME = 100;
+    public static final int SESSION_DEPTH = 104;
+    public static final int SESSION_DURATION = 102;
+    public static final int SESSION_ID = 101;
+    public static final int TEMPLATE_SIGNAL = 500;
+    public static final int UNCLOSED_AD = 105;
+
+    private SignalKey() {
+    }
+}

decompiled/sources/com/vungle/ads/internal/signals/SignalManager.java

@@ -0,0 +1,352 @@
+package com.vungle.ads.internal.signals;
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import androidx.annotation.VisibleForTesting;
+import com.vungle.ads.ServiceLocator;
+import com.vungle.ads.internal.ConfigManager;
+import com.vungle.ads.internal.executor.Executors;
+import com.vungle.ads.internal.model.UnclosedAd;
+import com.vungle.ads.internal.persistence.FilePreferences;
+import com.vungle.ads.internal.session.UnclosedAdDetector;
+import com.vungle.ads.internal.util.ActivityManager;
+import com.vungle.ads.internal.util.Logger;
+import com.vungle.ads.internal.util.PathProvider;
+import java.util.concurrent.ConcurrentHashMap;
+import kotlin.Lazy;
+import kotlin.LazyKt__LazyJVMKt;
+import kotlin.LazyThreadSafetyMode;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Reflection;
+import kotlinx.serialization.SerializationStrategy;
+import kotlinx.serialization.SerializersKt;
+import kotlinx.serialization.StringFormat;
+import kotlinx.serialization.json.Json;
+import kotlinx.serialization.json.JsonBuilder;
+import kotlinx.serialization.json.JsonKt;
+
+/* loaded from: classes4.dex */
+public final class SignalManager {
+    public static final Companion Companion = new Companion(null);
+    public static final String SESSION_COUNT_KEY = "vungle_signal_session_count";
+    private static final int SESSION_COUNT_NOT_SET = -1;
+    public static final String SESSION_TIME_KEY = "vungle_signal_session_creation_time";
+    public static final int SIGNAL_VERSION = 1;
+    private static final String TAG = "SignalManager";
+    public static final long TWENTY_FOUR_HOURS_MILLIS = 86400000;
+    private final Context context;
+    private SessionData currentSession;
+    private long enterBackgroundTime;
+    private long enterForegroundTime;
+    private final Lazy filePreferences$delegate;
+    private final Json json;
+    private ConcurrentHashMap<String, Long> mapOfLastLoadTimes;
+    private int sessionCount;
+    private long sessionDuration;
+    private long sessionSeriesCreatedTime;
+    private UnclosedAdDetector unclosedAdDetector;
+
+    @VisibleForTesting(otherwise = 2)
+    public static /* synthetic */ void getCurrentSession$vungle_ads_release$annotations() {
+    }
+
+    public final Context getContext() {
+        return this.context;
+    }
+
+    public final SessionData getCurrentSession$vungle_ads_release() {
+        return this.currentSession;
+    }
+
+    public final long getEnterBackgroundTime() {
+        return this.enterBackgroundTime;
+    }
+
+    public final long getEnterForegroundTime() {
+        return this.enterForegroundTime;
+    }
+
+    public final ConcurrentHashMap<String, Long> getMapOfLastLoadTimes() {
+        return this.mapOfLastLoadTimes;
+    }
+
+    public final int getSessionCount() {
+        return this.sessionCount;
+    }
+
+    public final long getSessionDuration() {
+        return this.sessionDuration;
+    }
+
+    public final long getSessionSeriesCreatedTime() {
+        return this.sessionSeriesCreatedTime;
+    }
+
+    public final void setCurrentSession$vungle_ads_release(SessionData sessionData) {
+        Intrinsics.checkNotNullParameter(sessionData, "<set-?>");
+        this.currentSession = sessionData;
+    }
+
+    public final void setEnterBackgroundTime(long j) {
+        this.enterBackgroundTime = j;
+    }
+
+    public final void setEnterForegroundTime(long j) {
+        this.enterForegroundTime = j;
+    }
+
+    public final void setMapOfLastLoadTimes(ConcurrentHashMap<String, Long> concurrentHashMap) {
+        Intrinsics.checkNotNullParameter(concurrentHashMap, "<set-?>");
+        this.mapOfLastLoadTimes = concurrentHashMap;
+    }
+
+    public final void setSessionCount(int i) {
+        this.sessionCount = i;
+    }
+
+    public final void setSessionDuration(long j) {
+        this.sessionDuration = j;
+    }
+
+    public final void setSessionSeriesCreatedTime(long j) {
+        this.sessionSeriesCreatedTime = j;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    public SignalManager(final Context context) {
+        Lazy lazy;
+        Lazy lazy2;
+        Lazy lazy3;
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+        this.json = JsonKt.Json$default((Json) null, new Function1() { // from class: com.vungle.ads.internal.signals.SignalManager$json$1
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+                invoke((JsonBuilder) obj);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(JsonBuilder Json) {
+                Intrinsics.checkNotNullParameter(Json, "$this$Json");
+                Json.setIgnoreUnknownKeys(true);
+                Json.setEncodeDefaults(true);
+                Json.setExplicitNulls(false);
+            }
+        }, 1, (Object) null);
+        this.enterForegroundTime = System.currentTimeMillis();
+        this.sessionCount = -1;
+        this.mapOfLastLoadTimes = new ConcurrentHashMap<>();
+        ServiceLocator.Companion companion = ServiceLocator.Companion;
+        LazyThreadSafetyMode lazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED;
+        lazy = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.signals.SignalManager$special$$inlined$inject$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(0);
+            }
+
+            /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.persistence.FilePreferences, java.lang.Object] */
+            @Override // kotlin.jvm.functions.Function0
+            public final FilePreferences invoke() {
+                return ServiceLocator.Companion.getInstance(context).getService(FilePreferences.class);
+            }
+        });
+        this.filePreferences$delegate = lazy;
+        registerNotifications();
+        this.sessionSeriesCreatedTime = getFilePreferences().getLong(SESSION_TIME_KEY, -1L);
+        updateSessionCount();
+        this.currentSession = new SessionData(this.sessionCount);
+        lazy2 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.signals.SignalManager$special$$inlined$inject$2
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(0);
+            }
+
+            /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.executor.Executors, java.lang.Object] */
+            @Override // kotlin.jvm.functions.Function0
+            public final Executors invoke() {
+                return ServiceLocator.Companion.getInstance(context).getService(Executors.class);
+            }
+        });
+        lazy3 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.signals.SignalManager$special$$inlined$inject$3
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(0);
+            }
+
+            /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.util.PathProvider, java.lang.Object] */
+            @Override // kotlin.jvm.functions.Function0
+            public final PathProvider invoke() {
+                return ServiceLocator.Companion.getInstance(context).getService(PathProvider.class);
+            }
+        });
+        UnclosedAdDetector unclosedAdDetector = new UnclosedAdDetector(context, this.currentSession.getSessionId(), m3970_init_$lambda0(lazy2), m3971_init_$lambda1(lazy3));
+        this.unclosedAdDetector = unclosedAdDetector;
+        this.currentSession.setUnclosedAd(unclosedAdDetector.retrieveUnclosedAd());
+    }
+
+    public final FilePreferences getFilePreferences() {
+        return (FilePreferences) this.filePreferences$delegate.getValue();
+    }
+
+    public final String getUuid() {
+        return this.currentSession.getSessionId();
+    }
+
+    /* renamed from: _init_$lambda-0, reason: not valid java name */
+    private static final Executors m3970_init_$lambda0(Lazy lazy) {
+        return (Executors) lazy.getValue();
+    }
+
+    /* renamed from: _init_$lambda-1, reason: not valid java name */
+    private static final PathProvider m3971_init_$lambda1(Lazy lazy) {
+        return (PathProvider) lazy.getValue();
+    }
+
+    private final void updateSessionCount() {
+        if (this.sessionCount == -1) {
+            this.sessionCount = getFilePreferences().getInt(SESSION_COUNT_KEY, 0);
+        }
+        long currentTimeMillis = System.currentTimeMillis();
+        long j = this.sessionSeriesCreatedTime;
+        long j2 = currentTimeMillis - j;
+        if (j < 0 || j2 >= TWENTY_FOUR_HOURS_MILLIS) {
+            this.sessionCount = 1;
+            getFilePreferences().put(SESSION_TIME_KEY, currentTimeMillis);
+            this.sessionSeriesCreatedTime = currentTimeMillis;
+        } else {
+            this.sessionCount++;
+        }
+        getFilePreferences().put(SESSION_COUNT_KEY, this.sessionCount);
+        getFilePreferences().apply();
+    }
+
+    private final void registerNotifications() {
+        ActivityManager.Companion.addLifecycleListener(new ActivityManager.LifeCycleCallback() { // from class: com.vungle.ads.internal.signals.SignalManager$registerNotifications$1
+            @Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
+            public void onResume() {
+                super.onResume();
+                if (SignalManager.this.getEnterBackgroundTime() == 0) {
+                    Logger.Companion.d("SignalManager", "SignalManager#onResume skipped");
+                    return;
+                }
+                long currentTimeMillis = System.currentTimeMillis();
+                if (currentTimeMillis - SignalManager.this.getEnterBackgroundTime() > ConfigManager.INSTANCE.getSignalsSessionTimeout()) {
+                    SignalManager.this.createNewSessionData();
+                }
+                SignalManager.this.setEnterForegroundTime(currentTimeMillis);
+                SignalManager.this.setEnterBackgroundTime(0L);
+            }
+
+            @Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
+            public void onPause() {
+                super.onPause();
+                SignalManager.this.setEnterBackgroundTime(System.currentTimeMillis());
+                SignalManager signalManager = SignalManager.this;
+                signalManager.setSessionDuration(signalManager.getSessionDuration() + (SignalManager.this.getEnterBackgroundTime() - SignalManager.this.getEnterForegroundTime()));
+            }
+        });
+    }
+
+    public final void createNewSessionData() {
+        updateSessionCount();
+        this.currentSession = new SessionData(this.sessionCount);
+    }
+
+    public final synchronized SignaledAd getSignaledAd(String placementId) {
+        long currentTimeMillis;
+        Long l;
+        try {
+            Intrinsics.checkNotNullParameter(placementId, "placementId");
+            currentTimeMillis = System.currentTimeMillis();
+            l = this.mapOfLastLoadTimes.containsKey(placementId) ? this.mapOfLastLoadTimes.get(placementId) : null;
+            this.mapOfLastLoadTimes.put(placementId, Long.valueOf(currentTimeMillis));
+        } catch (Throwable th) {
+            throw th;
+        }
+        return new SignaledAd(l, currentTimeMillis);
+    }
+
+    public final synchronized void increaseSessionDepthCounter() {
+        SessionData sessionData = this.currentSession;
+        sessionData.setSessionDepthCounter(sessionData.getSessionDepthCounter() + 1);
+    }
+
+    public final void recordUnclosedAd(UnclosedAd unclosedAd) {
+        Intrinsics.checkNotNullParameter(unclosedAd, "unclosedAd");
+        if (ConfigManager.INSTANCE.signalsDisabled()) {
+            return;
+        }
+        this.unclosedAdDetector.addUnclosedAd(unclosedAd);
+    }
+
+    public final void removeUnclosedAd(UnclosedAd unclosedAd) {
+        Intrinsics.checkNotNullParameter(unclosedAd, "unclosedAd");
+        if (ConfigManager.INSTANCE.signalsDisabled()) {
+            return;
+        }
+        this.unclosedAdDetector.removeUnclosedAd(unclosedAd);
+    }
+
+    public final void registerSignaledAd(Context context, SignaledAd signaledAd) {
+        Intrinsics.checkNotNullParameter(signaledAd, "signaledAd");
+        this.currentSession.getSignaledAd().clear();
+        this.currentSession.getSignaledAd().add(signaledAd);
+        this.currentSession.getSignaledAd().get(0).setScreenOrientation(screenOrientation(context));
+    }
+
+    public final void updateTemplateSignals(String str) {
+        if (str == null || str.length() == 0 || !(!this.currentSession.getSignaledAd().isEmpty())) {
+            return;
+        }
+        this.currentSession.getSignaledAd().get(0).setTemplateSignals(str);
+    }
+
+    private final void updateSessionDuration() {
+        this.currentSession.setSessionDuration((this.sessionDuration + System.currentTimeMillis()) - this.enterForegroundTime);
+    }
+
+    public final String generateSignals() {
+        updateSessionDuration();
+        try {
+            StringBuilder sb = new StringBuilder();
+            sb.append("1:");
+            StringFormat stringFormat = this.json;
+            SessionData sessionData = this.currentSession;
+            SerializationStrategy serializer = SerializersKt.serializer(stringFormat.getSerializersModule(), Reflection.typeOf(SessionData.class));
+            Intrinsics.checkNotNull(serializer, "null cannot be cast to non-null type kotlinx.serialization.KSerializer<T of kotlinx.serialization.internal.Platform_commonKt.cast>");
+            sb.append(stringFormat.encodeToString(serializer, sessionData));
+            return sb.toString();
+        } catch (Error | Exception unused) {
+            return null;
+        }
+    }
+
+    public final int screenOrientation(Context context) {
+        Configuration configuration;
+        if (context == null) {
+            context = this.context;
+        }
+        Resources resources = context.getResources();
+        Integer valueOf = (resources == null || (configuration = resources.getConfiguration()) == null) ? null : Integer.valueOf(configuration.orientation);
+        if (valueOf != null && valueOf.intValue() == 2) {
+            return 2;
+        }
+        if (valueOf != null && valueOf.intValue() == 1) {
+            return 1;
+        }
+        return (valueOf != null && valueOf.intValue() == 0) ? 0 : -1;
+    }
+}

decompiled/sources/com/vungle/ads/internal/signals/SignaledAd$$serializer.java

@@ -0,0 +1,123 @@
+package com.vungle.ads.internal.signals;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.serialization.KSerializer;
+import kotlinx.serialization.UnknownFieldException;
+import kotlinx.serialization.builtins.BuiltinSerializersKt;
+import kotlinx.serialization.descriptors.SerialDescriptor;
+import kotlinx.serialization.encoding.CompositeDecoder;
+import kotlinx.serialization.encoding.CompositeEncoder;
+import kotlinx.serialization.encoding.Decoder;
+import kotlinx.serialization.encoding.Encoder;
+import kotlinx.serialization.internal.GeneratedSerializer;
+import kotlinx.serialization.internal.IntSerializer;
+import kotlinx.serialization.internal.LongSerializer;
+import kotlinx.serialization.internal.PluginGeneratedSerialDescriptor;
+import kotlinx.serialization.internal.StringSerializer;
+
+/* loaded from: classes4.dex */
+public final class SignaledAd$$serializer implements GeneratedSerializer<SignaledAd> {
+    public static final SignaledAd$$serializer INSTANCE;
+    public static final /* synthetic */ SerialDescriptor descriptor;
+
+    public SerialDescriptor getDescriptor() {
+        return descriptor;
+    }
+
+    static {
+        SignaledAd$$serializer signaledAd$$serializer = new SignaledAd$$serializer();
+        INSTANCE = signaledAd$$serializer;
+        SerialDescriptor pluginGeneratedSerialDescriptor = new PluginGeneratedSerialDescriptor("com.vungle.ads.internal.signals.SignaledAd", signaledAd$$serializer, 5);
+        pluginGeneratedSerialDescriptor.addElement("500", true);
+        pluginGeneratedSerialDescriptor.addElement("109", false);
+        pluginGeneratedSerialDescriptor.addElement("107", true);
+        pluginGeneratedSerialDescriptor.addElement("110", true);
+        pluginGeneratedSerialDescriptor.addElement("108", true);
+        descriptor = pluginGeneratedSerialDescriptor;
+    }
+
+    private SignaledAd$$serializer() {
+    }
+
+    public KSerializer<?>[] childSerializers() {
+        return new KSerializer[]{BuiltinSerializersKt.getNullable(StringSerializer.INSTANCE), (KSerializer) LongSerializer.INSTANCE, BuiltinSerializersKt.getNullable(StringSerializer.INSTANCE), (KSerializer) LongSerializer.INSTANCE, (KSerializer) IntSerializer.INSTANCE};
+    }
+
+    /* renamed from: deserialize, reason: merged with bridge method [inline-methods] */
+    public SignaledAd m3972deserialize(Decoder decoder) {
+        int i;
+        long j;
+        Object obj;
+        long j2;
+        int i2;
+        Object obj2;
+        Intrinsics.checkNotNullParameter(decoder, "decoder");
+        SerialDescriptor descriptor2 = getDescriptor();
+        CompositeDecoder beginStructure = decoder.beginStructure(descriptor2);
+        int i3 = 3;
+        if (beginStructure.decodeSequentially()) {
+            obj2 = beginStructure.decodeNullableSerializableElement(descriptor2, 0, StringSerializer.INSTANCE, (Object) null);
+            j = beginStructure.decodeLongElement(descriptor2, 1);
+            obj = beginStructure.decodeNullableSerializableElement(descriptor2, 2, StringSerializer.INSTANCE, (Object) null);
+            long decodeLongElement = beginStructure.decodeLongElement(descriptor2, 3);
+            i = 31;
+            i2 = beginStructure.decodeIntElement(descriptor2, 4);
+            j2 = decodeLongElement;
+        } else {
+            long j3 = 0;
+            boolean z = true;
+            int i4 = 0;
+            Object obj3 = null;
+            Object obj4 = null;
+            long j4 = 0;
+            int i5 = 0;
+            while (z) {
+                int decodeElementIndex = beginStructure.decodeElementIndex(descriptor2);
+                if (decodeElementIndex == -1) {
+                    z = false;
+                } else if (decodeElementIndex == 0) {
+                    obj3 = beginStructure.decodeNullableSerializableElement(descriptor2, 0, StringSerializer.INSTANCE, obj3);
+                    i5 |= 1;
+                } else if (decodeElementIndex == 1) {
+                    j3 = beginStructure.decodeLongElement(descriptor2, 1);
+                    i5 |= 2;
+                } else if (decodeElementIndex == 2) {
+                    obj4 = beginStructure.decodeNullableSerializableElement(descriptor2, 2, StringSerializer.INSTANCE, obj4);
+                    i5 |= 4;
+                } else if (decodeElementIndex == i3) {
+                    j4 = beginStructure.decodeLongElement(descriptor2, i3);
+                    i5 |= 8;
+                } else {
+                    if (decodeElementIndex != 4) {
+                        throw new UnknownFieldException(decodeElementIndex);
+                    }
+                    i4 = beginStructure.decodeIntElement(descriptor2, 4);
+                    i5 |= 16;
+                }
+                i3 = 3;
+            }
+            i = i5;
+            j = j3;
+            obj = obj4;
+            j2 = j4;
+            Object obj5 = obj3;
+            i2 = i4;
+            obj2 = obj5;
+        }
+        beginStructure.endStructure(descriptor2);
+        return new SignaledAd(i, (String) obj2, j, (String) obj, j2, i2, null);
+    }
+
+    public void serialize(Encoder encoder, SignaledAd value) {
+        Intrinsics.checkNotNullParameter(encoder, "encoder");
+        Intrinsics.checkNotNullParameter(value, "value");
+        SerialDescriptor descriptor2 = getDescriptor();
+        CompositeEncoder beginStructure = encoder.beginStructure(descriptor2);
+        SignaledAd.write$Self(value, beginStructure, descriptor2);
+        beginStructure.endStructure(descriptor2);
+    }
+
+    public KSerializer<?>[] typeParametersSerializers() {
+        return GeneratedSerializer.DefaultImpls.typeParametersSerializers(this);
+    }
+}

decompiled/sources/com/vungle/ads/internal/signals/SignaledAd.java

@@ -0,0 +1,260 @@
+package com.vungle.ads.internal.signals;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.serialization.KSerializer;
+import kotlinx.serialization.SerialName;
+import kotlinx.serialization.Serializable;
+import kotlinx.serialization.Transient;
+import kotlinx.serialization.descriptors.SerialDescriptor;
+import kotlinx.serialization.encoding.CompositeEncoder;
+import kotlinx.serialization.internal.PluginExceptionsKt;
+import kotlinx.serialization.internal.SerializationConstructorMarker;
+import kotlinx.serialization.internal.StringSerializer;
+
+@Serializable
+/* loaded from: classes4.dex */
+public final class SignaledAd {
+    public static final Companion Companion = new Companion(null);
+    private long adAvailabilityCallbackTime;
+    private String eventId;
+    private final Long lastAdLoadTime;
+    private final long loadAdTime;
+    private long playAdTime;
+    private int screenOrientation;
+    private String templateSignals;
+    private long timeBetweenAdAvailabilityAndPlayAd;
+    private final long timeSinceLastAdLoad;
+
+    public SignaledAd() {
+        this(null, 0L, 3, null);
+    }
+
+    public static /* synthetic */ SignaledAd copy$default(SignaledAd signaledAd, Long l, long j, int i, Object obj) {
+        if ((i & 1) != 0) {
+            l = signaledAd.lastAdLoadTime;
+        }
+        if ((i & 2) != 0) {
+            j = signaledAd.loadAdTime;
+        }
+        return signaledAd.copy(l, j);
+    }
+
+    @Transient
+    public static /* synthetic */ void getAdAvailabilityCallbackTime$annotations() {
+    }
+
+    @SerialName("107")
+    public static /* synthetic */ void getEventId$annotations() {
+    }
+
+    @Transient
+    public static /* synthetic */ void getLastAdLoadTime$annotations() {
+    }
+
+    @Transient
+    public static /* synthetic */ void getLoadAdTime$annotations() {
+    }
+
+    @Transient
+    public static /* synthetic */ void getPlayAdTime$annotations() {
+    }
+
+    @SerialName("108")
+    public static /* synthetic */ void getScreenOrientation$annotations() {
+    }
+
+    @SerialName("500")
+    public static /* synthetic */ void getTemplateSignals$annotations() {
+    }
+
+    @SerialName("110")
+    public static /* synthetic */ void getTimeBetweenAdAvailabilityAndPlayAd$annotations() {
+    }
+
+    @SerialName("109")
+    public static /* synthetic */ void getTimeSinceLastAdLoad$annotations() {
+    }
+
+    public final Long component1() {
+        return this.lastAdLoadTime;
+    }
+
+    public final long component2() {
+        return this.loadAdTime;
+    }
+
+    public final SignaledAd copy(Long l, long j) {
+        return new SignaledAd(l, j);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof SignaledAd)) {
+            return false;
+        }
+        SignaledAd signaledAd = (SignaledAd) obj;
+        return Intrinsics.areEqual(this.lastAdLoadTime, signaledAd.lastAdLoadTime) && this.loadAdTime == signaledAd.loadAdTime;
+    }
+
+    public final long getAdAvailabilityCallbackTime() {
+        return this.adAvailabilityCallbackTime;
+    }
+
+    public final String getEventId() {
+        return this.eventId;
+    }
+
+    public final Long getLastAdLoadTime() {
+        return this.lastAdLoadTime;
+    }
+
+    public final long getLoadAdTime() {
+        return this.loadAdTime;
+    }
+
+    public final long getPlayAdTime() {
+        return this.playAdTime;
+    }
+
+    public final int getScreenOrientation() {
+        return this.screenOrientation;
+    }
+
+    public final String getTemplateSignals() {
+        return this.templateSignals;
+    }
+
+    public final long getTimeBetweenAdAvailabilityAndPlayAd() {
+        return this.timeBetweenAdAvailabilityAndPlayAd;
+    }
+
+    public final long getTimeSinceLastAdLoad() {
+        return this.timeSinceLastAdLoad;
+    }
+
+    public int hashCode() {
+        Long l = this.lastAdLoadTime;
+        return ((l == null ? 0 : l.hashCode()) * 31) + Long.hashCode(this.loadAdTime);
+    }
+
+    public final void setAdAvailabilityCallbackTime(long j) {
+        this.adAvailabilityCallbackTime = j;
+    }
+
+    public final void setEventId(String str) {
+        this.eventId = str;
+    }
+
+    public final void setPlayAdTime(long j) {
+        this.playAdTime = j;
+    }
+
+    public final void setScreenOrientation(int i) {
+        this.screenOrientation = i;
+    }
+
+    public final void setTemplateSignals(String str) {
+        this.templateSignals = str;
+    }
+
+    public final void setTimeBetweenAdAvailabilityAndPlayAd(long j) {
+        this.timeBetweenAdAvailabilityAndPlayAd = j;
+    }
+
+    public String toString() {
+        return "SignaledAd(lastAdLoadTime=" + this.lastAdLoadTime + ", loadAdTime=" + this.loadAdTime + ')';
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final KSerializer<SignaledAd> serializer() {
+            return SignaledAd$$serializer.INSTANCE;
+        }
+    }
+
+    public /* synthetic */ SignaledAd(int i, @SerialName("500") String str, @SerialName("109") long j, @SerialName("107") String str2, @SerialName("110") long j2, @SerialName("108") int i2, SerializationConstructorMarker serializationConstructorMarker) {
+        if (2 != (i & 2)) {
+            PluginExceptionsKt.throwMissingFieldException(i, 2, SignaledAd$$serializer.INSTANCE.getDescriptor());
+        }
+        this.lastAdLoadTime = 0L;
+        this.loadAdTime = 0L;
+        if ((i & 1) == 0) {
+            this.templateSignals = null;
+        } else {
+            this.templateSignals = str;
+        }
+        this.timeSinceLastAdLoad = j;
+        if ((i & 4) == 0) {
+            this.eventId = null;
+        } else {
+            this.eventId = str2;
+        }
+        if ((i & 8) == 0) {
+            this.timeBetweenAdAvailabilityAndPlayAd = 0L;
+        } else {
+            this.timeBetweenAdAvailabilityAndPlayAd = j2;
+        }
+        if ((i & 16) == 0) {
+            this.screenOrientation = 0;
+        } else {
+            this.screenOrientation = i2;
+        }
+        this.adAvailabilityCallbackTime = 0L;
+        this.playAdTime = 0L;
+        this.timeSinceLastAdLoad = getTimeDifference(0L, 0L);
+    }
+
+    public SignaledAd(Long l, long j) {
+        this.lastAdLoadTime = l;
+        this.loadAdTime = j;
+        this.timeSinceLastAdLoad = getTimeDifference(l, j);
+    }
+
+    public static final void write$Self(SignaledAd self, CompositeEncoder output, SerialDescriptor serialDesc) {
+        Intrinsics.checkNotNullParameter(self, "self");
+        Intrinsics.checkNotNullParameter(output, "output");
+        Intrinsics.checkNotNullParameter(serialDesc, "serialDesc");
+        if (output.shouldEncodeElementDefault(serialDesc, 0) || self.templateSignals != null) {
+            output.encodeNullableSerializableElement(serialDesc, 0, StringSerializer.INSTANCE, self.templateSignals);
+        }
+        output.encodeLongElement(serialDesc, 1, self.timeSinceLastAdLoad);
+        if (output.shouldEncodeElementDefault(serialDesc, 2) || self.eventId != null) {
+            output.encodeNullableSerializableElement(serialDesc, 2, StringSerializer.INSTANCE, self.eventId);
+        }
+        if (output.shouldEncodeElementDefault(serialDesc, 3) || self.timeBetweenAdAvailabilityAndPlayAd != 0) {
+            output.encodeLongElement(serialDesc, 3, self.timeBetweenAdAvailabilityAndPlayAd);
+        }
+        if (!output.shouldEncodeElementDefault(serialDesc, 4) && self.screenOrientation == 0) {
+            return;
+        }
+        output.encodeIntElement(serialDesc, 4, self.screenOrientation);
+    }
+
+    public /* synthetic */ SignaledAd(Long l, long j, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this((i & 1) != 0 ? 0L : l, (i & 2) != 0 ? 0L : j);
+    }
+
+    public final void calculateTimeBetweenAdAvailabilityAndPlayAd() {
+        this.timeBetweenAdAvailabilityAndPlayAd = getTimeDifference(Long.valueOf(this.adAvailabilityCallbackTime), this.playAdTime);
+    }
+
+    private final long getTimeDifference(Long l, long j) {
+        if (l == null) {
+            return -1L;
+        }
+        long longValue = j - l.longValue();
+        if (longValue < 0) {
+            return -1L;
+        }
+        return longValue;
+    }
+}