इस डेवलपर गाइड में, ऐप्लिकेशन को Android Camera2 API की मदद से कैमरे के खास कंट्रोल के बीच आसानी से स्विच करने और ARCore के साथ कैमरा ऐक्सेस शेयर करने का तरीका बताया गया है.
यह विषय आपको मानता है:
ARCore क्विकस्टार्ट को पूरा कर लिया है
Android Camera2 API के बारे में जानकारी हो (ज़्यादा जानने के लिए, Android के लिए खास तौर पर बनाया गया Camera2 सैंपल देखें)
सैंपल ऐप्लिकेशन बनाएं और चलाएं
शेयर किए गए कैमरा Java सैंपल ऐप्लिकेशन को बनाने और चलाने पर, यह ARCore सेशन बनाता है. इस सेशन में, कैमरे को शेयर किए गए ऐक्सेस की सुविधा भी मिलती है. ऐप्लिकेशन बिना एआर (ऑगमेंटेड रिएलिटी) मोड में शुरू होता है, जिसमें ARCore रुका हुआ है.
जब ऐप्लिकेशन बिना एआर (ऑगमेंटेड रिएलिटी) मोड में काम करता है, तो कैमरा व्यूअर सेपिया कलर इफ़ेक्ट दिखाता है. एआर मोड पर स्विच करने पर, सेपिया इफ़ेक्ट बंद हो जाता है. ऐसा इसलिए होता है, क्योंकि ऐप, रोके गए सेशन को फिर से शुरू करके कैमरे का कंट्रोल ARCore पर लौटा देता है.
मोड बदलने के लिए आप ऐप्लिकेशन में एआर स्विच का इस्तेमाल कर सकते हैं. झलक के दौरान, दोनों मोड कैमरा2 से कैप्चर किए गए लगातार फ़्रेम की संख्या दिखाते हैं.
शेयर किया गया कैमरा Java सैंपल ऐप्लिकेशन बनाने और चलाने के लिए:
Android के लिए Google ARCore SDK टूल डाउनलोड करें और एक्सट्रैक्ट करें.
samples/shared_camera_javaप्रोजेक्ट खोलें.पक्का करें कि आपका Android डिवाइस, यूएसबी के ज़रिए डेवलपमेंट मशीन से कनेक्ट हो. ज़्यादा जानकारी के लिए ARCore काम करने वाले डिवाइस देखें.
Android Studio में, Run
पर क्लिक करें.
अपने डिवाइस को डिप्लॉयमेंट टारगेट के तौर पर चुनें और अपने डिवाइस पर सैंपल ऐप्लिकेशन लॉन्च करने के लिए, OK पर क्लिक करें.
डिवाइस पर, पुष्टि करें कि आप ऐप्लिकेशन को फ़ोटो लेने और वीडियो रिकॉर्ड करने की अनुमति देना चाहते हैं.
अगर आपसे ऐसा करने के लिए कहा जाए, तो ARCore के नए वर्शन को अपडेट या इंस्टॉल करें.
नॉन-एआर और एआर (ऑगमेंटेड रिएलिटी) मोड के बीच स्विच करने के लिए, AR स्विच का इस्तेमाल करें.
पर क्लिक करें.ARCore के साथ कैमरा ऐक्सेस शेयर करने के लिए ऐप्लिकेशन चालू करने की खास जानकारी
अपने ऐप्लिकेशन में, ARCore के साथ शेयर किए गए कैमरे का ऐक्सेस लागू करने के लिए, यह तरीका अपनाएं.
सभी कोड स्निपेट,
shared_camera_java
सैंपल के
SharedCameraActivity.java
में उपलब्ध हैं.
CAMERA की अनुमति के लिए अनुरोध करें
डिवाइस का कैमरा इस्तेमाल करने के लिए, उपयोगकर्ता को
आपके ऐप्लिकेशन को CAMERA की अनुमति देनी होगी.
ARCore नमूनों में एक CameraPermissionHelper शामिल है,
जो आपके ऐप्लिकेशन के लिए सही अनुमति मांगने वाली सुविधाएं देता है.
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)
}
}
पक्का करें कि ARCore इंस्टॉल और अप-टू-डेट है
ARCore का इस्तेमाल करने से पहले, यह इंस्टॉल और अप-टू-डेट होना चाहिए. नीचे दिया गया स्निपेट, डिवाइस पर ARCore इंस्टॉल न होने पर, इंस्टॉल करने के लिए अनुरोध करने का तरीका बताता है.
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
}
}
}
ऐसा ARCore सेशन बनाएं जो कैमरा शेयर करने की सुविधा देता हो
इसमें सेशन बनाना और 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
(ज़रूरी नहीं) ARCore को किसी भी कस्टम प्लैटफ़ॉर्म के बारे में बताएं
ज़्यादा कस्टम प्लैटफ़ॉर्म के लिए अनुरोध करने से, डिवाइस की परफ़ॉर्मेंस की मांग बढ़ जाती है. यह पक्का करने के लिए कि ऐप्लिकेशन सही तरीके से काम करे, अपने ऐप्लिकेशन को उन डिवाइसों पर टेस्ट करें जिनका इस्तेमाल आपके उपयोगकर्ता करेंगे.
ARCore डिफ़ॉल्ट रूप से दो स्ट्रीम का अनुरोध करेगा:
- 1x YUV सीपीयू स्ट्रीम, फ़िलहाल
640x480में.
ARCore, मोशन ट्रैकिंग के लिए इस स्ट्रीम का इस्तेमाल करता है. - 1x जीपीयू स्ट्रीम, आम तौर पर
1920x1080
मौजूदा जीपीयू स्ट्रीम रिज़ॉल्यूशन तय करने के लिए,Session#getCameraConfig()का इस्तेमाल करें.
getSupportedCameraConfigs() और
setCameraConfig() का इस्तेमाल करके, उन डिवाइसों पर जीपीयू स्ट्रीम का रिज़ॉल्यूशन बदला जा सकता है जिन पर यह सुविधा काम करती है.
मोटे तौर पर इसके संकेत के रूप में, इसकी उम्मीद की जा सकती है:
| डिवाइस का टाइप | एक साथ स्ट्रीम करने की सुविधा |
|---|---|
| महंगे फ़ोन |
|
| मिड-टियर फ़ोन |
|
सीपीयू इमेज रीडर जैसे प्लैटफ़ॉर्म का इस्तेमाल करने के लिए, पक्का करें कि आपने उन प्लैटफ़ॉर्म की सूची में इसे जोड़ा हो जिन्हें अपडेट किया जाना है. उदाहरण के लिए, ImageReader.
Java
sharedCamera.setAppSurfaces(this.cameraId, Arrays.asList(imageReader.getSurface()));
Kotlin
sharedCamera.setAppSurfaces(this.cameraId, listOf(imageReader.surface))
कैमरा चालू करें
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)
कैमरे के डिवाइस की स्थिति के कॉलबैक का इस्तेमाल करें
कैमरा डिवाइस के स्टेट कॉलबैक में, कैमरा डिवाइस का रेफ़रंस स्टोर किया जाता है और नया कैप्चर सेशन शुरू किया जाता है.
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()
}
नया कैप्चर सेशन बनाएं
कैप्चर करने का नया अनुरोध करें. TEMPLATE_RECORD का इस्तेमाल करके पक्का करें कि कैप्चर करने का अनुरोध, ARCore के साथ काम करता है. साथ ही, रनटाइम के दौरान, बिना एआर (ऑगमेंटेड रिएलिटी) और एआर (ऑगमेंटेड रिएलिटी) मोड के बीच आसानी से स्विच करने के लिए भी इसका इस्तेमाल किया जा सकता है.
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)
}
}
गैर-एआर या एआर (ऑगमेंटेड रिएलिटी) मोड में शुरू होना
फ़्रेम कैप्चर करने के लिए, कैमरा कैप्चर सेशन onConfigured() स्टेट कॉलबैक से captureSession.setRepeatingRequest() को कॉल करें.
एआर मोड में शुरू करने के लिए, onActive() कॉलबैक में ARCore सेशन फिर से शुरू करें.
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)
}
रनटाइम के दौरान, बिना एआर (ऑगमेंटेड रिएलिटी) या एआर (ऑगमेंटेड रिएलिटी) मोड के बीच आसानी से स्विच करें
बिना एआर (ऑगमेंटेड रिएलिटी) वाले मोड से एआर (ऑगमेंटेड रिएलिटी) मोड में स्विच करने और रोके गए ARCore सेशन को फिर से शुरू करने के लिए:
Java
// Resume the ARCore session.
resumeARCore();
Kotlin
// Resume the ARCore session.
resumeARCore()
एआर-मोड से गैर-एआर मोड पर स्विच करने के लिए:
Java
// Pause ARCore.
sharedSession.pause();
// Create the Camera2 repeating capture request.
setRepeatingCaptureRequest();
Kotlin
// Pause ARCore.
sharedSession.pause()
// Create the Camera2 repeating capture request.
setRepeatingCaptureRequest()