package com.seewo.libmcuservice;

import android.content.Context;
import android.os.Binder;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.RemoteException;
import android.util.Log;
import com.seewo.libmcuservice.aidl.IEthernetService;
import com.seewo.libmcuservice.aidl.IMcuService;
import com.seewo.libmcuservice.aidl.IServiceCallback;
import com.seewo.libmcuservice.constant.IEthernetConstant;
import java.lang.ref.WeakReference;

/* JADX INFO: loaded from: classes.dex */
public class EthernetBox extends AbstractMailbox {
    private static final int MAX_SEND_MSG_RETRY_TIMES = 3;
    private static final int MSG_GET_MAC_ADDRESS = 2;
    private static final int MSG_QUERY_ETHERNETSTATE = 1;
    private static final int MSG_SET_MAC_ADDRESS = 3;
    private static final int MSG_SET_USB_PHY = 4;
    private static final int SEND_MSG_DELAYED_TIME = 500;
    private static final String TAG = "EthernetBox";
    private Context mContext;
    private AbstractEthernetCallback mEthernetCallback;
    private BoxHandler mHandler;
    private IEthernetService mService;
    private ThreadLocal<Integer> mCurrentTryTime = new ThreadLocal<>();
    private IServiceCallback mServiceCallback = new IServiceCallback.Stub() { // from class: com.seewo.libmcuservice.EthernetBox.1
        @Override // com.seewo.libmcuservice.aidl.IServiceCallback
        public void onCallback(int i, Bundle bundle) throws RemoteException {
            Log.d(EthernetBox.TAG, "onCallback:--->pAction: " + i);
            switch (i) {
                case 41:
                    EthernetBox.this.mEthernetCallback.onGetEthernetState(bundle);
                    break;
                case 42:
                    EthernetBox.this.mEthernetCallback.onGetMacAddress(bundle);
                    break;
                case 43:
                    EthernetBox.this.mEthernetCallback.onSetMacAddress(bundle);
                    break;
                case 44:
                    EthernetBox.this.mEthernetCallback.onUsbPhyPowerReset();
                    break;
            }
        }
    };

    public static abstract class AbstractEthernetCallback {
        protected void onGetEthernetState(Bundle bundle) {
        }

        protected void onGetMacAddress(Bundle bundle) {
        }

        protected void onSetMacAddress(Bundle bundle) {
        }

        protected void onUsbPhyPowerReset() {
        }
    }

    private static class BoxHandler extends Handler {
        private WeakReference<EthernetBox> mBoxWeakReference;

        BoxHandler(EthernetBox ethernetBox) {
            this.mBoxWeakReference = new WeakReference<>(ethernetBox);
        }

        private void setMacAddress(Message message, EthernetBox ethernetBox) {
            if (message.obj instanceof String) {
                Bundle bundle = new Bundle();
                bundle.putString(IEthernetConstant.KEY_MAC_ADDRESS, (String) message.obj);
                ethernetBox.sendQueryMsg(43, message.what, bundle);
            }
        }

        @Override // android.os.Handler
        public void handleMessage(Message message) {
            EthernetBox ethernetBox = this.mBoxWeakReference.get();
            if (ethernetBox == null) {
                return;
            }
            int i = message.what;
            if (i == 1) {
                ethernetBox.sendQueryMsg(41, i, new Bundle());
                return;
            }
            if (i == 2) {
                ethernetBox.sendQueryMsg(42, i, new Bundle());
            } else if (i == 3) {
                setMacAddress(message, ethernetBox);
            } else {
                if (i != 4) {
                    return;
                }
                ethernetBox.sendQueryMsg(44, i, new Bundle());
            }
        }
    }

    public EthernetBox(Context context, AbstractEthernetCallback abstractEthernetCallback) {
        this.mContext = context;
        this.mEthernetCallback = abstractEthernetCallback;
        this.mCurrentTryTime.set(0);
        this.mHandler = new BoxHandler(this);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void sendQueryMsg(int i, int i2, Bundle bundle) {
        Log.d(TAG, "sendQueryMsg-->action: " + i);
        ThreadLocal<Integer> threadLocal = this.mCurrentTryTime;
        threadLocal.set(Integer.valueOf(threadLocal.get().intValue() + 1));
        if (this.mService != null) {
            try {
                Log.d(TAG, "mService != null, just send Message");
                this.mService.sendMessage(McuMailboxes.getID(), i, bundle);
                return;
            } catch (RemoteException e2) {
                Log.e(TAG, LibMcuApplication.REMOTE_EXCEPTION, e2);
                return;
            }
        }
        Log.d(TAG, "mService == null,  then will check retry times");
        if (this.mCurrentTryTime.get().intValue() < 3) {
            Log.d(TAG, "retry times less than max, will resend msg after 500 ms");
            this.mHandler.sendEmptyMessageDelayed(i2, 500L);
        }
    }

    @Override // com.seewo.libmcuservice.AbstractMailbox
    protected void clearService() {
        this.mService = null;
    }

    @Override // com.seewo.libmcuservice.AbstractMailbox
    protected void initService(IMcuService iMcuService) {
        try {
            IEthernetService ethernetService = iMcuService.getEthernetService();
            this.mService = ethernetService;
            if (this.mEthernetCallback != null) {
                ethernetService.registerCallback(new Binder(), this.mContext.getPackageName(), this.mServiceCallback);
            }
        } catch (RemoteException e2) {
            Log.e(TAG, LibMcuApplication.REMOTE_EXCEPTION, e2);
        }
    }

    @Override // com.seewo.libmcuservice.AbstractMailbox
    protected void onWorkDone() {
    }

    public void postQueryEthernetState() {
        this.mCurrentTryTime.set(0);
        this.mHandler.sendEmptyMessage(1);
    }

    public void postQueryMacAddress() {
        this.mCurrentTryTime.set(0);
        this.mHandler.sendEmptyMessage(2);
    }

    public void postSetMacAddress(String str) {
        Log.d(TAG, "postSetMacAddress-->macAddress: " + str);
        this.mCurrentTryTime.set(0);
        Message messageObtainMessage = this.mHandler.obtainMessage(3);
        messageObtainMessage.obj = str;
        messageObtainMessage.sendToTarget();
    }

    public void postSetUsbPhyPowerReset() {
        this.mCurrentTryTime.set(0);
        this.mHandler.obtainMessage(4).sendToTarget();
    }

    @Override // com.seewo.libmcuservice.AbstractMailbox
    protected void release() {
        IEthernetService iEthernetService;
        Log.d(TAG, "release callback");
        if (this.mEthernetCallback == null || (iEthernetService = this.mService) == null) {
            return;
        }
        try {
            iEthernetService.unregisterCallback(this.mContext.getPackageName(), this.mServiceCallback);
        } catch (RemoteException e2) {
            Log.e(TAG, LibMcuApplication.REMOTE_EXCEPTION, e2);
        }
    }
}