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

package o;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.util.Log;
import java.util.LinkedHashMap;
import java.util.Map;
import kotlin.Unit;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

public final class onReadingThreadFinished extends Service {
    private int setBackground;
    private final Map<Integer, String> setOptions = new LinkedHashMap();
    private final RemoteCallbackList<getMaxPayloadSize> setFieldValue = new setError();
    private final getHandshakeBuilder$setLabel setLabel = new setFieldValue();

    public final int setBackground() {
        return this.setBackground;
    }

    public final void setFieldValue(int i) {
        this.setBackground = i;
    }

    public final Map<Integer, String> setLabel() {
        return this.setOptions;
    }

    public static final class setError extends RemoteCallbackList<getMaxPayloadSize> {
        setError() {
        }

        @Override
        public void onCallbackDied(getMaxPayloadSize getmaxpayloadsize, Object obj) {
            Intrinsics.checkNotNullParameter(getmaxpayloadsize, "");
            Intrinsics.checkNotNullParameter(obj, "");
            onReadingThreadFinished.this.setLabel().remove((Integer) obj);
        }
    }

    public final RemoteCallbackList<getMaxPayloadSize> setOptions() {
        return this.setFieldValue;
    }

    public static final class setFieldValue extends getHandshakeBuilder$setLabel {
        setFieldValue() {
        }

        public int setBackground(getMaxPayloadSize getmaxpayloadsize, String str) {
            Intrinsics.checkNotNullParameter(getmaxpayloadsize, "");
            int i = 0;
            if (str == null) {
                return 0;
            }
            RemoteCallbackList<getMaxPayloadSize> options = onReadingThreadFinished.this.setOptions();
            onReadingThreadFinished onreadingthreadfinished = onReadingThreadFinished.this;
            synchronized (options) {
                onreadingthreadfinished.setFieldValue(onreadingthreadfinished.setBackground() + 1);
                int background = onreadingthreadfinished.setBackground();
                if (onreadingthreadfinished.setOptions().register(getmaxpayloadsize, Integer.valueOf(background))) {
                    onreadingthreadfinished.setLabel().put(Integer.valueOf(background), str);
                    i = background;
                } else {
                    onreadingthreadfinished.setFieldValue(onreadingthreadfinished.setBackground() - 1);
                    onreadingthreadfinished.setBackground();
                }
            }
            return i;
        }

        public void setOptions(getMaxPayloadSize getmaxpayloadsize, int i) {
            Intrinsics.checkNotNullParameter(getmaxpayloadsize, "");
            RemoteCallbackList<getMaxPayloadSize> options = onReadingThreadFinished.this.setOptions();
            onReadingThreadFinished onreadingthreadfinished = onReadingThreadFinished.this;
            synchronized (options) {
                onreadingthreadfinished.setOptions().unregister(getmaxpayloadsize);
                onreadingthreadfinished.setLabel().remove(Integer.valueOf(i));
            }
        }

        public void setOptions(int i, String[] strArr) {
            Intrinsics.checkNotNullParameter(strArr, "");
            RemoteCallbackList<getMaxPayloadSize> options = onReadingThreadFinished.this.setOptions();
            onReadingThreadFinished onreadingthreadfinished = onReadingThreadFinished.this;
            synchronized (options) {
                String str = onreadingthreadfinished.setLabel().get(Integer.valueOf(i));
                if (str == null) {
                    Log.w("ROOM", "Remote invalidation client ID not registered");
                    return;
                }
                int beginBroadcast = onreadingthreadfinished.setOptions().beginBroadcast();
                for (int i2 = 0; i2 < beginBroadcast; i2++) {
                    try {
                        Object broadcastCookie = onreadingthreadfinished.setOptions().getBroadcastCookie(i2);
                        Intrinsics.setLabel(broadcastCookie, "");
                        Integer num = (Integer) broadcastCookie;
                        int intValue = num.intValue();
                        String str2 = onreadingthreadfinished.setLabel().get(num);
                        if (i != intValue && Intrinsics.setFieldValue(str, str2)) {
                            try {
                                onreadingthreadfinished.setOptions().getBroadcastItem(i2).setError(strArr);
                                Unit unit = Unit.INSTANCE;
                            } catch (RemoteException e) {
                                Log.w("ROOM", "Error invoking a remote callback", e);
                            }
                        }
                    } catch (Throwable th) {
                        onreadingthreadfinished.setOptions().finishBroadcast();
                        throw th;
                    }
                }
                onreadingthreadfinished.setOptions().finishBroadcast();
                Unit unit2 = Unit.INSTANCE;
            }
        }
    }

    @Override
    public IBinder onBind(@NotNull Intent intent) {
        Intrinsics.checkNotNullParameter(intent, "");
        return this.setLabel;
    }

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

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