package com.mstar.android.samba;

import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import e1.AbstractC0453a;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/* JADX INFO: loaded from: classes.dex */
public class SmbClient {
    private static final int SCAN_TIMEOUT = 10000;
    private static final String TAG = "SmbClient";
    private static final String VERSION = "1.1";
    private Handler mHandler;
    private String mHost;
    public SambaNative mSambaNative;
    private boolean mSmbScanTimeoutFlag;
    ArrayList<SmbDevice> deviceList = new ArrayList<>();
    private int mScanCompleted = 0;
    private volatile boolean mStoprun = false;
    private int mTimeout = 5000;
    private boolean mScanning = false;
    private OnRecvMsgListener onRecvMsglistener = null;
    private int mTries = 1;
    Map<String, String> mSmbMap = new HashMap();
    private final Object mLock = new Object();
    public final Runnable mSmbScanTimeout = new Runnable() { // from class: com.mstar.android.samba.SmbClient.1
        @Override // java.lang.Runnable
        public void run() {
            SmbClient.this.mSmbScanTimeoutFlag = true;
            Log.d(SmbClient.TAG, "smb scan time out!!");
        }
    };

    class scanHostByPing implements Runnable {
        OnRecvMsgListener callback;
        String startIp;

        scanHostByPing(String str, OnRecvMsgListener onRecvMsgListener) {
            this.startIp = str;
            this.callback = onRecvMsgListener;
        }

        @Override // java.lang.Runnable
        public void run() {
            if (this.startIp == null) {
                return;
            }
            System.out.println("startIp = " + this.startIp);
            int i2 = 0;
            for (int i3 = 0; i3 < SmbClient.this.mTries; i3++) {
                SambaNative sambaNative = SmbClient.this.mSambaNative;
                SambaNative.nativeInit();
                SambaNative sambaNative2 = SmbClient.this.mSambaNative;
                SambaNative.nativeStartSambaScan(this.startIp);
                while (true) {
                    SambaNative sambaNative3 = SmbClient.this.mSambaNative;
                    String strNativeWaitForEvent = SambaNative.nativeWaitForEvent();
                    Log.d(SmbClient.TAG, "----------eventStr---------: " + strNativeWaitForEvent);
                    if (!strNativeWaitForEvent.equals(" ")) {
                        if (strNativeWaitForEvent.equals("done")) {
                            break;
                        }
                        i2++;
                        SmbClient.this.mSmbMap.put(strNativeWaitForEvent, strNativeWaitForEvent);
                    }
                }
            }
            Iterator<Map.Entry<String, String>> it = SmbClient.this.mSmbMap.entrySet().iterator();
            while (it.hasNext()) {
                SmbClient.this.deviceList.add(new SmbDevice(it.next().getValue()));
                this.callback.onRecvMsgListener(3);
            }
            Log.d(SmbClient.TAG, "===============total = " + i2);
            this.callback.onRecvMsgListener(2);
            SmbClient.this.mScanning = true;
            if (SmbClient.this.mSmbScanTimeoutFlag && SmbClient.this.mScanning) {
                SmbClient.this.mScanning = false;
                SmbClient.this.mHandler.removeCallbacks(SmbClient.this.mSmbScanTimeout);
                if (SmbClient.this.mStoprun) {
                    this.callback.onRecvMsgListener(1);
                } else {
                    this.callback.onRecvMsgListener(2);
                }
            }
        }
    }

    public SmbClient() {
        HandlerThread handlerThread = new HandlerThread("Smb HandlerThread");
        handlerThread.start();
        this.mSambaNative = new SambaNative();
        this.mHandler = new Handler(handlerThread.getLooper());
    }

    private String getLocalIP() {
        String string = null;
        try {
            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
            while (networkInterfaces.hasMoreElements()) {
                Enumeration<InetAddress> inetAddresses = networkInterfaces.nextElement().getInetAddresses();
                while (inetAddresses.hasMoreElements()) {
                    InetAddress inetAddressNextElement = inetAddresses.nextElement();
                    if (!inetAddressNextElement.getHostAddress().toString().contains(":")) {
                        if (!inetAddressNextElement.isLoopbackAddress()) {
                            string = inetAddressNextElement.getHostAddress().toString();
                        }
                        Log.d(TAG, "inetAddress is = " + inetAddressNextElement.getHostAddress().toString());
                    }
                }
            }
        } catch (SocketException e2) {
            Log.d(TAG, "WifiPreference IpAddress" + e2.toString());
        }
        Log.d(TAG, "ip addr =: " + string);
        return string;
    }

    public static void initSamba() {
        Log.d(TAG, "smbclient_version : 1.1");
        AbstractC0453a.k("jcifs.encoding", "GBK");
        AbstractC0453a.k("jcifs.smb.lmCompatibility", "0");
        AbstractC0453a.k("jcifs.smb.client.responseTimeout", "10000");
        AbstractC0453a.k("jcifs.netbios.retryTimeout", "10000");
        AbstractC0453a.k("jcifs.smb.client.dfs.disabled", "true");
        AbstractC0453a.j();
    }

    public void SetPingTimeout(int i2) {
        if (i2 > 100) {
            this.mTimeout = i2;
        }
    }

    public void StopUpdate() {
        this.mStoprun = true;
        this.mScanning = false;
        Log.d(TAG, "stop update");
    }

    public ArrayList<SmbDevice> getSmbDeviceList() {
        return this.deviceList;
    }

    public boolean isUpdating() {
        return this.mScanning;
    }

    public void setOnRecvMsgListener(OnRecvMsgListener onRecvMsgListener) {
        this.onRecvMsglistener = onRecvMsgListener;
    }

    public void updateSmbDeviceList() {
        this.deviceList.clear();
        String localIP = getLocalIP();
        if (localIP == null) {
            Log.d(TAG, "no ip address!");
            OnRecvMsgListener onRecvMsgListener = this.onRecvMsglistener;
            if (onRecvMsgListener != null) {
                onRecvMsgListener.onRecvMsgListener(1);
                return;
            }
            return;
        }
        if (localIP.contentEquals("127.0.0.1") || this.onRecvMsglistener == null) {
            this.mScanning = false;
            Log.d(TAG, "no ip address or recv listener! ");
            OnRecvMsgListener onRecvMsgListener2 = this.onRecvMsglistener;
            if (onRecvMsgListener2 != null) {
                onRecvMsgListener2.onRecvMsgListener(1);
                return;
            }
            return;
        }
        int iLastIndexOf = localIP.lastIndexOf(46);
        if (iLastIndexOf >= 0) {
            localIP = localIP.substring(0, iLastIndexOf + 1);
        }
        String str = localIP + "1-150";
        String str2 = localIP + "151-255";
        this.mScanCompleted = 0;
        this.mSmbScanTimeoutFlag = false;
        this.mScanning = true;
        this.mHandler.postDelayed(this.mSmbScanTimeout, 10000L);
        int i2 = 0;
        for (int i3 = 0; i3 < this.mTries; i3++) {
            SambaNative.nativeStartSambaScan(str);
            while (true) {
                String strNativeWaitForEvent = SambaNative.nativeWaitForEvent();
                Log.d(TAG, "----------eventStr---------: " + strNativeWaitForEvent);
                if (!strNativeWaitForEvent.equals(" ")) {
                    if (strNativeWaitForEvent.equals("done")) {
                        break;
                    }
                    i2++;
                    this.mSmbMap.put(strNativeWaitForEvent, strNativeWaitForEvent);
                }
            }
            SambaNative.nativeStartSambaScan(str2);
            while (true) {
                String strNativeWaitForEvent2 = SambaNative.nativeWaitForEvent();
                Log.d(TAG, "----------eventStr---------: " + strNativeWaitForEvent2);
                if (!strNativeWaitForEvent2.equals(" ")) {
                    if (strNativeWaitForEvent2.equals("done")) {
                        break;
                    }
                    i2++;
                    this.mSmbMap.put(strNativeWaitForEvent2, strNativeWaitForEvent2);
                }
            }
        }
        Iterator<Map.Entry<String, String>> it = this.mSmbMap.entrySet().iterator();
        while (it.hasNext()) {
            this.deviceList.add(new SmbDevice(it.next().getValue()));
            this.onRecvMsglistener.onRecvMsgListener(3);
        }
        Log.d(TAG, "===============total = " + i2);
        this.onRecvMsglistener.onRecvMsgListener(2);
        this.mScanning = true;
        if (this.mSmbScanTimeoutFlag) {
            this.mScanning = false;
            this.mHandler.removeCallbacks(this.mSmbScanTimeout);
            if (this.mStoprun) {
                this.onRecvMsglistener.onRecvMsgListener(1);
            } else {
                this.onRecvMsglistener.onRecvMsgListener(2);
            }
        }
    }
}