content: package androidx.core.app.unusedapprestrictions;
  
  import android.os.Binder;
  import android.os.IBinder;
  import android.os.IInterface;
  import android.os.Parcel;
  import android.os.RemoteException;
  import androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportCallback;
  
  public interface IUnusedAppRestrictionsBackportService extends IInterface {
  
      public static class Default implements IUnusedAppRestrictionsBackportService {
          public IBinder asBinder() {
              return null;
          }
  
          public void isPermissionRevocationEnabledForApp(IUnusedAppRestrictionsBackportCallback callback) throws RemoteException {
          }
      }
  
      public static abstract class Stub extends Binder implements IUnusedAppRestrictionsBackportService {
          private static final String DESCRIPTOR = "androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportService";
          static final int TRANSACTION_isPermissionRevocationEnabledForApp = 1;
  
          private static class Proxy implements IUnusedAppRestrictionsBackportService {
              public static IUnusedAppRestrictionsBackportService sDefaultImpl;
              private IBinder mRemote;
  
              Proxy(IBinder remote) {
                  this.mRemote = remote;
              }
  
              public IBinder asBinder() {
                  return this.mRemote;
              }
  
              public String getInterfaceDescriptor() {
                  return Stub.DESCRIPTOR;
              }
  
              public void isPermissionRevocationEnabledForApp(IUnusedAppRestrictionsBackportCallback callback) throws RemoteException {
                  Parcel obtain = Parcel.obtain();
                  try {
                      obtain.writeInterfaceToken(Stub.DESCRIPTOR);
                      obtain.writeStrongBinder(callback != null ? callback.asBinder() : null);
                      if (this.mRemote.transact(1, obtain, (Parcel) null, 1) || Stub.getDefaultImpl() == null) {
                          obtain.recycle();
                      } else {
                          Stub.getDefaultImpl().isPermissionRevocationEnabledForApp(callback);
                      }
                  } finally {
                      obtain.recycle();
                  }
              }
          }
  
          public Stub() {
              attachInterface(this, DESCRIPTOR);
          }
  
          public static IUnusedAppRestrictionsBackportService asInterface(IBinder obj) {
              if (obj == null) {
                  return null;
              }
              IInterface queryLocalInterface = obj.queryLocalInterface(DESCRIPTOR);
              return (queryLocalInterface == null || !(queryLocalInterface instanceof IUnusedAppRestrictionsBackportService)) ? new Proxy(obj) : (IUnusedAppRestrictionsBackportService) queryLocalInterface;
          }
  
          public static IUnusedAppRestrictionsBackportService getDefaultImpl() {
              return Proxy.sDefaultImpl;
          }
  
          public static boolean setDefaultImpl(IUnusedAppRestrictionsBackportService impl) {
              if (Proxy.sDefaultImpl != null) {
                  throw new IllegalStateException("setDefaultImpl() called twice");
              } else if (impl == null) {
                  return false;
              } else {
                  Proxy.sDefaultImpl = impl;
                  return true;
              }
          }
  
          public IBinder asBinder() {
              return this;
          }
  
          public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
              switch (code) {
                  case 1:
                      data.enforceInterface(DESCRIPTOR);
                      isPermissionRevocationEnabledForApp(IUnusedAppRestrictionsBackportCallback.Stub.asInterface(data.readStrongBinder()));
                      return true;
                  case 1598968902:
                      reply.writeString(DESCRIPTOR);
                      return true;
                  default:
                      return super.onTransact(code, data, reply, flags);
              }
          }
      }
  
      void isPermissionRevocationEnabledForApp(IUnusedAppRestrictionsBackportCallback iUnusedAppRestrictionsBackportCallback) throws RemoteException;
  }
  