Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/work/multiprocess/IListenableWorkerImpl.java

@@ -0,0 +1,122 @@
+package androidx.work.multiprocess;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import androidx.annotation.RestrictTo;
+import androidx.work.multiprocess.IWorkManagerImplCallback;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public interface IListenableWorkerImpl extends IInterface {
+    public static final String DESCRIPTOR = "androidx$work$multiprocess$IListenableWorkerImpl".replace('$', '.');
+
+    public static class Default implements IListenableWorkerImpl {
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return null;
+        }
+
+        @Override // androidx.work.multiprocess.IListenableWorkerImpl
+        public void interrupt(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IListenableWorkerImpl
+        public void startWork(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+    }
+
+    void interrupt(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    void startWork(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    public static abstract class Stub extends Binder implements IListenableWorkerImpl {
+        static final int TRANSACTION_interrupt = 2;
+        static final int TRANSACTION_startWork = 1;
+
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return this;
+        }
+
+        public Stub() {
+            attachInterface(this, IListenableWorkerImpl.DESCRIPTOR);
+        }
+
+        public static IListenableWorkerImpl asInterface(IBinder iBinder) {
+            if (iBinder == null) {
+                return null;
+            }
+            IInterface queryLocalInterface = iBinder.queryLocalInterface(IListenableWorkerImpl.DESCRIPTOR);
+            if (queryLocalInterface != null && (queryLocalInterface instanceof IListenableWorkerImpl)) {
+                return (IListenableWorkerImpl) queryLocalInterface;
+            }
+            return new Proxy(iBinder);
+        }
+
+        @Override // android.os.Binder
+        public boolean onTransact(int i, Parcel parcel, Parcel parcel2, int i2) throws RemoteException {
+            String str = IListenableWorkerImpl.DESCRIPTOR;
+            if (i >= 1 && i <= 16777215) {
+                parcel.enforceInterface(str);
+            }
+            if (i == 1598968902) {
+                parcel2.writeString(str);
+                return true;
+            }
+            if (i == 1) {
+                startWork(parcel.createByteArray(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+            } else if (i == 2) {
+                interrupt(parcel.createByteArray(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+            } else {
+                return super.onTransact(i, parcel, parcel2, i2);
+            }
+            return true;
+        }
+
+        public static class Proxy implements IListenableWorkerImpl {
+            private IBinder mRemote;
+
+            @Override // android.os.IInterface
+            public IBinder asBinder() {
+                return this.mRemote;
+            }
+
+            public String getInterfaceDescriptor() {
+                return IListenableWorkerImpl.DESCRIPTOR;
+            }
+
+            public Proxy(IBinder iBinder) {
+                this.mRemote = iBinder;
+            }
+
+            @Override // androidx.work.multiprocess.IListenableWorkerImpl
+            public void startWork(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IListenableWorkerImpl.DESCRIPTOR);
+                    obtain.writeByteArray(bArr);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(1, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IListenableWorkerImpl
+            public void interrupt(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IListenableWorkerImpl.DESCRIPTOR);
+                    obtain.writeByteArray(bArr);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(2, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+        }
+    }
+}

decompiled/sources/androidx/work/multiprocess/IWorkManagerImpl.java

@@ -0,0 +1,308 @@
+package androidx.work.multiprocess;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import androidx.annotation.RestrictTo;
+import androidx.work.multiprocess.IWorkManagerImplCallback;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public interface IWorkManagerImpl extends IInterface {
+    public static final String DESCRIPTOR = "androidx$work$multiprocess$IWorkManagerImpl".replace('$', '.');
+
+    public static class Default implements IWorkManagerImpl {
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return null;
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImpl
+        public void cancelAllWork(IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImpl
+        public void cancelAllWorkByTag(String str, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImpl
+        public void cancelUniqueWork(String str, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImpl
+        public void cancelWorkById(String str, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImpl
+        public void enqueueContinuation(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImpl
+        public void enqueueWorkRequests(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImpl
+        public void queryWorkInfo(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImpl
+        public void setForegroundAsync(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImpl
+        public void setProgress(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImpl
+        public void updateUniquePeriodicWorkRequest(String str, byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+        }
+    }
+
+    void cancelAllWork(IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    void cancelAllWorkByTag(String str, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    void cancelUniqueWork(String str, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    void cancelWorkById(String str, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    void enqueueContinuation(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    void enqueueWorkRequests(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    void queryWorkInfo(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    void setForegroundAsync(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    void setProgress(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    void updateUniquePeriodicWorkRequest(String str, byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException;
+
+    public static abstract class Stub extends Binder implements IWorkManagerImpl {
+        static final int TRANSACTION_cancelAllWork = 7;
+        static final int TRANSACTION_cancelAllWorkByTag = 5;
+        static final int TRANSACTION_cancelUniqueWork = 6;
+        static final int TRANSACTION_cancelWorkById = 4;
+        static final int TRANSACTION_enqueueContinuation = 3;
+        static final int TRANSACTION_enqueueWorkRequests = 1;
+        static final int TRANSACTION_queryWorkInfo = 8;
+        static final int TRANSACTION_setForegroundAsync = 10;
+        static final int TRANSACTION_setProgress = 9;
+        static final int TRANSACTION_updateUniquePeriodicWorkRequest = 2;
+
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return this;
+        }
+
+        public Stub() {
+            attachInterface(this, IWorkManagerImpl.DESCRIPTOR);
+        }
+
+        public static IWorkManagerImpl asInterface(IBinder iBinder) {
+            if (iBinder == null) {
+                return null;
+            }
+            IInterface queryLocalInterface = iBinder.queryLocalInterface(IWorkManagerImpl.DESCRIPTOR);
+            if (queryLocalInterface != null && (queryLocalInterface instanceof IWorkManagerImpl)) {
+                return (IWorkManagerImpl) queryLocalInterface;
+            }
+            return new Proxy(iBinder);
+        }
+
+        @Override // android.os.Binder
+        public boolean onTransact(int i, Parcel parcel, Parcel parcel2, int i2) throws RemoteException {
+            String str = IWorkManagerImpl.DESCRIPTOR;
+            if (i >= 1 && i <= 16777215) {
+                parcel.enforceInterface(str);
+            }
+            if (i == 1598968902) {
+                parcel2.writeString(str);
+                return true;
+            }
+            switch (i) {
+                case 1:
+                    enqueueWorkRequests(parcel.createByteArray(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+                    return true;
+                case 2:
+                    updateUniquePeriodicWorkRequest(parcel.readString(), parcel.createByteArray(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+                    return true;
+                case 3:
+                    enqueueContinuation(parcel.createByteArray(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+                    return true;
+                case 4:
+                    cancelWorkById(parcel.readString(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+                    return true;
+                case 5:
+                    cancelAllWorkByTag(parcel.readString(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+                    return true;
+                case 6:
+                    cancelUniqueWork(parcel.readString(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+                    return true;
+                case 7:
+                    cancelAllWork(IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+                    return true;
+                case 8:
+                    queryWorkInfo(parcel.createByteArray(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+                    return true;
+                case 9:
+                    setProgress(parcel.createByteArray(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+                    return true;
+                case 10:
+                    setForegroundAsync(parcel.createByteArray(), IWorkManagerImplCallback.Stub.asInterface(parcel.readStrongBinder()));
+                    return true;
+                default:
+                    return super.onTransact(i, parcel, parcel2, i2);
+            }
+        }
+
+        public static class Proxy implements IWorkManagerImpl {
+            private IBinder mRemote;
+
+            @Override // android.os.IInterface
+            public IBinder asBinder() {
+                return this.mRemote;
+            }
+
+            public String getInterfaceDescriptor() {
+                return IWorkManagerImpl.DESCRIPTOR;
+            }
+
+            public Proxy(IBinder iBinder) {
+                this.mRemote = iBinder;
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImpl
+            public void enqueueWorkRequests(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImpl.DESCRIPTOR);
+                    obtain.writeByteArray(bArr);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(1, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImpl
+            public void updateUniquePeriodicWorkRequest(String str, byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImpl.DESCRIPTOR);
+                    obtain.writeString(str);
+                    obtain.writeByteArray(bArr);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(2, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImpl
+            public void enqueueContinuation(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImpl.DESCRIPTOR);
+                    obtain.writeByteArray(bArr);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(3, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImpl
+            public void cancelWorkById(String str, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImpl.DESCRIPTOR);
+                    obtain.writeString(str);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(4, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImpl
+            public void cancelAllWorkByTag(String str, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImpl.DESCRIPTOR);
+                    obtain.writeString(str);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(5, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImpl
+            public void cancelUniqueWork(String str, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImpl.DESCRIPTOR);
+                    obtain.writeString(str);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(6, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImpl
+            public void cancelAllWork(IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImpl.DESCRIPTOR);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(7, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImpl
+            public void queryWorkInfo(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImpl.DESCRIPTOR);
+                    obtain.writeByteArray(bArr);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(8, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImpl
+            public void setProgress(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImpl.DESCRIPTOR);
+                    obtain.writeByteArray(bArr);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(9, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImpl
+            public void setForegroundAsync(byte[] bArr, IWorkManagerImplCallback iWorkManagerImplCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImpl.DESCRIPTOR);
+                    obtain.writeByteArray(bArr);
+                    obtain.writeStrongInterface(iWorkManagerImplCallback);
+                    this.mRemote.transact(10, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+        }
+    }
+}

decompiled/sources/androidx/work/multiprocess/IWorkManagerImplCallback.java

@@ -0,0 +1,119 @@
+package androidx.work.multiprocess;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import androidx.annotation.RestrictTo;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public interface IWorkManagerImplCallback extends IInterface {
+    public static final String DESCRIPTOR = "androidx$work$multiprocess$IWorkManagerImplCallback".replace('$', '.');
+
+    public static class Default implements IWorkManagerImplCallback {
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return null;
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImplCallback
+        public void onFailure(String str) throws RemoteException {
+        }
+
+        @Override // androidx.work.multiprocess.IWorkManagerImplCallback
+        public void onSuccess(byte[] bArr) throws RemoteException {
+        }
+    }
+
+    void onFailure(String str) throws RemoteException;
+
+    void onSuccess(byte[] bArr) throws RemoteException;
+
+    public static abstract class Stub extends Binder implements IWorkManagerImplCallback {
+        static final int TRANSACTION_onFailure = 2;
+        static final int TRANSACTION_onSuccess = 1;
+
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return this;
+        }
+
+        public Stub() {
+            attachInterface(this, IWorkManagerImplCallback.DESCRIPTOR);
+        }
+
+        public static IWorkManagerImplCallback asInterface(IBinder iBinder) {
+            if (iBinder == null) {
+                return null;
+            }
+            IInterface queryLocalInterface = iBinder.queryLocalInterface(IWorkManagerImplCallback.DESCRIPTOR);
+            if (queryLocalInterface != null && (queryLocalInterface instanceof IWorkManagerImplCallback)) {
+                return (IWorkManagerImplCallback) queryLocalInterface;
+            }
+            return new Proxy(iBinder);
+        }
+
+        @Override // android.os.Binder
+        public boolean onTransact(int i, Parcel parcel, Parcel parcel2, int i2) throws RemoteException {
+            String str = IWorkManagerImplCallback.DESCRIPTOR;
+            if (i >= 1 && i <= 16777215) {
+                parcel.enforceInterface(str);
+            }
+            if (i == 1598968902) {
+                parcel2.writeString(str);
+                return true;
+            }
+            if (i == 1) {
+                onSuccess(parcel.createByteArray());
+            } else if (i == 2) {
+                onFailure(parcel.readString());
+            } else {
+                return super.onTransact(i, parcel, parcel2, i2);
+            }
+            return true;
+        }
+
+        public static class Proxy implements IWorkManagerImplCallback {
+            private IBinder mRemote;
+
+            @Override // android.os.IInterface
+            public IBinder asBinder() {
+                return this.mRemote;
+            }
+
+            public String getInterfaceDescriptor() {
+                return IWorkManagerImplCallback.DESCRIPTOR;
+            }
+
+            public Proxy(IBinder iBinder) {
+                this.mRemote = iBinder;
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImplCallback
+            public void onSuccess(byte[] bArr) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImplCallback.DESCRIPTOR);
+                    obtain.writeByteArray(bArr);
+                    this.mRemote.transact(1, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+
+            @Override // androidx.work.multiprocess.IWorkManagerImplCallback
+            public void onFailure(String str) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IWorkManagerImplCallback.DESCRIPTOR);
+                    obtain.writeString(str);
+                    this.mRemote.transact(2, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+        }
+    }
+}

decompiled/sources/androidx/work/multiprocess/RemoteWorkContinuation.java

@@ -0,0 +1,35 @@
+package androidx.work.multiprocess;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.work.OneTimeWorkRequest;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public abstract class RemoteWorkContinuation {
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public abstract RemoteWorkContinuation combineInternal(@NonNull List<RemoteWorkContinuation> list);
+
+    @NonNull
+    public abstract ListenableFuture enqueue();
+
+    @NonNull
+    public abstract RemoteWorkContinuation then(@NonNull List<OneTimeWorkRequest> list);
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public RemoteWorkContinuation() {
+    }
+
+    @NonNull
+    public final RemoteWorkContinuation then(@NonNull OneTimeWorkRequest oneTimeWorkRequest) {
+        return then(Collections.singletonList(oneTimeWorkRequest));
+    }
+
+    @NonNull
+    public static RemoteWorkContinuation combine(@NonNull List<RemoteWorkContinuation> list) {
+        return list.get(0).combineInternal(list);
+    }
+}

decompiled/sources/androidx/work/multiprocess/RemoteWorkManager.java

@@ -0,0 +1,95 @@
+package androidx.work.multiprocess;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.work.Data;
+import androidx.work.ExistingPeriodicWorkPolicy;
+import androidx.work.ExistingWorkPolicy;
+import androidx.work.ForegroundInfo;
+import androidx.work.OneTimeWorkRequest;
+import androidx.work.PeriodicWorkRequest;
+import androidx.work.WorkContinuation;
+import androidx.work.WorkQuery;
+import androidx.work.WorkRequest;
+import androidx.work.impl.WorkManagerImpl;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+/* loaded from: classes.dex */
+public abstract class RemoteWorkManager {
+    @NonNull
+    public abstract RemoteWorkContinuation beginUniqueWork(@NonNull String str, @NonNull ExistingWorkPolicy existingWorkPolicy, @NonNull List<OneTimeWorkRequest> list);
+
+    @NonNull
+    public abstract RemoteWorkContinuation beginWith(@NonNull List<OneTimeWorkRequest> list);
+
+    @NonNull
+    public abstract ListenableFuture cancelAllWork();
+
+    @NonNull
+    public abstract ListenableFuture cancelAllWorkByTag(@NonNull String str);
+
+    @NonNull
+    public abstract ListenableFuture cancelUniqueWork(@NonNull String str);
+
+    @NonNull
+    public abstract ListenableFuture cancelWorkById(@NonNull UUID uuid);
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public abstract ListenableFuture enqueue(@NonNull WorkContinuation workContinuation);
+
+    @NonNull
+    public abstract ListenableFuture enqueue(@NonNull WorkRequest workRequest);
+
+    @NonNull
+    public abstract ListenableFuture enqueue(@NonNull List<WorkRequest> list);
+
+    @NonNull
+    public abstract ListenableFuture enqueueUniquePeriodicWork(@NonNull String str, @NonNull ExistingPeriodicWorkPolicy existingPeriodicWorkPolicy, @NonNull PeriodicWorkRequest periodicWorkRequest);
+
+    @NonNull
+    public abstract ListenableFuture enqueueUniqueWork(@NonNull String str, @NonNull ExistingWorkPolicy existingWorkPolicy, @NonNull List<OneTimeWorkRequest> list);
+
+    @NonNull
+    public abstract ListenableFuture getWorkInfos(@NonNull WorkQuery workQuery);
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public abstract ListenableFuture setForegroundAsync(@NonNull String str, @NonNull ForegroundInfo foregroundInfo);
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public abstract ListenableFuture setProgress(@NonNull UUID uuid, @NonNull Data data);
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public RemoteWorkManager() {
+    }
+
+    @NonNull
+    public final ListenableFuture enqueueUniqueWork(@NonNull String str, @NonNull ExistingWorkPolicy existingWorkPolicy, @NonNull OneTimeWorkRequest oneTimeWorkRequest) {
+        return enqueueUniqueWork(str, existingWorkPolicy, Collections.singletonList(oneTimeWorkRequest));
+    }
+
+    @NonNull
+    public final RemoteWorkContinuation beginWith(@NonNull OneTimeWorkRequest oneTimeWorkRequest) {
+        return beginWith(Collections.singletonList(oneTimeWorkRequest));
+    }
+
+    @NonNull
+    public final RemoteWorkContinuation beginUniqueWork(@NonNull String str, @NonNull ExistingWorkPolicy existingWorkPolicy, @NonNull OneTimeWorkRequest oneTimeWorkRequest) {
+        return beginUniqueWork(str, existingWorkPolicy, Collections.singletonList(oneTimeWorkRequest));
+    }
+
+    @NonNull
+    public static RemoteWorkManager getInstance(@NonNull Context context) {
+        RemoteWorkManager remoteWorkManager = WorkManagerImpl.getInstance(context).getRemoteWorkManager();
+        if (remoteWorkManager != null) {
+            return remoteWorkManager;
+        }
+        throw new IllegalStateException("Unable to initialize RemoteWorkManager");
+    }
+}