Creeu una aplicació per a Android de realitat augmentada amb Google ARCore

Content

Importació de models 3D, amb el complement Sceneform
Instal·lació del complement Sceneform
Sceneform UX i Java 8: actualització de les dependències del projecte
Sol·licitud de permisos amb ArFragment
AR obligatori o opcional?
1. AR Obligatori
2. AR Opcional
Afegiu ArFragment al vostre disseny
Baixant models en 3D mitjançant Google Poly
Importació de models 3D a Android Studio
Mostra el vostre model 3D
1. Crear una variable de membre ArFragment
2. Creeu un ModelRenderable
3. Respon a l’entrada de l’usuari
4. Ancoren el vostre model
5. Afegiu suport per moure, escalar i girar
MainActivity finalitzada
Prova de l'aplicació de realitat augmentada de Google ARCore
Prova d'ARCore en un dispositiu virtual Android
Embalatge

Importació de models 3D, amb el complement Sceneform

Normalment, treballar amb models 3D requereix coneixements especialitzats, però amb la publicació del complement Sceneform, Google ha permès la reproducció de models 3D mitjançant Java - i sense haver d’aprendre OpenGL.

El complement Sceneform proporciona una API d’alt nivell que podeu utilitzar per crear Renderdables a partir de ginys, formes o materials estàndard d’Android o des d’activitats 3D, com ara fitxers .OBJ o .FBX.

En el nostre projecte, utilitzarem el complement Sceneform per importar un fitxer .OBJ a Android Studio. Sempre que importeu un fitxer mitjançant Sceneform, aquest complement automàticament:

Convertiu el fitxer d’actiu en un fitxer .sfb. Es tracta d’un format binari d’escenografia optimitzat en temps d’execució (.sfb) que s’afegeix al vostre APK i es carrega en temps d’execució. Utilitzarem aquest fitxer .sfb per crear un rendible, que consta de malles, materials i textures i es pot col·locar en qualsevol part de l'escena augmentada.
Genereu un fitxer .sfa. Es tracta d’un fitxer de descripció d’actius, que és un fitxer de text que conté una descripció llegible per part del fitxer .sfb. Segons el model, podeu canviar la seva aparença editant el text dins del fitxer .sfa.

Si us plau, tingueu en compte que en el moment d’escriure, el complement Sceneform encara estava en beta, de manera que podríeu trobar errors, errors o altres comportaments estranys quan utilitzeu aquest plugin.

Instal·lació del complement Sceneform

El complement Sceneform requereix Android Studio 3.1 o superior. Si no esteu segurs quina versió d'Android Studio utilitzeu, seleccioneu "Android Studio> Quant a Android Studio" a la barra d'eines. La finestra emergent següent conté informació bàsica sobre la instal·lació d'Android Studio, inclòs el número de versió.

Per instal·lar el complement Sceneform:

Si sou a un Mac, seleccioneu "Android Studio> Preferències ..." a la barra d'eines d'Android Studio i, a continuació, trieu "Plugins" al menú de l'esquerra. Si us trobeu en un PC de Windows, seleccioneu "Fitxer> Configuració> Complements> Examinar dipòsits."
Cerqueu "Forma d'escena". Quan aparegui "Eines de l'escenari de Google", seleccioneu "Instal·la".
Reinicieu Android Studio quan se us demani i el vostre plugin estarà llest per utilitzar-lo.

Sceneform UX i Java 8: actualització de les dependències del projecte

Comencem per afegir les dependències que utilitzarem durant tot aquest projecte. Obriu el fitxer build.gradle a nivell de mòdul i afegiu la biblioteca Sceneform UX, que conté l’arbitratge que farem servir en el nostre disseny:

dependencies {implement fileTree (dir: libs, include:) implementació androidx.appcompat: appcompat: 1.0.2 implementació androidx.constraintlayout: constraintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1 // Sceneform UX proporciona recursos UX, incloent ArFragment // implementació "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" implementació "com. android.support:appcompat-v7:28.0.0 "}

Sceneform utilitza construccions de llenguatge a partir de Java 8, per la qual cosa també haurem d’actualitzar la compatibilitat de font i la compatibilitat d’orientació del nostre projecte a Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Finalment, hem d'aplicar el complement Sceneform:

apply plugin: com.google.ar.sceneform.plugin

El fitxer build.gradle completat hauria de semblar una cosa així:

apply plugin: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.runner.AndroidJUnitRititors JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled fals proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} dependències {implement fileTree (dir: libs, include:) implementació androidx.appcompat: appcompat: 1.0 .2 implementació androidx.constraintlayout: constraintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1 implementació "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "implementació" com.android.support:appcompat-v7:28.0.0 "} apply plugin: com.google.ar .sceneform.plugin

Sol·licitud de permisos amb ArFragment

La nostra aplicació utilitzarà la càmera del dispositiu per analitzar el seu entorn i posicionar models en 3D al món real. Abans que la nostra aplicació pugui accedir a la càmera, necessita el permís de la càmera, així que obriu el Manifest del vostre projecte i afegiu el següent:

Android 6.0 va permetre als usuaris la possibilitat de concedir, denegar i revocar permisos de manera permís per permís. Si bé això millorava l’experiència d’usuari, els desenvolupadors d’Android ara han de sol·licitar manualment permisos en temps d’execució i gestionar la resposta de l’usuari. La bona notícia és que quan es treballa Google ARCore, el procés de sol·licitar permís de la càmera i de gestionar la resposta de l’usuari s’implementa automàticament.

El component ArFragment comprova automàticament si la vostra aplicació té permís de la càmera i, si es requereix, la sol·licita abans de crear la sessió AR. Com que utilitzarem ArFragment a la nostra aplicació, no cal que escrivim cap codi per sol·licitar el permís de la càmera.

AR obligatori o opcional?

Hi ha dos tipus d'aplicacions que utilitzen la funcionalitat AR:

1. AR Obligatori

Si la vostra aplicació es basa en Google ARCore per oferir una bona experiència d’usuari, haureu d’assegurar-vos que només s’ha baixat en dispositius que admetin ARCore. Si marqueu l'aplicació com a "AR obligatòria", només apareixerà a la botiga de Google Play, si el dispositiu és compatible amb ARCore.

Des de la nostra aplicació ho fa requereix ARCore, obre el manifest i afegeix el següent:

També hi ha la possibilitat que es pugui descarregar la vostra aplicació en un dispositiu que admeti teòricament ARCore, però en realitat no té ARCore instal·lat. Un cop marquem la nostra aplicació com a “AR Obligatori”, Google Play descarregarà i instal·larà ARCore al costat de la seva aplicació, si encara no està present al dispositiu de destinació.

Si us plau, tingueu en compte que, fins i tot si la vostra aplicació és Android: necessària = "true", ho fareu encara heu de comprovar que ARCore estigui present en temps d'execució, ja que és possible que l'usuari hagi desinstal·lat ARCore des que ha baixat l'aplicació o que la seva versió de ARCore no sigui actualitzada.

La bona notícia és que estem utilitzant ArFragment, que comprova automàticament si ARCore està instal·lat i actualitzat abans de crear cadascun Sessió d’AR - així que una vegada més, això no hem de implementar manualment.

2. AR Opcional

Si la vostra aplicació inclou funcions d'AR que són agradables, però que no són essencials per proporcionar la seva funcionalitat principal, podeu marcar aquesta aplicació com a "Op Opcional". La vostra aplicació pot comprovar si Google ARCore està present en temps d'execució i desactivar-ne Funcions AR en dispositius que no admeten ARCore.

Si creeu una aplicació "AR Opcional", ARCore ho farà no s’instal·li automàticament al costat de l’aplicació, fins i tot si el dispositiu disposa de tot el maquinari i el programari necessaris per suportar ARCore. L'aplicació "Op Opcional" AR haurà de comprovar si ARCore està actual i actualitzat i descarregar-ne la versió més recent segons quan sigui necessari.

Si ARCore no és crucial per a la vostra aplicació, podeu afegir el següent al manifest:

Mentre tinc obert el Manifest, també afegeixo Android: configChanges i Android: screenOrientation, per garantir que MainActivity gestiona els canvis d'orientació amb gràcia.

Després d’afegir tot això al manifest, el fitxer completat hauria d’assemblar-se a això:

Afegiu ArFragment al vostre disseny

Faré servir ArFragment d’ARCore, ja que gestiona automàticament diverses tasques clau d’ARCore al començament de cada sessió d’AR. Sobretot, ArFragment comprova que hi hagi instal·lada una versió compatible d’ARCore al dispositiu i que l’aplicació disposi actualment del permís de la càmera.

Un cop ArFragment ha comprovat que el dispositiu pot donar suport a les funcions AR de la vostra aplicació, crea una sessió ArSceneView ARCore i ja està a punt per començar l'experiència AR de l'aplicació.

Podeu afegir el fragment ArFragment a un fitxer de disseny, tal com un Fragment normal d'Android, de manera que obriu el fitxer Activity_main.xml i afegiu un component "com.google.ar.sceneform.ux.ArFragment".

Baixant models en 3D mitjançant Google Poly

Hi ha diverses maneres de crear rendibilitats diferents, però en aquest article utilitzarem un fitxer d’actius en 3D.

Sceneform és compatible amb els recursos 3D en formats .OBJ, .glTF i .FBX, amb o sense animacions. Hi ha un munt de llocs on podeu adquirir models 3D en un d'aquests formats compatibles, però en aquest tutorial utilitzaré un fitxer .OBJ, descarregat del dipòsit Poly de Google.

Dirigiu-vos al lloc web de Poly i descarregueu l’actiu que voleu utilitzar en format .OBJ (faig servir aquest model T-Rex).

Descomprimeu la carpeta, que hauria de contenir el fitxer d’actiu font del vostre model (.OBJ, .FBX o .glTF). Depenent del model, aquesta carpeta també pot contenir algunes dependències del model, com ara fitxers en els formats .mtl, .bin, .png o .jpeg.

Importació de models 3D a Android Studio

Un cop tingueu el vostre recurs, heu d’importar-lo a Android Studio mitjançant el complement Sceneform. Aquest és un procés de diversos passos que requereix que:

Creeu una carpeta "mostrejada". Sampledata és un nou tipus de carpeta per a les dades d’exemple de temps de disseny que no s’inclouran a l’APK, però estaran disponibles a l’editor d’Android Studio.
Arrossegueu i deixeu anar el fitxer d’actius .OBJ original a la vostra carpeta “sampledata”.
Realitzeu la importació i la conversió de Sceneform al fitxer .OBJ, que generarà els fitxers .sfa i .sfb.

Tot i que pugui semblar més senzill, no arrossegueu i deixeu anar el fitxer .OBJ directament al directori "res" del vostre projecte, ja que això inclourà el model a la vostra APK innecessàriament.

Els projectes d'Android Studio no contenen una carpeta "mostrejada" de manera predeterminada, així que haureu de crear-ne una de forma manual:

Feu clic amb el botó de control a la carpeta "aplicació" del vostre projecte.
Seleccioneu "Nou> Directori de dades d'exemple" i creeu una carpeta anomenada "Sampleata".
Desplaceu-vos als fitxers de models 3D que vau descarregar anteriorment. Cerqueu el fitxer d'actiu d'origen (.OBJ, .FBX o .glTF) i arrossegueu-lo al directori "Sampleata".
Comproveu si el vostre model té dependències (com ara fitxers als formats .mtl, .bin, .png o .jpeg). Si trobeu algun d'aquests fitxers, arrossegueu-los i deixeu-los anar a la carpeta "mostrejada".
A Android Studio, feu clic a Control sobre el fitxer font del model 3D (.OBJ, .FBX o .glTF) i, a continuació, seleccioneu "Importa actiu de l'escenari".

A la finestra següent es mostra informació sobre els fitxers que Sceneform generarà, inclòs on es guardarà el fitxer .sfa resultant al vostre projecte; Utilitzaré el directori "en brut".
Quan estigueu satisfet amb la informació que heu introduït, feu clic a "Finalitza".

Aquesta importació fa uns quants canvis al vostre projecte. Si obriu el fitxer build.gradle, veureu que s'ha afegit el complement Sceneform com a dependència del projecte:

dependències {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // NOTA: No col·loqueu les dependències de l'aplicació aquí; pertanyen al fitxer individual del mòdul build.gradle}}

Obriu el fitxer build.gradle a nivell de mòdul i trobareu una nova entrada de sceneform.asset () per al vostre model 3D importat:

apply plugin: com.google.ar.sceneform.plugin // El "camí d'accés font" que vau especificar durant la importació // sceneform.asset (sampledata / dinosaur.obj, // La "ruta de material" que vau especificar durant la importació // predeterminat , // El "camí de sortida .sfa" que vau especificar durant la importació // sampledata / dinosaur.sfa, // El "camí de sortida .sfb" que vau especificar durant la importació // src / main / assets / dinosaure)

Si mireu les carpetes "mostrejades" i "en brut", veureu que conté fitxers .sfa i .sfb nous, respectivament.

Podeu veure una vista prèvia del fitxer .sfa al nou visor d'escenaform d'Android Studio:

Seleccioneu "Veure> Eines Windows> Visualitzador" a la barra de menús d'Android Studio.
Al menú de l’esquerra, seleccioneu el vostre fitxer .sfa. Ara el vostre model 3D hauria d'aparèixer a la finestra del visualitzador.

Mostra el vostre model 3D

La nostra següent tasca és crear una sessió d’AR que entengui el seu entorn i que permeti a l’usuari col·locar models 3D en una escena augmentada.

Això requereix que fem el següent:

1. Crear una variable de membre ArFragment

ArFragment realitza gran part de la càrrega pesada que implica la creació d’una sessió d’AR, per la qual cosa farem referència a aquest fragment a tota la nostra classe MainActivity.

Al fragment següent, creo una variable de membre per a ArFragment i després la inicialitzo al mètode onCreate ():

ArFragment privat arCoreFragment; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Busqueu el fragment amb el gestor de fragments // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Creeu un ModelRenderable

Ara hem de transformar el nostre fitxer .sfb en un ModelRenderable, que acabarà sent el nostre objecte 3D.

Aquí, creo un ModelRenderable del fitxer .sfb de res / raw / dinosaure del meu projecte:

Model privat: dino rendible; ... ... ... ModelRenderable.builder () .setSource (això, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .excepcionalment (llançable -> {Log.e ( TAG, "No es pot carregar rendible"); retorn nul;}); }

3. Respon a l’entrada de l’usuari

ArFragment té un suport integrat per a gestions de toc, arrossegament, pessig i retorçament.

A la nostra aplicació, l'usuari afegirà un model 3D a un avió ARCore, donant-li un toc a aquest pla.

Per lliurar aquesta funcionalitat, hem de registrar una devolució de trucada que s'invocarà sempre que es toqui un avió:

arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;}

4. Ancoren el vostre model

En aquest pas, recuperarem un ArSceneView i l’adjuntarem a un AnchorNode, que servirà com a node pare de l’escena.

ArSceneView s’encarrega de realitzar diverses tasques importants d’ARCore, com ara la representació d’imatges de càmera del dispositiu i la visualització d’una animació Sceneform UX que demostra com l’usuari hauria de mantenir i moure el dispositiu per iniciar l’experiència AR. L’ArSceneView també ressaltarà els avions que detecti, a punt per a l’usuari per situar els seus models 3D dins de l’escena.

El component ARSceneView té una escena adjunta a ella, que és una estructura de dades parent-fill que conté tots els nodes que cal presentar.

Començarem per crear un node de tipus AnchorNode, que actuarà com a node pare de la nostra ArSceneView.

Tots els nodes d'ancoratge es mantenen en la mateixa posició del món real, de manera que creant un node d'ancoratge ens assegurem que els nostres models 3D es mantindran fixats dins de l'escena augmentada.

Creem el nostre node d'ancoratge:

AnchorNode anchorNode = nou AnchorNode (àncora);

Aleshores podem recuperar un ArSceneView, utilitzant getArSceneView (), i adjuntar-lo al AnchorNode:

anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ());

5. Afegiu suport per moure, escalar i girar

A continuació, crearé un node del tipus TransformableNode. El TransformableNode s’encarrega de moure, escalar i girar nodes basats en els gestos de l’usuari.

Un cop hàgiu creat un TransformableNode, podeu afegir-hi el Renderable, que permetrà al model escalar i desplaçar-se en funció de la interacció dels usuaris. Finalment, heu de connectar el TransformableNode a l'AnchorNode, en una relació fill-progenitor que asseguri el TransformableNode i La rendibilitat roman en el seu lloc dins de l'escena augmentada.

TransformableNode transformableNode = nou TransformableNode (arCoreFragment.getTransformationSystem ()); // Connectar transformableNode a anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Seleccioneu el node // transformableNode.select (); }); }

MainActivity finalitzada

Després d’executar tot allò que es menciona anteriorment, el vostre MainActivity hauria d’assemblar a una cosa així:

importa android.app.Activitat; importa android.app.ActivityManager; importar androidx.appcompat.app.AppCompatActivity; importa android.content.Context; importa android.net.Uri; importa android.os.Build; importa android.os.Build.VERSION_CODES; importa android.os.Bundle; importa android.util.Log; importa android.view.MotionEvent; importa androidx.annotation.RequiresApi; importa com.google.ar.core.Anchor; import com.google.ar.core.HitResult; importa com.google.ar.core.Plane; 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; public class MainActivity s'estén AppCompatActivity {private static final String TAG = MainActivity.class.getSimpleName (); doble estàtic privat privat MIN_OPENGL_VERSION = 3,0; // Crea una variable de membre per ModelRenderable // private ModelRenderable dinoRenderable; // Crea una variable de membre per a ArFragment // privat ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override protected void onCreate (paquet salvatInstanceState) {super.onCreate (guardatInstanceState); if (! checkDevice ((this))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Trobeu el fragment, fent servir el gestor de fragments // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Construir el ModelRenderable // ModelRenderable.builder () .setSource (això, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable ). excepcionalment (// Si es produeix un error ... // llançable -> {//...then imprimeix el següent a Logcat // Log.e (TAG, "No es pot carregar rendible"); torna nul;} ); } // Escolteu esdeveniments onTap // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Ancora anker = hitResult.createAnchor (); // Build a node del tipus AnchorNode // AnchorNode anchorNode = nou AnchorNode (àncora); // Connecta el AnchorNode a l'escena // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Construeix un node del tipus TransformableNode // TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Connecta el TransformableNode al AnchorNode // transformableNode.setParent (anchorNode); // Adjunta el Renderable // transformableNode.setRenderable (dinoRenderable); // Configura el node / / transformableNode.select ();}); } public static boolean checkDevice (activitat final de l'activitat) {// Si el dispositiu funciona amb Android Marshmallow o anterior ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//... expandir el següent a Logcat // Log.e (TAG, "La forma d'escena requereix Android N o superior"); activitat.finish (); tornar fals; } String openGlVersionString = ((ActivityManager) Activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Comprova la versió d'OpenGL ES // .getGlEsVersion (); // Si el dispositiu funciona amb menys de OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//... expandir el següent a Logcat // Log.e (TAG, " Requereix OpenGL ES 3.0 o superior "); activitat.finish (); tornar fals; } tornar veritable; }}

Podeu descarregar el projecte completat de GitHub.

Prova de l'aplicació de realitat augmentada de Google ARCore

Ja esteu preparats per provar la vostra aplicació en un dispositiu Android amb suport físic. Si no disposeu d’un dispositiu que admet ARCore, és possible provar la vostra aplicació AR a l’emulador d’Android (amb una mica de configuració addicional, que veurem a la següent secció).

Per provar el vostre projecte a físic Dispositiu Android:

Instal·leu la vostra aplicació al dispositiu de destinació.
Quan se us demani, concediu l’aplicació accés a la càmera del dispositiu.
Si se us demana instal·lar o actualitzar l’aplicació ARCore, toqueu “Continuar” i després completeu el diàleg per assegurar-vos que esteu executant la versió més recent i més gran d’ARCore.
Ara haureu de veure una vista de la càmera, completa amb una animació d'una mà que sosté un dispositiu. Assenyaleu la càmera cap a una superfície plana i moveu el dispositiu en un moviment circular, tal com demostra l’animació. Al cap d’uns moments, haurien d’aparèixer una sèrie de punts que indiquen que s’ha detectat un avió.

Un cop estàs satisfet amb la posició d’aquests punts, fes-los un toc: el model 3D ara hauria d’aparèixer al pla escollit.

Intenta moure's físicament pel model; depenent del vostre entorn, potser podreu fer els 360 graus al seu voltant. També heu de comprovar que l'objecte està llançant una ombra d'acord amb les fonts de llum del món real.

Prova d'ARCore en un dispositiu virtual Android

Per provar les vostres aplicacions ARCore en un dispositiu virtual d’Android (AVD), haureu de tenir la versió 27.2.9 o superior de l’Emulador d’Android. També heu d’iniciar la sessió a la botiga de Google Play al vostre AVD i tenir habilitat OpenGL ES 3.0 o superior.

Per comprovar si OpenGL ES 3.0 o superior està activat actualment a l’AVD:

Llanceu el vostre AVD, de forma normal.
Obriu una nova finestra del terminal (Mac) o una finestra de comanda (Windows).
Canvieu el directori ("cd") de manera que el Sol·licitud Terminal / Command indica que es troba a la ubicació del programa "adb" del vostre SDK d'Android, per exemple, la meva comanda sembla:

Cd / Users / jessicathornsby / Library / Android / sdk / platform-tools

Premeu la tecla "Enter" del teclat.
Copieu / enganxeu la següent comanda al Terminal i, a continuació, premeu la tecla "Enter":

./adb logcat | grep eglMakeCurrent

Si el terminal retorna "ver 3 0" o superior, llavors OpenGL ES està configurat correctament. Si el símbol del terminal o del comandament mostra qualsevol cosa anterior a 3.0, haureu d’activar OpenGL ES 3.0:

Torneu a la vostra AVD.
Cerqueu la llista de botons de “control ampliat” que floten al costat de l’emulador d’Android i, a continuació, seleccioneu “Configuració> Avançada”.
Vés a "Nivell API de OpenGL ES> Representació màxima (fins a OpenGL ES 3.1)."
Reinicieu l'emulador.

A la finestra de sol·licitud de Terminal / Command, copieu / enganxeu la següent comanda i després premeu la tecla "Enter".

./adb logcat | grep eglMakeCurrent

Ara hauríeu d’obtenir un resultat de “ver 3 0” o superior, cosa que significa que OpenGL ES està configurat correctament.

Finalment, assegureu-vos que el vostre AVD estigui executant l’última versió d’ARCore:

Dirigiu-vos a la pàgina GitHub de ARCore i descarregueu l'última versió de ARCore per a l'emulador. Per exemple, en el moment d’escriure la versió més recent va ser "ARCore_1.7.0.x86_for_emulator.apk"
Arrossegueu i deixeu anar l’APK al vostre AVD en execució.

Per provar el vostre projecte en un AVD, instal·leu l'aplicació i concediu-li accés a la "càmera" de l'AVD quan se us demani.

Ara hauríeu de veure una vista de la càmera d’una habitació simulada. Per provar la vostra aplicació, moveu-vos per aquest espai virtual, cerqueu una superfície plana simulada i feu clic per col·locar un model en aquesta superfície.

Podeu moure la càmera virtual per la sala virtual, mantenint pressionades les tecles "Opció" (macOS) o "Alt" (Linux o Windows) i, seguidament, utilitzant qualsevol de les dreceres de teclat següents:

Mou a l’esquerra o a la dreta. Premeu A o D.
Desplaceu-vos cap avall o cap amunt. Premeu Q o E.
Avança o retrocedeix. Premeu W o S.

També es pot "moure" per l'escena virtual, prement "Opció" o "Alt" i després amb el ratolí. Al principi, això pot tenir una mica de malestar, però amb la pràctica hauríeu de poder explorar amb èxit l’espai virtual. Un cop trobeu un pla simulat, feu clic als punts blancs per situar el model 3D en aquesta superfície.

Embalatge

En aquest article, hem creat una aplicació de realitat augmentada simple, utilitzant ARCore i el complement Sceneform.

Si decidiu utilitzar Google ARCore en els vostres propis projectes, no deixeu de compartir les vostres creacions als comentaris següents.