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.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/* JADX INFO: loaded from: classes.dex */
public class SDKMediaDataManager implements ISDKMediaData {
    public static final int CODE_INTERNAL_ERROR = 100;
    public static final int CODE_NOT_CONNECTED = 0;
    public static final int CODE_RESOURCES_OCCUPIED = 1;
    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.";

    @Deprecated
    public static final int GET_AUDIO_DATA_FAIL = 1;

    @Deprecated
    public static final int GET_SCREEN_DATA_FAIL = 0;
    private static final byte[] SEGMENTED_DATA_WRAP = {-1, -1};
    private static final byte[] SEGMENTED_LAST_DATA_WRAP = {-1, -2};
    private static final String TAG = "SDKMediaDataManager";
    private static volatile SDKMediaDataManager mInstance;
    private IMediaDataService mMediaDataService;
    private ConcurrentHashMap<String, ISDKMediaDataCallback> mClientList = new ConcurrentHashMap<>();
    private final List<byte[]> mSegmentedDataCache = new ArrayList();

    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);
        }
        if (!SDKMediaHelper.I.obtainingScreenData()) {
            this.mSegmentedDataCache.clear();
        }
        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 {
                        if (SDKMediaDataManager.isSegmentedData(bArr)) {
                            SDKMediaDataManager.this.mSegmentedDataCache.add(bArr);
                        } else if (SDKMediaDataManager.isLastSegmentedData(bArr)) {
                            SDKMediaDataManager.this.mSegmentedDataCache.add(bArr);
                            iSDKMediaDataCallback.onGetScreenData(SDKMediaDataManager.this.getAndClearCache());
                        } else {
                            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);
                this.mSegmentedDataCache.clear();
            } catch (RemoteException e) {
                RLog.e(TAG, "unRegisterCallback: ", e);
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public byte[] getAndClearCache() {
        Iterator<byte[]> it = this.mSegmentedDataCache.iterator();
        int i = 0;
        int length = 0;
        while (it.hasNext()) {
            length += it.next().length - (SEGMENTED_DATA_WRAP.length * 2);
        }
        byte[] bArr = new byte[length];
        for (byte[] bArr2 : this.mSegmentedDataCache) {
            byte[] bArr3 = SEGMENTED_DATA_WRAP;
            int length2 = bArr3.length;
            int length3 = bArr2.length - (bArr3.length * 2);
            System.arraycopy(bArr2, length2, bArr, i, length3);
            i += length3;
        }
        this.mSegmentedDataCache.clear();
        return bArr;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static boolean isSegmentedData(byte[] bArr) {
        return isWrapWith(bArr, SEGMENTED_DATA_WRAP);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static boolean isLastSegmentedData(byte[] bArr) {
        return isWrapWith(bArr, SEGMENTED_LAST_DATA_WRAP);
    }

    private static boolean isWrapWith(byte[] bArr, byte[] bArr2) {
        if (bArr == null || bArr.length < bArr2.length * 2) {
            return false;
        }
        for (int i = 0; i < bArr2.length; i++) {
            byte b = bArr[i];
            byte b2 = bArr2[i];
            if (b != b2 || bArr[(bArr.length - bArr2.length) + i] != b2) {
                return false;
            }
        }
        return true;
    }
}