MACRO NEPAL
Immersive Experiences: Augmented Reality with ARCore in Java
awiskar acharya
November 15, 2025
4:26 am

ARCore brings powerful augmented reality capabilities to Android applications. This comprehensive guide covers ARCore integration, 3D rendering, plane detection, and interactive AR experiences using Java.

ARCore Architecture Overview

ARCore Processing Pipeline:
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│  Camera Input   │ -> │  Motion Tracking  │ -> │  Plane Detection │
│                 │    │                  │    │                 │
└─────────────────┘    └──────────────────┘    └─────────────────┘
│                      │                      │
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│  Light          │    │  Environmental   │    │  Anchor         │
│  Estimation     │    │  Understanding   │    │  Management     │
└─────────────────┘    └──────────────────┘    └─────────────────┘

Project Setup and Dependencies

1. Android Manifest Configuration

<!-- AndroidManifest.xml -->
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-feature android:name="android.hardware.camera.ar" android:required="true" />
<application>
<!-- ARCore requirement -->
<meta-data
android:name="com.google.ar.core"
android:value="required" />
<!-- Sceneform requirement -->
<meta-data
android:name="com.google.ar.core.min_apk_version"
android:value="200304000" />
</application>

2. Gradle Dependencies

// app/build.gradle
android {
compileSdkVersion 33
defaultConfig {
minSdkVersion 24
targetSdkVersion 33
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}
dependencies {
// ARCore
implementation 'com.google.ar:core:1.36.0'
// Sceneform
implementation 'com.google.ar.sceneform:core:1.17.1'
implementation 'com.google.ar.sceneform:animation:1.17.1'
implementation 'com.google.ar.sceneform:filament-android:1.17.1'
// UI Components
implementation 'androidx.appcompat:appcompat:1.6.1'
implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
// Permission handling
implementation 'com.karumi:dexter:6.2.3'
// 3D Model loading
implementation 'com.github.appoly:ARCore-Location:1.2.0'
}

Core ARCore Implementation

1. Base AR Activity

package com.arcore.app;
import android.opengl.GLSurfaceView;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import com.google.ar.core.*;
import com.google.ar.core.exceptions.*;
import com.google.ar.sceneform.ArSceneView;
import com.google.ar.sceneform.SceneView;
import com.google.ar.sceneform.Scene;
import com.google.ar.sceneform.ux.ArFragment;
import com.google.ar.sceneform.ux.BaseArFragment;
import java.util.EnumSet;
import java.util.Set;
public class BaseARActivity extends AppCompatActivity {
private static final String TAG = "BaseARActivity";
protected ArSceneView arSceneView;
protected Scene arScene;
protected Config arConfig;
protected Session arSession;
protected boolean installRequested;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_ar);
initializeARComponents();
setupARSession();
}
protected void initializeARComponents() {
arSceneView = findViewById(R.id.ar_scene_view);
arScene = arSceneView.getScene();
// Configure AR session
arConfig = new Config(arSession);
arConfig.setPlaneFindingMode(Config.PlaneFindingMode.HORIZONTAL_AND_VERTICAL);
arConfig.setLightEstimationMode(Config.LightEstimationMode.ENVIRONMENTAL_HDR);
// Set focus mode
arConfig.setFocusMode(Config.FocusMode.AUTO);
}
protected void setupARSession() {
// Check if ARCore is supported
Exception exception = null;
String message = null;
try {
switch (ArCoreApk.getInstance().requestInstall(this, !installRequested)) {
case INSTALL_REQUESTED:
installRequested = true;
return;
case INSTALLED:
break;
}
// Create AR session
arSession = new Session(this);
arSession.configure(arConfig);
} catch (UnavailableArcoreNotInstalledException e) {
message = "Please install ARCore";
exception = e;
} catch (UnavailableUserDeclinedInstallationException e) {
message = "Please install ARCore";
exception = e;
} catch (UnavailableApkTooOldException e) {
message = "Please update ARCore";
exception = e;
} catch (UnavailableSdkTooOldException e) {
message = "Please update this app";
exception = e;
} catch (UnavailableDeviceNotCompatibleException e) {
message = "This device does not support AR";
exception = e;
} catch (Exception e) {
message = "Failed to create AR session";
exception = e;
}
if (message != null) {
Log.e(TAG, "Exception creating session", exception);
Toast.makeText(this, message, Toast.LENGTH_LONG).show();
return;
}
// Set up scene view
arSceneView.setupSession(arSession);
// Add session listeners
arSession.setCameraConfig(arSession.getCameraConfig());
}
@Override
protected void onResume() {
super.onResume();
if (arSession != null) {
try {
arSession.resume();
arSceneView.resume();
} catch (CameraNotAvailableException e) {
Log.e(TAG, "Camera not available", e);
Toast.makeText(this, "Camera not available", Toast.LENGTH_LONG).show();
finish();
}
}
}
@Override
protected void onPause() {
super.onPause();
if (arSession != null) {
arSceneView.pause();
arSession.pause();
}
}
@Override
protected void onDestroy() {
super.onDestroy();
if (arSession != null) {
arSession.close();
}
if (arSceneView != null) {
arSceneView.destroy();
}
}
protected boolean isARSupported() {
return ArCoreApk.getInstance().checkAvailability(this).isSupported();
}
}

2. Advanced AR Session Manager

package com.arcore.manager;
import android.content.Context;
import android.util.Log;
import com.google.ar.core.*;
import com.google.ar.core.exceptions.*;
import java.util.concurrent.ArrayBlockingQueue;
public class ARSessionManager {
private static final String TAG = "ARSessionManager";
private Session arSession;
private Config arConfig;
private Context context;
private ARSessionListener sessionListener;
// Thread-safe queue for AR frame processing
private ArrayBlockingQueue<Frame> frameQueue = new ArrayBlockingQueue<>(10);
public ARSessionManager(Context context, ARSessionListener listener) {
this.context = context;
this.sessionListener = listener;
}
public boolean initializeSession() {
try {
// Create AR session
arSession = new Session(context);
// Configure session
arConfig = new Config(arSession);
configureSession(arConfig);
// Apply configuration
arSession.configure(arConfig);
// Set up session listeners
setupSessionListeners();
Log.i(TAG, "AR session initialized successfully");
return true;
} catch (Exception e) {
Log.e(TAG, "Failed to initialize AR session", e);
if (sessionListener != null) {
sessionListener.onSessionError("Failed to initialize AR: " + e.getMessage());
}
return false;
}
}
private void configureSession(Config config) {
// Enable plane detection
config.setPlaneFindingMode(Config.PlaneFindingMode.HORIZONTAL_AND_VERTICAL);
// Enable light estimation
config.setLightEstimationMode(Config.LightEstimationMode.ENVIRONMENTAL_HDR);
// Enable cloud anchors if needed
config.setCloudAnchorMode(Config.CloudAnchorMode.ENABLED);
// Set focus mode
config.setFocusMode(Config.FocusMode.AUTO);
// Enable depth if available
if (arSession.isDepthModeSupported(Config.DepthMode.AUTOMATIC)) {
config.setDepthMode(Config.DepthMode.AUTOMATIC);
}
}
private void setupSessionListeners() {
arSession.setCameraConfig(arSession.getCameraConfig());
// Add frame listener for custom processing
new Thread(this::processFrames).start();
}
public Frame acquireLatestFrame() {
try {
return arSession.update();
} catch (Exception e) {
Log.e(TAG, "Error acquiring frame", e);
return null;
}
}
public Anchor createAnchor(Pose pose) {
if (arSession != null) {
return arSession.createAnchor(pose);
}
return null;
}
public Trackable[] getAllTrackables() {
if (arSession != null) {
return arSession.getAllTrackables(Trackable.class).toArray(new Trackable[0]);
}
return new Trackable[0];
}
public Plane[] getDetectedPlanes() {
if (arSession != null) {
return arSession.getAllTrackables(Plane.class).toArray(new Plane[0]);
}
return new Plane[0];
}
public void resume() {
if (arSession != null) {
try {
arSession.resume();
} catch (CameraNotAvailableException e) {
Log.e(TAG, "Camera not available on resume", e);
if (sessionListener != null) {
sessionListener.onSessionError("Camera not available");
}
}
}
}
public void pause() {
if (arSession != null) {
arSession.pause();
}
}
public void close() {
if (arSession != null) {
arSession.close();
arSession = null;
}
}
public boolean isDepthSupported() {
return arSession != null && 
arSession.isDepthModeSupported(Config.DepthMode.AUTOMATIC);
}
public boolean isEnvironmentalHDREsupported() {
return arSession != null &&
arSession.isLightEstimationModeSupported(Config.LightEstimationMode.ENVIRONMENTAL_HDR);
}
private void processFrames() {
while (!Thread.currentThread().isInterrupted()) {
try {
Frame frame = frameQueue.take();
processARFrame(frame);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
} catch (Exception e) {
Log.e(TAG, "Error processing frame", e);
}
}
}
private void processARFrame(Frame frame) {
// Custom frame processing logic
Camera camera = frame.getCamera();
TrackingState trackingState = camera.getTrackingState();
if (trackingState == TrackingState.TRACKING) {
// Process tracked frame
processTrackedFrame(frame, camera);
}
}
private void processTrackedFrame(Frame frame, Camera camera) {
// Implement custom tracking logic
LightEstimate lightEstimate = frame.getLightEstimate();
if (lightEstimate != null) {
float[] environmentalHDR = lightEstimate.getEnvironmentalHdrAmbientSphericalHarmonics();
float[] mainLightDirection = lightEstimate.getEnvironmentalHdrMainLightDirection();
float mainLightIntensity = lightEstimate.getEnvironmentalHdrMainLightIntensity();
// Update lighting in scene
updateSceneLighting(environmentalHDR, mainLightDirection, mainLightIntensity);
}
}
private void updateSceneLighting(float[] sphericalHarmonics, 
float[] mainLightDirection, 
float mainLightIntensity) {
// Update scene lighting based on environmental HDR data
if (sessionListener != null) {
sessionListener.onLightingUpdated(sphericalHarmonics, mainLightDirection, mainLightIntensity);
}
}
public interface ARSessionListener {
void onSessionError(String errorMessage);
void onPlaneDetected(Plane plane);
void onAnchorCreated(Anchor anchor);
void onLightingUpdated(float[] sphericalHarmonics, float[] mainLightDirection, float mainLightIntensity);
}
}

3D Object Rendering and Management

1. 3D Object Manager

package com.arcore.renderer;
import android.content.Context;
import android.util.Log;
import com.google.ar.core.Anchor;
import com.google.ar.core.Pose;
import com.google.ar.sceneform.AnchorNode;
import com.google.ar.sceneform.Node;
import com.google.ar.sceneform.NodeParent;
import com.google.ar.sceneform.math.Vector3;
import com.google.ar.sceneform.rendering.ModelRenderable;
import com.google.ar.sceneform.rendering.Renderable;
import com.google.ar.sceneform.rendering.Texture;
import com.google.ar.sceneform.rendering.Material;
import com.google.ar.sceneform.rendering.MaterialFactory;
import com.google.ar.sceneform.rendering.Color;
import java.util.concurrent.CompletableFuture;
import java.util.HashMap;
import java.util.Map;
public class Object3DManager {
private static final String TAG = "Object3DManager";
private Context context;
private Map<String, Renderable> objectCache;
private Map<String, Material> materialCache;
public Object3DManager(Context context) {
this.context = context;
this.objectCache = new HashMap<>();
this.materialCache = new HashMap<>();
initializeDefaultMaterials();
}
private void initializeDefaultMaterials() {
// Create default materials
createMaterial("default_red", Color.red());
createMaterial("default_blue", Color.blue());
createMaterial("default_green", Color.green());
createMaterial("default_white", Color.white());
}
public CompletableFuture<ModelRenderable> loadModel(int modelResourceId) {
return ModelRenderable.builder()
.setSource(context, modelResourceId)
.build()
.thenApply(renderable -> {
Log.i(TAG, "3D model loaded successfully");
return renderable;
})
.exceptionally(throwable -> {
Log.e(TAG, "Failed to load 3D model", throwable);
return null;
});
}
public CompletableFuture<Material> createMaterial(String materialName, Color color) {
return MaterialFactory.makeOpaqueWithColor(context, color)
.thenApply(material -> {
materialCache.put(materialName, material);
return material;
})
.exceptionally(throwable -> {
Log.e(TAG, "Failed to create material: " + materialName, throwable);
return null;
});
}
public AnchorNode placeObjectAtAnchor(Anchor anchor, Renderable renderable) {
AnchorNode anchorNode = new AnchorNode(anchor);
Node objectNode = new Node();
objectNode.setRenderable(renderable);
objectNode.setParent(anchorNode);
return anchorNode;
}
public AnchorNode placeObjectAtPose(Pose pose, Renderable renderable, NodeParent scene) {
AnchorNode anchorNode = new AnchorNode();
anchorNode.setWorldPosition(new Vector3(
pose.tx(), pose.ty(), pose.tz()
));
anchorNode.setWorldRotation(pose.getRotationQuaternion());
Node objectNode = new Node();
objectNode.setRenderable(renderable);
objectNode.setParent(anchorNode);
if (scene != null) {
anchorNode.setParent(scene);
}
return anchorNode;
}
public void scaleObject(Node objectNode, float scale) {
objectNode.setWorldScale(new Vector3(scale, scale, scale));
}
public void rotateObject(Node objectNode, float degreesX, float degreesY, float degreesZ) {
// Convert degrees to quaternion rotation
// Implementation depends on specific rotation requirements
}
public void animateObject(Node objectNode, Vector3 startPosition, Vector3 endPosition, 
long duration) {
// Implement object animation
objectNode.setWorldPosition(startPosition);
// Use ValueAnimator or similar for smooth animation
// This is a simplified placeholder
new android.animation.ValueAnimator().setDuration(duration);
}
public void applyMaterialToObject(Node objectNode, String materialName) {
Material material = materialCache.get(materialName);
if (material != null && objectNode.getRenderable() != null) {
objectNode.getRenderable().setMaterial(material);
}
}
public void cleanup() {
objectCache.clear();
materialCache.clear();
}
}

2. Interactive AR Object

package com.arcore.objects;
import android.view.MotionEvent;
import com.google.ar.sceneform.Node;
import com.google.ar.sceneform.math.Quaternion;
import com.google.ar.sceneform.math.Vector3;
import com.google.ar.sceneform.rendering.Renderable;
public class InteractiveObject extends Node {
public interface InteractionListener {
void onObjectTapped(InteractiveObject object);
void onObjectDragged(InteractiveObject object, Vector3 newPosition);
void onObjectRotated(InteractiveObject object, Quaternion newRotation);
}
private InteractionListener interactionListener;
private boolean isDraggable = true;
private boolean isRotatable = true;
private boolean isScalable = true;
private Vector3 originalScale;
public InteractiveObject() {
super();
setOnTapListener((hitResult, motionEvent) -> {
if (interactionListener != null) {
interactionListener.onObjectTapped(this);
}
});
}
@Override
public boolean onTouchEvent(HitTestResult hitTestResult, MotionEvent motionEvent) {
if (motionEvent.getAction() == MotionEvent.ACTION_MOVE) {
handleDrag(motionEvent);
return true;
}
return super.onTouchEvent(hitTestResult, motionEvent);
}
private void handleDrag(MotionEvent motionEvent) {
if (!isDraggable || getParent() == null) {
return;
}
// Get world position from screen coordinates
// This is simplified - actual implementation would use hit testing
if (interactionListener != null) {
interactionListener.onObjectDragged(this, getWorldPosition());
}
}
public void setDraggable(boolean draggable) {
this.isDraggable = draggable;
}
public void setRotatable(boolean rotatable) {
this.isRotatable = rotatable;
}
public void setScalable(boolean scalable) {
this.isScalable = scalable;
}
public void setInteractionListener(InteractionListener listener) {
this.interactionListener = listener;
}
public void scale(float scaleFactor) {
if (isScalable) {
if (originalScale == null) {
originalScale = getWorldScale();
}
Vector3 newScale = new Vector3(
originalScale.x * scaleFactor,
originalScale.y * scaleFactor,
originalScale.z * scaleFactor
);
setWorldScale(newScale);
}
}
public void resetScale() {
if (originalScale != null) {
setWorldScale(originalScale);
}
}
public void rotate(float degreesX, float degreesY, float degreesZ) {
if (isRotatable) {
Quaternion currentRotation = getWorldRotation();
Quaternion additionalRotation = Quaternion.axisAngle(
new Vector3(degreesX, degreesY, degreesZ), 1.0f
);
setWorldRotation(Quaternion.multiply(currentRotation, additionalRotation));
if (interactionListener != null) {
interactionListener.onObjectRotated(this, getWorldRotation());
}
}
}
}

Plane Detection and Visualization

1. Plane Visualization Manager

package com.arcore.planes;
import android.content.Context;
import android.util.Log;
import com.google.ar.core.Plane;
import com.google.ar.core.Pose;
import com.google.ar.core.TrackingState;
import com.google.ar.sceneform.AnchorNode;
import com.google.ar.sceneform.Node;
import com.google.ar.sceneform.math.Vector3;
import com.google.ar.sceneform.rendering.Material;
import com.google.ar.sceneform.rendering.MaterialFactory;
import com.google.ar.sceneform.rendering.Color;
import com.google.ar.sceneform.rendering.ShapeFactory;
import com.google.ar.sceneform.rendering.ModelRenderable;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
public class PlaneVisualizationManager {
private static final String TAG = "PlaneVisualizationManager";
private Context context;
private Map<Plane, AnchorNode> planeNodes;
private Material horizontalPlaneMaterial;
private Material verticalPlaneMaterial;
private boolean showPlanes = true;
public PlaneVisualizationManager(Context context) {
this.context = context;
this.planeNodes = new HashMap<>();
initializeMaterials();
}
private void initializeMaterials() {
// Create materials for different plane types
MaterialFactory.makeTransparentWithColor(context, new Color(0, 1, 0, 0.3f))
.thenAccept(material -> horizontalPlaneMaterial = material)
.exceptionally(throwable -> {
Log.e(TAG, "Failed to create horizontal plane material", throwable);
return null;
});
MaterialFactory.makeTransparentWithColor(context, new Color(0, 0, 1, 0.3f))
.thenAccept(material -> verticalPlaneMaterial = material)
.exceptionally(throwable -> {
Log.e(TAG, "Failed to create vertical plane material", throwable);
return null;
});
}
public void updatePlaneVisualization(Plane plane, AnchorNode anchorNode) {
if (!showPlanes) return;
if (plane.getTrackingState() != TrackingState.TRACKING) {
removePlaneVisualization(plane);
return;
}
if (!planeNodes.containsKey(plane)) {
createPlaneVisualization(plane, anchorNode);
} else {
updateExistingPlane(plane);
}
}
private void createPlaneVisualization(Plane plane, AnchorNode anchorNode) {
Node planeNode = new Node();
planeNode.setParent(anchorNode);
// Create plane geometry based on plane type and extent
Pose centerPose = plane.getCenterPose();
float[] extent = plane.getExtentXZ();
ModelRenderable planeRenderable = ShapeFactory.makeCube(
new Vector3(extent[0], 0.01f, extent[1]), 
new Vector3(0, 0, 0), 
getMaterialForPlane(plane)
);
planeNode.setRenderable(planeRenderable);
planeNode.setWorldPosition(new Vector3(
centerPose.tx(), centerPose.ty(), centerPose.tz()
));
planeNodes.put(plane, anchorNode);
}
private void updateExistingPlane(Plane plane) {
AnchorNode anchorNode = planeNodes.get(plane);
if (anchorNode != null) {
Pose centerPose = plane.getCenterPose();
anchorNode.setWorldPosition(new Vector3(
centerPose.tx(), centerPose.ty(), centerPose.tz()
));
// Update plane size if needed
updatePlaneSize(plane, anchorNode);
}
}
private void updatePlaneSize(Plane plane, AnchorNode anchorNode) {
// Update the visual representation when plane size changes
float[] extent = plane.getExtentXZ();
// Implementation would update the renderable's size
}
private Material getMaterialForPlane(Plane plane) {
switch (plane.getType()) {
case HORIZONTAL_DOWNWARD_FACING:
case HORIZONTAL_UPWARD_FACING:
return horizontalPlaneMaterial;
case VERTICAL:
return verticalPlaneMaterial;
default:
return horizontalPlaneMaterial;
}
}
public void removePlaneVisualization(Plane plane) {
AnchorNode anchorNode = planeNodes.remove(plane);
if (anchorNode != null) {
anchorNode.setParent(null);
}
}
public void setPlaneVisibility(boolean visible) {
this.showPlanes = visible;
for (AnchorNode node : planeNodes.values()) {
node.setEnabled(visible);
}
}
public void cleanup() {
for (AnchorNode node : planeNodes.values()) {
node.setParent(null);
}
planeNodes.clear();
}
}

Advanced AR Features

1. Image Recognition and Tracking

package com.arcore.tracking;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import com.google.ar.core.AugmentedImage;
import com.google.ar.core.AugmentedImageDatabase;
import com.google.ar.core.Config;
import com.google.ar.core.Session;
import com.google.ar.core.TrackingState;
import com.google.ar.sceneform.AnchorNode;
import com.google.ar.sceneform.Node;
import com.google.ar.sceneform.math.Vector3;
import com.google.ar.sceneform.rendering.ModelRenderable;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
public class ImageTrackingManager {
private static final String TAG = "ImageTrackingManager";
private Context context;
private Session arSession;
private AugmentedImageDatabase imageDatabase;
private Map<String, ModelRenderable> trackedImageModels;
private Map<AugmentedImage, AnchorNode> trackedImageNodes;
public ImageTrackingManager(Context context, Session session) {
this.context = context;
this.arSession = session;
this.trackedImageModels = new HashMap<>();
this.trackedImageNodes = new HashMap<>();
this.imageDatabase = new AugmentedImageDatabase(arSession);
}
public boolean addTrackedImage(String imageName, int imageResourceId, ModelRenderable model) {
try {
// Load image bitmap
InputStream is = context.getResources().openRawResource(imageResourceId);
Bitmap bitmap = BitmapFactory.decodeStream(is);
// Add to database
int index = imageDatabase.addImage(imageName, bitmap);
// Store model reference
trackedImageModels.put(imageName, model);
Log.i(TAG, "Added tracked image: " + imageName + " at index: " + index);
return true;
} catch (IOException e) {
Log.e(TAG, "Failed to add tracked image: " + imageName, e);
return false;
}
}
public void configureSessionForImageTracking(Config config) {
config.setAugmentedImageDatabase(imageDatabase);
config.setPlaneFindingMode(Config.PlaneFindingMode.DISABLED);
}
public void updateTrackedImages(AugmentedImage[] updatedImages) {
for (AugmentedImage image : updatedImages) {
switch (image.getTrackingState()) {
case TRACKING:
if (!trackedImageNodes.containsKey(image)) {
onImageTracked(image);
}
break;
case STOPPED:
onImageTrackingStopped(image);
break;
case PAUSED:
// Image tracking paused, keep the node but don't update
break;
}
}
}
private void onImageTracked(AugmentedImage image) {
String imageName = image.getName();
ModelRenderable model = trackedImageModels.get(imageName);
if (model != null) {
// Create anchor at image center
AnchorNode anchorNode = new AnchorNode(image.createAnchor(image.getCenterPose()));
// Create object node
Node objectNode = new Node();
objectNode.setRenderable(model);
objectNode.setParent(anchorNode);
// Position object above the image
objectNode.setWorldPosition(new Vector3(0, image.getExtentX() * 0.5f, 0));
trackedImageNodes.put(image, anchorNode);
Log.i(TAG, "Started tracking image: " + imageName);
}
}
private void onImageTrackingStopped(AugmentedImage image) {
AnchorNode anchorNode = trackedImageNodes.remove(image);
if (anchorNode != null) {
anchorNode.setParent(null);
Log.i(TAG, "Stopped tracking image: " + image.getName());
}
}
public void cleanup() {
for (AnchorNode node : trackedImageNodes.values()) {
node.setParent(null);
}
trackedImageNodes.clear();
trackedImageModels.clear();
}
}

2. Cloud Anchors for Multi-user AR

package com.arcore.cloud;
import android.util.Log;
import com.google.ar.core.Anchor;
import com.google.ar.core.Anchor.CloudAnchorState;
import com.google.ar.core.Session;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
public class CloudAnchorManager {
private static final String TAG = "CloudAnchorManager";
private Session arSession;
private Map<String, Anchor> hostedAnchors;
private Map<String, CompletableFuture<String>> hostingFutures;
private Map<String, CompletableFuture<Anchor>> resolvingFutures;
public CloudAnchorManager(Session session) {
this.arSession = session;
this.hostedAnchors = new HashMap<>();
this.hostingFutures = new HashMap<>();
this.resolvingFutures = new HashMap<>();
}
public CompletableFuture<String> hostCloudAnchor(Anchor localAnchor, int ttlDays) {
CompletableFuture<String> future = new CompletableFuture<>();
Anchor cloudAnchor = arSession.hostCloudAnchorWithTtl(localAnchor, ttlDays);
String anchorId = cloudAnchor.getCloudAnchorId();
hostedAnchors.put(anchorId, cloudAnchor);
hostingFutures.put(anchorId, future);
// Check anchor state periodically
checkCloudAnchorState(cloudAnchor);
return future;
}
public CompletableFuture<Anchor> resolveCloudAnchor(String cloudAnchorId) {
CompletableFuture<Anchor> future = new CompletableFuture<>();
Anchor cloudAnchor = arSession.resolveCloudAnchor(cloudAnchorId);
resolvingFutures.put(cloudAnchorId, future);
// Check anchor state periodically
checkCloudAnchorState(cloudAnchor);
return future;
}
private void checkCloudAnchorState(Anchor cloudAnchor) {
CloudAnchorState state = cloudAnchor.getCloudAnchorState();
switch (state) {
case SUCCESS:
onCloudAnchorSuccess(cloudAnchor);
break;
case ERROR_INTERNAL:
case ERROR_NOT_AUTHORIZED:
case ERROR_SERVICE_UNAVAILABLE:
onCloudAnchorError(cloudAnchor, state);
break;
case TASK_IN_PROGRESS:
// Continue checking
scheduleStateCheck(cloudAnchor);
break;
}
}
private void onCloudAnchorSuccess(Anchor cloudAnchor) {
String anchorId = cloudAnchor.getCloudAnchorId();
CompletableFuture<String> hostingFuture = hostingFutures.remove(anchorId);
if (hostingFuture != null) {
hostingFuture.complete(anchorId);
}
CompletableFuture<Anchor> resolvingFuture = resolvingFutures.remove(anchorId);
if (resolvingFuture != null) {
resolvingFuture.complete(cloudAnchor);
}
Log.i(TAG, "Cloud anchor operation successful: " + anchorId);
}
private void onCloudAnchorError(Anchor cloudAnchor, CloudAnchorState errorState) {
String anchorId = cloudAnchor.getCloudAnchorId();
String errorMessage = "Cloud anchor error: " + errorState.toString();
CompletableFuture<String> hostingFuture = hostingFutures.remove(anchorId);
if (hostingFuture != null) {
hostingFuture.completeExceptionally(new RuntimeException(errorMessage));
}
CompletableFuture<Anchor> resolvingFuture = resolvingFutures.remove(anchorId);
if (resolvingFuture != null) {
resolvingFuture.completeExceptionally(new RuntimeException(errorMessage));
}
Log.e(TAG, errorMessage);
}
private void scheduleStateCheck(Anchor cloudAnchor) {
// Schedule next state check (simplified)
new android.os.Handler().postDelayed(() -> {
checkCloudAnchorState(cloudAnchor);
}, 500);
}
public void cleanup() {
for (Anchor anchor : hostedAnchors.values()) {
anchor.detach();
}
hostedAnchors.clear();
hostingFutures.clear();
resolvingFutures.clear();
}
}

Complete AR Application Example

1. Main AR Activity

package com.arcore.app;
import android.os.Bundle;
import android.widget.Button;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import com.google.ar.core.*;
import com.google.ar.sceneform.ArSceneView;
import com.google.ar.sceneform.Scene;
import com.google.ar.sceneform.ux.ArFragment;
import com.arcore.manager.ARSessionManager;
import com.arcore.renderer.Object3DManager;
import com.arcore.planes.PlaneVisualizationManager;
import com.arcore.tracking.ImageTrackingManager;
public class MainARActivity extends AppCompatActivity 
implements ARSessionManager.ARSessionListener {
private ArSceneView arSceneView;
private ArFragment arFragment;
private Button placeObjectButton;
private Button clearButton;
private ARSessionManager sessionManager;
private Object3DManager objectManager;
private PlaneVisualizationManager planeManager;
private ImageTrackingManager imageTrackingManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main_ar);
initializeUI();
initializeARComponents();
}
private void initializeUI() {
arFragment = (ArFragment) getSupportFragmentManager().findFragmentById(R.id.ar_fragment);
arSceneView = arFragment.getArSceneView();
placeObjectButton = findViewById(R.id.btn_place_object);
clearButton = findViewById(R.id.btn_clear);
placeObjectButton.setOnClickListener(v -> placeSampleObject());
clearButton.setOnClickListener(v -> clearScene());
}
private void initializeARComponents() {
// Initialize session manager
sessionManager = new ARSessionManager(this, this);
if (!sessionManager.initializeSession()) {
Toast.makeText(this, "ARCore not supported", Toast.LENGTH_LONG).show();
finish();
return;
}
// Initialize other managers
objectManager = new Object3DManager(this);
planeManager = new PlaneVisualizationManager(this);
// Set up AR scene
setupARScene();
}
private void setupARScene() {
Scene scene = arSceneView.getScene();
// Add plane detection
arFragment.setOnTapArPlaneListener((hitResult, plane, motionEvent) -> {
onPlaneTapped(hitResult, plane);
});
// Set up image tracking if needed
imageTrackingManager = new ImageTrackingManager(this, sessionManager.getSession());
// Add tracked images here
}
private void onPlaneTapped(HitResult hitResult, Plane plane) {
// Create anchor at tapped position
Anchor anchor = hitResult.createAnchor();
placeObjectAtAnchor(anchor);
}
private void placeSampleObject() {
// Place object at screen center
Frame frame = sessionManager.acquireLatestFrame();
if (frame != null && frame.getCamera().getTrackingState() == TrackingState.TRACKING) {
// Implementation for placing object at screen center
}
}
private void placeObjectAtAnchor(Anchor anchor) {
// Load and place a 3D object
objectManager.loadModel(R.raw.sample_object)
.thenAccept(renderable -> {
objectManager.placeObjectAtAnchor(anchor, renderable);
Toast.makeText(this, "Object placed", Toast.LENGTH_SHORT).show();
})
.exceptionally(throwable -> {
Toast.makeText(this, "Failed to load object", Toast.LENGTH_SHORT).show();
return null;
});
}
private void clearScene() {
// Clear all placed objects
Scene scene = arSceneView.getScene();
// Implementation to clear scene nodes
}
// ARSessionManager callbacks
@Override
public void onSessionError(String errorMessage) {
runOnUiThread(() -> Toast.makeText(this, errorMessage, Toast.LENGTH_LONG).show());
}
@Override
public void onPlaneDetected(Plane plane) {
// Handle plane detection
}
@Override
public void onAnchorCreated(Anchor anchor) {
// Handle anchor creation
}
@Override
public void onLightingUpdated(float[] sphericalHarmonics, float[] mainLightDirection, 
float mainLightIntensity) {
// Update scene lighting
}
@Override
protected void onResume() {
super.onResume();
sessionManager.resume();
}
@Override
protected void onPause() {
super.onPause();
sessionManager.pause();
}
@Override
protected void onDestroy() {
super.onDestroy();
sessionManager.close();
objectManager.cleanup();
planeManager.cleanup();
if (imageTrackingManager != null) {
imageTrackingManager.cleanup();
}
}
}

Performance Optimization

1. AR Performance Monitor

package com.arcore.performance;
import android.util.Log;
import com.google.ar.core.Frame;
import com.google.ar.core.Session;
import java.util.concurrent.atomic.AtomicLong;
public class ARPerformanceMonitor {
private static final String TAG = "ARPerformanceMonitor";
private AtomicLong frameCount = new AtomicLong();
private AtomicLong totalFrameTime = new AtomicLong();
private long startTime;
private boolean monitoring = false;
public void startMonitoring() {
frameCount.set(0);
totalFrameTime.set(0);
startTime = System.currentTimeMillis();
monitoring = true;
}
public void stopMonitoring() {
monitoring = false;
}
public void recordFrame(Frame frame) {
if (!monitoring) return;
frameCount.incrementAndGet();
// Calculate frame processing time
long frameTimestamp = frame.getTimestamp();
// Implementation would track frame processing performance
}
public PerformanceStats getStats() {
long currentTime = System.currentTimeMillis();
long monitoringDuration = currentTime - startTime;
long frames = frameCount.get();
double fps = monitoringDuration > 0 ? (frames * 1000.0) / monitoringDuration : 0;
return new PerformanceStats(fps, frames, monitoringDuration);
}
public static class PerformanceStats {
public final double framesPerSecond;
public final long totalFrames;
public final long monitoringDurationMs;
public PerformanceStats(double fps, long totalFrames, long duration) {
this.framesPerSecond = fps;
this.totalFrames = totalFrames;
this.monitoringDurationMs = duration;
}
}
}

Conclusion

ARCore with Java enables powerful augmented reality experiences:

Key ARCore Features:

  • Motion Tracking - Device position and orientation
  • Environmental Understanding - Plane detection and lighting
  • Light Estimation - Real-world lighting matching
  • Cloud Anchors - Multi-user shared experiences
  • Image Tracking - Marker-based AR

Best Practices:

  • Optimize 3D models for mobile rendering
  • Implement proper session management
  • Handle ARCore availability checks
  • Use appropriate plane detection modes
  • Implement fallback for unsupported features

Use Cases:

  • Product visualization - Furniture, retail
  • Education - Interactive learning experiences
  • Gaming - Immersive AR games
  • Navigation - Indoor wayfinding
  • Maintenance - Industrial AR instructions

ARCore's robust feature set combined with Java's development ecosystem creates compelling AR applications that bridge digital and physical worlds seamlessly.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper