Questa guida per gli sviluppatori illustra i passaggi per consentire alla tua app di passare senza interruzioni tra il controllo esclusivo della fotocamera tramite l'API Android Camera2 e la condivisione dell'accesso alla fotocamera con ARCore.
Questo argomento presuppone che tu:
Aver completato la guida rapida di ARCore.
Conosci l'API Android Camera2 (per scoprire di più, esamina l'esempio di Camera2 specifico per Android)
Crea ed esegui l'app di esempio
Quando crei ed esegui l'app di esempio Shared Camera Java, viene creata una sessione ARCore che supporta l'accesso alla videocamera condivisa. L'app si avvia in modalità non AR, con ARCore in pausa.
Quando l'app funziona in modalità non AR, il visualizzatore della fotocamera mostra un effetto di colore seppia. Quando passi alla modalità AR, l'effetto seppia viene disattivato quando l'app restituisce il controllo della fotocamera ad ARCore ripristinando la sessione in pausa.
Per cambiare modalità puoi utilizzare l'opzione AR presente nell'app. Durante l'anteprima, in entrambe le modalità viene visualizzato il numero di fotogrammi continui acquisiti dalla Fotocamera2.
Per creare ed eseguire l'app Java di esempio per la videocamera condivisa:
Scarica ed estrai l'SDK Google ARCore per Android.
Apri il progetto
samples/shared_camera_java
.Assicurati che il tuo dispositivo Android sia collegato alla macchina di sviluppo tramite USB. Vedi ARCore Dispositivi supportati per informazioni dettagliate.
In Android Studio, fai clic su Run .
Scegli il tuo dispositivo come destinazione del deployment e fai clic su OK per avviare l'app di esempio sul tuo dispositivo.
Conferma sul dispositivo che vuoi consentire all'app di scattare foto e registrare video.
Se richiesto, aggiorna o installa l'ultima versione di ARCore.
Utilizza l'interruttore AR per passare dalla modalità non AR alla modalità AR e viceversa.
Panoramica dell'attivazione di un'app per condividere l'accesso alla fotocamera con ARCore
Segui questi passaggi per implementare l'accesso alla fotocamera condivisa con ARCore nella tua app.
Tutti gli snippet di codice sono disponibili in
SharedCameraActivity.java
all'interno dell'esempio shared_camera_java
.
Richiedi l'autorizzazione CAMERA
Per poter utilizzare la fotocamera del dispositivo, l'utente
deve concedere alla tua app l'autorizzazione CAMERA
.
Gli esempi ARCore includono un elemento CameraPermissionHelper
,
che fornisce utilità per richiedere l'autorizzazione corretta per la tua app.
Java
protected void onResume() {
// Request the camera permission, if necessary.
if (!CameraPermissionHelper.hasCameraPermission(this)) {
CameraPermissionHelper.requestCameraPermission(this);
}
}
Kotlin
override fun onResume() {
// Request the camera permission, if necessary.
if (!CameraPermissionHelper.hasCameraPermission(this)) {
CameraPermissionHelper.requestCameraPermission(this)
}
}
Assicurati che ARCore sia installato e aggiornato
Per poter utilizzare ARCore, è necessario installare e aggiornare l'app. Lo snippet seguente mostra come richiedere l'installazione di ARCore se non è già stato installato sul dispositivo.
Java
boolean isARCoreSupportedAndUpToDate() {
// Make sure that ARCore is installed and supported on this device.
ArCoreApk.Availability availability = ArCoreApk.getInstance().checkAvailability(this);
switch (availability) {
case SUPPORTED_INSTALLED:
return true;
case SUPPORTED_APK_TOO_OLD:
case SUPPORTED_NOT_INSTALLED:
// Requests an ARCore installation or updates ARCore if needed.
ArCoreApk.InstallStatus installStatus = ArCoreApk.getInstance().requestInstall(this, userRequestedInstall);
switch (installStatus) {
case INSTALL_REQUESTED:
return false;
case INSTALLED:
return true;
}
return false;
default:
// Handle the error. For example, show the user a snackbar that tells them
// ARCore is not supported on their device.
return false;
}
}
Kotlin
// Determine ARCore installation status.
// Requests an ARCore installation or updates ARCore if needed.
fun isARCoreSupportedAndUpToDate(): Boolean {
when (ArCoreApk.getInstance().checkAvailability(this)) {
Availability.SUPPORTED_INSTALLED -> return true
Availability.SUPPORTED_APK_TOO_OLD,
Availability.SUPPORTED_NOT_INSTALLED -> {
when(ArCoreApk.getInstance().requestInstall(this, userRequestedInstall)) {
InstallStatus.INSTALLED -> return true
else -> return false
}
}
else -> {
// Handle the error. For example, show the user a snackbar that tells them
// ARCore is not supported on their device.
return false
}
}
}
Creare una sessione ARCore che supporti la condivisione della videocamera
Ciò comporta la creazione della sessione e l'archiviazione del riferimento e dell'ID della videocamera condivisa ARCore:
Java
// Create an ARCore session that supports camera sharing.
sharedSession = new Session(this, EnumSet.of(Session.Feature.SHARED_CAMERA))
// Store the ARCore shared camera reference.
sharedCamera = sharedSession.getSharedCamera();
// Store the ID of the camera that ARCore uses.
cameraId = sharedSession.getCameraConfig().getCameraId();
Kotlin
// Create an ARCore session that supports camera sharing.
sharedSession = Session(this, EnumSet.of(Session.Feature.SHARED_CAMERA))
// Store the ARCore shared camera reference.
sharedCamera = sharedSession.sharedCamera
// Store the ID of the camera that ARCore uses.
cameraId = sharedSession.cameraConfig.cameraId
(Facoltativo) Comunicare ad ARCore eventuali piattaforme personalizzate
La richiesta di altre piattaforme personalizzate aumenta le esigenze di prestazioni del dispositivo. Per assicurarti che funzioni correttamente, testa l'app sui dispositivi che verranno utilizzati dagli utenti.
ARCore richiederà due flussi per impostazione predefinita:
- Stream della CPU YUV 1x, attualmente sempre sempre
640x480
.
ARCore utilizza questo stream per il monitoraggio del movimento. - Uno stream GPU 1x, in genere
1920x1080
UtilizzaSession#getCameraConfig()
per determinare l'attuale risoluzione dello stream GPU.
Puoi modificare la risoluzione dello stream GPU sui dispositivi supportati utilizzando
getSupportedCameraConfigs()
e
setCameraConfig()
.
Come indicatore approssimativo, puoi aspettarti:
Tipo di dispositivo | Stream simultanei supportati |
---|---|
Telefoni di fascia alta |
|
Telefoni di fascia media |
|
Per utilizzare piattaforme personalizzate, ad esempio una piattaforma per il lettore di immagini della CPU, assicurati di aggiungerla all'elenco delle piattaforme che devono essere aggiornate (ad esempio, una ImageReader
).
Java
sharedCamera.setAppSurfaces(this.cameraId, Arrays.asList(imageReader.getSurface()));
Kotlin
sharedCamera.setAppSurfaces(this.cameraId, listOf(imageReader.surface))
Apri la fotocamera
Apri la fotocamera utilizzando un callback con wrapping ARCore:
Java
// Wrap the callback in a shared camera callback.
CameraDevice.StateCallback wrappedCallback =
sharedCamera.createARDeviceStateCallback(cameraDeviceCallback, backgroundHandler);
// Store a reference to the camera system service.
cameraManager = (CameraManager) this.getSystemService(Context.CAMERA_SERVICE);
// Open the camera device using the ARCore wrapped callback.
cameraManager.openCamera(cameraId, wrappedCallback, backgroundHandler);
Kotlin
// Wrap the callback in a shared camera callback.
val wrappedCallback = sharedCamera.createARDeviceStateCallback(cameraDeviceCallback, backgroundHandler)
// Store a reference to the camera system service.
val cameraManager = this.getSystemService(Context.CAMERA_SERVICE) as CameraManager
// Open the camera device using the ARCore wrapped callback.
cameraManager.openCamera(cameraId, wrappedCallback, backgroundHandler)
Usa il callback dello stato del dispositivo della videocamera
Nella funzionalità di callback dello stato del dispositivo della videocamera, archivia un riferimento al dispositivo della videocamera e avvia una nuova sessione di acquisizione.
Java
public void onOpened(@NonNull CameraDevice cameraDevice) {
Log.d(TAG, "Camera device ID " + cameraDevice.getId() + " opened.");
SharedCameraActivity.this.cameraDevice = cameraDevice;
createCameraPreviewSession();
}
Kotlin
fun onOpened(cameraDevice: CameraDevice) {
Log.d(TAG, "Camera device ID " + cameraDevice.id + " opened.")
this.cameraDevice = cameraDevice
createCameraPreviewSession()
}
Crea una nuova sessione di acquisizione
Crea una nuova richiesta di acquisizione. Utilizza TEMPLATE_RECORD
per assicurarti che la richiesta di acquisizione sia compatibile con ARCore e per consentire il passaggio senza problemi dalla modalità non AR alla modalità AR in fase di runtime.
Java
void createCameraPreviewSession() {
try {
// Create an ARCore-compatible capture request using `TEMPLATE_RECORD`.
previewCaptureRequestBuilder =
cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
// Build a list of surfaces, starting with ARCore provided surfaces.
List<Surface> surfaceList = sharedCamera.getArCoreSurfaces();
// (Optional) Add a CPU image reader surface.
surfaceList.add(cpuImageReader.getSurface());
// The list should now contain three surfaces:
// 0. sharedCamera.getSurfaceTexture()
// 1. …
// 2. cpuImageReader.getSurface()
// Add ARCore surfaces and CPU image surface targets.
for (Surface surface : surfaceList) {
previewCaptureRequestBuilder.addTarget(surface);
}
// Wrap our callback in a shared camera callback.
CameraCaptureSession.StateCallback wrappedCallback =
sharedCamera.createARSessionStateCallback(cameraSessionStateCallback, backgroundHandler);
// Create a camera capture session for camera preview using an ARCore wrapped callback.
cameraDevice.createCaptureSession(surfaceList, wrappedCallback, backgroundHandler);
} catch (CameraAccessException e) {
Log.e(TAG, "CameraAccessException", e);
}
}
Kotlin
fun createCameraPreviewSession() {
try {
// Create an ARCore-compatible capture request using `TEMPLATE_RECORD`.
previewCaptureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD)
// Build a list of surfaces, starting with ARCore provided surfaces.
val surfaceList: MutableList<Surface> = sharedCamera.arCoreSurfaces
// (Optional) Add a CPU image reader surface.
surfaceList.add(cpuImageReader.getSurface())
// The list should now contain three surfaces:
// 0. sharedCamera.getSurfaceTexture()
// 1. …
// 2. cpuImageReader.getSurface()
// Add ARCore surfaces and CPU image surface targets.
for (surface in surfaceList) {
previewCaptureRequestBuilder.addTarget(surface)
}
// Wrap the callback in a shared camera callback.
val wrappedCallback = sharedCamera.createARSessionStateCallback(cameraSessionStateCallback, backgroundHandler)
// Create a camera capture session for camera preview using an ARCore wrapped callback.
cameraDevice.createCaptureSession(surfaceList, wrappedCallback, backgroundHandler)
} catch (e: CameraAccessException) {
Log.e(TAG, "CameraAccessException", e)
}
}
Avvia in modalità non AR o AR
Per iniziare ad acquisire i fotogrammi, chiama captureSession.setRepeatingRequest()
dal callback dello stato della sessione di acquisizione della fotocamera onConfigured()
.
Riprendi la sessione ARCore all'interno del callback onActive()
per iniziare in modalità AR.
Java
// Repeating camera capture session state callback.
CameraCaptureSession.StateCallback cameraSessionStateCallback =
new CameraCaptureSession.StateCallback() {
// Called when ARCore first configures the camera capture session after
// initializing the app, and again each time the activity resumes.
@Override
public void onConfigured(@NonNull CameraCaptureSession session) {
captureSession = session;
setRepeatingCaptureRequest();
}
@Override
public void onActive(@NonNull CameraCaptureSession session) {
if (arMode && !arcoreActive) {
resumeARCore();
}
}
};
// A repeating camera capture session capture callback.
CameraCaptureSession.CaptureCallback cameraCaptureCallback =
new CameraCaptureSession.CaptureCallback() {
@Override
public void onCaptureCompleted(…) {
shouldUpdateSurfaceTexture.set(true);
}
};
void setRepeatingCaptureRequest() {
captureSession.setRepeatingRequest(
previewCaptureRequestBuilder.build(), cameraCaptureCallback, backgroundHandler);
}
void resumeARCore() {
// Resume ARCore.
sharedSession.resume();
arcoreActive = true;
// Set the capture session callback while in AR mode.
sharedCamera.setCaptureCallback(cameraCaptureCallback, backgroundHandler);
}
Kotlin
val cameraSessionStateCallback = object : CameraCaptureSession.StateCallback() {
// Called when ARCore first configures the camera capture session after
// initializing the app, and again each time the activity resumes.
override fun onConfigured(session: CameraCaptureSession) {
captureSession = session
setRepeatingCaptureRequest()
}
override fun onActive(session: CameraCaptureSession) {
if (arMode && !arcoreActive) {
resumeARCore()
}
}
}
val cameraCaptureCallback = object : CameraCaptureSession.CaptureCallback() {
override fun onCaptureCompleted(
session: CameraCaptureSession,
request: CaptureRequest,
result: TotalCaptureResult
) {
shouldUpdateSurfaceTexture.set(true);
}
}
fun setRepeatingCaptureRequest() {
captureSession.setRepeatingRequest(
previewCaptureRequestBuilder.build(), cameraCaptureCallback, backgroundHandler
)
}
fun resumeARCore() {
// Resume ARCore.
sharedSession.resume()
arcoreActive = true
// Set the capture session callback while in AR mode.
sharedCamera.setCaptureCallback(cameraCaptureCallback, backgroundHandler)
}
Passa senza interruzioni tra le modalità non AR e AR in fase di runtime
Per passare dalla modalità non AR a quella AR e riprendere una sessione ARCore in pausa:
Java
// Resume the ARCore session.
resumeARCore();
Kotlin
// Resume the ARCore session.
resumeARCore()
Per passare dalla modalità AR a quella non AR:
Java
// Pause ARCore.
sharedSession.pause();
// Create the Camera2 repeating capture request.
setRepeatingCaptureRequest();
Kotlin
// Pause ARCore.
sharedSession.pause()
// Create the Camera2 repeating capture request.
setRepeatingCaptureRequest()