IssueTracker

Process.isApplicationUid(Process.myUid()) will at least let you know when you're running in the main application process on SDK 24+, but it still makes sense to add an androidx API here.

AFAIK, there are no public Android APIs by which we can check for this.

If there are no public APIs, there is nothing we can do in Jetpack.

*There are no APIs visible to apps.

Is androidx allowed to use non-SDK, but technically public APIs (@hide or @UnsupportedAppUsage)? If so, android.os.UserHandle can be be used for this at least as far back as API 17, and again `android.os.Process

Accidentally submitted my previous comment too early.

to continue,

android.os.Process has legitimate public APIs for this for 24+.

Is androidx allowed to use non-SDK, but technically public APIs

To the same extent that apps can, yes. We have the same non-SDK usage restrictions as apps starting in P as well, which means no hidden APIs are accessible in P or later.

We also have a policy that requires any reflective non-SDK usage prior to P to be paired with a new platform API, so this would have to start as a platform feature request before it could be added to Jetpack. And even then, it wouldn't work on P, Q, or R.

Is Process.isApplicationUid(Process.myUid()) the full extent of the API that you need? Could you provide a pointer to code that uses reflective non-SDK access to get the same result on SDK < 24?

Discussed offline.

Meets the criteria for a backport as androidx.core.os.ProcessCompat.isApplicationUid(int uid)

Reference implementation:

    if (Build.VERSION.SDK_INT >= 24) {
      return android.os.Process.isApplicationUid(uid);
    } else if (Build.VERSION.SDK_INT >= 17) {
      // Should be available in all APIs >= 17, unless there were OEM modifications.
      try {
        Method isAppMethod = UserHandle.class.getDeclaredMethod("isApp", int.class);
        return (Boolean) isAppMethod.invoke(null, uid);
      } catch (Exception e) {
        return true;
      }
    } else if (Build.VERSION.SDK_INT == 16) {
      // In Android J MR1, UserHandle was a private API in android.os.UserId.
      try {
        Method isAppMethod =
            Class.forName("android.os.UserId").getDeclaredMethod("isApp", int.class);
        return (Boolean) isAppMethod.invoke(null, uid);
      } catch (Exception e) {
        return true;
      }
    } else {
      // Application UIDs and IsolatedProcess did not exist in Android 15 and below. Isolated
      // Services were introduced in API 16:
      // https://developer.android.com/about/versions/android-4.1.html#Isolated
      return true;
    }

https://android-review.googlesource.com/c/platform/frameworks/support/+/1282612/4/core/core/src/main/java/androidx/core/os/ProcessCompat.java#104

           if (sMethodUserHandleIsAppMethod != null) {
                Boolean result = (Boolean) sMethodUserHandleIsAppMethod.invoke(null, uid);
                if (result == null) {
                    // This should never happen, as the method returns a boolean primitive.
                    throw new NullPointerException();
                }
           }

Is API17 implementation work as expected? Looks like the result is not used here