package com.seewo.sdk;

import android.os.RemoteException;
import com.seewo.sdk.interfaces.ISDKMediaData;
import com.seewo.sdk.interfaces.ISDKMediaDataCallback;
import com.seewo.sdk.internal.command.media.CmdMedia;
import com.seewo.sdk.internal.command.media.SDKMediaType;
import com.seewo.sdk.internal.utils.Constants;
import com.seewo.sdk.internal.utils.SDKServiceManager;
import com.seewo.sdk.media.IMediaDataCallback;
import com.seewo.sdk.media.IMediaDataService;
import com.seewo.sdk.util.ParseUtil;
import com.seewo.sdk.util.RLog;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/* JADX INFO: loaded from: classes.dex */
public class SDKMediaDataManager implements ISDKMediaData {
    public static final String ERROR_MCU_SERVICE_UNABLE_CONNECTION = "OpenSDKService unable connection to get data.";
    public static final String ERROR_SCREEN_RECORDER_UNABLE_CONNECTION = "ScreenRecorder OpenSDKService unable connection to get data.";
    public static final String ERROR_SCREEN_RECORDING_STARTED = "screen recording has started,please unRegister callback.";
    public static final int GET_AUDIO_DATA_FAIL = 1;
    public static final int GET_SCREEN_DATA_FAIL = 0;
    private static final String TAG = "SDKMediaDataManager";
    private static volatile SDKMediaDataManager mInstance;
    private ConcurrentHashMap<String, ISDKMediaDataCallback> mClientList = new ConcurrentHashMap<>();
    private IMediaDataService mMediaDataService;

    private SDKMediaDataManager() {
    }

    public static SDKMediaDataManager getInstance() {
        if (mInstance == null) {
            synchronized (SDKMediaDataManager.class) {
                if (mInstance == null) {
                    mInstance = new SDKMediaDataManager();
                }
            }
        }
        return mInstance;
    }

    public void reConnect() {
        RLog.i(TAG, "reConnect: ");
        init();
        ConcurrentHashMap<String, ISDKMediaDataCallback> concurrentHashMap = this.mClientList;
        if (concurrentHashMap == null || concurrentHashMap.isEmpty()) {
            return;
        }
        Iterator<Map.Entry<String, ISDKMediaDataCallback>> it = this.mClientList.entrySet().iterator();
        while (it.hasNext()) {
            String key = it.next().getKey();
            registerCallback(key, this.mClientList.get(key));
        }
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaData
    public boolean checkConfiguration() {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.CHECK_MEDIA_DATA_CONFIGURATION)));
    }

    private void init() {
        this.mMediaDataService = IMediaDataService.Stub.asInterface(SDKServiceManager.i().getService(Constants.MEDIA_DATA_SERVICE));
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaData
    public void registerCallback(String str, final ISDKMediaDataCallback iSDKMediaDataCallback) {
        RLog.d(TAG, "registerCallback: " + str);
        if (!OpenSDK.getInstance().isConnected() || this.mMediaDataService == null) {
            iSDKMediaDataCallback.onError(0, str + ERROR_MCU_SERVICE_UNABLE_CONNECTION);
        }
        IMediaDataService iMediaDataService = this.mMediaDataService;
        if (iMediaDataService != null) {
            try {
                iMediaDataService.registerCallback(str, new IMediaDataCallback.Stub() { // from class: com.seewo.sdk.SDKMediaDataManager.1
                    @Override // com.seewo.sdk.media.IMediaDataCallback
                    public void onGetScreenData(byte[] bArr) throws RemoteException {
                        iSDKMediaDataCallback.onGetScreenData(bArr);
                    }

                    @Override // com.seewo.sdk.media.IMediaDataCallback
                    public void onError(int i, String str2) throws RemoteException {
                        iSDKMediaDataCallback.onError(i, str2);
                    }
                });
                this.mClientList.put(str, iSDKMediaDataCallback);
            } catch (RemoteException e) {
                RLog.e(TAG, "registerCallback: ", e);
            }
        }
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaData
    public void unRegisterCallback(String str) {
        RLog.d(TAG, "unRegisterCallback: " + str);
        IMediaDataService iMediaDataService = this.mMediaDataService;
        if (iMediaDataService != null) {
            try {
                iMediaDataService.unRegisterCallback(str);
                this.mClientList.remove(str);
            } catch (RemoteException e) {
                RLog.e(TAG, "unRegisterCallback: ", e);
            }
        }
    }
}