Készítsen kibővített valóságú Android alkalmazást a Google ARCore segítségével

Tartalom

3D modellek importálása, a Sceneform bővítménnyel
A Sceneform plugin telepítése
Sceneform UX és Java 8: A projektfüggőségek frissítése
Engedélyek kérése az ArFragment segítségével
AR kötelező vagy opcionális?
1. AR szükséges
2. AR opcionális
Adja hozzá az ArFragment az elrendezéshez
3D modellek letöltése a Google Poly segítségével
3D modellek importálása az Android Studio alkalmazásba
Mutassa meg 3D modelljét
1. Hozzon létre egy ArFragment tagváltozót
2. Készítsen egy ModelRenderable-t
3. Válasz a felhasználói beadásra
4. Rögzítse a modelljét
5. Adjon hozzá támogatást a mozgatáshoz, méretezéshez és forgatáshoz
A teljes MainActivity
A Google ARCore kibővített valóság alkalmazásának tesztelése
Az ARCore tesztelése egy Android virtuális eszközön
Csomagolás

3D modellek importálása, a Sceneform bővítménnyel

A 3D modellekkel való munka általában speciális ismereteket igényel, de a Sceneform plugin kiadásával a Google lehetővé tette a 3D modellek Java - és nélkül meg kell tanulniuk az OpenGL-t.

A Sceneform beépülő modul egy magas szintű API-t biztosít, amely segítségével Renderdables-t hozhat létre szokásos Android-kütyüből, formákból vagy anyagokból, vagy 3D-s eszközökből, például .OBJ vagy .FBX fájlokból.

Projektünkben a Sceneform beépülő modult fogjuk használni .OBJ fájl importálásához az Android Studio alkalmazásba. Amikor egy fájlt a Sceneform használatával importál, ez a bővítmény automatikusan:

Konvertálja az eszközfájlt .sfb fájlba. Ez egy futásidejűre optimalizált Sceneform bináris formátum (.sfb), amelyet hozzáadtak az APK-hez, majd betöltötted futási időben. Ezt az .sfb fájlt fogjuk használni egy Renderable létrehozásához, amely hálóból, anyagból és textúrából áll, és bárhová elhelyezhető a kibővített jelenetben.
Generáljon .sfa fájlt. Ez egy eszközleíró fájl, amely egy szöveges fájl, amely az .sfb fájl emberi olvasható leírását tartalmazza. A típustól függően előfordulhat, hogy megváltoztatja annak megjelenését a .sfa fájlban található szöveg szerkesztésével.

Ne feledje, hogy az írás idején a Sceneform plugin még mindig bétaverzióban volt, így hibákat, hibákat vagy egyéb furcsa viselkedéseket tapasztalhat a plugin használatakor.

A Sceneform plugin telepítése

A Sceneform bővítményhez Android Studio 3.1 vagy újabb szükséges. Ha nem biztos benne, hogy az Android Studio melyik verzióját használja, válassza az Eszköztár „Android Studio> Az Android Studio névjegye” menüpontját. A következő felugró ablak néhány alapvető információt tartalmaz az Android Studio telepítéséről, beleértve annak verziószámát.

A Sceneform plugin telepítése:

Ha Mac számítógépen dolgozik, válassza az „Android Studio> Beállítások…” lehetőséget az Android Studio eszköztáron, majd válassza a bal oldali menü „Plugins” menüpontját. Ha Windows PC-n van, válassza a „Fájl> Beállítások> Bővítmények> Böngészés az adattárakban lehetőséget.”
Keressen a „Sceneform” kifejezésre. Amikor megjelenik a „Google Sceneform Tools”, válassza az „Install” lehetőséget.
Indítsa újra az Android Studio alkalmazást, amikor a rendszer erre kéri, és a bővítmény készen áll a használatra.

Sceneform UX és Java 8: A projektfüggőségek frissítése

Kezdjük azzal, hogy hozzáadjuk azokat a függőségeket, amelyeket a projekt során felhasználunk. Nyissa meg a modulszintű build.gradle fájlt, és adja hozzá a Sceneform UX könyvtárat, amely tartalmazza az ArFragment-et, amelyet elrendezésünkben használunk:

függőségek {végrehajtási fájlTree (könyv: libs, tartalmaz:) implementáció androidx.appcompat: appcompat: 1.0.2 implementáció androidx.constraintlayout: kényszerlejátszás: 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 // A Sceneform UX UX erőforrásokat biztosít, beleértve az ArFragment // megvalósítást. "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" implementáció "com. android.support:appcompat-v7:28.0.0 "}

A Sceneform a Java 8 nyelvi konstrukcióit használja, ezért frissítenünk kell a projekt forráskompatibilitását és cél-kompatibilitását a Java 8-ra is:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Végül alkalmaznunk kell a Sceneform bővítményt:

alkalmazza a bővítményt: com.google.ar.sceneform.plugin

A kitöltött build.gradle fájlnak így kell kinéznie:

plugin alkalmazása: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.ReserverCommissionNeaveRecionalsAndroidJunnerAndroidJerstionAndroidJunnersApps JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} függőségek {implementation fileTree (dir: libs, include:) implementáció androidx.appcompat: appcompatpat: appcompatpat .2 végrehajtás androidx.constraintlayout: kényszerleadás: 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 implementation "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "implementáció" com.android.support:appcompat-v7:28.0.0 "} plugin alkalmazása: com.google.ar .sceneform.plugin

Engedélyek kérése az ArFragment segítségével

Alkalmazásunk az eszköz kameráját használja a környezetének elemzésére és a 3D modellek pozícionálására a valós világban. Mielőtt alkalmazásunk hozzáférhet a kamerához, szüksége van a kamera engedélyére, ezért nyissa meg a projekt manifesztumát, és adja hozzá a következőket:

Az Android 6.0 lehetőséget adott a felhasználók számára engedélyek megadására, megtagadására és visszavonására engedélyek alapján. Míg ez javította a felhasználói élményt, az Android fejlesztőknek manuálisan kell engedélyeket kérniük futási időben, és kezelniük kell a felhasználó válaszát. A jó hír az, hogy amikor a Google ARCore működik, végrehajtásra kerül a kamera engedélyének kérésére és a felhasználó válaszának kezelésére szolgáló eljárás. automatikusan.

Az ArFragment összetevő automatikusan ellenőrzi, hogy az alkalmazás rendelkezik-e a kamera engedélyével, majd kéri, ha szükséges, az AR-munkamenet létrehozása előtt. Mivel az ArFragment alkalmazást fogjuk használni alkalmazásunkban, nem kell írnunk semmilyen kódot a kamera engedélyének kéréséhez.

AR kötelező vagy opcionális?

Kétféle alkalmazás használható AR funkcióval:

1. AR szükséges

Ha az alkalmazás a Google ARCore-ra támaszkodik a jó felhasználói élmény biztosítása érdekében, akkor ellenőriznie kell, hogy azt csak az ARCore-t támogató eszközökre töltik-e le. Ha az alkalmazást „AR szükséges” jelöli, akkor csak akkor jelenik meg a Google Play Áruházban, ha az eszköz támogatja az ARCore-t.

Mióta a mi alkalmazás csinál igényelnie kell az ARCore-t, nyissa meg a Manifestot és adja hozzá a következőket:

Van is esély arra, hogy alkalmazásod letölthető egy eszközre, amely elméletileg támogatja az ARCore-t, de valójában nincs telepítve az ARCore-ra. Ha egyszer megjelöljük alkalmazásunkat „AR szükséges”, akkor a Google Play automatikusan letölti és telepíti az ARCore-t az alkalmazásához, ha még nem létezik a cél eszközön.

Ne feledje, hogy még akkor is, ha az alkalmazás android: required = ”true”, akkor meg fogod jelenni még mindig ellenőriznie kell, hogy van-e az ARCore futásidejű, mivel előfordulhat, hogy a felhasználó az alkalmazás letöltése óta eltávolította az ARCore-t, vagy hogy az ARCore verziója elavult.

A jó hír az, hogy ArFragment alkalmazunk, amely automatikusan ellenőrzi, hogy az ARCore telepítve van-e és naprakész-e minden egyes AR-munkamenet - tehát ismét, ezt nem kell manuálisan végrehajtanunk.

2. AR opcionális

Ha az alkalmazás olyan AR funkciókat tartalmaz, amelyek kedvezőek, de nem nélkülözhetetlenek az alapvető funkciók biztosításához, akkor ezt az alkalmazást „AR opcionálisnak” megjelölheti. Az alkalmazás ellenőrizheti, hogy a Google ARCore jelen van-e a futásidejű funkcióban, és letilthatja Az AR funkciói olyan eszközökön, amelyek nem támogatják az ARCore-t.

Ha létrehoz egy „AR opcionális” alkalmazást, akkor az ARCore megteszi nem automatikusan telepítve lesz az alkalmazás mellett, még akkor is, ha az eszköz rendelkezik az ARCore támogatásához szükséges összes hardverrel és szoftverrel. Ezután az „AR Opcionális” alkalmazásnak ellenőriznie kell, hogy az ARCore van-e és naprakész-e, és szükség szerint le kell töltenie a legújabb verziót.

Ha az ARCore nem döntő jelentőségű az Ön alkalmazásában, akkor a következőt adhatja hozzá a manifeszthez:

Amíg a Manifest nyitva van, hozzáteszem az android: configChanges és android: screenOrientation funkciót is, hogy a MainActivity az orientációs változásokat kecsesen kezeli.

Miután ezt hozzáadta a manifeszthez, a kész fájlnak így kellene kinéznie:

Adja hozzá az ArFragment az elrendezéshez

Az ARCore ArFragmentjét fogom használni, mivel az automatikusan számos kulcsfontosságú ARCore feladatot kezeli minden AR munkamenet kezdetén. Nevezetesen az ArFragment ellenőrzi, hogy az ARCore kompatibilis verziója telepítve van-e az eszközön, és hogy az alkalmazásnak jelenleg van-e a kamera engedélye.

Miután az ArFragment meggyőződött arról, hogy az eszköz támogatja az alkalmazás AR funkcióit, létrehoz egy ArSceneView ARCore munkamenetet, és az alkalmazás AR tapasztalata készen áll a használatra!

Az ArFragment fragmenst hozzáadhatja az elrendezési fájlhoz, akárcsak a szokásos Android töredék, tehát nyissa meg a activity_main.xml fájlt, és adjon hozzá egy „com.google.ar.sceneform.ux.ArFragment” összetevőt.

3D modellek letöltése a Google Poly segítségével

Számosféle módon hozhat létre Megújíthatók, de ebben a cikkben egy 3D-s eszközfájlt fogunk használni.

A Sceneform támogatja a 3D eszközöket .OBJ, .glTF és .FBX formátumban, animációkkal vagy anélkül. Rengeteg hely található, ahol 3D modelleket szerezhet be a támogatott formátumok egyikében, de ebben az oktatóanyagban egy .OBJ fájlt fogok használni, amelyet letöltöttek a Google Poly tárolójából.

Menjen tovább a Poly webhelyre, és töltse le a használni kívánt eszközt .OBJ formátumban (ezt a T-Rex modellt használom).

Csomagolja ki a mappát, amelynek tartalmaznia kell a modell forráseszközfájlját (.OBJ, .FBX vagy .glTF). A típustól függően ez a mappa tartalmazhat bizonyos modellfüggőségeket is, például .mtl, .bin, .png vagy .jpeg formátumú fájlokat.

3D modellek importálása az Android Studio alkalmazásba

Miután megszerezte eszközét, importálnia kell azt az Android Studio alkalmazásba a Sceneform plugin segítségével. Ez egy többlépcsős folyamat, amely megköveteli a következőket:

Hozzon létre egy „minta adat” mappát. A Sampledata egy új mappatípus a tervezési időadatokhoz, amelyek nem kerülnek fel az APK-ba, de elérhetőek lesznek az Android Studio szerkesztőben.
Húzza az eredeti .OBJ eszközfájlt a „mintaadatok” mappába.
Végezze el a Sceneform importálását és átalakítását az .OBJ fájlon, amely az .sfa és .sfb fájlokat generálja.

Bár egyszerűbbnek tűnik, nem húzza át és dobja be az .OBJ fájlt közvetlenül a projekt „res” könyvtárába, mivel ez szükségtelenül a modell beillesztését az APK-ba.

Az Android Studio projektek alapértelmezés szerint nem tartalmaznak „minta adatok” mappát, ezért manuálisan kell létrehoznia:

Kattintson a vezérlőgombra a projekt „app” mappájára.
Válassza az „Új> Mintaadatbázis” lehetőséget, és hozzon létre egy „mintaadat” nevű mappát.
Keresse meg a korábban letöltött 3D-modell fájlokat. Keresse meg a forrás eszközfájlt (.OBJ, .FBX vagy .glTF), majd húzza le és dobja be a „mintaadatok” könyvtárba.
Ellenőrizze, hogy a modell rendelkezik-e függőségekkel (például .mtl, .bin, .png vagy .jpeg formátumú fájlok). Ha talál ilyen fájlokat, húzza át őket a „minta adatok” mappába.
Az Android Stúdióban kattintson a Vezérlőgombra a 3D modell forrásfájljára (.OBJ, .FBX vagy .glTF), majd válassza az „Sceneform Asset importálása” lehetőséget.

A következő ablak néhány információt jelenít meg a Sceneform által létrehozott fájlokról, ideértve azt is, hogy a kapott .sfa fájlt miként tárolják a projektben; A „nyers” könyvtárat fogom használni.
Ha elégedett a bevitt információkkal, kattintson a „Befejezés” gombra.

Ez az import néhány változtatást hajt végre a projektben. Ha megnyitja a build.gradle fájlt, akkor látni fogja, hogy a Sceneform plugin hozzáadásra került projektfüggőségként:

függőségek {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // MEGJEGYZÉS: Ne tegye ide az alkalmazásfüggőségeket; tartoznak // az egyes build.gradle fájlok moduljában}}}

Nyissa meg a modulszintű build.gradle fájlt, és meg fog találni egy új sceneform.asset () bejegyzést az importált 3D-s modellhez:

plugin alkalmazása: com.google.ar.sceneform.plugin // Az importálás során megadott „Forrás eszköz elérési út” // sceneform.asset (sampledata / dinosaur.obj, // Az importálás során megadott „Anyag út” // Alapértelmezés) , // Az importálás során megadott „.sfa kimeneti út” // mintadata / dinosaur.sfa, // az „.sfb kimeneti útvonal”, amelyet az importálás során határozott meg // src / main / eszközök / dinoszaurusz)

Ha megnézi a „mintaadatok” és a „nyers” mappákat, akkor látni fogja, hogy azok új .sfa és .sfb fájlokat tartalmaznak.

A .sfa fájlt előnézetben megtekintheti az Android Studio új Sceneform Viewer alkalmazásában:

Az Android Studio menüsorában válassza a „Nézet> Windows eszközök> Viewer” lehetőséget.
A bal oldali menüben válassza ki a .sfa fájlt. A 3D modelljének most meg kell jelennie a Viewer ablakban.

Mutassa meg 3D modelljét

Következő feladatunk egy AR-munkamenet létrehozása, amely megérti a környezetét, és lehetővé teszi a felhasználó számára, hogy 3D modelleket kibővített jelenetbe helyezhessen.

Ehhez a következőket kell tennünk:

1. Hozzon létre egy ArFragment tagváltozót

Az ArFragment végrehajtja az AR-munkamenet létrehozásában részt vevő nehéz feladatok nagy részét, tehát ezt a fragmenst a MainActivity osztályunkban hivatkozni fogjuk.

A következő részben létrehozom egy tagváltozót az ArFragment számára, majd inicializálom az onCreate () módszerrel:

magán ArFragment arCoreFragment; @ Felülírja a védett érvénytelen onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Keresse meg a fragmentumot a fragment manager segítségével // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Készítsen egy ModelRenderable-t

Most átalakítanunk kell az .sfb fájlt ModelRenderable-ké, amely végül 3D objektummá válik.

Itt modelleket hozok létre a projekt res / raw / dinosaur .sfb fájljából:

privát ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (ez, R.raw.dinosaur) .build () .thenAccept (megjeleníthető -> dinoRenderable = renderelhető). Kivételesen (dobható -> {Log.e ( TAG, "Nem lehet betölteni olvasható"); null visszatér;}); }

3. Válasz a felhasználói beadásra

Az ArFragment beépített támogatással rendelkezik a tapintás, húzás, szorítás és csavarás mozdulatokhoz.

Alkalmazásunkban a felhasználó hozzáad egy 3D-s modellt az ARCore Plane-hez, ha csapot ad erre a síkra.

Ennek a funkciónak a teljesítéséhez regisztrálnunk kell egy visszahívást, amelyet minden repülőgép megérintésekor meghívunk:

arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Sík sík, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;}

4. Rögzítse a modelljét

Ebben a lépésben lekérjük az ArSceneView-t, és csatoljuk egy AnchorNode-hoz, amely a Jelenet szülőcsomópontjaként szolgál.

Az ArSceneView felelős számos fontos ARCore feladat elvégzéséért, beleértve az eszköz kameraképeinek megjelenítését és egy Sceneform UX animáció megjelenítését, amely bemutatja, hogy a felhasználónak miként kell tartania és mozgatnia készülékét az AR élmény elindításához. Az ArSceneView kiemel minden olyan síkot, amelyet észlelt, készen arra, hogy a felhasználó 3D-s modelljeit a jelenetbe helyezze.

Az ARSceneView összetevőhez csatolva van egy Jelenet, amely egy szülő-gyermek adatstruktúra, amely tartalmazza az összes megjelenítendő csomópontot.

Először AnchorNode típusú csomópontot fogunk létrehozni, amely az ArSceneView szülőcsomópontjaként fog működni.

Az összes horgonycsomópont azonos valós helyzetben marad, tehát egy horgonycsomópont létrehozásával biztosítjuk, hogy 3D-s modelljeink rögzített helyzetben maradjanak a kibővített jelenetben.

Hozzuk létre a horgonycsomópontot:

AnchorNode anchorNode = új AnchorNode (horgony);

Ezután lekérhetjük az ArSceneView fájlt a getArSceneView () használatával, és csatolhatjuk az AnchorNode-hoz:

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

5. Adjon hozzá támogatást a mozgatáshoz, méretezéshez és forgatáshoz

Ezután létrehozom a TransformableNode típusú csomópontot. A TransformableNode felelős a csomópontok mozgatásáért, méretezéséért és forgatásáért, a felhasználói gesztusok alapján.

Miután létrehozta a TransformableNode elemet, csatolhatja azt az Renderable-hez, amely a felhasználó interakciója alapján a modell számára lehetővé teszi a méretezést és a mozgatást. Végül csatlakoztatnia kell a TransformableNode-ot az AnchorNode-hoz, egy gyermek-szülő kapcsolatban, amely biztosítja a TransformableNode-ot és Az eldobható marad a helyén a kibővített jelenetben.

TransformableNode transformableNode = új TransformableNode (arCoreFragment.getTransformationSystem ()); // Csatlakoztassa a transformableNode elemet az anchorNode elemhez // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Válassza ki a csomópontot // transformableNode.select (); }); }

A teljes MainActivity

A fenti műveletek elvégzése után a MainActivity-nek valamivel így néz ki:

import android.app.Activity; import android.app.ActivityManager; import androidx.appcompat.app.AppCompatActivity; import android.content.Context; import android.net.Uri; import android.os.Build; import android.os.Build.VERSION_CODES; import android.os.Bundle; import android.util.Log; import android.view.MotionEvent; import androidx.annotation.RequiresApi; import com.google.ar.core.Anchor; import com.google.ar.core.HitResult; import 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; MainActivity nyilvános osztály kiterjeszti az AppCompatActivity {magán statikus végleges karakterláncot TAG = MainActivity.class.getSimpleName (); privát statikus végleges dupla MIN_OPENGL_VERSION = 3.0; // Tagváltozó létrehozása a ModelRenderable számára // magán ModelRenderable dinoRenderable; // Tagváltozó létrehozása az ArFragmenthez // magán ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @A védett void felülírása az onCreate (Bundle SaveInstanceState) {super.onCreate (SaveInstanceState); if (! checkDevice ((this)))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Keresse meg a fragmentumot a fragment manager segítségével // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Építsd meg a ModelRenderable // ModelRenderable.builder () .setSource (ez, R.raw.dinosaur) .build () .thenAccept (nyújtható -> dinoRenderable = nyújtott ). Kivételesen (// Hiba esetén ... // dobható -> {//...végre nyomtassa ki a következőt a Logcat // Log.e fájlba (TAG, "Nem sikerült betölteni a renderelhetőt"); null visszatér;} ); } // Figyeljen onTap eseményekre // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Horgony horgony = hitResult.createAnchor (); // AnchorNode típusú csomópont // AnchorNode anchorNode = új AnchorNode (horgony); // Csatlakoztassa az AnchorNode jelenetet // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // A TransformableNode típusú csomópont készítése TransformableNode transformableNode = új TransformableNode (arCoreFragment.getTransformationSystem ()); // Csatlakoztassa a TransformableNode-ot az AnchorNode-hoz // transformableNode.setParent (anchorNode); // Csatlakoztassa az Renderable // transformableNode.setRenderable (dinoRenderable); / transformableNode.select ();}); } nyilvános statikus logikai checkDevice (végső tevékenységi tevékenység) {// Ha az eszköz Android Marshmallow vagy régebbi verziót futtat ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//...végre nyomtassa ki az alábbiakat: Logcat // Log.e (TAG, "A Sceneform Android N vagy újabb verziót igényel"); activity.finish (); hamis visszaadást; } String openGlVersionString = (((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Ellenőrizze az OpenGL ES verzióját. .GetGlEsVersion (); // Ha az eszköz valami kevesebb, mint az OpenGL ES 3.0 ... // ha fut (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//...végre nyomtassa ki a következőt a Logcat // Log.e (TAG, " OpenGL ES 3.0 vagy újabb verziót igényel "); activity.finish (); hamis visszaadást; } visszatér igaz; }}

A befejezett projektet letöltheti a GitHubból.

A Google ARCore kibővített valóság alkalmazásának tesztelése

Most már készen áll az alkalmazás tesztelésére egy fizikai, támogatott Android-eszközön. Ha nem rendelkezik olyan eszközzel, amely támogatja az ARCore-t, akkor kipróbálhatja AR alkalmazását az Android emulátorban (egy kis extra konfigurációval, amelyet a következő szakaszban tárgyalunk).

A projekt tesztelése a fizikai Android-eszköz:

Telepítse az alkalmazást a cél eszközre.
Amikor a rendszer kéri, adja meg az alkalmazás számára a hozzáférést az eszköz kamerájához.
Ha a rendszer felkéri az ARCore alkalmazás telepítésére vagy frissítésére, koppintson a „Folytatás” elemre, majd fejezze be a párbeszédet, hogy megbizonyosodjon arról, hogy az ARCore legújabb és legnagyobb verziója van-e.
Most látnia kell egy kamera nézetet, kiegészítve egy eszköz animációjával. Irányítsa a fényképezőgépet egy sima felületre, és mozgassa körbe a készüléket, amint azt az animáció mutatja. Néhány pillanat múlva pontsorozatoknak kell megjelenniük, jelezve, hogy síkot észleltek.

Miután elégedett ezeknek a pontoknak a helyzetével, érintse meg őket - a 3D modellnek most meg kell jelennie a választott síkon!

Próbáljon fizikailag mozogni a modell körül; a környezetetől függően előfordulhat, hogy a teljes 360 fokot megteheti körülötte. Azt is ellenőriznie kell, hogy az objektum olyan árnyékot vet-e, amely összhangban van a valós világforrásokkal.

Az ARCore tesztelése egy Android virtuális eszközön

Az ARCore-alkalmazások Android virtuális eszközön (AVD) történő teszteléséhez az Android Emulator 27.2.9 vagy újabb verziójára van szüksége. Be kell jelentkeznie az AVD-jén a Google Play áruházba, és engedélyeznie kell az OpenGL ES 3.0 vagy újabb verziót.

Annak ellenőrzéséhez, hogy az OpenGL ES 3.0 vagy újabb - e jelenleg engedélyezve van-e az AVD-n:

Indítsa el az AVD-t, mint általában.
Nyisson meg egy új terminál ablakot (Mac) vagy egy parancssort (Windows).
Változtassa meg a könyvtárat („cd”), így a Terminal / Command Prompt az Android SDK „adb” programjának helyére mutat, például a parancsom így néz ki:

CD / felhasználók / jessicathornsby / könyvtár / Android / sdk / platform-eszközök

Nyomja meg a billentyűzet „Enter” billentyűjét.
Másolja / illessze be a következő parancsot a terminálra, majd nyomja meg az „Enter” gombot:

./adb logcat | grep eglMakeCurrent

Ha a terminál „ver 3 0” vagy annál magasabb értéket ad vissza, akkor az OpenGL ES helyesen van konfigurálva. Ha a terminál vagy a parancssor 3.0-nál korábban jelenik meg, akkor engedélyeznie kell az OpenGL ES 3.0-t:

Váltás vissza az AVD-re.
Keresse meg az Android emulátor mellett lebegő „kibővített vezérlés” gombok csíkját, majd válassza a „Beállítások> Speciális” lehetőséget.
Keresse meg az „OpenGL ES API szint> Renderer maximális értéke (OpenGL ES 3.1-ig)” pontot.
Indítsa újra az emulátort.

A Terminal / Command Prompt ablakban másolja / illessze be a következő parancsot, majd nyomja meg az “Enter” gombot ”

./adb logcat | grep eglMakeCurrent

Most meg kell kapnia a „ver 3 0” vagy annál magasabb eredményt, azaz az OpenGL ES helyesen van konfigurálva.

Végül győződjön meg arról, hogy az AVD futtatja az ARCore legújabb verzióját:

Menjen át az ARCore GitHub oldalára, és töltse le az ARCore legújabb kiadását az emulátor számára. Például az írás megírásakor a legfrissebb kiadás az „ARCore_1.7.0.x86_for_emulator.apk” volt.
Húzza az APK-t a futó AVD-re.

A projekt AVD-n történő teszteléséhez telepítse az alkalmazást, és kérje meg a hozzáférést az AVD „kamerájához”.

Most látnia kell egy szimulált szoba kamera nézetét. Az alkalmazás teszteléséhez mozogjon ezen a virtuális terepen, keressen egy szimulált sík felületet, és kattintson a gombra, hogy egy modellt feltegyen erre a felületre.

A virtuális kamerát a virtuális hely körül mozgathatja úgy, hogy lenyomva tartja az „Opció” (macOS) vagy az „Alt” (Linux vagy Windows) billentyűket, majd az alábbi billentyűparancsok bármelyikét használják:

Mozgás balra vagy jobbra. Nyomja meg az A vagy a D gombot.
Mozgassa le vagy fel. Nyomja meg a Q vagy az E gombot.
Előre vagy hátra. Nyomja meg a W vagy a S gombot.

A virtuális jelenet körül is mozoghat az „Opció” vagy az „Alt” megnyomásával, majd az egér használatával. Ez eleinte kissé nehézkesnek érzi magát, de a gyakorlat során képesnek kell lennie arra, hogy sikeresen felfedezze a virtuális teret. Miután megtalálta a szimulált síkot, kattintson a fehér pontokra, és helyezze el 3D modelljét ezen a felületen.

Csomagolás

Ebben a cikkben egy egyszerű kibővített valóság alkalmazást készítettünk, ARCore és a Sceneform plugin segítségével.

Ha úgy dönt, hogy a Google ARCore-t használja saját projektjeiben, akkor mindenképpen ossza meg alkotásait az alábbi megjegyzésekben!