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

package o;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.media.browse.MediaBrowser;
import android.media.session.MediaSession;
import android.media.session.MediaSessionManager;
import android.os.Binder;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.RemoteException;
import android.service.media.MediaBrowserService;
import android.support.v4.media.MediaBrowserCompat;
import android.support.v4.media.session.MediaSessionCompat;
import android.text.TextUtils;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import o.logErrorCodes;

public abstract class validateModel extends Service {
    public static final int IconCompatParcelizer = 1;
    private static final float MediaMetadataCompat = 1.0E-5f;
    public static final int RemoteActionCompatParcelizer = 0;
    static final int read = 1;
    public static final String setBackground = "search_results";
    static final int setElement = 4;
    public static final String setError = "media_item";
    public static final int setFieldValue = -1;
    static final int setLabel = 2;
    public static final String write = "android.media.browse.MediaBrowserService";
    setOptions MediaBrowserCompatCustomActionResultReceiver;
    MediaSessionCompat.Token MediaBrowserCompatItemReceiver;
    private setLabel MediaBrowserCompatMediaItem;
    static final String AudioAttributesImplApi26Parcelizer = "MBServiceCompat";
    static final boolean setOptions = Log.isLoggable(AudioAttributesImplApi26Parcelizer, 3);
    private final MediaBrowserCompatCustomActionResultReceiver MediaBrowserCompatSearchResultReceiver = new MediaBrowserCompatCustomActionResultReceiver();
    final setOptions AudioAttributesImplBaseParcelizer = new setOptions(logErrorCodes.setOptions.setFieldValue, -1, -1, null, null);
    final ArrayList<setOptions> MediaDescriptionCompat = new ArrayList<>();
    final LifecycleEffectKtLifecycleStartEffectImpl2<IBinder, setOptions> AudioAttributesImplApi21Parcelizer = new LifecycleEffectKtLifecycleStartEffectImpl2<>();
    final AudioAttributesImplBaseParcelizer AudioAttributesCompatParcelizer = new AudioAttributesImplBaseParcelizer(this);

    interface AudioAttributesImplApi21Parcelizer {
        IBinder setError();

        void setLabel(String str, MediaSessionCompat.Token token, Bundle bundle) throws RemoteException;

        void setLabel(String str, List<MediaBrowserCompat.MediaItem> list, Bundle bundle, Bundle bundle2) throws RemoteException;

        void setOptions() throws RemoteException;
    }

    interface setLabel {
        logErrorCodes.setOptions setBackground();

        void setBackground(String str, Bundle bundle);

        void setBackground(logErrorCodes.setOptions setoptions, String str, Bundle bundle);

        Bundle setLabel();

        void setLabel(MediaSessionCompat.Token token);

        IBinder setOptions(Intent intent);

        void setOptions();
    }

    @Override
    public void dump(FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
    }

    public abstract void setFieldValue(@NonNull String str, @NonNull RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>> remoteActionCompatParcelizer);

    public abstract setError setLabel(@NonNull String str, int i, @Nullable Bundle bundle);

    public void setLabel(String str) {
    }

    public void setOptions(String str, Bundle bundle) {
    }

    class setElement implements setLabel {
        private Messenger setBackground;

        setElement() {
        }

        @Override
        public void setOptions() {
            this.setBackground = new Messenger(validateModel.this.AudioAttributesCompatParcelizer);
        }

        @Override
        public IBinder setOptions(Intent intent) {
            if (validateModel.write.equals(intent.getAction())) {
                return this.setBackground.getBinder();
            }
            return null;
        }

        @Override
        public void setLabel(final MediaSessionCompat.Token token) {
            validateModel.this.AudioAttributesCompatParcelizer.post(new Runnable() {
                @Override
                public void run() {
                    Iterator it = validateModel.this.AudioAttributesImplApi21Parcelizer.values().iterator();
                    while (it.hasNext()) {
                        setOptions setoptions = (setOptions) it.next();
                        try {
                            setoptions.setBackground.setLabel(setoptions.setOptions.setOptions(), token, setoptions.setOptions.setLabel());
                        } catch (RemoteException unused) {
                            Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "Connection for " + setoptions.setError + " is no longer valid.");
                            it.remove();
                        }
                    }
                }
            });
        }

        @Override
        public void setBackground(@NonNull final String str, final Bundle bundle) {
            validateModel.this.AudioAttributesCompatParcelizer.post(new Runnable() {
                @Override
                public void run() {
                    Iterator it = validateModel.this.AudioAttributesImplApi21Parcelizer.keySet().iterator();
                    while (it.hasNext()) {
                        setElement.this.setError((setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.get((IBinder) it.next()), str, bundle);
                    }
                }
            });
        }

        @Override
        public void setBackground(@NonNull final logErrorCodes.setOptions setoptions, @NonNull final String str, final Bundle bundle) {
            validateModel.this.AudioAttributesCompatParcelizer.post(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < validateModel.this.AudioAttributesImplApi21Parcelizer.size(); i++) {
                        setOptions setoptions2 = (setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.setBackground(i);
                        if (setoptions2.setFieldValue.equals(setoptions)) {
                            setElement.this.setError(setoptions2, str, bundle);
                            return;
                        }
                    }
                }
            });
        }

        void setError(setOptions setoptions, String str, Bundle bundle) {
            List<setChipEndPadding<IBinder, Bundle>> list = setoptions.setElement.get(str);
            if (list != null) {
                for (setChipEndPadding<IBinder, Bundle> setchipendpadding : list) {
                    if (constructModel.setOptions(bundle, (Bundle) setchipendpadding.setBackground)) {
                        validateModel.this.setError(str, setoptions, (Bundle) setchipendpadding.setBackground, bundle);
                    }
                }
            }
        }

        @Override
        public Bundle setLabel() {
            setOptions setoptions = validateModel.this.MediaBrowserCompatCustomActionResultReceiver;
            if (setoptions == null) {
                throw new IllegalStateException("This should be called inside of onLoadChildren, onLoadItem, onSearch, or onCustomAction methods");
            }
            if (setoptions.IconCompatParcelizer == null) {
                return null;
            }
            return new Bundle(validateModel.this.MediaBrowserCompatCustomActionResultReceiver.IconCompatParcelizer);
        }

        @Override
        public logErrorCodes.setOptions setBackground() {
            setOptions setoptions = validateModel.this.MediaBrowserCompatCustomActionResultReceiver;
            if (setoptions == null) {
                throw new IllegalStateException("This should be called inside of onLoadChildren, onLoadItem, onSearch, or onCustomAction methods");
            }
            return setoptions.setFieldValue;
        }
    }

    class setBackground implements setLabel {
        MediaBrowserService setBackground;
        final List<Bundle> setFieldValue = new ArrayList();
        Messenger setLabel;

        setBackground() {
        }

        @Override
        public void setOptions() {
            setFieldValue setfieldvalue = new setFieldValue(validateModel.this);
            this.setBackground = setfieldvalue;
            setfieldvalue.onCreate();
        }

        @Override
        public IBinder setOptions(Intent intent) {
            return this.setBackground.onBind(intent);
        }

        @Override
        public void setLabel(final MediaSessionCompat.Token token) {
            validateModel.this.AudioAttributesCompatParcelizer.setError(new Runnable() {
                @Override
                public void run() {
                    setBackground.this.setError(token);
                }
            });
        }

        void setError(MediaSessionCompat.Token token) {
            if (!this.setFieldValue.isEmpty()) {
                MediaBrowserCompatItemReceiver fieldValue = token.setFieldValue();
                if (fieldValue != null) {
                    Iterator<Bundle> it = this.setFieldValue.iterator();
                    while (it.hasNext()) {
                        recognizeNative.setBackground(it.next(), ModelValidator.ComponentActivity6, fieldValue.asBinder());
                    }
                }
                this.setFieldValue.clear();
            }
            this.setBackground.setSessionToken((MediaSession.Token) token.setBackground());
        }

        @Override
        public void setBackground(String str, Bundle bundle) {
            setError(str, bundle);
            setFieldValue(str, bundle);
        }

        @Override
        public void setBackground(logErrorCodes.setOptions setoptions, String str, Bundle bundle) {
            setFieldValue(setoptions, str, bundle);
        }

        public setError setError(String str, int i, Bundle bundle) {
            Bundle bundle2;
            int i2 = -1;
            if (bundle == null || bundle.getInt(ModelValidator.ParcelableVolumeInfo, 0) == 0) {
                bundle2 = null;
            } else {
                bundle.remove(ModelValidator.ParcelableVolumeInfo);
                this.setLabel = new Messenger(validateModel.this.AudioAttributesCompatParcelizer);
                bundle2 = new Bundle();
                bundle2.putInt(ModelValidator.ComponentActivity2, 2);
                recognizeNative.setBackground(bundle2, ModelValidator.setContentView, this.setLabel.getBinder());
                MediaSessionCompat.Token token = validateModel.this.MediaBrowserCompatItemReceiver;
                if (token != null) {
                    MediaBrowserCompatItemReceiver fieldValue = token.setFieldValue();
                    recognizeNative.setBackground(bundle2, ModelValidator.ComponentActivity6, fieldValue == null ? null : fieldValue.asBinder());
                } else {
                    this.setFieldValue.add(bundle2);
                }
                i2 = bundle.getInt(ModelValidator.PlaybackStateCompatCustomAction, -1);
                bundle.remove(ModelValidator.PlaybackStateCompatCustomAction);
            }
            setOptions setoptions = validateModel.this.new setOptions(str, i2, i, bundle, null);
            validateModel validatemodel = validateModel.this;
            validatemodel.MediaBrowserCompatCustomActionResultReceiver = setoptions;
            setError label = validatemodel.setLabel(str, i, bundle);
            validateModel validatemodel2 = validateModel.this;
            validatemodel2.MediaBrowserCompatCustomActionResultReceiver = null;
            if (label == null) {
                return null;
            }
            if (this.setLabel != null) {
                validatemodel2.MediaDescriptionCompat.add(setoptions);
            }
            if (bundle2 == null) {
                bundle2 = label.setLabel();
            } else if (label.setLabel() != null) {
                bundle2.putAll(label.setLabel());
            }
            return new setError(label.setOptions(), bundle2);
        }

        public void setLabel(String str, final IconCompatParcelizer<List<Parcel>> iconCompatParcelizer) {
            RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>> remoteActionCompatParcelizer = new RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>>(str) {
                @Override
                public void setLabel(@Nullable List<MediaBrowserCompat.MediaItem> list) {
                    ArrayList arrayList;
                    if (list == null) {
                        arrayList = null;
                    } else {
                        ArrayList arrayList2 = new ArrayList(list.size());
                        for (MediaBrowserCompat.MediaItem mediaItem : list) {
                            Parcel obtain = Parcel.obtain();
                            mediaItem.writeToParcel(obtain, 0);
                            arrayList2.add(obtain);
                        }
                        arrayList = arrayList2;
                    }
                    iconCompatParcelizer.setOptions(arrayList);
                }

                @Override
                public void setError() {
                    iconCompatParcelizer.setFieldValue();
                }
            };
            validateModel validatemodel = validateModel.this;
            validatemodel.MediaBrowserCompatCustomActionResultReceiver = validatemodel.AudioAttributesImplBaseParcelizer;
            validatemodel.setFieldValue(str, remoteActionCompatParcelizer);
            validateModel.this.MediaBrowserCompatCustomActionResultReceiver = null;
        }

        void setError(String str, Bundle bundle) {
            this.setBackground.notifyChildrenChanged(str);
        }

        void setFieldValue(final String str, final Bundle bundle) {
            validateModel.this.AudioAttributesCompatParcelizer.post(new Runnable() {
                @Override
                public void run() {
                    Iterator it = validateModel.this.AudioAttributesImplApi21Parcelizer.keySet().iterator();
                    while (it.hasNext()) {
                        setBackground.this.setBackground((setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.get((IBinder) it.next()), str, bundle);
                    }
                }
            });
        }

        void setFieldValue(final logErrorCodes.setOptions setoptions, final String str, final Bundle bundle) {
            validateModel.this.AudioAttributesCompatParcelizer.post(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < validateModel.this.AudioAttributesImplApi21Parcelizer.size(); i++) {
                        setOptions setoptions2 = (setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.setBackground(i);
                        if (setoptions2.setFieldValue.equals(setoptions)) {
                            setBackground.this.setBackground(setoptions2, str, bundle);
                        }
                    }
                }
            });
        }

        void setBackground(setOptions setoptions, String str, Bundle bundle) {
            List<setChipEndPadding<IBinder, Bundle>> list = setoptions.setElement.get(str);
            if (list != null) {
                for (setChipEndPadding<IBinder, Bundle> setchipendpadding : list) {
                    if (constructModel.setOptions(bundle, (Bundle) setchipendpadding.setBackground)) {
                        validateModel.this.setError(str, setoptions, (Bundle) setchipendpadding.setBackground, bundle);
                    }
                }
            }
        }

        @Override
        public Bundle setLabel() {
            if (this.setLabel == null) {
                return null;
            }
            setOptions setoptions = validateModel.this.MediaBrowserCompatCustomActionResultReceiver;
            if (setoptions == null) {
                throw new IllegalStateException("This should be called inside of onGetRoot, onLoadChildren, onLoadItem, onSearch, or onCustomAction methods");
            }
            if (setoptions.IconCompatParcelizer == null) {
                return null;
            }
            return new Bundle(validateModel.this.MediaBrowserCompatCustomActionResultReceiver.IconCompatParcelizer);
        }

        @Override
        public logErrorCodes.setOptions setBackground() {
            setOptions setoptions = validateModel.this.MediaBrowserCompatCustomActionResultReceiver;
            if (setoptions == null) {
                throw new IllegalStateException("This should be called inside of onGetRoot, onLoadChildren, onLoadItem, onSearch, or onCustomAction methods");
            }
            return setoptions.setFieldValue;
        }

        class setFieldValue extends MediaBrowserService {
            setFieldValue(Context context) {
                attachBaseContext(context);
            }

            @Override
            public MediaBrowserService.BrowserRoot onGetRoot(String str, int i, Bundle bundle) {
                MediaSessionCompat.setError(bundle);
                setError error = setBackground.this.setError(str, i, bundle == null ? null : new Bundle(bundle));
                if (error == null) {
                    return null;
                }
                return new MediaBrowserService.BrowserRoot(error.RemoteActionCompatParcelizer, error.setOptions);
            }

            @Override
            public void onLoadChildren(String str, MediaBrowserService.Result<List<MediaBrowser.MediaItem>> result) {
                setBackground.this.setLabel(str, new IconCompatParcelizer<>(result));
            }

            @Override
            public void onCreate() {
                super.onCreate();
            }

            @Override
            public void attachBaseContext(Context context) {
                super.attachBaseContext(context);
            }
        }
    }

    class setFieldValue extends setBackground {
        setFieldValue() {
            super();
        }

        @Override
        public void setOptions() {
            setLabel setlabel = new setLabel(validateModel.this);
            this.setBackground = setlabel;
            setlabel.onCreate();
        }

        public void setOptions(String str, final IconCompatParcelizer<Parcel> iconCompatParcelizer) {
            RemoteActionCompatParcelizer<MediaBrowserCompat.MediaItem> remoteActionCompatParcelizer = new RemoteActionCompatParcelizer<MediaBrowserCompat.MediaItem>(str) {
                @Override
                public void setLabel(@Nullable MediaBrowserCompat.MediaItem mediaItem) {
                    if (mediaItem == null) {
                        iconCompatParcelizer.setOptions(null);
                        return;
                    }
                    Parcel obtain = Parcel.obtain();
                    mediaItem.writeToParcel(obtain, 0);
                    iconCompatParcelizer.setOptions(obtain);
                }

                @Override
                public void setError() {
                    iconCompatParcelizer.setFieldValue();
                }
            };
            validateModel validatemodel = validateModel.this;
            validatemodel.MediaBrowserCompatCustomActionResultReceiver = validatemodel.AudioAttributesImplBaseParcelizer;
            validatemodel.setOptions(str, remoteActionCompatParcelizer);
            validateModel.this.MediaBrowserCompatCustomActionResultReceiver = null;
        }

        class setLabel extends setBackground.setFieldValue {
            setLabel(Context context) {
                super(context);
            }

            @Override
            public void onLoadItem(String str, MediaBrowserService.Result<MediaBrowser.MediaItem> result) {
                setFieldValue.this.setOptions(str, new IconCompatParcelizer<>(result));
            }

            @Override
            public void onCreate() {
                super.onCreate();
            }

            @Override
            public void attachBaseContext(Context context) {
                super.attachBaseContext(context);
            }
        }
    }

    class read extends setFieldValue {
        read() {
            super();
        }

        @Override
        public void setOptions() {
            setError seterror = new setError(validateModel.this);
            this.setBackground = seterror;
            seterror.onCreate();
        }

        public void setOptions(String str, final IconCompatParcelizer<List<Parcel>> iconCompatParcelizer, final Bundle bundle) {
            RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>> remoteActionCompatParcelizer = new RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>>(str) {
                @Override
                public void setLabel(@Nullable List<MediaBrowserCompat.MediaItem> list) {
                    if (list == null) {
                        iconCompatParcelizer.setOptions(null);
                        return;
                    }
                    if ((setOptions() & 1) != 0) {
                        list = validateModel.this.setError(list, bundle);
                    }
                    ArrayList arrayList = new ArrayList(list.size());
                    for (MediaBrowserCompat.MediaItem mediaItem : list) {
                        Parcel obtain = Parcel.obtain();
                        mediaItem.writeToParcel(obtain, 0);
                        arrayList.add(obtain);
                    }
                    iconCompatParcelizer.setOptions(arrayList);
                }

                @Override
                public void setError() {
                    iconCompatParcelizer.setFieldValue();
                }
            };
            validateModel validatemodel = validateModel.this;
            validatemodel.MediaBrowserCompatCustomActionResultReceiver = validatemodel.AudioAttributesImplBaseParcelizer;
            validatemodel.setFieldValue(str, remoteActionCompatParcelizer, bundle);
            validateModel.this.MediaBrowserCompatCustomActionResultReceiver = null;
        }

        @Override
        public Bundle setLabel() {
            validateModel validatemodel = validateModel.this;
            setOptions setoptions = validatemodel.MediaBrowserCompatCustomActionResultReceiver;
            if (setoptions == null) {
                throw new IllegalStateException("This should be called inside of onGetRoot, onLoadChildren, onLoadItem, onSearch, or onCustomAction methods");
            }
            if (setoptions == validatemodel.AudioAttributesImplBaseParcelizer) {
                return this.setBackground.getBrowserRootHints();
            }
            if (setoptions.IconCompatParcelizer == null) {
                return null;
            }
            return new Bundle(validateModel.this.MediaBrowserCompatCustomActionResultReceiver.IconCompatParcelizer);
        }

        @Override
        void setError(String str, Bundle bundle) {
            if (bundle != null) {
                this.setBackground.notifyChildrenChanged(str, bundle);
            } else {
                super.setError(str, bundle);
            }
        }

        class setError extends setFieldValue.setLabel {
            setError(Context context) {
                super(context);
            }

            @Override
            public void onLoadChildren(String str, MediaBrowserService.Result<List<MediaBrowser.MediaItem>> result, Bundle bundle) {
                MediaSessionCompat.setError(bundle);
                read readVar = read.this;
                validateModel validatemodel = validateModel.this;
                validatemodel.MediaBrowserCompatCustomActionResultReceiver = validatemodel.AudioAttributesImplBaseParcelizer;
                readVar.setOptions(str, new IconCompatParcelizer<>(result), bundle);
                validateModel.this.MediaBrowserCompatCustomActionResultReceiver = null;
            }

            @Override
            public void onCreate() {
                super.onCreate();
            }

            @Override
            public void attachBaseContext(Context context) {
                super.attachBaseContext(context);
            }
        }
    }

    class write extends read {
        write() {
            super();
        }

        @Override
        public logErrorCodes.setOptions setBackground() {
            MediaSessionManager.RemoteUserInfo currentBrowserInfo;
            validateModel validatemodel = validateModel.this;
            setOptions setoptions = validatemodel.MediaBrowserCompatCustomActionResultReceiver;
            if (setoptions == null) {
                throw new IllegalStateException("This should be called inside of onGetRoot, onLoadChildren, onLoadItem, onSearch, or onCustomAction methods");
            }
            if (setoptions == validatemodel.AudioAttributesImplBaseParcelizer) {
                currentBrowserInfo = this.setBackground.getCurrentBrowserInfo();
                return new logErrorCodes.setOptions(currentBrowserInfo);
            }
            return setoptions.setFieldValue;
        }
    }

    static final class AudioAttributesImplBaseParcelizer extends Handler {
        private validateModel setLabel;

        AudioAttributesImplBaseParcelizer(@NonNull validateModel validatemodel) {
            this.setLabel = validatemodel;
        }

        @Override
        public void handleMessage(@NonNull Message message) {
            validateModel validatemodel = this.setLabel;
            if (validatemodel != null) {
                validatemodel.setBackground(message);
            } else {
                removeCallbacksAndMessages(null);
            }
        }

        public void setFieldValue() {
            this.setLabel = null;
        }

        @Override
        public boolean sendMessageAtTime(Message message, long j) {
            Bundle data = message.getData();
            data.setClassLoader(MediaBrowserCompat.class.getClassLoader());
            data.putInt(ModelValidator.AudioAttributesImplApi21Parcelizer, Binder.getCallingUid());
            int callingPid = Binder.getCallingPid();
            if (callingPid > 0) {
                data.putInt(ModelValidator.MediaBrowserCompatCustomActionResultReceiver, callingPid);
            } else if (!data.containsKey(ModelValidator.MediaBrowserCompatCustomActionResultReceiver)) {
                data.putInt(ModelValidator.MediaBrowserCompatCustomActionResultReceiver, -1);
            }
            return super.sendMessageAtTime(message, j);
        }

        public void setError(Runnable runnable) {
            if (Thread.currentThread() == getLooper().getThread()) {
                runnable.run();
            } else {
                post(runnable);
            }
        }
    }

    class setOptions implements IBinder.DeathRecipient {
        public final Bundle IconCompatParcelizer;
        public final int read;
        public final AudioAttributesImplApi21Parcelizer setBackground;
        public final HashMap<String, List<setChipEndPadding<IBinder, Bundle>>> setElement = new HashMap<>();
        public final String setError;
        public final logErrorCodes.setOptions setFieldValue;
        public final int setLabel;
        public setError setOptions;

        setOptions(String str, int i, int i2, Bundle bundle, AudioAttributesImplApi21Parcelizer audioAttributesImplApi21Parcelizer) {
            this.setError = str;
            this.setLabel = i;
            this.read = i2;
            this.setFieldValue = new logErrorCodes.setOptions(str, i, i2);
            this.IconCompatParcelizer = bundle;
            this.setBackground = audioAttributesImplApi21Parcelizer;
        }

        @Override
        public void binderDied() {
            validateModel.this.AudioAttributesCompatParcelizer.post(new Runnable() {
                @Override
                public void run() {
                    setOptions setoptions = setOptions.this;
                    validateModel.this.AudioAttributesImplApi21Parcelizer.remove(setoptions.setBackground.setError());
                }
            });
        }
    }

    public static class RemoteActionCompatParcelizer<T> {
        private boolean setBackground;
        private final Object setError;
        private boolean setFieldValue;
        private int setLabel;
        private boolean setOptions;

        void setLabel(@Nullable T t) {
        }

        RemoteActionCompatParcelizer(Object obj) {
            this.setError = obj;
        }

        public void setBackground(@Nullable T t) {
            if (this.setBackground || this.setOptions) {
                throw new IllegalStateException("sendResult() called when either sendResult() or sendError() had already been called for: " + this.setError);
            }
            this.setBackground = true;
            setLabel((RemoteActionCompatParcelizer<T>) t);
        }

        public void setError(@Nullable Bundle bundle) {
            if (this.setBackground || this.setOptions) {
                throw new IllegalStateException("sendProgressUpdate() called when either sendResult() or sendError() had already been called for: " + this.setError);
            }
            setFieldValue(bundle);
            setLabel(bundle);
        }

        public void setOptions(@Nullable Bundle bundle) {
            if (this.setBackground || this.setOptions) {
                throw new IllegalStateException("sendError() called when either sendResult() or sendError() had already been called for: " + this.setError);
            }
            this.setOptions = true;
            setBackground(bundle);
        }

        public void setError() {
            if (this.setFieldValue) {
                throw new IllegalStateException("detach() called when detach() had already been called for: " + this.setError);
            }
            if (this.setBackground) {
                throw new IllegalStateException("detach() called when sendResult() had already been called for: " + this.setError);
            }
            if (this.setOptions) {
                throw new IllegalStateException("detach() called when sendError() had already been called for: " + this.setError);
            }
            this.setFieldValue = true;
        }

        boolean setFieldValue() {
            return this.setFieldValue || this.setBackground || this.setOptions;
        }

        void setLabel(int i) {
            this.setLabel = i;
        }

        int setOptions() {
            return this.setLabel;
        }

        void setLabel(@Nullable Bundle bundle) {
            throw new UnsupportedOperationException("It is not supported to send an interim update for " + this.setError);
        }

        void setBackground(@Nullable Bundle bundle) {
            throw new UnsupportedOperationException("It is not supported to send an error for " + this.setError);
        }

        private void setFieldValue(@Nullable Bundle bundle) {
            if (bundle != null && bundle.containsKey("android.media.browse.extra.DOWNLOAD_PROGRESS")) {
                float f = bundle.getFloat("android.media.browse.extra.DOWNLOAD_PROGRESS");
                if (f < -1.0E-5f || f > 1.00001f) {
                    throw new IllegalArgumentException("The value of the EXTRA_DOWNLOAD_PROGRESS field must be a float number within [0.0, 1.0]");
                }
            }
        }
    }

    class MediaBrowserCompatCustomActionResultReceiver {
        MediaBrowserCompatCustomActionResultReceiver() {
        }

        public void setError(final String str, final int i, final int i2, final Bundle bundle, final AudioAttributesImplApi21Parcelizer audioAttributesImplApi21Parcelizer) {
            if (!validateModel.this.setError(str, i2)) {
                throw new IllegalArgumentException("Package/uid mismatch: uid=" + i2 + " package=" + str);
            }
            validateModel.this.AudioAttributesCompatParcelizer.setError(new Runnable() {
                @Override
                public void run() {
                    IBinder error = audioAttributesImplApi21Parcelizer.setError();
                    validateModel.this.AudioAttributesImplApi21Parcelizer.remove(error);
                    setOptions setoptions = validateModel.this.new setOptions(str, i, i2, bundle, audioAttributesImplApi21Parcelizer);
                    validateModel validatemodel = validateModel.this;
                    validatemodel.MediaBrowserCompatCustomActionResultReceiver = setoptions;
                    setError label = validatemodel.setLabel(str, i2, bundle);
                    setoptions.setOptions = label;
                    validateModel validatemodel2 = validateModel.this;
                    validatemodel2.MediaBrowserCompatCustomActionResultReceiver = null;
                    if (label == null) {
                        Log.i(validateModel.AudioAttributesImplApi26Parcelizer, "No root for client " + str + " from service " + getClass().getName());
                        try {
                            audioAttributesImplApi21Parcelizer.setOptions();
                            return;
                        } catch (RemoteException unused) {
                            Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "Calling onConnectFailed() failed. Ignoring. pkg=" + str);
                            return;
                        }
                    }
                    try {
                        validatemodel2.AudioAttributesImplApi21Parcelizer.put(error, setoptions);
                        error.linkToDeath(setoptions, 0);
                        if (validateModel.this.MediaBrowserCompatItemReceiver != null) {
                            audioAttributesImplApi21Parcelizer.setLabel(setoptions.setOptions.setOptions(), validateModel.this.MediaBrowserCompatItemReceiver, setoptions.setOptions.setLabel());
                        }
                    } catch (RemoteException unused2) {
                        Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "Calling onConnect() failed. Dropping client. pkg=" + str);
                        validateModel.this.AudioAttributesImplApi21Parcelizer.remove(error);
                    }
                }
            });
        }

        public void setLabel(final AudioAttributesImplApi21Parcelizer audioAttributesImplApi21Parcelizer) {
            validateModel.this.AudioAttributesCompatParcelizer.setError(new Runnable() {
                @Override
                public void run() {
                    setOptions setoptions = (setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.remove(audioAttributesImplApi21Parcelizer.setError());
                    if (setoptions != null) {
                        setoptions.setBackground.setError().unlinkToDeath(setoptions, 0);
                    }
                }
            });
        }

        public void setBackground(final String str, final IBinder iBinder, final Bundle bundle, final AudioAttributesImplApi21Parcelizer audioAttributesImplApi21Parcelizer) {
            validateModel.this.AudioAttributesCompatParcelizer.setError(new Runnable() {
                @Override
                public void run() {
                    setOptions setoptions = (setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.get(audioAttributesImplApi21Parcelizer.setError());
                    if (setoptions == null) {
                        Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "addSubscription for callback that isn't registered id=" + str);
                        return;
                    }
                    validateModel.this.setFieldValue(str, setoptions, iBinder, bundle);
                }
            });
        }

        public void setBackground(final String str, final IBinder iBinder, final AudioAttributesImplApi21Parcelizer audioAttributesImplApi21Parcelizer) {
            validateModel.this.AudioAttributesCompatParcelizer.setError(new Runnable() {
                @Override
                public void run() {
                    setOptions setoptions = (setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.get(audioAttributesImplApi21Parcelizer.setError());
                    if (setoptions == null) {
                        Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "removeSubscription for callback that isn't registered id=" + str);
                        return;
                    }
                    if (validateModel.this.setError(str, setoptions, iBinder)) {
                        return;
                    }
                    Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "removeSubscription called for " + str + " which is not subscribed");
                }
            });
        }

        public void setError(final String str, final ParcelableVolumeInfo parcelableVolumeInfo, final AudioAttributesImplApi21Parcelizer audioAttributesImplApi21Parcelizer) {
            if (TextUtils.isEmpty(str) || parcelableVolumeInfo == null) {
                return;
            }
            validateModel.this.AudioAttributesCompatParcelizer.setError(new Runnable() {
                @Override
                public void run() {
                    setOptions setoptions = (setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.get(audioAttributesImplApi21Parcelizer.setError());
                    if (setoptions == null) {
                        Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "getMediaItem for callback that isn't registered id=" + str);
                        return;
                    }
                    validateModel.this.setLabel(str, setoptions, parcelableVolumeInfo);
                }
            });
        }

        public void setFieldValue(final AudioAttributesImplApi21Parcelizer audioAttributesImplApi21Parcelizer, final String str, final int i, final int i2, final Bundle bundle) {
            validateModel.this.AudioAttributesCompatParcelizer.setError(new Runnable() {
                @Override
                public void run() {
                    setOptions setoptions;
                    IBinder error = audioAttributesImplApi21Parcelizer.setError();
                    validateModel.this.AudioAttributesImplApi21Parcelizer.remove(error);
                    Iterator<setOptions> it = validateModel.this.MediaDescriptionCompat.iterator();
                    while (true) {
                        if (!it.hasNext()) {
                            break;
                        }
                        setOptions next = it.next();
                        if (next.read == i2) {
                            setoptions = (TextUtils.isEmpty(str) || i <= 0) ? validateModel.this.new setOptions(next.setError, next.setLabel, next.read, bundle, audioAttributesImplApi21Parcelizer) : null;
                            it.remove();
                        }
                    }
                    if (setoptions == null) {
                        setoptions = validateModel.this.new setOptions(str, i, i2, bundle, audioAttributesImplApi21Parcelizer);
                    }
                    validateModel.this.AudioAttributesImplApi21Parcelizer.put(error, setoptions);
                    try {
                        error.linkToDeath(setoptions, 0);
                    } catch (RemoteException unused) {
                        Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "IBinder is already dead.");
                    }
                }
            });
        }

        public void setFieldValue(final AudioAttributesImplApi21Parcelizer audioAttributesImplApi21Parcelizer) {
            validateModel.this.AudioAttributesCompatParcelizer.setError(new Runnable() {
                @Override
                public void run() {
                    IBinder error = audioAttributesImplApi21Parcelizer.setError();
                    setOptions setoptions = (setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.remove(error);
                    if (setoptions != null) {
                        error.unlinkToDeath(setoptions, 0);
                    }
                }
            });
        }

        public void setFieldValue(final String str, final Bundle bundle, final ParcelableVolumeInfo parcelableVolumeInfo, final AudioAttributesImplApi21Parcelizer audioAttributesImplApi21Parcelizer) {
            if (TextUtils.isEmpty(str) || parcelableVolumeInfo == null) {
                return;
            }
            validateModel.this.AudioAttributesCompatParcelizer.setError(new Runnable() {
                @Override
                public void run() {
                    setOptions setoptions = (setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.get(audioAttributesImplApi21Parcelizer.setError());
                    if (setoptions == null) {
                        Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "search for callback that isn't registered query=" + str);
                        return;
                    }
                    validateModel.this.setBackground(str, bundle, setoptions, parcelableVolumeInfo);
                }
            });
        }

        public void setError(final String str, final Bundle bundle, final ParcelableVolumeInfo parcelableVolumeInfo, final AudioAttributesImplApi21Parcelizer audioAttributesImplApi21Parcelizer) {
            if (TextUtils.isEmpty(str) || parcelableVolumeInfo == null) {
                return;
            }
            validateModel.this.AudioAttributesCompatParcelizer.setError(new Runnable() {
                @Override
                public void run() {
                    setOptions setoptions = (setOptions) validateModel.this.AudioAttributesImplApi21Parcelizer.get(audioAttributesImplApi21Parcelizer.setError());
                    if (setoptions == null) {
                        Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "sendCustomAction for callback that isn't registered action=" + str + ", extras=" + bundle);
                        return;
                    }
                    validateModel.this.setOptions(str, bundle, setoptions, parcelableVolumeInfo);
                }
            });
        }
    }

    static class AudioAttributesImplApi26Parcelizer implements AudioAttributesImplApi21Parcelizer {
        final Messenger setBackground;

        AudioAttributesImplApi26Parcelizer(Messenger messenger) {
            this.setBackground = messenger;
        }

        @Override
        public IBinder setError() {
            return this.setBackground.getBinder();
        }

        @Override
        public void setLabel(String str, MediaSessionCompat.Token token, Bundle bundle) throws RemoteException {
            if (bundle == null) {
                bundle = new Bundle();
            }
            bundle.putInt(ModelValidator.ComponentActivity2, 2);
            Bundle bundle2 = new Bundle();
            bundle2.putString(ModelValidator.MediaBrowserCompatSearchResultReceiver, str);
            bundle2.putParcelable(ModelValidator.MediaMetadataCompat, token);
            bundle2.putBundle(ModelValidator.MediaSessionCompatResultReceiverWrapper, bundle);
            setFieldValue(1, bundle2);
        }

        @Override
        public void setOptions() throws RemoteException {
            setFieldValue(2, null);
        }

        @Override
        public void setLabel(String str, List<MediaBrowserCompat.MediaItem> list, Bundle bundle, Bundle bundle2) throws RemoteException {
            Bundle bundle3 = new Bundle();
            bundle3.putString(ModelValidator.MediaBrowserCompatSearchResultReceiver, str);
            bundle3.putBundle(ModelValidator.RatingCompat, bundle);
            bundle3.putBundle(ModelValidator.MediaBrowserCompatMediaItem, bundle2);
            if (list != null) {
                bundle3.putParcelableArrayList(ModelValidator.MediaBrowserCompatItemReceiver, list instanceof ArrayList ? (ArrayList) list : new ArrayList<>(list));
            }
            setFieldValue(3, bundle3);
        }

        private void setFieldValue(int i, Bundle bundle) throws RemoteException {
            Message obtain = Message.obtain();
            obtain.what = i;
            obtain.arg1 = 2;
            obtain.setData(bundle);
            this.setBackground.send(obtain);
        }
    }

    static class IconCompatParcelizer<T> {
        MediaBrowserService.Result setLabel;

        IconCompatParcelizer(MediaBrowserService.Result result) {
            this.setLabel = result;
        }

        public void setOptions(T t) {
            if (t instanceof List) {
                this.setLabel.sendResult(setError((List) t));
                return;
            }
            if (t instanceof Parcel) {
                Parcel parcel = (Parcel) t;
                parcel.setDataPosition(0);
                this.setLabel.sendResult(MediaBrowser.MediaItem.CREATOR.createFromParcel(parcel));
                parcel.recycle();
                return;
            }
            this.setLabel.sendResult(null);
        }

        public void setFieldValue() {
            this.setLabel.detach();
        }

        List<MediaBrowser.MediaItem> setError(List<Parcel> list) {
            if (list == null) {
                return null;
            }
            ArrayList arrayList = new ArrayList(list.size());
            for (Parcel parcel : list) {
                parcel.setDataPosition(0);
                arrayList.add((MediaBrowser.MediaItem) MediaBrowser.MediaItem.CREATOR.createFromParcel(parcel));
                parcel.recycle();
            }
            return arrayList;
        }
    }

    public void setError(Context context) {
        attachBaseContext(context);
    }

    @Override
    public void onCreate() {
        super.onCreate();
        if (Build.VERSION.SDK_INT >= 28) {
            this.MediaBrowserCompatMediaItem = new write();
        } else {
            this.MediaBrowserCompatMediaItem = new read();
        }
        this.MediaBrowserCompatMediaItem.setOptions();
    }

    @Override
    public void onDestroy() {
        this.AudioAttributesCompatParcelizer.setFieldValue();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return this.MediaBrowserCompatMediaItem.setOptions(intent);
    }

    public void setFieldValue(@NonNull String str, @NonNull RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>> remoteActionCompatParcelizer, @NonNull Bundle bundle) {
        remoteActionCompatParcelizer.setLabel(1);
        setFieldValue(str, remoteActionCompatParcelizer);
    }

    public void setOptions(String str, @NonNull RemoteActionCompatParcelizer<MediaBrowserCompat.MediaItem> remoteActionCompatParcelizer) {
        remoteActionCompatParcelizer.setLabel(2);
        remoteActionCompatParcelizer.setBackground((RemoteActionCompatParcelizer<MediaBrowserCompat.MediaItem>) null);
    }

    public void setError(@NonNull String str, Bundle bundle, @NonNull RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>> remoteActionCompatParcelizer) {
        remoteActionCompatParcelizer.setLabel(4);
        remoteActionCompatParcelizer.setBackground((RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>>) null);
    }

    public void setBackground(@NonNull String str, Bundle bundle, @NonNull RemoteActionCompatParcelizer<Bundle> remoteActionCompatParcelizer) {
        remoteActionCompatParcelizer.setOptions(null);
    }

    public void setBackground(MediaSessionCompat.Token token) {
        if (token == null) {
            throw new IllegalArgumentException("Session token may not be null");
        }
        if (this.MediaBrowserCompatItemReceiver != null) {
            throw new IllegalStateException("The session token has already been set");
        }
        this.MediaBrowserCompatItemReceiver = token;
        this.MediaBrowserCompatMediaItem.setLabel(token);
    }

    public MediaSessionCompat.Token setOptions() {
        return this.MediaBrowserCompatItemReceiver;
    }

    public final Bundle setLabel() {
        return this.MediaBrowserCompatMediaItem.setLabel();
    }

    public final logErrorCodes.setOptions setBackground() {
        return this.MediaBrowserCompatMediaItem.setBackground();
    }

    public void setOptions(@NonNull String str) {
        if (str == null) {
            throw new IllegalArgumentException("parentId cannot be null in notifyChildrenChanged");
        }
        this.MediaBrowserCompatMediaItem.setBackground(str, null);
    }

    public void setBackground(@NonNull String str, @NonNull Bundle bundle) {
        if (str == null) {
            throw new IllegalArgumentException("parentId cannot be null in notifyChildrenChanged");
        }
        if (bundle == null) {
            throw new IllegalArgumentException("options cannot be null in notifyChildrenChanged");
        }
        this.MediaBrowserCompatMediaItem.setBackground(str, bundle);
    }

    public void setOptions(@NonNull logErrorCodes.setOptions setoptions, @NonNull String str, @NonNull Bundle bundle) {
        if (setoptions == null) {
            throw new IllegalArgumentException("remoteUserInfo cannot be null in notifyChildrenChanged");
        }
        if (str == null) {
            throw new IllegalArgumentException("parentId cannot be null in notifyChildrenChanged");
        }
        if (bundle == null) {
            throw new IllegalArgumentException("options cannot be null in notifyChildrenChanged");
        }
        this.MediaBrowserCompatMediaItem.setBackground(setoptions, str, bundle);
    }

    void setBackground(Message message) {
        Bundle data = message.getData();
        switch (message.what) {
            case 1:
                Bundle bundle = data.getBundle(ModelValidator.MediaSessionCompatResultReceiverWrapper);
                MediaSessionCompat.setError(bundle);
                this.MediaBrowserCompatSearchResultReceiver.setError(data.getString(ModelValidator.MediaSessionCompatToken), data.getInt(ModelValidator.MediaBrowserCompatCustomActionResultReceiver), data.getInt(ModelValidator.AudioAttributesImplApi21Parcelizer), bundle, new AudioAttributesImplApi26Parcelizer(message.replyTo));
                break;
            case 2:
                this.MediaBrowserCompatSearchResultReceiver.setLabel(new AudioAttributesImplApi26Parcelizer(message.replyTo));
                break;
            case 3:
                Bundle bundle2 = data.getBundle(ModelValidator.RatingCompat);
                MediaSessionCompat.setError(bundle2);
                this.MediaBrowserCompatSearchResultReceiver.setBackground(data.getString(ModelValidator.MediaBrowserCompatSearchResultReceiver), recognizeNative.setFieldValue(data, ModelValidator.AudioAttributesCompatParcelizer), bundle2, new AudioAttributesImplApi26Parcelizer(message.replyTo));
                break;
            case 4:
                this.MediaBrowserCompatSearchResultReceiver.setBackground(data.getString(ModelValidator.MediaBrowserCompatSearchResultReceiver), recognizeNative.setFieldValue(data, ModelValidator.AudioAttributesCompatParcelizer), new AudioAttributesImplApi26Parcelizer(message.replyTo));
                break;
            case 5:
                this.MediaBrowserCompatSearchResultReceiver.setError(data.getString(ModelValidator.MediaBrowserCompatSearchResultReceiver), (ParcelableVolumeInfo) data.getParcelable(ModelValidator.MediaControllerCompatMediaControllerImplApi21ExtraBinderRequestResultReceiver), new AudioAttributesImplApi26Parcelizer(message.replyTo));
                break;
            case 6:
                Bundle bundle3 = data.getBundle(ModelValidator.MediaSessionCompatResultReceiverWrapper);
                MediaSessionCompat.setError(bundle3);
                this.MediaBrowserCompatSearchResultReceiver.setFieldValue(new AudioAttributesImplApi26Parcelizer(message.replyTo), data.getString(ModelValidator.MediaSessionCompatToken), data.getInt(ModelValidator.MediaBrowserCompatCustomActionResultReceiver), data.getInt(ModelValidator.AudioAttributesImplApi21Parcelizer), bundle3);
                break;
            case 7:
                this.MediaBrowserCompatSearchResultReceiver.setFieldValue(new AudioAttributesImplApi26Parcelizer(message.replyTo));
                break;
            case 8:
                Bundle bundle4 = data.getBundle(ModelValidator.MediaSessionCompatQueueItem);
                MediaSessionCompat.setError(bundle4);
                this.MediaBrowserCompatSearchResultReceiver.setFieldValue(data.getString(ModelValidator.PlaybackStateCompat), bundle4, (ParcelableVolumeInfo) data.getParcelable(ModelValidator.MediaControllerCompatMediaControllerImplApi21ExtraBinderRequestResultReceiver), new AudioAttributesImplApi26Parcelizer(message.replyTo));
                break;
            case 9:
                Bundle bundle5 = data.getBundle(ModelValidator.MediaDescriptionCompat);
                MediaSessionCompat.setError(bundle5);
                this.MediaBrowserCompatSearchResultReceiver.setError(data.getString(ModelValidator.AudioAttributesImplBaseParcelizer), bundle5, (ParcelableVolumeInfo) data.getParcelable(ModelValidator.MediaControllerCompatMediaControllerImplApi21ExtraBinderRequestResultReceiver), new AudioAttributesImplApi26Parcelizer(message.replyTo));
                break;
            default:
                Log.w(AudioAttributesImplApi26Parcelizer, "Unhandled message: " + message + "\n  Service version: 2\n  Client version: " + message.arg1);
                break;
        }
    }

    boolean setError(String str, int i) {
        if (str == null) {
            return false;
        }
        for (String str2 : getPackageManager().getPackagesForUid(i)) {
            if (str2.equals(str)) {
                return true;
            }
        }
        return false;
    }

    void setFieldValue(String str, setOptions setoptions, IBinder iBinder, Bundle bundle) {
        List<setChipEndPadding<IBinder, Bundle>> list = setoptions.setElement.get(str);
        if (list == null) {
            list = new ArrayList<>();
        }
        for (setChipEndPadding<IBinder, Bundle> setchipendpadding : list) {
            if (iBinder == setchipendpadding.setFieldValue && constructModel.setLabel(bundle, (Bundle) setchipendpadding.setBackground)) {
                return;
            }
        }
        list.add(new setChipEndPadding<>(iBinder, bundle));
        setoptions.setElement.put(str, list);
        setError(str, setoptions, bundle, null);
        this.MediaBrowserCompatCustomActionResultReceiver = setoptions;
        setOptions(str, bundle);
        this.MediaBrowserCompatCustomActionResultReceiver = null;
    }

    boolean setError(String str, setOptions setoptions, IBinder iBinder) {
        boolean z = true;
        boolean z2 = false;
        try {
            if (iBinder == null) {
                if (setoptions.setElement.remove(str) != null) {
                    return z;
                }
            } else {
                List<setChipEndPadding<IBinder, Bundle>> list = setoptions.setElement.get(str);
                if (list != null) {
                    Iterator<setChipEndPadding<IBinder, Bundle>> it = list.iterator();
                    while (it.hasNext()) {
                        if (iBinder == it.next().setFieldValue) {
                            it.remove();
                            z2 = true;
                        }
                    }
                    if (list.size() == 0) {
                        setoptions.setElement.remove(str);
                    }
                }
            }
            z = z2;
            return z;
        } finally {
            this.MediaBrowserCompatCustomActionResultReceiver = setoptions;
            setLabel(str);
            this.MediaBrowserCompatCustomActionResultReceiver = null;
        }
    }

    void setError(final String str, final setOptions setoptions, final Bundle bundle, final Bundle bundle2) {
        RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>> remoteActionCompatParcelizer = new RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>>(str) {
            @Override
            public void setLabel(@Nullable List<MediaBrowserCompat.MediaItem> list) {
                if (validateModel.this.AudioAttributesImplApi21Parcelizer.get(setoptions.setBackground.setError()) != setoptions) {
                    if (validateModel.setOptions) {
                        Log.d(validateModel.AudioAttributesImplApi26Parcelizer, "Not sending onLoadChildren result for connection that has been disconnected. pkg=" + setoptions.setError + " id=" + str);
                        return;
                    }
                    return;
                }
                if ((setOptions() & 1) != 0) {
                    list = validateModel.this.setError(list, bundle);
                }
                try {
                    setoptions.setBackground.setLabel(str, list, bundle, bundle2);
                } catch (RemoteException unused) {
                    Log.w(validateModel.AudioAttributesImplApi26Parcelizer, "Calling onLoadChildren() failed for id=" + str + " package=" + setoptions.setError);
                }
            }
        };
        this.MediaBrowserCompatCustomActionResultReceiver = setoptions;
        if (bundle == null) {
            setFieldValue(str, remoteActionCompatParcelizer);
        } else {
            setFieldValue(str, remoteActionCompatParcelizer, bundle);
        }
        this.MediaBrowserCompatCustomActionResultReceiver = null;
        if (remoteActionCompatParcelizer.setFieldValue()) {
            return;
        }
        throw new IllegalStateException("onLoadChildren must call detach() or sendResult() before returning for package=" + setoptions.setError + " id=" + str);
    }

    List<MediaBrowserCompat.MediaItem> setError(List<MediaBrowserCompat.MediaItem> list, Bundle bundle) {
        if (list == null) {
            return null;
        }
        int i = bundle.getInt("android.media.browse.extra.PAGE", -1);
        int i2 = bundle.getInt("android.media.browse.extra.PAGE_SIZE", -1);
        if (i == -1 && i2 == -1) {
            return list;
        }
        int i3 = i2 * i;
        int i4 = i3 + i2;
        if (i < 0 || i2 < 1 || i3 >= list.size()) {
            return Collections.emptyList();
        }
        if (i4 > list.size()) {
            i4 = list.size();
        }
        return list.subList(i3, i4);
    }

    void setLabel(String str, setOptions setoptions, final ParcelableVolumeInfo parcelableVolumeInfo) {
        RemoteActionCompatParcelizer<MediaBrowserCompat.MediaItem> remoteActionCompatParcelizer = new RemoteActionCompatParcelizer<MediaBrowserCompat.MediaItem>(str) {
            @Override
            public void setLabel(@Nullable MediaBrowserCompat.MediaItem mediaItem) {
                if ((setOptions() & 2) != 0) {
                    parcelableVolumeInfo.setLabel(-1, (Bundle) null);
                    return;
                }
                Bundle bundle = new Bundle();
                bundle.putParcelable(validateModel.setError, mediaItem);
                parcelableVolumeInfo.setLabel(0, bundle);
            }
        };
        this.MediaBrowserCompatCustomActionResultReceiver = setoptions;
        setOptions(str, remoteActionCompatParcelizer);
        this.MediaBrowserCompatCustomActionResultReceiver = null;
        if (remoteActionCompatParcelizer.setFieldValue()) {
            return;
        }
        throw new IllegalStateException("onLoadItem must call detach() or sendResult() before returning for id=" + str);
    }

    void setBackground(String str, Bundle bundle, setOptions setoptions, final ParcelableVolumeInfo parcelableVolumeInfo) {
        RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>> remoteActionCompatParcelizer = new RemoteActionCompatParcelizer<List<MediaBrowserCompat.MediaItem>>(str) {
            @Override
            public void setLabel(@Nullable List<MediaBrowserCompat.MediaItem> list) {
                if ((setOptions() & 4) != 0 || list == null) {
                    parcelableVolumeInfo.setLabel(-1, (Bundle) null);
                    return;
                }
                Bundle bundle2 = new Bundle();
                bundle2.putParcelableArray(validateModel.setBackground, (Parcelable[]) list.toArray(new MediaBrowserCompat.MediaItem[0]));
                parcelableVolumeInfo.setLabel(0, bundle2);
            }
        };
        this.MediaBrowserCompatCustomActionResultReceiver = setoptions;
        setError(str, bundle, remoteActionCompatParcelizer);
        this.MediaBrowserCompatCustomActionResultReceiver = null;
        if (remoteActionCompatParcelizer.setFieldValue()) {
            return;
        }
        throw new IllegalStateException("onSearch must call detach() or sendResult() before returning for query=" + str);
    }

    void setOptions(String str, Bundle bundle, setOptions setoptions, final ParcelableVolumeInfo parcelableVolumeInfo) {
        RemoteActionCompatParcelizer<Bundle> remoteActionCompatParcelizer = new RemoteActionCompatParcelizer<Bundle>(str) {
            @Override
            public void setLabel(@Nullable Bundle bundle2) {
                parcelableVolumeInfo.setLabel(0, bundle2);
            }

            @Override
            void setLabel(@Nullable Bundle bundle2) {
                parcelableVolumeInfo.setLabel(1, bundle2);
            }

            @Override
            void setBackground(@Nullable Bundle bundle2) {
                parcelableVolumeInfo.setLabel(-1, bundle2);
            }
        };
        this.MediaBrowserCompatCustomActionResultReceiver = setoptions;
        setBackground(str, bundle, remoteActionCompatParcelizer);
        this.MediaBrowserCompatCustomActionResultReceiver = null;
        if (remoteActionCompatParcelizer.setFieldValue()) {
            return;
        }
        throw new IllegalStateException("onCustomAction must call detach() or sendResult() or sendError() before returning for action=" + str + " extras=" + bundle);
    }

    public static final class setError {

        @Deprecated
        public static final String setBackground = "android.service.media.extra.SUGGESTION_KEYWORDS";
        public static final String setError = "android.service.media.extra.OFFLINE";
        public static final String setFieldValue = "android.service.media.extra.RECENT";
        public static final String setLabel = "android.service.media.extra.SUGGESTED";
        private final String RemoteActionCompatParcelizer;
        private final Bundle setOptions;

        public setError(@NonNull String str, @Nullable Bundle bundle) {
            if (str == null) {
                throw new IllegalArgumentException("The root id in BrowserRoot cannot be null. Use null for BrowserRoot instead");
            }
            this.RemoteActionCompatParcelizer = str;
            this.setOptions = bundle;
        }

        public String setOptions() {
            return this.RemoteActionCompatParcelizer;
        }

        public Bundle setLabel() {
            return this.setOptions;
        }
    }

    @Override
    public void attachBaseContext(Context context) {
        super.attachBaseContext(context);
    }
}