Kaspi.kz v5.85.1 - getPreviousMode.java 源代码

package o;

import android.media.DeniedByServerException;
import android.media.MediaCryptoException;
import android.media.MediaDrm;
import android.media.MediaDrmException;
import android.media.NotProvisionedException;
import android.media.UnsupportedSchemeException;
import android.os.Handler;
import android.os.PersistableBundle;
import android.text.TextUtils;
import androidx.annotation.Nullable;
import androidx.media3.exoplayer.drm.UnsupportedDrmException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import o.getLatchBytes;
import o.setMaxSupportedZoomRatio;

public final class getPreviousMode implements getLatchBytes {
    private static final String AudioAttributesCompatParcelizer = "FrameworkMediaDrm";
    private static final String IconCompatParcelizer = "<LA_URL>https://x</LA_URL>";
    private static final int MediaBrowserCompatCustomActionResultReceiver = 2;
    private static final String RemoteActionCompatParcelizer = "cenc";
    private static final String read = "https://x";
    public static final getLatchBytes.RemoteActionCompatParcelizer setElement = new getLatchBytes.RemoteActionCompatParcelizer() {
        @Override
        public final getLatchBytes setError(UUID uuid) {
            getLatchBytes label;
            label = getPreviousMode.setLabel(uuid);
            return label;
        }
    };
    private int AudioAttributesImplApi21Parcelizer;
    private final MediaDrm AudioAttributesImplApi26Parcelizer;
    private final UUID AudioAttributesImplBaseParcelizer;

    @Override
    public int setFieldValue() {
        return 2;
    }

    public static getLatchBytes setLabel(UUID uuid) {
        try {
            return setBackground(uuid);
        } catch (UnsupportedDrmException unused) {
            getAllLandmarks.setLabel(AudioAttributesCompatParcelizer, "Failed to instantiate a FrameworkMediaDrm for uuid: " + uuid + ".");
            return new getX12Words();
        }
    }

    public static boolean setOptions(UUID uuid) {
        return MediaDrm.isCryptoSchemeSupported(setFieldValue(uuid));
    }

    public static getPreviousMode setBackground(UUID uuid) throws UnsupportedDrmException {
        try {
            return new getPreviousMode(uuid);
        } catch (UnsupportedSchemeException e) {
            throw new UnsupportedDrmException(1, e);
        } catch (Exception e2) {
            throw new UnsupportedDrmException(2, e2);
        }
    }

    private getPreviousMode(UUID uuid) throws UnsupportedSchemeException {
        nv21ToBitmap.setBackground(uuid);
        nv21ToBitmap.setOptions(!openConnection.r8lambdaqrzmfDOyDuplJFtpJLozn3P9EZI.equals(uuid), "Use C.CLEARKEY_UUID instead");
        this.AudioAttributesImplBaseParcelizer = uuid;
        MediaDrm mediaDrm = new MediaDrm(setFieldValue(uuid));
        this.AudioAttributesImplApi26Parcelizer = mediaDrm;
        this.AudioAttributesImplApi21Parcelizer = 1;
        if (openConnection.setThumbDrawable.equals(uuid) && RemoteActionCompatParcelizer()) {
            setLabel(mediaDrm);
        }
    }

    @Override
    public void setFieldValue(@Nullable getLatchBytes.setFieldValue setfieldvalue) {
        this.AudioAttributesImplApi26Parcelizer.setOnEventListener(setfieldvalue == null ? null : new getHorizontalDataRegions(this, setfieldvalue));
    }

    public void setError(getLatchBytes.setFieldValue setfieldvalue, MediaDrm mediaDrm, byte[] bArr, int i, int i2, byte[] bArr2) {
        setfieldvalue.setError(this, bArr, i, i2, bArr2);
    }

    @Override
    public void setOptions(@Nullable getLatchBytes.setElement setelement) {
        if (getLandmarkType.read < 23) {
            throw new UnsupportedOperationException();
        }
        this.AudioAttributesImplApi26Parcelizer.setOnKeyStatusChangeListener(setelement == null ? null : new getVerticalDataRegions(this, setelement), (Handler) null);
    }

    public void setError(getLatchBytes.setElement setelement, MediaDrm mediaDrm, byte[] bArr, List list, boolean z) {
        ArrayList arrayList = new ArrayList();
        Iterator it = list.iterator();
        while (it.hasNext()) {
            MediaDrm.KeyStatus keyStatus = (MediaDrm.KeyStatus) it.next();
            arrayList.add(new getLatchBytes.setLabel(keyStatus.getStatusCode(), keyStatus.getKeyId()));
        }
        setelement.setError(this, bArr, arrayList, z);
    }

    @Override
    public void setError(@Nullable getLatchBytes.setBackground setbackground) {
        if (getLandmarkType.read < 23) {
            throw new UnsupportedOperationException();
        }
        this.AudioAttributesImplApi26Parcelizer.setOnExpirationUpdateListener(setbackground == null ? null : new getMacroId(this, setbackground), (Handler) null);
    }

    public void setError(getLatchBytes.setBackground setbackground, MediaDrm mediaDrm, byte[] bArr, long j) {
        setbackground.setOptions(this, bArr, j);
    }

    @Override
    public byte[] IconCompatParcelizer() throws MediaDrmException {
        return this.AudioAttributesImplApi26Parcelizer.openSession();
    }

    @Override
    public void setLabel(byte[] bArr) {
        this.AudioAttributesImplApi26Parcelizer.closeSession(bArr);
    }

    @Override
    public void setBackground(byte[] bArr, DecodedBitStreamParser1 decodedBitStreamParser1) {
        if (getLandmarkType.read >= 31) {
            try {
                setBackground.setBackground(this.AudioAttributesImplApi26Parcelizer, bArr, decodedBitStreamParser1);
            } catch (UnsupportedOperationException unused) {
                getAllLandmarks.setError(AudioAttributesCompatParcelizer, "setLogSessionId failed.");
            }
        }
    }

    @Override
    public getLatchBytes.setOptions setError(byte[] bArr, @Nullable List<setMaxSupportedZoomRatio.setFieldValue> list, int i, @Nullable HashMap<String, String> hashMap) throws NotProvisionedException {
        setMaxSupportedZoomRatio.setFieldValue setfieldvalue;
        byte[] bArr2;
        String str;
        if (list != null) {
            setfieldvalue = setBackground(this.AudioAttributesImplBaseParcelizer, list);
            bArr2 = setError(this.AudioAttributesImplBaseParcelizer, (byte[]) nv21ToBitmap.setBackground(setfieldvalue.setBackground));
            str = setLabel(this.AudioAttributesImplBaseParcelizer, setfieldvalue.setLabel);
        } else {
            setfieldvalue = null;
            bArr2 = null;
            str = null;
        }
        MediaDrm.KeyRequest keyRequest = this.AudioAttributesImplApi26Parcelizer.getKeyRequest(bArr, bArr2, str, i, hashMap);
        byte[] background = setBackground(this.AudioAttributesImplBaseParcelizer, keyRequest.getData());
        String background2 = setBackground(keyRequest.getDefaultUrl());
        if (TextUtils.isEmpty(background2) && setfieldvalue != null && !TextUtils.isEmpty(setfieldvalue.setOptions)) {
            background2 = setfieldvalue.setOptions;
        }
        return new getLatchBytes.setOptions(background, background2, getLandmarkType.read >= 23 ? keyRequest.getRequestType() : Integer.MIN_VALUE);
    }

    private String setBackground(String str) {
        if (IconCompatParcelizer.equals(str)) {
            return "";
        }
        if (getLandmarkType.read >= 33 && "https://default.url".equals(str)) {
            String error = setError("version");
            if (Objects.equals(error, "1.2") || Objects.equals(error, "aidl-1")) {
                return "";
            }
        }
        return str;
    }

    @Override
    public byte[] setBackground(byte[] bArr, byte[] bArr2) throws NotProvisionedException, DeniedByServerException {
        if (openConnection.MediaSessionCompatResultReceiverWrapper.equals(this.AudioAttributesImplBaseParcelizer)) {
            bArr2 = min.setOptions(bArr2);
        }
        return this.AudioAttributesImplApi26Parcelizer.provideKeyResponse(bArr, bArr2);
    }

    @Override
    public getLatchBytes.write setOptions() {
        MediaDrm.ProvisionRequest provisionRequest = this.AudioAttributesImplApi26Parcelizer.getProvisionRequest();
        return new getLatchBytes.write(provisionRequest.getData(), provisionRequest.getDefaultUrl());
    }

    @Override
    public void setFieldValue(byte[] bArr) throws DeniedByServerException {
        this.AudioAttributesImplApi26Parcelizer.provideProvisionResponse(bArr);
    }

    @Override
    public Map<String, String> setError(byte[] bArr) {
        return this.AudioAttributesImplApi26Parcelizer.queryKeyStatus(bArr);
    }

    @Override
    public boolean setFieldValue(byte[] r4, java.lang.String r5) {
        throw new UnsupportedOperationException("Method not decompiled: o.getPreviousMode.setFieldValue(byte[], java.lang.String):boolean");
    }

    @Override
    public void setLabel() {
        synchronized (this) {
            nv21ToBitmap.setFieldValue(this.AudioAttributesImplApi21Parcelizer > 0);
            this.AudioAttributesImplApi21Parcelizer++;
        }
    }

    @Override
    public void setElement() {
        synchronized (this) {
            int i = this.AudioAttributesImplApi21Parcelizer - 1;
            this.AudioAttributesImplApi21Parcelizer = i;
            if (i == 0) {
                this.AudioAttributesImplApi26Parcelizer.release();
            }
        }
    }

    @Override
    public void setError(byte[] bArr, byte[] bArr2) {
        this.AudioAttributesImplApi26Parcelizer.restoreKeys(bArr, bArr2);
    }

    @Override
    public void setBackground(byte[] bArr) {
        if (getLandmarkType.read < 29) {
            throw new UnsupportedOperationException();
        }
        getShapeHint.setBackground(this.AudioAttributesImplApi26Parcelizer, bArr);
    }

    @Override
    public List<byte[]> write() {
        if (getLandmarkType.read < 29) {
            throw new UnsupportedOperationException();
        }
        return MinimalEncoderInput.setLabel(this.AudioAttributesImplApi26Parcelizer);
    }

    @Override
    public PersistableBundle setError() {
        if (getLandmarkType.read < 28) {
            return null;
        }
        return MinimalEncoderMode.setFieldValue(this.AudioAttributesImplApi26Parcelizer);
    }

    @Override
    public String setError(String str) {
        return this.AudioAttributesImplApi26Parcelizer.getPropertyString(str);
    }

    @Override
    public byte[] setOptions(String str) {
        return this.AudioAttributesImplApi26Parcelizer.getPropertyByteArray(str);
    }

    @Override
    public void setLabel(String str, String str2) {
        this.AudioAttributesImplApi26Parcelizer.setPropertyString(str, str2);
    }

    @Override
    public void setFieldValue(String str, byte[] bArr) {
        this.AudioAttributesImplApi26Parcelizer.setPropertyByteArray(str, bArr);
    }

    @Override
    public getMinSymbolSize setOptions(byte[] bArr) throws MediaCryptoException {
        return new getMinSymbolSize(setFieldValue(this.AudioAttributesImplBaseParcelizer), bArr, read());
    }

    private boolean read() {
        return getLandmarkType.read < 21 && openConnection.setThumbDrawable.equals(this.AudioAttributesImplBaseParcelizer) && "L3".equals(setError("securityLevel"));
    }

    private boolean setBackground() {
        if (this.AudioAttributesImplBaseParcelizer.equals(openConnection.setThumbDrawable)) {
            String error = setError("version");
            return (error.startsWith("v5.") || error.startsWith("14.") || error.startsWith("15.") || error.startsWith("16.0")) ? false : true;
        }
        return this.AudioAttributesImplBaseParcelizer.equals(openConnection.MediaSessionCompatResultReceiverWrapper);
    }

    private static setMaxSupportedZoomRatio.setFieldValue setBackground(UUID uuid, List<setMaxSupportedZoomRatio.setFieldValue> list) {
        if (!openConnection.setThumbDrawable.equals(uuid)) {
            return list.get(0);
        }
        if (getLandmarkType.read >= 28 && list.size() > 1) {
            setMaxSupportedZoomRatio.setFieldValue setfieldvalue = list.get(0);
            int i = 0;
            for (int i2 = 0; i2 < list.size(); i2++) {
                setMaxSupportedZoomRatio.setFieldValue setfieldvalue2 = list.get(i2);
                byte[] bArr = (byte[]) nv21ToBitmap.setBackground(setfieldvalue2.setBackground);
                if (getLandmarkType.setError(setfieldvalue2.setLabel, setfieldvalue.setLabel) && getLandmarkType.setError(setfieldvalue2.setOptions, setfieldvalue.setOptions) && applyMaskPenaltyRule1.setOptions(bArr)) {
                    i += bArr.length;
                }
            }
            byte[] bArr2 = new byte[i];
            int i3 = 0;
            for (int i4 = 0; i4 < list.size(); i4++) {
                byte[] bArr3 = (byte[]) nv21ToBitmap.setBackground(list.get(i4).setBackground);
                int length = bArr3.length;
                System.arraycopy(bArr3, 0, bArr2, i3, length);
                i3 += length;
            }
            return setfieldvalue.setError(bArr2);
        }
        for (int i5 = 0; i5 < list.size(); i5++) {
            setMaxSupportedZoomRatio.setFieldValue setfieldvalue3 = list.get(i5);
            int background = applyMaskPenaltyRule1.setBackground((byte[]) nv21ToBitmap.setBackground(setfieldvalue3.setBackground));
            int i6 = getLandmarkType.read;
            if (i6 < 23 && background == 0) {
                return setfieldvalue3;
            }
            if (i6 >= 23 && background == 1) {
                return setfieldvalue3;
            }
        }
        return list.get(0);
    }

    private static UUID setFieldValue(UUID uuid) {
        return (getLandmarkType.read >= 27 || !openConnection.MediaSessionCompatResultReceiverWrapper.equals(uuid)) ? uuid : openConnection.r8lambdaqrzmfDOyDuplJFtpJLozn3P9EZI;
    }

    private static byte[] setError(java.util.UUID r3, byte[] r4) {
        throw new UnsupportedOperationException("Method not decompiled: o.getPreviousMode.setError(java.util.UUID, byte[]):byte[]");
    }

    private static String setLabel(UUID uuid, String str) {
        return (getLandmarkType.read < 26 && openConnection.MediaSessionCompatResultReceiverWrapper.equals(uuid) && ("video/mp4".equals(str) || "audio/mp4".equals(str))) ? RemoteActionCompatParcelizer : str;
    }

    private static byte[] setBackground(UUID uuid, byte[] bArr) {
        return openConnection.MediaSessionCompatResultReceiverWrapper.equals(uuid) ? min.setError(bArr) : bArr;
    }

    private static void setLabel(MediaDrm mediaDrm) {
        mediaDrm.setPropertyString("securityLevel", "L3");
    }

    private static boolean RemoteActionCompatParcelizer() {
        return "ASUS_Z00AD".equals(getLandmarkType.setElement);
    }

    private static byte[] setElement(byte[] bArr) {
        FaceDetectorOptions faceDetectorOptions = new FaceDetectorOptions(bArr);
        int AudioAttributesImplApi26Parcelizer = faceDetectorOptions.AudioAttributesImplApi26Parcelizer();
        short MediaMetadataCompat = faceDetectorOptions.MediaMetadataCompat();
        short MediaMetadataCompat2 = faceDetectorOptions.MediaMetadataCompat();
        if (MediaMetadataCompat != 1 || MediaMetadataCompat2 != 1) {
            getAllLandmarks.setOptions(AudioAttributesCompatParcelizer, "Unexpected record count or type. Skipping LA_URL workaround.");
            return bArr;
        }
        short MediaMetadataCompat3 = faceDetectorOptions.MediaMetadataCompat();
        Charset charset = childSafe.setOptions;
        String error = faceDetectorOptions.setError(MediaMetadataCompat3, charset);
        if (error.contains("<LA_URL>")) {
            return bArr;
        }
        int indexOf = error.indexOf("</DATA>");
        if (indexOf == -1) {
            getAllLandmarks.setError(AudioAttributesCompatParcelizer, "Could not find the </DATA> tag. Skipping LA_URL workaround.");
        }
        String str = error.substring(0, indexOf) + IconCompatParcelizer + error.substring(indexOf);
        int i = AudioAttributesImplApi26Parcelizer + 52;
        ByteBuffer allocate = ByteBuffer.allocate(i);
        allocate.order(ByteOrder.LITTLE_ENDIAN);
        allocate.putInt(i);
        allocate.putShort(MediaMetadataCompat);
        allocate.putShort(MediaMetadataCompat2);
        allocate.putShort((short) (str.length() * 2));
        allocate.put(str.getBytes(charset));
        return allocate.array();
    }
}