Vi App v10.18.0 - OriChatActivity.java 源代码

package com.oriserve.orichat;

import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.Uri;
import android.util.Base64;
import android.view.KeyEvent;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.webkit.JavascriptInterface;
import android.webkit.ValueCallback;
import android.webkit.WebChromeClient;
import android.webkit.WebView;
import android.widget.LinearLayout;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import com.google.android.gms.measurement.api.AppMeasurementSdk;
import com.google.android.gms.plus.PlusShare;
import com.google.firebase.remoteconfig.FirebaseRemoteConfig;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import org.json.JSONException;
import org.json.JSONObject;

public class OriChatActivity extends AppCompatActivity {
    private static Toast toast;
    public ValueCallback<Uri[]> uploadMessage;
    private WebView webView;
    private static Boolean isInternalRedirection = Boolean.FALSE;
    public static String baseUrl = FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING;
    private static String localStoragePSID = null;
    public static String useEvents = "false";
    private final String JAVASCRIPT_OBJ = "javascript_obj";
    private final String prefsKey = FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING;
    public long lastBackPressed = 0;
    private String botKeys = FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING;
    private String psid = FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING;
    private boolean webviewSuccess = true;
    private int refreshCounter = 0;

    public class AnonymousClass7 implements Runnable {
        public final OriChatActivity this$0;

        @Override
        public void run() {
            this.this$0.webView.loadUrl("javascript:localStorage.setItem('appMinimizedfrom','');");
            this.this$0.webView.loadUrl("javascript:localStorage.setItem('chatBotTimeStamp','');");
        }
    }

    class AnonymousClass8 implements ValueCallback<String> {
        public final OriChatActivity this$0;

        @Override
        public void onReceiveValue(String str) {
            if (str.equalsIgnoreCase(FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING)) {
                return;
            }
            this.this$0.psid = str;
            String unused = this.this$0.psid;
        }
    }

    public class OriJavaScriptInterface {

        public class AnonymousClass2 implements Runnable {
            public final OriJavaScriptInterface this$1;

            @Override
            public void run() {
                OriChatActivity.this.webView.loadUrl("javascript:localStorage.setItem('appMinimizedfrom','');");
                OriChatActivity.this.webView.loadUrl("javascript:localStorage.setItem('chatBotTimeStamp','');");
            }
        }

        public OriJavaScriptInterface() {
        }

        @JavascriptInterface
        public void textFromWeb(String str) {
            OriChatActivity.OriLog("OriChatActivityTAG", "Got string from JS Interface: " + str);
            try {
                JSONObject jSONObject = new JSONObject(str);
                if (jSONObject.has("button")) {
                    JSONObject jSONObject2 = jSONObject.getJSONObject("button");
                    if (jSONObject2.has("deeplink") && !jSONObject2.getString("deeplink").equalsIgnoreCase(FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING)) {
                        OriChatActivity.OriLog("OriChatActivityTAG", "Button has deeplink: and it is not empty");
                        String string = jSONObject2.getString("deeplink");
                        OriChatBot oriChatBot = OriChatBot.getInstance();
                        JSONObject jSONObject3 = new JSONObject();
                        jSONObject3.put("case", "handleRedirection");
                        jSONObject3.put("type", "deeplink");
                        jSONObject3.put(AppMeasurementSdk.ConditionalUserProperty.VALUE, string);
                        oriChatBot.fireEvent(jSONObject3);
                        OriChatActivity.this.finish();
                    } else if (jSONObject2.has("b_id") && !jSONObject2.getString("b_id").equalsIgnoreCase(FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING)) {
                        OriChatActivity.OriLog("OriChatActivityTAG", "Button has b_id: and it is not empty");
                        String string2 = jSONObject2.getString("b_id");
                        Intent intent = new Intent("android.intent.action.VIEW", Uri.parse(string2));
                        intent.putExtra("android.intent.extra.STREAM", Uri.parse(string2));
                        OriChatActivity.this.startActivity(intent);
                    } else if (!jSONObject2.has("androidType") || jSONObject2.getString("androidType").equalsIgnoreCase(FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING) || !jSONObject2.has("androidTypeKey") || jSONObject2.getString("androidTypeKey").equalsIgnoreCase(FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING)) {
                        OriChatActivity.this.openPage(jSONObject2.getString(PlusShare.KEY_CALL_TO_ACTION_URL));
                    } else {
                        OriChatActivity.OriLog("OriChatActivityTAG", "Button has androidType: and it is not empty");
                        String string3 = jSONObject2.getString("androidTypeKey");
                        String string4 = jSONObject2.getString("androidType");
                        OriChatActivity.OriLog("OriChatActivityTAG", string3);
                        OriChatActivity.OriLog("OriChatActivityTAG", string4);
                        Intent intent2 = new Intent();
                        intent2.putExtra("type", string3);
                        intent2.putExtra("data", string4);
                        OriChatActivity.this.setResult(-1, intent2);
                        OriChatActivity.this.finish();
                    }
                } else {
                    OriChatActivity.OriLog("OriChatActivityTAG", "NOOOOOOOOO button -------------");
                }
            } catch (Exception e) {
                OriChatActivity.OriLog("OriChatActivityTAG", "Got error ooooo from JS Interface: ");
                e.printStackTrace();
                ErrorHandler.handleException(e);
            }
        }

        @JavascriptInterface
        public void updateFromReact(String str, String str2) {
            OriChatActivity.OriLog("OriChatActivityTAG", "UpdateFromWeb called: " + str + " " + str2);
            try {
                if (str.equals("endChatSubmit")) {
                    OriChatActivity.OriLog("OriChatActivityTAG", "endChatSubmit success: ");
                    OriChatActivity.this.finish();
                    OriChatActivity.this.endChat();
                    OriChatActivity.this.webView.post(new Runnable() {
                        @Override
                        public void run() {
                            OriChatActivity.this.webView.evaluateJavascript("localStorage.setItem('appMinimizedfrom','');", null);
                            OriChatActivity.this.webView.evaluateJavascript("localStorage.setItem('chatBotTimeStamp','');", null);
                        }
                    });
                }
            } catch (Exception e) {
                OriChatActivity.OriLog("OriChatActivityTAG", "UpdateFromWeb error: ");
                e.printStackTrace();
                ErrorHandler.handleException(e);
            }
        }
    }

    public static void OriLog(String str, String str2) {
        int i = BuildConfig.a;
    }

    public static int access$708(OriChatActivity oriChatActivity) {
        int i = oriChatActivity.refreshCounter;
        oriChatActivity.refreshCounter = i + 1;
        return i;
    }

    public void endChat() {
        try {
            this.webView.post(new Runnable() {
                @Override
                public void run() {
                    OriChatActivity.this.webView.evaluateJavascript("localStorage.setItem('appMinimizedfrom','');", null);
                    OriChatActivity.this.webView.evaluateJavascript("localStorage.setItem('chatBotTimeStamp','');", null);
                }
            });
        } catch (Exception e) {
            OriLog("OriChatActivityTAG", "okat okay error: ");
            e.printStackTrace();
            ErrorHandler.handleException(e);
        }
    }

    private void getAndSetPsidFromLocalStorage(WebView webView) {
        webView.evaluateJavascript("(function() {var regex = /^msgs_/;var keys = [];for (var i = 0; i < localStorage.length; i++) {var key = localStorage.key(i);if (regex.test(key)) { keys.push(key); }}return JSON.stringify(keys);})();", new ValueCallback() {
            @Override
            public final void onReceiveValue(Object obj) {
                OriChatActivity.lambda$getAndSetPsidFromLocalStorage$1((String) obj);
            }
        });
    }

    private static String guid() {
        try {
            return "and-" + s4() + "-" + s4() + "-" + s4() + "-" + new SimpleDateFormat("yyyyMMdd-HHmmss", Locale.getDefault()).format(new Date());
        } catch (Exception e) {
            ErrorHandler.handleException(e);
            return FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING;
        }
    }

    private void injectBackButtonAction() {
        OriLog("OriChatActivityTAG", "callingBack Button JS function");
        JSONObject jSONObject = new JSONObject();
        finish();
        this.webView.evaluateJavascript("window.androidObj.updateFromAndroid('endchat','" + jSONObject + "');", null);
    }

    @RequiresApi
    public void injectJavaScriptFunction() {
        String str;
        this.webView.evaluateJavascript("window.androidObj.textToAndroid = function(message) { javascript_obj.textFromWeb(message) }", null);
        this.webView.evaluateJavascript("window.androidObj.updateFromWeb = function(type,data) { javascript_obj.updateFromReact(type,data) }", null);
        OriLog("OriChatActivityTAG", "calling JS function");
        JSONObject jSONObject = new JSONObject();
        try {
            getIntent().getStringExtra("appdetails");
        } catch (Exception unused) {
        }
        try {
            jSONObject.put("psid", getPSID());
            jSONObject.put("psid", this.psid);
            JSONObject jSONObject2 = new JSONObject();
            JSONObject jSONObject3 = new JSONObject();
            try {
                str = getIntent().getStringExtra("userData");
            } catch (Exception unused2) {
                str = FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING;
            }
            if (!str.isEmpty()) {
                jSONObject2 = JsonUtils.convertJsonStringToJsonObjectWithAllLevels(str);
            }
            jSONObject3.put("rawData", jSONObject2);
            jSONObject2.put("token", "h73hz8BG@h5qW5tpn");
            jSONObject3.put("hash", returnSHA(jSONObject2.toString(), "dish_UR2WwS4g45bYdTpj"));
            jSONObject.put("params", jSONObject3);
            OriLog("OriChatActivityTAG", "params : " + jSONObject2);
            OriLog("OriChatActivityTAG", "encrypted params : " + returnSHA(jSONObject2.toString(), "dish_UR2WwS4g45bYdTpj"));
        } catch (JSONException e) {
            ErrorHandler.handleException(e);
        }
        this.webView.evaluateJavascript("window.androidObj.updateFromAndroid('android','');", null);
        this.webView.evaluateJavascript("window.androidObj.updateFromAndroid('psid','" + jSONObject + "');", null);
    }

    public static boolean isNetworkAvailable(Context context) {
        try {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
            if (connectivityManager == null || connectivityManager.getActiveNetworkInfo() == null) {
                return false;
            }
            return connectivityManager.getActiveNetworkInfo().isConnected();
        } catch (Exception e) {
            ErrorHandler.handleException(e);
            return false;
        }
    }

    public boolean isPermissionGranted() {
        try {
            return ContextCompat.checkSelfPermission(this, "android.permission.RECORD_AUDIO") == 0;
        } catch (Exception e) {
            System.out.println("Error Occured : Checking Mic Permissions, Scope : isPermissionGranted,  Error : " + e.getMessage());
            ErrorHandler.handleException(e);
            return false;
        }
    }

    public static void lambda$getAndSetPsidFromLocalStorage$1(String str) {
        if (str == null || str.equals("null")) {
            return;
        }
        try {
            localStoragePSID = str.substring(str.indexOf("msgs_") + 5, str.lastIndexOf("\"") - 3);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void lambda$onCreate$3() {
        getAndSetPsidFromLocalStorage(this.webView);
    }

    public static void lambda$onPause$0(String str) {
        if (str == null || str.equals("null")) {
            return;
        }
        try {
            localStoragePSID = str.substring(str.indexOf("msgs_") + 5, str.lastIndexOf("\"") - 3);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void lambda$onResume$2(String str) {
        if (str == null || str.equals("null")) {
            return;
        }
        try {
            localStoragePSID = str.substring(str.indexOf("msgs_") + 5, str.lastIndexOf("\"") - 3);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void openAppSettings() {
        try {
            Intent intent = new Intent("android.settings.APPLICATION_DETAILS_SETTINGS");
            intent.setData(Uri.fromParts("package", getPackageName(), null));
            startActivityForResult(intent, 123);
        } catch (Exception e) {
            System.out.println("Error Occured : Requesting Mic Permissions, Scope : openAppSettings,  Error : " + e.getMessage());
            ErrorHandler.handleException(e);
        }
    }

    public void openPage(String str) {
        try {
            if (!str.equalsIgnoreCase(FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING)) {
                if (isInternalRedirection.booleanValue()) {
                    Intent intent = new Intent((Context) this, (Class<?>) WebActivity.class);
                    intent.putExtra("showToolbar", getIntent().getBooleanExtra("showToolbar", true));
                    intent.putExtra("showMiniToolbar", getIntent().getBooleanExtra("showMiniToolbar", false));
                    intent.putExtra("pageTitle", FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING);
                    intent.putExtra("pageURL", str);
                    startActivity(intent);
                } else {
                    startActivity(new Intent("android.intent.action.VIEW", Uri.parse(str)));
                }
            }
        } catch (Exception e) {
            ErrorHandler.handleException(e);
        }
    }

    public void requestPermission() {
        try {
            ActivityCompat.requestPermissions(this, new String[]{"android.permission.RECORD_AUDIO"}, 123);
        } catch (Exception e) {
            System.out.println("Error Occured : Requesting Mic Permissions, Scope : requestPermission,  Error : " + e.getMessage());
            ErrorHandler.handleException(e);
        }
    }

    @RequiresApi
    public static String returnSHA(String str, String str2) {
        try {
            Mac mac = Mac.getInstance("HmacSHA512");
            mac.init(new SecretKeySpec(str2.getBytes(StandardCharsets.UTF_8), mac.getAlgorithm()));
            return Base64.encodeToString(mac.doFinal(str.getBytes(StandardCharsets.UTF_8)), 2);
        } catch (Exception e) {
            e.printStackTrace();
            ErrorHandler.handleException(e);
            return FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING;
        }
    }

    public static String s4() {
        try {
            return Integer.toString((int) Math.floor((Math.random() + 1.0d) * 65536.0d)).substring(1);
        } catch (Exception e) {
            ErrorHandler.handleException(e);
            return FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING;
        }
    }

    private void setUpUI() {
        try {
            if (getIntent() != null) {
                if (getIntent().getBooleanExtra("showToolbar", true)) {
                    if (getSupportActionBar() != null) {
                        getSupportActionBar().setTitle(getIntent().getStringExtra("pageTitle"));
                        getSupportActionBar().setHomeButtonEnabled(true);
                        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
                    } else {
                        ViewGroup viewGroup = (ViewGroup) findViewById(R.id.toolbar_holder);
                        viewGroup.setVisibility(0);
                        getLayoutInflater().inflate(R.layout.ori_toolbar, viewGroup);
                        setSupportActionBar(findViewById(R.id.toolbar));
                        if (getSupportActionBar() != null) {
                            getSupportActionBar().setTitle(getIntent().getStringExtra("pageTitle"));
                            getSupportActionBar().setHomeButtonEnabled(true);
                            getSupportActionBar().setDisplayHomeAsUpEnabled(true);
                        }
                    }
                } else if (getSupportActionBar() != null) {
                    getSupportActionBar().hide();
                }
                if (!getIntent().getBooleanExtra("showMiniToolbar", false)) {
                    findViewById(R.id.header).setVisibility(8);
                    return;
                }
                LinearLayout linearLayout = (LinearLayout) findViewById(R.id.header);
                linearLayout.setVisibility(0);
                linearLayout.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        OriChatActivity.this.onBackPressed();
                    }
                });
            }
        } catch (Exception e) {
            ErrorHandler.handleException(e);
        }
    }

    private void showPermissionSettingsDialog() {
        try {
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setTitle("Microphone Permission Required");
            builder.setMessage("To use this feature, you need to enable the microphone permission in the app settings.");
            builder.setPositiveButton("Go to Settings", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialogInterface, int i) {
                    OriChatActivity.this.openAppSettings();
                }
            });
            builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialogInterface, int i) {
                }
            });
            builder.show();
        } catch (Exception e) {
            System.out.println("Error Occured : Requesting Mic Permissions, Scope : showPermissionSettingsDialog,  Error : " + e.getMessage());
            ErrorHandler.handleException(e);
        }
    }

    public void finish() {
        super/*android.app.Activity*/.finish();
    }

    public String getPSID() {
        try {
            OriLog("OriChatActivityTAG", "Shared Preferences " + getSharedPreferences("ORI_PREFS", 0));
            return guid();
        } catch (Exception e) {
            ErrorHandler.handleException(e);
            return null;
        }
    }

    public void onActivityResult(int i, int i2, Intent intent) {
        ValueCallback<Uri[]> valueCallback;
        try {
            super/*androidx.fragment.app.FragmentActivity*/.onActivityResult(i, i2, intent);
            if (i != 100 || (valueCallback = this.uploadMessage) == null) {
                return;
            }
            valueCallback.onReceiveValue(WebChromeClient.FileChooserParams.parseResult(i2, intent));
            this.uploadMessage = null;
        } catch (Exception e) {
            ErrorHandler.handleException(e);
        }
    }

    public void onBackPressed() {
        onKeyDown(4, null);
    }

    @android.annotation.SuppressLint({"SetJavaScriptEnabled", "AddJavascriptInterface"})
    public void onCreate(android.os.Bundle r9) {
        throw new UnsupportedOperationException("Method not decompiled: com.oriserve.orichat.OriChatActivity.onCreate(android.os.Bundle):void");
    }

    public void onDestroy() {
        this.webView.removeJavascriptInterface("javascript_obj");
        super.onDestroy();
    }

    public boolean onKeyDown(int i, KeyEvent keyEvent) {
        if (keyEvent != null) {
            try {
                String keyEvent2 = keyEvent.toString();
                if (keyEvent2.contains("VOLUME_DOWN") || keyEvent2.contains("VOLUME_UP")) {
                    return super.onKeyDown(i, keyEvent);
                }
            } catch (Exception e) {
                ErrorHandler.handleException(e);
                return false;
            }
        }
        if (isNetworkAvailable(this)) {
            injectBackButtonAction();
        } else {
            long currentTimeMillis = System.currentTimeMillis();
            if (currentTimeMillis - this.lastBackPressed > 2000) {
                Toast.makeText((Context) this, (CharSequence) "Press Back again to exit..", 0).show();
                this.lastBackPressed = currentTimeMillis;
            } else {
                Toast toast2 = toast;
                if (toast2 != null) {
                    toast2.cancel();
                }
                super/*androidx.activity.ComponentActivity*/.onBackPressed();
            }
        }
        if (i == 4) {
            return true;
        }
        return super.onKeyDown(i, keyEvent);
    }

    public boolean onOptionsItemSelected(MenuItem menuItem) {
        try {
            if (menuItem.getItemId() != 16908332) {
                return super/*android.app.Activity*/.onOptionsItemSelected(menuItem);
            }
            onBackPressed();
            return true;
        } catch (Exception e) {
            ErrorHandler.handleException(e);
            return false;
        }
    }

    public void onPause() {
        super/*androidx.fragment.app.FragmentActivity*/.onPause();
        OriLog("OriChatActivityTAG", "callingBack Button JS function");
        String str = localStoragePSID;
        if (str == null || str.equals("null")) {
            this.webView.evaluateJavascript("(function() {var regex = /^msgs_/;var keys = [];for (var i = 0; i < localStorage.length; i++) {var key = localStorage.key(i);if (regex.test(key)) { keys.push(key); }}return JSON.stringify(keys);})();", new ValueCallback() {
                @Override
                public final void onReceiveValue(Object obj) {
                    OriChatActivity.lambda$onPause$0((String) obj);
                }
            });
        }
        String str2 = localStoragePSID;
        if (str2 == null || str2.equals("null")) {
            return;
        }
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("onBackground", true);
            jSONObject.put("onBackgroundTimeStamp", new Date());
            jSONObject.put("psid", localStoragePSID);
            new EventSender().sendEvent("background|forgroundUpdates", jSONObject);
            System.out.println("********< --- onPause --> ++++++++++++++++++++++++++++++++++== ");
        } catch (JSONException e) {
            throw new RuntimeException(e);
        }
    }

    public void onRequestPermissionsResult(int i, @NonNull String[] strArr, @NonNull int[] iArr) {
        if (i == 123) {
            try {
                if ((iArr.length <= 0 || iArr[0] != 0) && !isPermissionGranted()) {
                    showPermissionSettingsDialog();
                }
            } catch (Exception e) {
                System.out.println("Error Occured : Requesting Mic Permissions, Scope : onRequestPermissionsResult,  Error : " + e.getMessage());
                ErrorHandler.handleException(e);
            }
        }
    }

    public void onResume() {
        super/*androidx.fragment.app.FragmentActivity*/.onResume();
        OriLog("OriChatActivityTAG", "callingBack Button JS function");
        String str = localStoragePSID;
        if (str == null || str.equals("null")) {
            this.webView.evaluateJavascript("(function() {var regex = /^msgs_/;var keys = [];for (var i = 0; i < localStorage.length; i++) {var key = localStorage.key(i);if (regex.test(key)) { keys.push(key); }}return JSON.stringify(keys);})();", new ValueCallback() {
                @Override
                public final void onReceiveValue(Object obj) {
                    OriChatActivity.lambda$onResume$2((String) obj);
                }
            });
        }
        String str2 = localStoragePSID;
        if (str2 == null || str2.equals("null")) {
            return;
        }
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("onForeground", true);
            jSONObject.put("onForegroundTimeStamp", new Date());
            jSONObject.put("psid", localStoragePSID);
            new EventSender().sendEvent("background|forgroundUpdates", jSONObject);
            System.out.println("********< --- onResume --> ++++++++++++++++++++++++++++++++++++++");
        } catch (JSONException e) {
            throw new RuntimeException(e);
        }
    }

    public void onUserLeaveHint() {
        try {
            String str = FirebaseRemoteConfig.DEFAULT_VALUE_FOR_STRING + (System.currentTimeMillis() / 1000);
            this.webView.evaluateJavascript("localStorage.setItem('appMinimizedfrom','chatbot');", null);
            this.webView.evaluateJavascript("localStorage.setItem('chatBotTimeStamp','" + str + "');", null);
            super/*androidx.activity.ComponentActivity*/.onUserLeaveHint();
        } catch (Exception e) {
            ErrorHandler.handleException(e);
        }
    }
}