Tasker v6.6.3 - ControlsProviderServiceTasker.java 源代码

package com.joaomgcd.taskerm.controlsprovider;

import android.app.PendingIntent;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.drawable.Icon;
import android.service.controls.Control;
import android.service.controls.ControlsProviderService;
import android.service.controls.actions.ControlAction;
import android.service.controls.templates.ControlButton;
import android.service.controls.templates.ControlTemplate;
import android.service.controls.templates.RangeTemplate;
import android.util.Log;
import androidx.annotation.Keep;
import com.joaomgcd.taskerm.action.input.PowerMenuActionType;
import com.joaomgcd.taskerm.action.input.StoredPowerMenuAction;
import com.joaomgcd.taskerm.action.input.StoredPowerMenuActions;
import com.joaomgcd.taskerm.controlsprovider.ControlsProviderServiceTasker;
import com.joaomgcd.taskerm.rx.EventBusRxSubscription;
import com.joaomgcd.taskerm.util.ActivitySecondaryApp;
import com.joaomgcd.taskerm.util.ExtensionsContextKt;
import com.joaomgcd.taskerm.util.b7;
import com.joaomgcd.taskerm.util.bi;
import ge.i4;
import ge.k4;
import ge.l4;
import ge.m4;
import ge.n4;
import ge.o4;
import ge.p4;
import ge.s4;
import ge.t4;
import ge.u;
import ge.u4;
import ge.v4;
import ge.w4;
import ik.l;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Flow;
import java.util.function.Consumer;
import jk.p;
import kotlin.collections.t;
import net.dinglisch.android.taskerm.ExecuteService;
import net.dinglisch.android.taskerm.fn;
import net.dinglisch.android.taskerm.fo;
import net.dinglisch.android.taskerm.g;
import sk.q;
import ti.r;
import vj.e0;
import vj.j;
import vj.k;
import vj.o;
import xg.e2;
import xg.h;
import ye.c;
import ye.e;
import ye.f;
import ye.i;

public final class ControlsProviderServiceTasker extends ControlsProviderService {
    private final j i = k.a(new ik.a() {
        public final Object e() {
            Icon y;
            y = ControlsProviderServiceTasker.y(ControlsProviderServiceTasker.this);
            return y;
        }
    });
    private final j q = k.a(new ik.a() {
        public final Object e() {
            HashMap V;
            V = ControlsProviderServiceTasker.V();
            return V;
        }
    });
    private final j r = k.a(new ik.a() {
        public final Object e() {
            HashMap W;
            W = ControlsProviderServiceTasker.W();
            return W;
        }
    });
    private final j s = k.a(new ik.a() {
        public final Object e() {
            wi.a z;
            z = ControlsProviderServiceTasker.z();
            return z;
        }
    });
    private Flow.Subscriber<? super Control> t;

    public static final class a {
        public static final int[] a;

        static {
            int[] iArr = new int[PowerMenuActionType.values().length];
            try {
                iArr[PowerMenuActionType.Button.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                iArr[PowerMenuActionType.Toggle.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                iArr[PowerMenuActionType.Range.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                iArr[PowerMenuActionType.ToggleRange.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                iArr[PowerMenuActionType.NoAction.ordinal()] = 5;
            } catch (NoSuchFieldError unused5) {
            }
            a = iArr;
        }
    }

    public static final class b implements Flow.Subscription {
        b() {
        }

        @Override
        public void cancel() {
            Log.d("ControlTest", "cancel");
        }

        @Override
        public void request(long j) {
            Log.d("ControlTest", "request " + j);
        }
    }

    private final ControlsProviderServiceTasker A() {
        return this;
    }

    private final Control B(fn fnVar) {
        final String E;
        String G;
        ControlTemplate a2;
        Control build;
        if (fnVar == null || (E = E(fnVar)) == null || (G = G(fnVar)) == null) {
            return null;
        }
        HashSet hashSet = new HashSet();
        fnVar.c2(this, false, hashSet, true, false, false);
        boolean contains = hashSet.contains(fn.h1(1));
        boolean contains2 = hashSet.contains(fn.h1(2));
        Intent intent = new Intent(A(), (Class<?>) ActivitySecondaryApp.class);
        u4.a();
        Control.StatefulBuilder a3 = s4.a(E, PendingIntent.getActivity(A(), 0, intent, bi.m(268435456, intent)));
        a3.setTitle(G);
        a3.setSubtitle("Trigger " + G);
        a3.setDeviceType(-1);
        a3.setControlId(E);
        a3.setStatus(1);
        a3.setCustomIcon(D(fnVar));
        if (contains || contains2) {
            l4.a();
            ControlButton a4 = k4.a(I(E), "id");
            ik.a aVar = new ik.a() {
                public final Object e() {
                    RangeTemplate q;
                    q = ControlsProviderServiceTasker.q(E, this);
                    return q;
                }
            };
            if (contains && contains2) {
                p4.a();
                a2 = t4.a(m4.a(E, a4, i.a(aVar.e())));
            } else {
                a2 = contains ? t4.a(n4.a(G, a4)) : t4.a(aVar.e());
            }
        } else {
            a2 = t4.a(o4.a(G));
        }
        a3.setControlTemplate(a2);
        build = a3.build();
        return build;
    }

    private final Control C(String str) {
        fn L = L(str);
        if (L != null) {
            return B(L);
        }
        return null;
    }

    private final Icon D(final fn fnVar) {
        if (fnVar == null) {
            return J();
        }
        if (!fnVar.G1()) {
            return J();
        }
        Bitmap bitmap = (Bitmap) b7.n6((l) null, new ik.a() {
            public final Object e() {
                Bitmap p;
                p = ControlsProviderServiceTasker.p(fnVar, this);
                return p;
            }
        }, 1, (Object) null);
        if (bitmap == null) {
            return J();
        }
        Icon createWithBitmap = Icon.createWithBitmap(bitmap);
        p.h(createWithBitmap, "createWithBitmap(...)");
        return createWithBitmap;
    }

    private final String E(fn fnVar) {
        String G = G(fnVar);
        if (G == null) {
            return null;
        }
        return "supertaskcontrolyeahbaby" + G;
    }

    private final String F(String str) {
        return q.z0(str, "supertaskcontrolyeahbaby");
    }

    private final String G(fn fnVar) {
        if (fnVar != null && fnVar.x()) {
            return fnVar.getName();
        }
        return null;
    }

    private final float H(String str) {
        Float f = M().get(str);
        if (f != null) {
            return f.floatValue();
        }
        return 0.0f;
    }

    private final boolean I(String str) {
        Boolean bool = N().get(str);
        if (bool != null) {
            return bool.booleanValue();
        }
        return false;
    }

    private final Icon J() {
        return (Icon) this.i.getValue();
    }

    private final wi.a K() {
        return (wi.a) this.s.getValue();
    }

    private final fn L(String str) {
        return fo.w1(A()).M(F(str));
    }

    private final HashMap<String, Float> M() {
        return (HashMap) this.q.getValue();
    }

    private final HashMap<String, Boolean> N() {
        return (HashMap) this.r.getValue();
    }

    private final void O(String str, ControlAction controlAction, Consumer<Integer> consumer) {
        String commandPrefix;
        Boolean active;
        Float rangeCurrent;
        float newValue;
        boolean newState;
        StoredPowerMenuAction byId = u.e(this).byId(str);
        if (byId == null || (commandPrefix = byId.getCommandPrefix()) == null) {
            return;
        }
        PowerMenuActionType type = byId.getType();
        if (ye.a.a(controlAction)) {
            newState = c.a(controlAction).getNewState();
            active = Boolean.valueOf(newState);
        } else {
            active = byId.getActive();
        }
        if (e.a(controlAction)) {
            newValue = f.a(controlAction).getNewValue();
            rangeCurrent = Float.valueOf(newValue);
        } else {
            rangeCurrent = byId.getRangeCurrent();
        }
        String P = P(type, commandPrefix, active, rangeCurrent, controlAction);
        if (P == null || P.length() == 0) {
            consumer.accept(2);
            return;
        }
        if (type != PowerMenuActionType.Button) {
            consumer.accept(1);
        } else {
            consumer.accept(1);
        }
        ExtensionsContextKt.K4(this, P, (String) null, 2, (Object) null);
    }

    private static final String P(PowerMenuActionType powerMenuActionType, String str, Boolean bool, Float f, ControlAction controlAction) {
        String str2;
        int i = a.a[powerMenuActionType.ordinal()];
        if (i == 1) {
            return str;
        }
        if (i == 2) {
            if (bool == null) {
                return str;
            }
            return str + "=:=" + bool;
        }
        if (i == 3) {
            if (f == null) {
                return str;
            }
            return str + "=:=" + f;
        }
        if (i != 4) {
            if (i == 5) {
                return null;
            }
            throw new o();
        }
        if (bool != null) {
            str = str + "=:=" + bool;
        }
        if (f != null) {
            str = str + "=:=" + f;
        }
        if (ye.a.a(controlAction)) {
            str2 = str + "=:=toggle";
        } else {
            if (!e.a(controlAction)) {
                return str;
            }
            str2 = str + "=:=range";
        }
        return str2;
    }

    private final boolean Q(String str, ControlAction controlAction, Consumer<Integer> consumer) {
        boolean I;
        float H;
        Flow.Subscriber<? super Control> subscriber;
        if (C(str) == null) {
            return false;
        }
        if (ye.a.a(controlAction)) {
            I = c.a(controlAction).getNewState();
            U(str, I);
        } else {
            I = I(str);
        }
        String valueOf = String.valueOf(I);
        if (e.a(controlAction)) {
            H = f.a(controlAction).getNewValue();
            T(str, H);
        } else {
            H = H(str);
        }
        ExecuteService.u7(this, F(str), valueOf, String.valueOf(lk.a.d(H)), "powermenu");
        consumer.accept(1);
        Control C = C(str);
        if (C != null && (subscriber = this.t) != null) {
            subscriber.onNext(C);
        }
        return true;
    }

    public static final e0 R() {
        return e0.a;
    }

    public static final e0 S(ControlsProviderServiceTasker controlsProviderServiceTasker, Control control) {
        p.i(control, "it");
        Flow.Subscriber<? super Control> subscriber = controlsProviderServiceTasker.t;
        if (subscriber != null) {
            subscriber.onNext(control);
        }
        return e0.a;
    }

    private final void T(String str, float f) {
        M().put(str, Float.valueOf(f));
    }

    private final void U(String str, boolean z) {
        N().put(str, Boolean.valueOf(z));
    }

    public static final HashMap V() {
        return new HashMap();
    }

    public static final HashMap W() {
        return new HashMap();
    }

    public static final Bitmap p(fn fnVar, ControlsProviderServiceTasker controlsProviderServiceTasker) {
        g icon = fnVar.getIcon();
        if (icon != null) {
            return icon.z(controlsProviderServiceTasker.A(), 50, 50, "ControlsProviderServiceTasker");
        }
        return null;
    }

    public static final RangeTemplate q(String str, ControlsProviderServiceTasker controlsProviderServiceTasker) {
        w4.a();
        return v4.a(str, 0.0f, 100.0f, controlsProviderServiceTasker.H(str), 1.0f, null);
    }

    public static final void r(final ControlsProviderServiceTasker controlsProviderServiceTasker, final List list, final Flow.Subscriber subscriber) {
        controlsProviderServiceTasker.t = subscriber;
        e2.T0(new ik.a() {
            public final Object e() {
                e0 s;
                s = ControlsProviderServiceTasker.s(ControlsProviderServiceTasker.this, list, subscriber);
                return s;
            }
        });
    }

    public static final e0 s(final ControlsProviderServiceTasker controlsProviderServiceTasker, List list, Flow.Subscriber subscriber) {
        final StoredPowerMenuActions e = u.e(controlsProviderServiceTasker);
        Iterator it = list.iterator();
        while (it.hasNext()) {
            final String str = (String) it.next();
            Control C = controlsProviderServiceTasker.C(str);
            if (C == null) {
                C = i4.a(b7.n6((l) null, new ik.a() {
                    public final Object e() {
                        Control t;
                        t = ControlsProviderServiceTasker.t(StoredPowerMenuActions.this, str, controlsProviderServiceTasker);
                        return t;
                    }
                }, 1, (Object) null));
            }
            if (C != null) {
                subscriber.onSubscribe(ye.j.a(new b()));
                subscriber.onNext(C);
            }
        }
        mf.q.a(controlsProviderServiceTasker, false);
        return e0.a;
    }

    public static final Control t(StoredPowerMenuActions storedPowerMenuActions, String str, ControlsProviderServiceTasker controlsProviderServiceTasker) {
        r control$default;
        StoredPowerMenuAction byId = storedPowerMenuActions.byId(str);
        if (byId == null || (control$default = StoredPowerMenuAction.getControl$default(byId, controlsProviderServiceTasker.A(), false, 2, null)) == null) {
            return null;
        }
        return i4.a(control$default.f());
    }

    public static final void u(final ControlsProviderServiceTasker controlsProviderServiceTasker, final Flow.Subscriber subscriber) {
        e2.T0(new ik.a() {
            public final Object e() {
                e0 v;
                v = ControlsProviderServiceTasker.v(ControlsProviderServiceTasker.this, subscriber);
                return v;
            }
        });
    }

    public static final e0 v(final ControlsProviderServiceTasker controlsProviderServiceTasker, Flow.Subscriber subscriber) {
        for (final StoredPowerMenuAction storedPowerMenuAction : u.e(controlsProviderServiceTasker)) {
            Control a2 = i4.a(b7.n6((l) null, new ik.a() {
                public final Object e() {
                    Control w;
                    w = ControlsProviderServiceTasker.w(StoredPowerMenuAction.this, controlsProviderServiceTasker);
                    return w;
                }
            }, 1, (Object) null));
            if (a2 != null) {
                subscriber.onNext(a2);
            }
        }
        ArrayList y1 = fo.w1(controlsProviderServiceTasker.A()).y1();
        p.h(y1, "getAllAlphabeticallySortedNamedTasks(...)");
        Iterator it = rk.k.C(t.W(y1), new l() {
            public final Object invoke(Object obj) {
                Control x;
                x = ControlsProviderServiceTasker.x(ControlsProviderServiceTasker.this, (fn) obj);
                return x;
            }
        }).iterator();
        while (it.hasNext()) {
            subscriber.onNext(i4.a(it.next()));
        }
        subscriber.onComplete();
        mf.q.a(controlsProviderServiceTasker, true);
        return e0.a;
    }

    public static final Control w(StoredPowerMenuAction storedPowerMenuAction, ControlsProviderServiceTasker controlsProviderServiceTasker) {
        return i4.a(storedPowerMenuAction.getControl(controlsProviderServiceTasker.A(), true).f());
    }

    public static final Control x(ControlsProviderServiceTasker controlsProviderServiceTasker, fn fnVar) {
        return controlsProviderServiceTasker.B(fnVar);
    }

    public static final Icon y(ControlsProviderServiceTasker controlsProviderServiceTasker) {
        Icon createWithResource = Icon.createWithResource(controlsProviderServiceTasker.A(), 2131689473);
        p.h(createWithResource, "createWithResource(...)");
        return createWithResource;
    }

    public static final wi.a z() {
        return new wi.a();
    }

    @Override
    public Flow.Publisher<Control> createPublisherFor(final List<String> list) {
        p.i(list, "controlIds");
        return new Flow.Publisher() {
            @Override
            public final void subscribe(Flow.Subscriber subscriber) {
                ControlsProviderServiceTasker.r(ControlsProviderServiceTasker.this, list, subscriber);
            }
        };
    }

    @Override
    public Flow.Publisher<Control> createPublisherForAllAvailable() {
        return new Flow.Publisher() {
            @Override
            public final void subscribe(Flow.Subscriber subscriber) {
                ControlsProviderServiceTasker.u(ControlsProviderServiceTasker.this, subscriber);
            }
        };
    }

    @Override
    public void onCreate() {
        super.onCreate();
        K().b(e2.y2(h.o(this), this, new ik.a() {
            public final Object e() {
                e0 R;
                R = ControlsProviderServiceTasker.R();
                return R;
            }
        }));
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        h.q(this);
        K().d();
    }

    @EventBusRxSubscription
    @Keep
    public final void onStoredPowerMenuAction(StoredPowerMenuAction storedPowerMenuAction) {
        p.i(storedPowerMenuAction, "action");
        K().b(e2.C2(StoredPowerMenuAction.getControl$default(storedPowerMenuAction, this, false, 2, null), this, new l() {
            public final Object invoke(Object obj) {
                e0 S;
                S = ControlsProviderServiceTasker.S(ControlsProviderServiceTasker.this, (Control) obj);
                return S;
            }
        }));
    }

    @Override
    public void performControlAction(String str, ControlAction controlAction, Consumer<Integer> consumer) {
        p.i(str, "controlId");
        p.i(controlAction, "action");
        p.i(consumer, "consumer");
        if (Q(str, controlAction, consumer)) {
            return;
        }
        O(str, controlAction, consumer);
    }
}