如何检查设备上是否安装了 ARCore lib/apk？

Question

If I understand well, once ARCore 1.0 will be released on Google Play, it will be necessary to install it on the device in order to be able to run an ARCore app.

How to check if ARCore lib/apk is installed on device ?

Answer 1

Should be sufficient to do something like:

    try {
        arCoreSession = Session(this)

        val config = Config(arCoreSession)
        if (!arCoreSession.isSupported(config)) {
            Logger.d("ARCore not installed")
        } else {
            arCoreSession.configure(config)
        }
    } catch (ex: Throwable) {
        Logger.d("ARCore not installed")
    }

This is what I'm using here for one my apps and works fine on devices with or wothout ARCore.

Answer 2

According to ARCore documentation 1.4.0 , if optional it is important check its availability recursively and then install it:

void maybeEnableArButton() {
  // Likely called from Activity.onCreate() of an activity with AR buttons.
  ArCoreApk.Availability availability = ArCoreApk.getInstance().checkAvailability(this);
  if (availability.isTransient()) {
    // re-query at 5Hz while we check compatibility.
    new Handler().postDelayed(new Runnable() {
      @Override
      public void run() {
        maybeEnableArButton();
      }
    }, 200);
  }
  if (availability.isSupported()) {
    mArButton.setVisibility(View.VISIBLE);
    mArButton.setEnabled(true);
    // indicator on the button.
  } else { // unsupported or unknown
    mArButton.setVisibility(View.INVISIBLE);
    mArButton.setEnabled(false);
  }
}

If already supported just check if ARCore is installed:

// Set to true ensures requestInstall() triggers installation if necessary.
private boolean mUserRequestedInstall = true;

// in onResume:
try {
  if (mSession == null) {
    switch (ArCoreApk.getInstance().requestInstall(this, mUserRequestedInstall)) {
      case INSTALLED:
        mSession = new Session(this);
        // Success.
        break;
      case INSTALL_REQUESTED:
        // Ensures next invocation of requestInstall() will either return
        // INSTALLED or throw an exception.
        mUserRequestedInstall = false;
        return;
    }
  }
} catch (UnavailableUserDeclinedInstallationException e) {
  // Display an appropriate message to the user and return gracefully.
  return;
} catch (...) {  // current catch statements
  ...
  return;  // mSession is still null
}

Answer 3

Sometimes it is easier to request this with Rx methodology. Here's the code:

private fun getArAvailabilityRx(context: Context): Single<ArCoreApk.Availability> {
    return Single.fromCallable<ArCoreApk.Availability> {
        ArCoreApk.getInstance().checkAvailability(context)
    }.flatMap { availability ->
        if (availability.isTransient) {
            // `isTransient` means it hasn't finished loading value; let's request the value in 500 ms
            getArAvailabilityRx(context).delaySubscription(500, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread())
        } else {
            Single.just(availability)
        }
    }.observeOn(AndroidSchedulers.mainThread())
}

Answer 4

Here's a little utility class I wrote (based originally on something from https://github.com/google/helloargdx ).

It will perform all the checks and setup necessary, in order to ensure it is safe to launch a Session .

abstract class ArCheckFragment : Fragment() {

    private var userRequestedInstall = true

    abstract fun onCameraPermissionDeny()

    abstract fun onArCoreUnavailable(availability: Availability)

    abstract fun onArCoreInstallFail(exception: UnavailableException)

    abstract fun onArCoreInstallSuccess()

    override fun onResume() {
        super.onResume()
        performCheck()
    }

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == REQUEST_CODE_CAMERA_PERMISSION) {
            for (i in permissions.indices) {
                if (permissions[i] == Manifest.permission.CAMERA &&
                    grantResults[i] == PackageManager.PERMISSION_GRANTED
                ) {
                    checkArCore()
                    return
                }
            }
            onCameraPermissionDeny()
        }
    }

    /**
     * Performs the whole check
     */
    fun performCheck() {
        if (requestCameraPermission()) {
            checkArCore()
        }
    }

    /**
     * Requests the camera permission, if necessary.
     * @return whether camera permission is already granted. If so, the permission won't be requested.
     */
    private fun requestCameraPermission(): Boolean {
        if (ContextCompat.checkSelfPermission(
                requireContext(),
                Manifest.permission.CAMERA
            ) == PackageManager.PERMISSION_GRANTED
        ) {
            return true
        }
        requestPermissions(arrayOf(Manifest.permission.CAMERA), REQUEST_CODE_CAMERA_PERMISSION)
        return false
    }

    private fun checkArCore() {
        if (!isResumed) {
            return
        }
        val availability = ArCoreApk.getInstance().checkAvailability(activity)
        if (availability.isTransient) {
            requireView().postDelayed(AR_CORE_CHECK_INTERVAL) { checkArCore() }
            return
        }
        when (availability) {
            Availability.SUPPORTED_INSTALLED ->
                onArCoreInstallSuccess()
            Availability.SUPPORTED_APK_TOO_OLD,
            Availability.SUPPORTED_NOT_INSTALLED ->
                startArCoreInstallation()
            else ->
                onArCoreUnavailable(availability)
        }
    }

    private fun startArCoreInstallation() {
        try {
            val installStatus =
                ArCoreApk.getInstance().requestInstall(activity, userRequestedInstall)
            when (installStatus) {
                InstallStatus.INSTALLED -> onArCoreInstallSuccess()
                InstallStatus.INSTALL_REQUESTED,
                null ->
                    // Ensures next invocation of requestInstall() will either return
                    // INSTALLED or throw an exception.
                    userRequestedInstall = false
            }
        } catch (exception: UnavailableException) {
            onArCoreInstallFail(exception)
        }
    }

    companion object {
        private const val REQUEST_CODE_CAMERA_PERMISSION = 1
        private const val AR_CORE_CHECK_INTERVAL = 200L
    }
}

You can subclass this Fragment and implement the abstract functions to receive callbacks on what the result of these checks is. Only in onArCoreInstallSuccess is it safe to create a Session .