Augmented Reality hat einen langen Weg von Sci-Fi-Geschichten zur wissenschaftlichen Realität zurückgelegt. Bei dieser Geschwindigkeit des technischen Fortschritts ist es wahrscheinlich nicht mehr weit, bis wir digitale Daten auch in dieser realen physischen Welt manipulieren können, wie es Tony Stark in seinem Labor tat. Wenn wir Informationen wie Ton, Text, Bild unserer realen Welt überlagern und auch mit ihr durch ein spezielles Medium interagieren können, das ist Augmented Reality. Die weltberühmte „Pokemon GO“-App ist nur ein weiteres Beispiel für eine Augmented-Reality-Anwendung. Lassen Sie uns eine sehr einfache Augmented Reality App in Android Studio mit JAVA erstellen . Diese App zeigt ein speziell angefertigtes oder heruntergeladenes 3D-Modell mit der Telefonkamera. Ein Beispiel-GIF ist unten angegeben, um eine Vorstellung davon zu bekommen, was wir in diesem Artikel tun werden.

Terminologien

• ARCore: Laut Google ist ARCore eine Plattform für Augmented Reality. ARCore hilft dem Telefon tatsächlich, seine Umgebung zu erkennen und mit der Welt zu interagieren. ARCore verwendet hauptsächlich 3 Schlüsselprinzipien – Bewegungsverfolgung, Verständnis der Umgebung und Lichtschätzung . Hier ist eine von Google bereitgestellte Liste der Telefone, die ARCore unterstützen.
• Sceneform: Laut Google ist Sceneform ein 3D-Framework, das den Entwicklern hilft, ARCore-Apps zu erstellen, ohne viel über OpenGL zu wissen. Sceneform bietet viele Funktionen wie das Überprüfen der Kameraberechtigung, das Bearbeiten von 3D-Assets und vieles mehr.

Schritt für Schritt Umsetzung

Schritt 1: Erstellen Sie ein neues Projekt

Informationen zum Erstellen eines neuen Projekts in Android Studio finden Sie unter So erstellen/starten Sie ein neues Projekt in Android Studio . 

Notiz: 

• Wählen Sie Java als Programmiersprache aus.
• Notieren Sie sich den Speicherort, an dem die App gespeichert wird, da wir diesen Pfad später benötigen.
• Wählen Sie „ Mindest-SDK “ als „ API 24: Android 7.0 (Nougat) “.

Schritt 2: Erhalten des 3D-Modells

Sceneform 1.16.0 unterstützt nur glTF- Dateien. glTF bedeutet GL-Übertragungsformat. Jetzt sind .glb- Dateien eine binäre Version des GL-Übertragungsformats. Diese Arten von 3D-Modelldateien werden in VR, AR verwendet, da sie Bewegung und Animation unterstützen.

• Für das 3D-Modell müssen Sie eine .glb -Datei erhalten.
• Es gibt zwei Möglichkeiten: Sie können ein 3D-Modell abrufen, aus dem Internet herunterladen oder selbst eines erstellen .
• Wenn Sie es aus dem Internet herunterladen möchten, gehen Sie zu diesem großartigen Repository für 3D-Modelle von Google, poly , und suchen Sie nach einer beliebigen glb-Datei . Laden Sie eine davon für Ihr Projekt herunter.
• ODER besorgen Sie sich eine 3D-Computergrafiksoftware und erstellen Sie selbst ein 3D-Modell.
• Ich habe Blender verwendet , das völlig kostenlos heruntergeladen werden kann, und ein 3D-Modell des Textes GEEKS FOR GEEKS erstellt. Holen Sie sich diese Datei von hier .
• Exportieren Sie das Modell als .glb -Datei in einen bestimmten Ordner und der Dateiname muss Kleinbuchstaben oder Zahlen enthalten .

• Kehren Sie zu Android Studio zurück.
• Klicken Sie im linken Bereich mit der rechten Maustaste auf das res - Verzeichnis. Gehen Sie zu Neu > Android-Ressourcenverzeichnis . Es öffnet sich ein Fenster.

• Ändern Sie den Ressourcentyp : in Raw . Klicken Sie auf OK . Unter dem res-Verzeichnis wird ein Raw-Ordner generiert.

• Kopieren Sie die . glb-Datei aus dem Verzeichnis, in dem Sie sie gespeichert haben, und fügen Sie sie unter dem Raw-Ordner ein.

Schritt 3: Herunterladen und Einrichten von SceneForm 1.16.0

Nun, für AR-Apps brauchen wir Sceneform SDK. SceneForm 1.15.0 ist sehr berühmt, aber in letzter Zeit sind einige Plugin-Fehler aufgetreten, als ich das Plugin „Google Sceneform Tools (Beta)“ im neuesten Android Studio 4.1 erhalten habe. Hier bin ich also, benutze das Sceneform 1.16.0 SDK und richte es manuell ein.

• Gehen Sie zu diesem GitHub- Link .
• Laden Sie die Datei „ sceneform-android-sdk-1.16.0.zip “ herunter.
• Extrahieren Sie die Ordner „ sceneformsrc “ und „ sceneformux “, in denen Sie Ihr Projekt erstellt haben. („E:\android\ARApp“ für mich)
• Gehen Sie zum Android-Studio
• Gehen Sie zu Gradle-Skripts > settings.gradle (Projekteinstellungen)
• Fügen Sie diese Zeilen hinzu:

// Dadurch wird der Ordner sceneformsrc zu Ihrem Projekt hinzugefügt

umfassen ':sceneform'

project(':sceneform').projectDir = new File('sceneformsrc/sceneform')

 

// Dadurch wird der Sceneformux-Ordner zu Ihrem Projekt hinzugefügt

':sceneformux' einschließen

project(':sceneformux').projectDir = new File('sceneformux/ux')

• Danach gehen Sie zu Gradle Scripts > build.gradle(Module:app)
• Fügen Sie diese Zeile innerhalb des Abhängigkeitsblocks hinzu.

API-Projekt („:sceneformux“)

• Fügen Sie dann in derselben Datei innerhalb des Blocks „android“ und direkt nach dem Block „buildTypes“ diese Zeilen hinzu (falls noch nicht vorhanden):

// zur Unterstützung von Java 8 in Ihrem Projekt

kompilierungsoptionen {

       sourceCompatibility JavaVersion.VERSION_1_8

       targetCompatibility JavaVersion.VERSION_1_8

}

• Schließlich klicken Sie für diese Änderungen im Popup oben auf „ Jetzt synchronisieren “. Jetzt sieht die Android-Dateistruktur so aus.

• Gehen Sie dann zu App > Manifeste > AndroidManifest.xml
• Fügen Sie diese Zeilen vor dem Block „ Anwendung “ hinzu:

<!--This permits the user to access Camera-->
<uses-permission android:name="android.permission.CAMERA" />
 
<!--This helps to check a specific feature in the phone's hardware,
    here it is OpenGlES version. Sceneform needs OpenGLES Version 3.0 or later-->
<uses-feature android:glEsVersion="0x00030000" android:required="true" />
 
<!--Indicates that this app requires Google Play Services for AR.
    Limits app visibility in the Google Play Store to ARCore supported devices-->
<uses-feature android:name="android.hardware.camera.ar" android:required="true"/>

 Fügen Sie danach diese Zeile vor dem Block „ Aktivität “ hinzu.

<!-- ARCore need to be installed, as the app does not include any non-AR features.
     For an "AR Optional" app, specify "optional" instead of "required".-->
<meta-data android:name="com.google.ar.core" android:value="required" />

 
 Nachfolgend finden Sie den vollständigen Code für die Datei „AndroidManifest.xml “. 

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.wheic.arapp">
 
    <!--This helps to permit the user to access Camera-->
    <uses-permission android:name="android.permission.CAMERA" />
     
    <!--This helps to check a specific feature in the phone's hardware,
        here it is OpenGl ES version 3-->
    <uses-feature
        android:glEsVersion="0x00030000"
        android:required="true" />
 
    <!--Here it is checking for AR feature in phone camera-->
    <uses-feature
        android:name="android.hardware.camera.ar"
        android:required="true" />
     
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.ARApp">
 
        <meta-data
            android:name="com.google.ar.core"
            android:value="required" />
 
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
 
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
 
</manifest>

 
Schritt 4: Fehlerkorrektur

Jetzt kommt ein etwas langweiliger Teil. Die heruntergeladenen Ordner sceneformsrc und sceneformux enthalten einige Java-Dateien, die die Java-Klassen von einem älteren Android.support importieren. Wenn Sie das Projekt jetzt erstellen, werden Sie deshalb viele Fehler sehen. Was Sie jetzt tun können, ist, Ihr Projekt auf das neue Androidx zu migrieren . Jetzt können Sie einen Weg finden, Ihr gesamtes Projekt auf Androidx zu migrieren, oder Sie können die Importe einzeln manuell ändern. Ich weiß, das ist langweilig, aber gute Dinge werden denen, die warten, richtig?

• Gehen Sie zu Erstellen > Projekt neu erstellen
• Sie werden jede Menge Fehler finden. Doppelklicken Sie also unten im Abschnitt „Build“ auf den Paketimportfehler. Es öffnet sich ein Code mit hervorgehobenem Fehlerabschnitt.
• Sie müssen nur drei Arten von Importpfaden ändern, die unten angegeben sind, wenn Sie sehen, dass der erste in den zweiten geändert wird:
  • android.support.annotation. -> androidx.annotation.
  • androidx.core.app -> androidx.fragment.app.
  • android.support.v7.widget. -> androidx.appcompat.widget.

• Sie müssen dies fortsetzen, bis keine Fehler mehr vorhanden sind.

Schritt 5: Arbeiten mit der  Datei activity_main.xml

• Gehen Sie zur Datei res > layout > activity_main.xml .
• Hier ist der Code dieser XML-Datei:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
 
    <!--This is the fragment that will be used as AR camera-->
    <fragment
        android:id="@+id/arCameraArea"
        android:name="com.google.ar.sceneform.ux.ArFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
 
</androidx.constraintlayout.widget.ConstraintLayout>

• ArFragment enthält selbst viele Funktionen, z. B. fordert es Sie auf, ARCore herunterzuladen, wenn es noch nicht auf Ihrem Telefon installiert ist, oder es fragt nach der Kameraerlaubnis, wenn diese noch nicht erteilt wurde. ArFragment ist hier also das Beste, was man verwenden kann.
• Nach dem Schreiben dieses Codes sieht die App-Benutzeroberfläche wie folgt aus:

Schritt 6: Arbeiten mit der MainActivity.java-Datei

• Gehen Sie zu Java > com.wheic.arapp (Ihre kann abweichen) > MainActivity.java
• In der MainActivity-Klasse müssen wir zuerst ein Objekt von ArFragment erstellen.

// object of ArFragment Class
private ArFragment arCam;

• Lassen Sie uns nun eine Hardware-Prüffunktion außerhalb der Funktion onCreate() erstellen . Diese Funktion überprüft, ob die Hardware Ihres Telefons alle systemischen Anforderungen zum Ausführen dieser AR-App erfüllt. Es wird überprüft:
  • Ist die API-Version des laufenden Android >= 24, bedeutet das Android Nougat 7.0
  • Ist die OpenGL-Version >= 3.0
• Diese sind zwingend erforderlich, um AR-Anwendungen mit ARCore und Sceneform auszuführen. Hier ist der Code dieser Funktion:

public static boolean checkSystemSupport(Activity activity) {
 
    // checking whether the API version of the running Android >= 24
      // that means Android Nougat 7.0
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
 
        String openGlVersion = ((ActivityManager) Objects.requireNonNull(activity.getSystemService(Context.ACTIVITY_SERVICE))).getDeviceConfigurationInfo().getGlEsVersion();
 
        // checking whether the OpenGL version >= 3.0
        if (Double.parseDouble(openGlVersion) >= 3.0) {
            return true;
        } else {
            Toast.makeText(activity, "App needs OpenGl Version 3.0 or later", Toast.LENGTH_SHORT).show();
            activity.finish();
            return false;
        }
    } else {
        Toast.makeText(activity, "App does not support required Build Version", Toast.LENGTH_SHORT).show();
        activity.finish();
        return false;
    }
}

• Innerhalb der Funktion onCreate() müssen wir zuerst die Hardware des Telefons überprüfen. Wenn es true zurückgibt, wird der Rest der Funktion ausgeführt.
• Nun wird das ArFragment mit seiner jeweiligen in der activity_main.xml verwendeten ID verknüpft .

// ArFragment is linked up with its respective id used in the activity_main.xml
arCam = (ArFragment) getSupportFragmentManager().findFragmentById(R.id.arCameraArea);

• Ein onTapListener wird aufgerufen, um das 3D-Modell anzuzeigen, wenn wir auf den Bildschirm tippen.
• Innerhalb von setOnTapArPlaneListener wird ein Anchor-Objekt erstellt. Anchor hilft tatsächlich dabei, virtuelle Objekte auf den Bildschirm zu bringen und sie an derselben Position und Ausrichtung im Raum zu halten.
• Jetzt wird eine ModelRenderable-Klasse mit einer Reihe von Funktionen verwendet. Diese Klasse wird verwendet, um das heruntergeladene oder erstellte 3D-Modell zu rendern, indem es an einen AnchorNode angehängt wird.
  • Die Funktion setSource() hilft, die Quelle des 3D-Modells zu erhalten.
  • Die Funktion setIsFilamentGltf() prüft, ob es sich um eine glb-Datei handelt.
  • Die Funktion build() rendert das Modell.
  • Innerhalb der Funktion thenAccept() wird eine Funktion aufgerufen , um das Modell zu erhalten, indem ein AnchorNode mit dem ModelRenderable verknüpft wird.
  • Die Funktion exceptionly() löst eine Ausnahme aus, wenn beim Erstellen des Modells etwas schief geht.

arCam.setOnTapArPlaneListener((hitResult, plane, motionEvent) -> {
    
      clickNo++;
   
    // the 3d model comes to the scene only the first time we tap the screen
    if (clickNo == 1) {
 
        Anchor anchor = hitResult.createAnchor();
        ModelRenderable.builder()
                .setSource(this, R.raw.gfg_gold_text_stand_2)
                .setIsFilamentGltf(true)
                .build()
                .thenAccept(modelRenderable -> addModel(anchor, modelRenderable))
                .exceptionally(throwable -> {
                    AlertDialog.Builder builder = new AlertDialog.Builder(this);
                    builder.setMessage("Something is not right" + throwable.getMessage()).show();
                    return null;
                });
    }
});

• Sehen wir uns nun an, was in der Funktion addModel() enthalten ist:
  • Es benötigt zwei Parameter, der erste ist Anchor und der andere ModelRenderable.
  • Ein AnchorNode- Objekt wird erstellt. Es ist der Wurzelknoten der Szene. AnchorNode wird basierend auf dem Anchor automatisch in der Welt positioniert.
  • TransformableNode hilft dem Benutzer, mit dem 3D-Modell zu interagieren, z. B. Position ändern, Größe ändern, drehen usw.

private void addModel(Anchor anchor, ModelRenderable modelRenderable) {
 
      // Creating a AnchorNode with a specific anchor
    AnchorNode anchorNode = new AnchorNode(anchor);
     
      // attaching the anchorNode with the ArFragment
    anchorNode.setParent(arCam.getArSceneView().getScene());
    TransformableNode transform = new TransformableNode(arCam.getTransformationSystem());
       
      // attaching the anchorNode with the TransformableNode
    transform.setParent(anchorNode);
     
      // attaching the 3d model with the TransformableNode that is
      // already attached with the node
    transform.setRenderable(modelRenderable);
    transform.select();
}

 
Hier ist der vollständige Code der MainActivity.java -Datei. Kommentare werden innerhalb des Codes hinzugefügt, um den Code genauer zu verstehen. 

import android.app.Activity;
import android.app.ActivityManager;
import android.app.AlertDialog;
import android.content.Context;
import android.os.Build;
import android.os.Bundle;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import com.google.ar.core.Anchor;
import com.google.ar.sceneform.AnchorNode;
import com.google.ar.sceneform.rendering.ModelRenderable;
import com.google.ar.sceneform.ux.ArFragment;
import com.google.ar.sceneform.ux.TransformableNode;
import java.util.Objects;
 
public class MainActivity extends AppCompatActivity {
 
    // object of ArFragment Class
    private ArFragment arCam;
 
    // helps to render the 3d model
    // only once when we tap the screen
    private int clickNo = 0;
 
    public static boolean checkSystemSupport(Activity activity) {
 
        // checking whether the API version of the running Android >= 24
        // that means Android Nougat 7.0
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            String openGlVersion = ((ActivityManager) Objects.requireNonNull(activity.getSystemService(Context.ACTIVITY_SERVICE))).getDeviceConfigurationInfo().getGlEsVersion();
 
            // checking whether the OpenGL version >= 3.0
            if (Double.parseDouble(openGlVersion) >= 3.0) {
                return true;
            } else {
                Toast.makeText(activity, "App needs OpenGl Version 3.0 or later", Toast.LENGTH_SHORT).show();
                activity.finish();
                return false;
            }
        } else {
            Toast.makeText(activity, "App does not support required Build Version", Toast.LENGTH_SHORT).show();
            activity.finish();
            return false;
        }
    }
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        if (checkSystemSupport(this)) {
 
            // ArFragment is linked up with its respective id used in the activity_main.xml
            arCam = (ArFragment) getSupportFragmentManager().findFragmentById(R.id.arCameraArea);          
            arCam.setOnTapArPlaneListener((hitResult, plane, motionEvent) -> {
                clickNo++;
                // the 3d model comes to the scene only
                // when clickNo is one that means once
                if (clickNo == 1) {
                    Anchor anchor = hitResult.createAnchor();
                    ModelRenderable.builder()
                            .setSource(this, R.raw.gfg_gold_text_stand_2)
                            .setIsFilamentGltf(true)
                            .build()
                            .thenAccept(modelRenderable -> addModel(anchor, modelRenderable))
                            .exceptionally(throwable -> {
                                AlertDialog.Builder builder = new AlertDialog.Builder(this);
                                builder.setMessage("Something is not right" + throwable.getMessage()).show();
                                return null;
                            });
                }
            });
        } else {
            return;
        }
    }
 
    private void addModel(Anchor anchor, ModelRenderable modelRenderable) {
 
        // Creating a AnchorNode with a specific anchor
        AnchorNode anchorNode = new AnchorNode(anchor);
 
        // attaching the anchorNode with the ArFragment
        anchorNode.setParent(arCam.getArSceneView().getScene());
 
        // attaching the anchorNode with the TransformableNode
        TransformableNode model = new TransformableNode(arCam.getTransformationSystem());
        model.setParent(anchorNode);
 
        // attaching the 3d model with the TransformableNode
        // that is already attached with the node
        model.setRenderable(modelRenderable);
        model.select();
    }
}

 
Ausgabe: Ausführung auf einem physischen Gerät

Schließlich haben wir mit Android Studio eine einfache Augmented-Reality-App erstellt. Sie können dieses Projekt in diesem GitHub- Link überprüfen.