FanCode v7.24.0 - VmaxSourceConfiguration.java 源代码

package com.vmax.ng.internal.sourceconfig;

import android.util.Base64;
import com.google.gson.Gson;
import com.google.gson.m;
import com.newrelic.agent.android.instrumentation.GsonInstrumentation;
import com.newrelic.agent.android.instrumentation.Instrumented;
import com.vmax.ng.core.VmaxManager;
import com.vmax.ng.enums.VmaxHttpMethod;
import com.vmax.ng.error.VmaxCoreError;
import com.vmax.ng.error.VmaxCoreException;
import com.vmax.ng.error.VmaxError;
import com.vmax.ng.interfaces.VmaxHttpClientStatusListener;
import com.vmax.ng.internal.sourceconfig.VmaxSourceConfiguration;
import com.vmax.ng.internal.sourceconfig.models.VmaxSourceConfigurationData;
import com.vmax.ng.network.VmaxHttpClientController;
import com.vmax.ng.network.VmaxHttpClientModel;
import com.vmax.ng.utilities.VmaxLogger;
import java.util.HashMap;
import javax.crypto.Cipher;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import kotlin.Metadata;
import kotlin.collections.l;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.jvm.internal.Intrinsics;
import kotlin.text.Charsets;
import kotlin.text.o;
import org.jetbrains.annotations.NotNull;

@Metadata
@Instrumented
public final class VmaxSourceConfiguration {

    @NotNull
    public static final Companion Companion = new Companion(null);
    private static VmaxSourceConfiguration singletonInstance;
    private String publisherSourceConfigData;
    private String sourceConfigData;
    private SourceConfigStatusListener sourceConfigStatusListener;

    @Metadata
    public static final class Companion {
        private Companion() {
        }

        public Companion(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }

        public static void getInstance$annotations() {
        }

        public final synchronized VmaxSourceConfiguration getInstance() {
            if (VmaxSourceConfiguration.singletonInstance == null) {
                VmaxSourceConfiguration.singletonInstance = new VmaxSourceConfiguration(null);
            }
            return VmaxSourceConfiguration.singletonInstance;
        }
    }

    @Metadata
    public interface SourceConfigStatusListener {
        void onFailure(VmaxError vmaxError);

        void onSuccess();
    }

    private VmaxSourceConfiguration() {
    }

    public VmaxSourceConfiguration(DefaultConstructorMarker defaultConstructorMarker) {
        this();
    }

    public final String decryptAesGcmBase64CipherText(String str) {
        byte[] h;
        byte[] h2;
        VmaxLogger.Companion companion = VmaxLogger.Companion;
        companion.showDebugLog("SourceConfigService: decrypting cipher text");
        VmaxManager companion2 = VmaxManager.Companion.getInstance();
        Intrinsics.checkNotNull(companion2);
        String privateKey = companion2.getPrivateKey();
        try {
            byte[] encryptedData = Base64.decode(str, 0);
            SecretKeySpec secretKeySpec = new SecretKeySpec(Base64.decode(privateKey, 0), "AES");
            Intrinsics.checkNotNullExpressionValue(encryptedData, "encryptedData");
            h = l.h(encryptedData, 0, 12);
            h2 = l.h(encryptedData, 12, encryptedData.length);
            GCMParameterSpec gCMParameterSpec = new GCMParameterSpec(128, h);
            Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
            cipher.init(2, secretKeySpec, gCMParameterSpec);
            byte[] decryptedBytes = cipher.doFinal(h2);
            Intrinsics.checkNotNullExpressionValue(decryptedBytes, "decryptedBytes");
            String str2 = new String(decryptedBytes, Charsets.UTF_8);
            companion.showDebugLog("SourceConfigService: decryption completed");
            return str2;
        } catch (Exception unused) {
            return null;
        }
    }

    public static final synchronized VmaxSourceConfiguration getInstance() {
        VmaxSourceConfiguration companion;
        synchronized (VmaxSourceConfiguration.class) {
            companion = Companion.getInstance();
        }
        return companion;
    }

    public final boolean isValidJson() {
        try {
            VmaxSourceConfigurationData vmaxSourceConfigurationData = (VmaxSourceConfigurationData) GsonInstrumentation.fromJson(new Gson(), this.sourceConfigData, VmaxSourceConfigurationData.class);
            if ((vmaxSourceConfigurationData != null ? vmaxSourceConfigurationData.getServices() : null) != null) {
                return vmaxSourceConfigurationData.getInventory() != null;
            }
            return false;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    public final void onFailure(VmaxError vmaxError) {
        SourceConfigStatusListener sourceConfigStatusListener = this.sourceConfigStatusListener;
        if (sourceConfigStatusListener != null) {
            sourceConfigStatusListener.onFailure(vmaxError);
        }
    }

    public final void preparePublisherSourceConfig() {
        try {
            com.google.gson.l f = m.c(this.sourceConfigData).f();
            f.v("services");
            this.publisherSourceConfigData = f.toString();
        } catch (Exception unused) {
        }
    }

    public final void fetchSourceConfig$VmaxNGCore_fancode(final SourceConfigStatusListener sourceConfigStatusListener) {
        String C;
        String C2;
        try {
            this.sourceConfigStatusListener = sourceConfigStatusListener;
            VmaxManager companion = VmaxManager.Companion.getInstance();
            Intrinsics.checkNotNull(companion);
            C = o.C("https://{source-config-domain}/{account-key}/source-config/{source-config-version}/{app-id}/{source-config-key-id}", "{source-config-domain}", "vmax-ads.fancode.com", false, 4, null);
            String accountKey = companion.getAccountKey();
            Intrinsics.checkNotNull(accountKey);
            C2 = o.C(o.A(C, "{account-key}", accountKey.toString(), true), "{source-config-version}", "1.0.0", false, 4, null);
            String appId = companion.getAppId();
            Intrinsics.checkNotNull(appId);
            String A = o.A(C2, "{app-id}", appId.toString(), true);
            String keyId = companion.getKeyId();
            Intrinsics.checkNotNull(keyId);
            String A2 = o.A(A, "{source-config-key-id}", keyId.toString(), true);
            VmaxLogger.Companion.showDebugLog("SourceConfigService: Fetching data");
            new VmaxHttpClientController(new VmaxHttpClientModel(A2, null, VmaxHttpMethod.GET, 0L, null, 0, 56, null), new VmaxHttpClientStatusListener() {
                @Override
                public void onFailure(VmaxError vmaxError) {
                    VmaxLogger.Companion companion2 = VmaxLogger.Companion;
                    StringBuilder sb = new StringBuilder();
                    sb.append("SourceConfigService : failed to fetch data | vmaxError: ");
                    sb.append(vmaxError != null ? vmaxError.getErrorDescription() : null);
                    companion2.showDebugLog(sb.toString());
                    VmaxSourceConfiguration.this.onFailure(new VmaxCoreError(1001, "failed to fetch data"));
                }

                @Override
                public void onSuccess(String str, HashMap<String, String> hashMap) {
                    String decryptAesGcmBase64CipherText;
                    boolean isValidJson;
                    VmaxLogger.Companion companion2 = VmaxLogger.Companion;
                    companion2.showDebugLog("SourceConfigService: response received");
                    if (str != null) {
                        if (str.length() > 0) {
                            try {
                                VmaxSourceConfiguration vmaxSourceConfiguration = VmaxSourceConfiguration.this;
                                decryptAesGcmBase64CipherText = vmaxSourceConfiguration.decryptAesGcmBase64CipherText(str);
                                vmaxSourceConfiguration.sourceConfigData = decryptAesGcmBase64CipherText;
                                isValidJson = VmaxSourceConfiguration.this.isValidJson();
                                if (isValidJson) {
                                    VmaxSourceConfiguration.this.preparePublisherSourceConfig();
                                    VmaxSourceConfiguration.SourceConfigStatusListener sourceConfigStatusListener2 = sourceConfigStatusListener;
                                    if (sourceConfigStatusListener2 != null) {
                                        sourceConfigStatusListener2.onSuccess();
                                    }
                                } else {
                                    VmaxSourceConfiguration.this.onFailure(new VmaxCoreError(1001, "Invalid Source Config Data"));
                                }
                                return;
                            } catch (Exception e) {
                                VmaxLogger.Companion.showErrorLog("Error parsing source config json : " + e);
                                VmaxSourceConfiguration.this.onFailure(new VmaxCoreError(1001, "Error parsing source config json"));
                                return;
                            }
                        }
                    }
                    VmaxSourceConfiguration.this.onFailure(new VmaxCoreError(1001, "Source config is empty"));
                    companion2.showErrorLog("Source config is empty");
                }
            }).request();
        } catch (VmaxCoreException unused) {
            VmaxLogger.Companion.showDebugLog("Source config : network failed to fetch data");
            onFailure(new VmaxCoreError(1001, "Failed to fetch data"));
        }
    }

    public final String getConfig$VmaxNGCore_fancode(@NotNull String key) {
        Intrinsics.checkNotNullParameter(key, "key");
        try {
            com.google.gson.l f = m.c(this.publisherSourceConfigData).f();
            if (f.u(key)) {
                return f.t(key).toString();
            }
        } catch (Exception unused) {
        }
        return null;
    }

    public final String getSdkConfig$VmaxNGCore_fancode(@NotNull String key) {
        Intrinsics.checkNotNullParameter(key, "key");
        try {
            com.google.gson.l f = m.c(this.sourceConfigData).f();
            if (f.u(key)) {
                return f.t(key).toString();
            }
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}