HoloLens (1. generációs) és az Azure 308: Eszközök közötti értesítések


Megjegyzés

Az Mixed Reality Academy oktatóanyagai HoloLens (1. generációs) és Mixed Reality Modern headsetekkel vannak megtervezve. Ezért fontos, hogy ezeket az oktatóanyagokat a helyére helyezzük azoknak a fejlesztőknek, akik továbbra is útmutatásra van szüksége az eszközök fejlesztéséhez. Ezek az oktatóanyagok nem frissülnek a 2. HoloLens használt legújabb eszközkészletekkel vagy interakciókkal. A rendszer fenntartja őket, hogy továbbra is a támogatott eszközökön dolgoznak. A jövőben egy új oktatóanyag-sorozat lesz közzétéve, amely bemutatja, hogyan fejleszthet a 2. HoloLens való fejlesztéshez. Ez az értesítés az oktatóanyagokra mutató hivatkozással fog frissülni, amikor közzé lesznek adva.


final product -start

Ebben a kurzusban megtudhatja, hogyan adhat hozzá Notification Hubs képességeket egy vegyes valóságú alkalmazáshoz az Azure Notification Hubs, az Azure Tables és a Azure Functions.

Az Azure Notification Hubs egy Microsoft-szolgáltatás, amely lehetővé teszi a fejlesztők számára, hogy célzott és személyre szabott leküldéses értesítéseket küldjenek bármely platformra, mindezt a felhőben működtetve. Ez lehetővé teszi a fejlesztők számára, hogy a forgatókönyvtől függően kommunikáljanak a végfelhasználókkal, vagy akár különböző alkalmazások között is. További információért látogasson el az Azure Notification Hubsoldalára.

Azure Functions egy Microsoft-szolgáltatás, amely lehetővé teszi a fejlesztők számára, hogy kis kódokat (függvényeket) futtassanak az Azure-ban. Így a helyi alkalmazás helyett a felhőbe delegálhatja a munkát, ami számos előnyt biztosít. Azure Functions nyelvet támogat, például a C#, az F#, a Node.js, a Java és a PHP nyelvet. További információért látogasson el a Azure Functionsoldalára.

Az Azure Tables egy Microsoft-felhőszolgáltatás, amely lehetővé teszi a fejlesztők számára, hogy strukturált, nem SQL adatokat tároljanak a felhőben, így bárhonnan könnyen elérhetők. A szolgáltatás egy séma nélküli kialakítást kínál, amely lehetővé teszi a táblák szükség szerint való fejlődését, és így rendkívül rugalmas. További információért látogasson el az Azure Tables (Azure-táblák) oldalra.

A kurzus befejezése után egy vegyes valóságú modern headset-alkalmazást és egy asztali PC-alkalmazást fog használni, amely a következőkre lesz képes:

  1. Az asztali pc alkalmazás lehetővé teszi, hogy a felhasználó 2D térben (X és Y) helyezzen át egy objektumot az egérrel.

  2. A PC-alkalmazáson belüli objektumok mozgása a felhőbe JSON használatával lesz elküldve, amely egy objektumazonosítót, típust és átalakítási információt (X és Y koordinátákat) tartalmazó sztring formájában lesz elküldve.

  3. A vegyes valóság alkalmazás, amely az asztali alkalmazással azonos jelenetekkel rendelkezik, az Notification Hubs szolgáltatástól (amelyet az asztali PC-alkalmazás épp most frissített) fog értesítéseket kapni az objektumok mozgásával kapcsolatban.

  4. Az objektumazonosítót, típust és átalakítást tartalmazó értesítés fogadása után a vegyes valóság alkalmazás a kapott információkat a saját jelenetére alkalmazza.

Az alkalmazásban Ön kell, hogy az eredményeket hogyan integrálja a tervbe. Ennek a kurzusnak az a célja, hogy megtanítsa, hogyan integrálhat egy Azure-szolgáltatást a Unity-Project. Az Ön feladata, hogy az ebben a kurzusban megszerezhető ismereteket használja fel a vegyes valóságon áteső alkalmazások továbbadása érdekében. Ez a kurzus egy önálló oktatóanyag, amely nem jár közvetlenül a Mixed Reality Laborokkal.

Eszköztámogatás

Tanfolyam HoloLens Modern headsetek
MR és Azure 308: Eszközök közötti értesítések ✔️ ✔️

Megjegyzés

Bár ez a kurzus elsősorban a Windows Mixed Reality (VR)-headsetekkel foglalkozik, a kurzusban tanultak használhatja a Microsoft HoloLens. Ahogy követi a kurzust, megjegyzéseket fog látni az esetleges változásokról, amelyekre szükség lehet a HoloLens. A HoloLens előfordulhat, hogy a hangrögzítés során valamilyen echo üzenetet fog kapni.

Előfeltételek

Megjegyzés

Ez az oktatóanyag olyan fejlesztők számára készült, akik alapszintű tapasztalattal rendelkeznek a Unity és a C# használatában. Vegye figyelembe azt is, hogy a jelen dokumentumban található előfeltételek és írásos utasítások az íráskor tesztelt és ellenőrzött adatokat jelölik (2018. május). Használhatja a legújabb szoftvereket, amelyek az eszközök telepítése cikkben szerepelnek, azonban nem feltételezhető, hogy a kurzusban szereplő információk tökéletesen megegyeznek az újabb szoftverekben található információkkal, mint az alább felsoroltak.

Ehhez a kurzushoz a következő hardvereket és szoftvereket javasoljuk:

Előkészületek

  • A projekt létrehozásakor felmerülő problémák elkerülése érdekében határozottan javasoljuk, hogy az oktatóanyagban említett projektet egy gyökér- vagy gyökérmappában hozza létre (a hosszú mappaútvonalak problémákat okozhatnak a build létrehozásakor).
  • Az alkalmazásregisztrációs portál és Microsoft Developer tulajdonosának kell lennie, ellenkező esetben nem lesz engedélye az alkalmazás elérésére a 2. fejezetben.

1. fejezet – Alkalmazás létrehozása a Microsoft Developer portálon

Az Azure Notification Hubs Service-hez létre kell hoznia egy alkalmazást a Microsoft Developer Portalon, mivel az alkalmazást regisztrálni kell, hogy az értesítéseket küldhet és fogadhat.

  1. Jelentkezzen be a Microsoft Developer portálra.

    Be kell jelentkeznie a Microsoft-fiókjába.

  2. Az Irányítópulton kattintson az Új alkalmazás létrehozása elemre.

    alkalmazás létrehozása

  3. Megjelenik egy előugró ablak, amelyben le kell foglalnia egy nevet az új alkalmazás számára. A szövegmezőbe szúrjon be egy megfelelő nevet; Ha a választott név elérhető, a szövegmező jobb oldalon megjelenik egy órajel. Miután beszúrta a rendelkezésre álló nevet, kattintson a Reserve product name (Terméknév lefoglalása) gombra a felugró ablak bal alsó részén.

    név megfordítva

  4. Most, hogy az alkalmazás létrejött, készen áll a következő fejezetre való továbblépni.

2. fejezet – Az új alkalmazások hitelesítő adatainak lekérése

Jelentkezzen be az alkalmazásregisztrációs portálra, ahol az új alkalmazás megjelenik, és lekérje a hitelesítő adatokat, amelyeket az Notification Hubs szolgáltatás beállításához fog használni az Azure Portalon.

  1. Lépjen az Alkalmazásregisztrációs portálra.

    alkalmazásregisztrációs portál

    Figyelmeztetés

    A bejelentkezéshez Microsoft-fiókját kell használnia.
    Ennek a Microsoft-fióknak kell lennie, amelyet az előző fejezetben használt a Windows Store Fejlesztői portállal.

  2. Az alkalmazást a Saját alkalmazások szakaszban találja. Ha megtalálta, kattintson rá, és meg fog jelenni egy új lap, amelyen az alkalmazás neve és a Regisztráció is megtalálható.

    az újonnan regisztrált alkalmazás

  3. Görgessen le a regisztrációs oldalon az Alkalmazás titkos kulcsok szakaszának és az alkalmazás csomag biztonsági azonosítójára. Másolja ki mindkettőt az Azure Notification Hubs szolgáltatás beállításával való használathoz a következő fejezetben.

    alkalmazás titkos kulcsok

3. fejezet – Az Azure Portal beállítása: Notification Hubs szolgáltatás létrehozása

Az alkalmazás hitelesítő adatainak lekérése után az Azure Portalon létre kell hoznia egy Azure Notification Hubs szolgáltatást.

  1. Jelentkezzen be az Azure Portalra.

    Megjegyzés

    Ha még nem rendelkezik Azure-fiókkal, létre kell hoznia egyet. Ha osztályterem- vagy laborhelyzetben követi ezt az oktatóanyagot, kérjen segítséget az oktatótól vagy valamelyik vezetőtől az új fiók beállításában.

  2. Miután bejelentkezett, kattintson az Új elemre a bal felső sarokban, keressen rá az Értesítésiközpont kifejezésre, majd kattintson az Enter gombra.

    értesítési központ keresése

    Megjegyzés

    Előfordulhat, hogy az Új szó helyére az Erőforráslétrehozása szó került az újabb portálok használatával.

  3. Az új oldal a szolgáltatás Notification Hubs meg. A parancssor bal alsó részén válassza a Létrehozás gombot a szolgáltatással való társítás létrehozásához.

    Notification Hubs-példány létrehozása

  4. Miután a Létrehozás gombra kattintott:

    1. Szúrja be a szolgáltatáspéldány kívánt nevét.

    2. Adjon meg egy névteret, amelyet hozzá tud majd társítani az alkalmazáshoz.

    3. Válasszon ki egy helyet.

    4. Válasszon ki egy erőforráscsoportot, vagy hozzon létre egy újat. Az erőforráscsoportokkal monitorzhatja, szabályozhatja a hozzáférést, kiépítheti és kezelheti az Azure-beli eszközök gyűjteményének számlázását. Javasoljuk, hogy egyetlen projekthez (például ezekhez a tesztkörnyezetekhez) társított összes Azure-szolgáltatást egy közös erőforráscsoportban tartsa.

      Ha többet szeretne tudni az Azure-erőforráscsoportokról, kövesse ezt a hivatkozást az erőforráscsoportok kezeléséhez.

    5. Válassza ki a megfelelő előfizetést.

    6. Azt is meg kell erősítenie, hogy megértette a szolgáltatásra alkalmazott használati feltételeket.

    7. Válassza a Létrehozás lehetőséget.

      szolgáltatás részleteinek kitöltése

  5. Miután a Létrehozás gombra kattintott,meg kell várnia a szolgáltatás létrejöttét, ez egy percet is igénybe vehet.

  6. A szolgáltatáspéldány létrehozása után egy értesítés jelenik meg a portálon.

    Értesítés

  7. Az értesítésben kattintson az Erőforrás ugrás gombra az új szolgáltatáspéldány felfedezéséhez. Meg fog kapni egy új Notification Hub-szolgáltatáspéldányt.

    ugrás az erőforrásra

  8. Az áttekintési oldalon, az oldal felénél kattintson a Windows (WNS) elemre. A jobb oldalon található panelen két szövegmező fog megváltozni, amelyekhez a csomag biztonsági azonosítójára és a biztonsági kulcsára van szükség a korábban beállított alkalmazásból.

    újonnan létrehozott hubs szolgáltatás

  9. Miután átmásolta a részleteket a megfelelő mezőkbe, kattintson a Mentés gombra, és értesítést kap az értesítési központ sikeres frissítéséről.

    biztonsági adatok másolása

4. fejezet – Az Azure Portal beállítása: Table Service létrehozása

A Notification Hubs service-példány létrehozása után lépjen vissza az Azure Portalra, ahol egy azure tables service-t fog létrehozni egy Storage erőforrás létrehozásával.

  1. Ha még nincs bejelentkezve, jelentkezzen be az Azure Portalra.

  2. Miután bejelentkezett, kattintson az Új elemre a bal felső sarokban, keressen rá az Storage,majd kattintson az Enter gombra.

    Megjegyzés

    Előfordulhat, hogy az Új szó helyett a Create a resource(Erőforrás létrehozása) szó lett az újabb portálon.

  3. Válassza Storage fiók – blob, fájl, tábla, üzenetsor listában.

    tárfiók keresése

  4. Az új oldal a fiókszolgáltatás Storage meg. A parancssor bal alsó részén kattintson a Létrehozás gombra a szolgáltatás egy példányának létrehozásához.

    tárolópéldány létrehozása

  5. Miután a Létrehozás gombra kattintott,megjelenik egy panel:

    1. Szúrja be a kívánt nevet a szolgáltatáspéldányhoz (csak kisbetűkből kell lennie).

    2. Az Üzembe helyezési modell esetében kattintsona Resource Manager elemre.

    3. A Fiók fajtájabeállításnál a legördülő menüben válassza a Storage (általános célú v1) lehetőséget.

    4. Válassza ki a megfelelő helyet.

    5. A Replikáció legördülő menüben válassza az Írási hozzáférés georedundáns tárolás (RA-GRS) lehetőséget.

    6. A Teljesítményhez kattintsona Standard elemre.

    7. A Biztonságos átvitelre van szükség szakaszban válassza a Letiltva lehetőséget.

    8. Az Előfizetés legördülő menüből válassza ki a megfelelő előfizetést.

    9. Válasszon ki egy erőforráscsoportot, vagy hozzon létre egy újat. Az erőforráscsoportokkal monitorzhatja, szabályozhatja a hozzáférést, kiépítheti és kezelheti az Azure-beli eszközök gyűjteményének számlázását. Javasoljuk, hogy egyetlen projekthez (például ezekhez a tesztkörnyezetekhez) társított összes Azure-szolgáltatást egy közös erőforráscsoportban tartsa.

      Ha többet szeretne tudni az Azure-erőforráscsoportokról, kövesse ezt a hivatkozást az erőforráscsoportok kezeléséhez.

    10. Ha ezt a lehetőséget választja, hagyja a Virtuális hálózatok beállítást Letiltva beállításon.

    11. Kattintson a Létrehozás lehetőségre.

      a tárolási adatok kitöltése

  6. Miután a Létrehozás gombra kattintott,meg kell várnia a szolgáltatás létrejöttét, ez egy percet is igénybe vehet.

  7. A szolgáltatáspéldány létrehozása után egy értesítés jelenik meg a portálon. Kattintson az értesítésekre az új szolgáltatáspéldány felfedezéséhez.

    új tárértesítés

  8. Az értesítésben kattintson az Erőforrás ugrás gombra az új szolgáltatáspéldány felfedezéséhez. Meg fog jelenni az új Storage szolgáltatáspéldány áttekintő oldala.

    ugrás az erőforrásra

  9. Az áttekintő oldalon kattintson a táblák elemre a jobb oldalon.

  10. A jobb oldalon a panel úgy változik, hogy a Table Service információit mutassa, ahol új táblát kell hozzáadnia. Ehhez kattintson a Táblázat ++ a bal felső sarokban.

    táblák megnyitása

  11. Megjelenik egy új oldal, ahol meg kell adnia egy Táblanevet. Ezt a nevet fogja használni az alkalmazásban található adatok későbbi fejezetek során való hivatkozásához. Szúrjon be egy megfelelő nevet, majd kattintson az OK gombra.

    új tábla létrehozása

  12. Az új tábla létrehozása után az a Table Service oldalon (alul) látható lesz.

    új tábla létrehozva

5. fejezet – Az Azure-tábla befejezése a Visual Studio

Most, hogy a Table Service Storage-fiók beállítása meg lett állítva, itt az ideje, hogy adatokat adjon hozzá, amelyek az adatok tárolására és lekéréséhez lesznek használva. A táblák a következővel szerkeszthetők: Visual Studio.

  1. Nyissa meg a Visual Studio.

  2. A menüben kattintson a ViewCloud Explorer (Felhőkezelő megtekintése) elemre.

    a Cloud Explorer megnyitása

  3. A Cloud Explorer rögzített elemként nyílik meg (legyen beteg, mert a betöltés időt is vehet).

    Megjegyzés

    Ha a fiókfiókok létrehozásához használt előfizetés Storage, ellenőrizze, hogy rendelkezik-e a következővel:

    • Ugyanoda a fiókba jelentkezett be, mint amit az Azure Portalhoz használt.

    • Az Előfizetés lehetőséget választotta a Fiókkezelés oldalon (előfordulhat, hogy a fiókbeállításokból kell szűrőt alkalmaznia):

      előfizetés megkeresve

  4. Megjelenik az Azure-felhőszolgáltatások. Keresse Storage fiókokat, és kattintson a bal oldalon található nyílra a fiókok kibontásához.

    tárfiókok megnyitása

  5. A kibontás után az újonnan létrehozott Storage fióknak elérhetőnek kell lennie. Kattintson a tárolótól balra található nyílra, majd miután kibontott, keresse meg a Táblák gombra, majd kattintson a mellette lévő nyílra, hogy felfedje az előző fejezetben létrehozott táblázatot. Kattintson duplán a táblázatra.

    nyitott jelenetobjektumok táblázata

  6. A tábla a saját ablakának közepén Visual Studio meg. Kattintson a táblázat ikonra a + (plusz) jel mellett.

    új tábla hozzáadása

  7. Megjelenik egy ablak, amely az Entitás hozzáadása gombra kéri. Összesen három entitást fog létrehozni, amelyek mindegyikének számos tulajdonsága van. Figyelje meg, hogy a PartitionKey és a RowKey már meg van téve, mivel a tábla ezekkel találja meg az adatokat.

    partíció- és sorkulcs

  8. Frissítse aPartitionKey és a RowKey értékét a következőképpen (ne felejtse el ezt megtenni minden hozzáadott sortulajdonságnál, bár minden alkalommal növelje a RowKey értékét):

    helyes értékek hozzáadása

  9. Kattintson a Tulajdonság hozzáadása elemre további adatsorok hozzáadásához. Az első üres táblát az alábbi táblázatnak megfelelőre kell tenni.

  10. Ha elkészült, kattintson az OK gombra.

    ha végzett, kattintson az OK gombra

    Figyelmeztetés

    Győződjön meg arról, hogy az X,Y,és Ztípusú bejegyzéseket Double típusra módosította.

  11. Figyelje meg, hogy a tábla most már tartalmaz egy adatsort. Kattintson ismét + a (plusz) ikonra egy másik entitás hozzáadásához.

    első sor

  12. Hozzon létre egy további tulajdonságot, majd állítsa be az új entitás értékeit úgy, hogy azok megegyeznek az alább látható értékekkel.

    kocka hozzáadása

  13. Ismételje meg az utolsó lépést egy másik entitás hozzáadásához. Állítsa az entitás értékeit az alább látható értékekre.

    henger hozzáadása

  14. A táblának most az alábbihoz hasonlónak kell lennie.

    tábla kész

  15. Ön befejezte ezt a fejezetet. Ne feledjük a mentést.

6. fejezet – Azure-függvényalkalmazás létrehozása

Hozzon létre egy Azure-függvényalkalmazást, amelyet az asztali alkalmazás hív meg a Table szolgáltatás frissítéséhez és az értesítési központon keresztül küldött értesítéshez.

Először létre kell hoznia egy fájlt, amely lehetővé teszi, hogy az Azure-függvény betöltse a szükséges kódtárakat.

  1. Nyissa Jegyzettömb (nyomja le a Windows billentyűt, és írja be a jegyzettömböt).

    a jegyzettömb megnyitása

  2. Ha Jegyzettömb, szúrja be az alábbi JSON-struktúrát. Miután ezt megtette, mentse az asztalra project.json fájlként. Fontos, hogy az elnevezés helyes legyen: győződjön meg arról, hogy NEM rendelkezik .txt fájlkiterjesztéssel. Ez a fájl határozza meg a függvény által használt kódtárakat, ha már használta a NuGetet, ismerősnek fog kinézni.

    {
    "frameworks": {
        "net46":{
        "dependencies": {
            "WindowsAzure.Storage": "7.0.0",
            "Microsoft.Azure.NotificationHubs" : "1.0.9",
            "Microsoft.Azure.WebJobs.Extensions.NotificationHubs" :"1.1.0"
        }
        }
    }
    }
    
  3. Jelentkezzen be az Azure Portalra.

  4. Miután bejelentkezett, kattintson az Új elemre a bal felső sarokban, és keressen rá a Függvényalkalmazáskifejezésre, és nyomja le az Enter billentyűt.

    függvényalkalmazás keresése

    Megjegyzés

    Előfordulhat, hogy az Új szó helyére az Erőforráslétrehozása szó került az újabb portálok használatával.

  5. Az új oldal a Függvényalkalmazás szolgáltatás leírását tartalmazza. A parancssor bal alsó részén válassza a Létrehozás gombot a szolgáltatással való társítás létrehozásához.

    függvényalkalmazás-példány

  6. Miután a Létrehozás gombra kattintott,töltse ki a következőket:

    1. Az Alkalmazás neve alattszúrja be a kívánt nevet a szolgáltatáspéldányhoz.

    2. Válasszon ki egy előfizetést.

    3. Válassza ki az Önnek megfelelő tarifacsomagot, ha elsőalkalommal hoz létre függvényt App Service, elérhetővé kell tennie az ingyenes szintet.

    4. Válasszon ki egy erőforráscsoportot, vagy hozzon létre egy újat. Az erőforráscsoport lehetővé teszi az Azure-eszközök gyűjteményének figyelése, hozzáférésének szabályozása, kiépítése és kezelése a számlázást. Javasoljuk, hogy az összes Azure-szolgáltatást egyetlen projektben (például ezekben a tesztkörnyezetekben) egy közös erőforráscsoportban tartsa.

      Ha többet szeretne tudni az Azure-erőforráscsoportokról, kövesse ezt a hivatkozást az erőforráscsoportok kezeléséhez.

    5. Operációs rendszerkéntkattintson Windows elemre, mivel ez a kívánt platform.

    6. Válasszon ki egy üzemeltetési tervet (ebben az oktatóanyagban használat alapján kell használni.

    7. Válasszon ki egy helyet(válassza ugyanazt a helyet, mint az előző lépésbenfelépített tároló)

    8. A Storage szakaszban ki kell választania Storage előző lépésben létrehozott Storage-szolgáltatást.

    9. Ebben az alkalmazásban nincs szükség Elemzések alkalmazásra, ezért nyugodtan hagyja kikapcsolva.

    10. Kattintson a Létrehozás lehetőségre.

      új példány létrehozása

  7. Miután a Létrehozás gombra kattintott, meg kell várnia a szolgáltatás létrejöttét, ez egy percet is igénybe vehet.

  8. A szolgáltatáspéldány létrehozása után egy értesítés jelenik meg a portálon.

    új értesítés

  9. Kattintson az értesítésekre az új szolgáltatáspéldány felfedezéséhez.

  10. Az értesítésben kattintson az Erőforrás ugrás gombra az új szolgáltatáspéldány felfedezéséhez.

    ugrás az erőforrásra

  11. Az új létrehozásához kattintson a ++melletti (plusz) ikonra.

    új függvény hozzáadása

  12. A központi panelen megjelenik a Függvény létrehozása ablak. Hagyja figyelmen kívül a panel felső felében található adatokat, és kattintson az alul található Custom function (Egyénifüggvény) elemre (az alább látható kék területen).

    egyéni függvény

  13. Az ablakban megjelenő új oldalon különböző függvénytípusok fognak jelenni. Görgessen le a lila típusok megtekintéséhez, és kattintson a HTTP PUT elemre.

    http put hivatkozás

    Fontos

    Előfordulhat, hogy az oldalt lejjebb kell görgetnie (és ha az Azure Portal frissítései már le vannak egyidejűleg, előfordulhat, hogy ez a kép nem teljesen azonos), de egy HTTP PUT nevű elemet keres.

  14. Megjelenik a HTTP PUT ablak, ahol konfigurálnia kell a függvényt (a képért lásd alább).

    1. A Nyelv legördülő menüben válassza a C# lehetőséget.

    2. A Név mezőben adja meg a megfelelő nevet.

    3. A Hitelesítési szint legördülő menüben válassza a Függvény lehetőséget.

    4. A Tábla neve szakaszban pontosan azt a nevet kell használnia, amelyet korábban a Table Service létrehozásához használt (beleértve a kisbetűs kisbetűt is).

    5. A fiók Storage szakaszban használja a legördülő menüt, és válassza ki onnan a tárfiókját. Ha nincs ott, kattintson az Új hivatkozásra a szakasz címe mellett, hogy egy másik panelt mutasson, ahol a tárfióknak meg kell lennie a listában.

      új tároló

  15. Kattintson a Létrehozás gombra, és értesítést kap arról, hogy a beállítások sikeresen frissültek.

    függvény létrehozása

  16. Miután a Létrehozás gombrakattintott, a rendszer átirányítja a függvényszerkesztőbe.

    függvénykód frissítése

  17. Szúrja be a következő kódot a függvényszerkesztőbe (a függvényben cserélje le a kódot):

    #r "Microsoft.WindowsAzure.Storage"
    
    using System;
    using Microsoft.WindowsAzure.Storage;
    using Microsoft.WindowsAzure.Storage.Table;
    using Microsoft.Azure.NotificationHubs;
    using Newtonsoft.Json;
    
    public static async Task Run(UnityGameObject gameObj, CloudTable table, IAsyncCollector<Notification> notification, TraceWriter log)
    {
        //RowKey of the table object to be changed
        string rowKey = gameObj.RowKey;
    
        //Retrieve the table object by its RowKey
        TableOperation operation = TableOperation.Retrieve<UnityGameObject>("UnityPartitionKey", rowKey); 
    
        TableResult result = table.Execute(operation);
    
        //Create a UnityGameObject so to set its parameters
        UnityGameObject existingGameObj = (UnityGameObject)result.Result; 
    
        existingGameObj.RowKey = rowKey;
        existingGameObj.X = gameObj.X;
        existingGameObj.Y = gameObj.Y;
        existingGameObj.Z = gameObj.Z;
    
        //Replace the table appropriate table Entity with the value of the UnityGameObject
        operation = TableOperation.Replace(existingGameObj); 
    
        table.Execute(operation);
    
        log.Verbose($"Updated object position");
    
        //Serialize the UnityGameObject
        string wnsNotificationPayload = JsonConvert.SerializeObject(existingGameObj);
    
        log.Info($"{wnsNotificationPayload}");
    
        var headers = new Dictionary<string, string>();
    
        headers["X-WNS-Type"] = @"wns/raw";
    
        //Send the raw notification to subscribed devices
        await notification.AddAsync(new WindowsNotification(wnsNotificationPayload, headers)); 
    
        log.Verbose($"Sent notification");
    }
    
    // This UnityGameObject represent a Table Entity
    public class UnityGameObject : TableEntity
    {
        public string Type { get; set; }
        public double X { get; set; }
        public double Y { get; set; }
        public double Z { get; set; }
        public string RowKey { get; set; }
    }
    

    Megjegyzés

    A mellékelt kódtárak használatával a függvény megkapja a Unity-jelenetbe áthelyezett objektum nevét és helyét (egy UnityGameObjectnevű C#-objektumként). Ezzel az objektummal frissítheti a létrehozott táblában található objektumparamétereket. Ezt követően a függvény hívást küld a létrehozott Notification Hub szolgáltatásnak, amely értesíti az összes feliratkozott alkalmazást.

  18. Ha a kód a helyén van, kattintson a Save (Mentés) gombra.

  19. Ezután kattintson a (nyíl) ikonra az oldal jobb < oldalán.

    a feltöltési panel megnyitása

  20. A panel jobbról fog becsúszni. A panelen kattintson a Feltöltéselemre, és megjelenik egy Fájlböngésző.

  21. Lépjen a korábban létrehozott project.json fájlra, Jegyzettömb kattintson a Megnyitás gombra. Ez a fájl határozza meg a függvény által használt kódtárakat.

    json feltöltése

  22. A fájl feltöltése után az megjelenik a jobb oldalon található panelen. Erre kattintva megnyílik a függvényszerkesztőben. Pontosan ugyanúgy kell kinéznie, mint a következő képen (a 23. lépés alatt).

  23. Ezután a bal oldali panelen, a Függvények alattkattintson az Integrálás hivatkozásra.

    integrate függvény

  24. A következő oldalon, a jobb felső sarokban kattintson a Speciális szerkesztő elemre (az alábbiak szerint).

    speciális szerkesztő megnyitása

  25. A középső panelen megnyílik egy function.json fájl, amelyet a következő kódrészletre kell cserélni. Ez határozza meg a függvényt, amelyből a függvényt ki kell építeni, és a paramétereket át kell adni a függvénynek.

    {
    "bindings": [
        {
        "authLevel": "function",
        "type": "httpTrigger",
        "methods": [
            "get",
            "post"
        ],
        "name": "gameObj",
        "direction": "in"
        },
        {
        "type": "table",
        "name": "table",
        "tableName": "SceneObjectsTable",
        "connection": "mrnothubstorage_STORAGE",
        "direction": "in"
        },
        {
        "type": "notificationHub",
        "direction": "out",
        "name": "notification",
        "hubName": "MR_NotHub_ServiceInstance",
        "connection": "MRNotHubNS_DefaultFullSharedAccessSignature_NH",
        "platform": "wns"
        }
    ]
    }
    
  26. A szerkesztőnek most az alábbi képhez hasonlónak kell lennie:

    vissza a standard szerkesztőbe

  27. Észreveheti, hogy az előbb beszúrt bemeneti paraméterek nem egyeznek meg a tábla és a tároló adataival, ezért frissíteni kell őket az adataival. Ne tegye ezt itt,mivel a következő lépés. Egyszerűen kattintson a Standard szerkesztő hivatkozásra az oldal jobb felső sarkában, hogy visszamehetek.

  28. A Standard szerkesztőben kattintson azAzure Table Storage (tábla)elemre a Bemenetek alatt.

    Táblabemenetek

  29. Győződjön meg arról, hogy a következő egyezést tartalmazza az ön adataival, mivel ezek eltérőek lehetnek (a következő lépések alatt egy kép látható):

    1. Tábla neve:az Azure-ban létrehozott tábla Storage, Tables service.

    2. Storage létrehozása: kattintson az újelemre, amely a legördülő menü mellett jelenik meg, és megjelenik egy panel az ablak jobb oldalon.

      új tároló

      1. Válassza ki Storage-fiókot,amelyet korábban a függvényalkalmazások számára hozott létre.

      2. Figyelje meg, hogy létrejött Storage fiók kapcsolati értéke.

      3. Ha végzett, mindenképpen nyomja le a Mentés gombot.

    3. A Bemenetek lapnak most meg kell egyeznie az alábbival, amely az Ön adatait mutatja.

      bemenetek befejezve

  30. Ezután kattintson az Azure Notification Hub (értesítés) elemre a Kimenetek alatt. Győződjön meg arról, hogy a következők megegyeznek az Ön adataival, mivel ezek eltérőek lehetnek (a következő lépések alatt egy kép látható):

    1. Notification Hub Name(Értesítési központ neve): ez a korábban létrehozott Notification Hub-szolgáltatáspéldány neve.

    2. Notification Hubs kapcsolat:kattintson az újelemre, amely a legördülő menü mellett jelenik meg.

      kimenetek ellenőrzése

    3. Megjelenik a Kapcsolat előugró ablak (lásd az alábbi képet), ahol ki kell választania a korábban beállított Értesítési központ Névterét.

    4. Válassza ki az értesítési központ nevét a középső legördülő menüből.

    5. A Szabályzat legördülő menüben adja meg a DefaultFullSharedAccessSignature értéket.

    6. A visszaúthoz kattintson a Kijelölés gombra.

      kimeneti frissítés

  31. A Kimenetek lapnak most meg kell egyeznie az alábbival, de inkább az Ön adataival. Mindenképpen nyomja le a Mentés gombot.

Figyelmeztetés

Ne szerkessze közvetlenül az értesítési központ nevét (ezt az alábbi parancs használatával kell Speciális szerkesztő,feltéve, hogy az előző lépéseket megfelelően követte.

kimenetek befejezve

  1. Ezen a ponton tesztelje a függvényt, hogy ellenőrizze, működik-e. Ehhez tegye a következőket:

    1. Lépjen ismét a függvény oldalára:

      kimenetek befejezve

    2. A függvény oldalára visszatérve kattintson a lap jobb oldalán található Teszt fülre a Teszt panel megnyitásához:

      kimenetek befejezve

    3. A panel Kérelem törzse szövegmezőbe illessze be az alábbi kódot:

      {  
          "Type":null,
          "X":3,
          "Y":0,
          "Z":1,
          "PartitionKey":null,
          "RowKey":"Obj2",
          "Timestamp":"0001-01-01T00:00:00+00:00",
          "ETag":null
      }
      
    4. Ha a tesztkód már a helyén van, kattintson a futtatás gombra a jobb alsó sarokban, és a teszt futni fog. A teszt kimeneti naplói a konzol területén, a függvénykód alatt jelennek meg.

      kimenetek befejezve

    Figyelmeztetés

    Ha a fenti teszt sikertelen, ellenőrizze, hogy pontosan követte-e a fenti lépéseket, különösen az integrálás panelen megadott beállításokat.

7. fejezet – A Desktop Unity Project

Fontos

A most létrehozott asztali alkalmazás nem fog működni a Unity-szerkesztőben. A szerkesztőn kívül kell futtatni, az alkalmazás kiépítése után, Visual Studio (vagy az üzembe helyezett alkalmazás) használatával.

Az alábbiakban egy tipikus fejlesztést mutatunk be a Unityvel és a vegyes valósággal való fejlesztéshez, és így jó sablon más projektekhez.

Állítsa be és tesztelje a vegyes valóságú modern headsetet.

Megjegyzés

Ehhez a kurzushoz nem lesz szükség mozgásvezérlőkre. Ha támogatásra van szüksége a modern headset beállításához, kövesse ezt a hivatkozást a modern Windows Mixed Reality.

  1. Nyissa meg a Unityt, és kattintson a New (Új) elemre.

    új Unity-projekt

  2. Meg kell adnia egy Unity-Project, és adja meg a UnityDesktopNotifHub nevet. Győződjön meg arról, hogy a projekt típusa 3D. A Hely beállításnál adja meg az Önnek megfelelő helyet (ne feledje, hogy a gyökérkönyvtárakhoz közelebb is jobb). Ezután kattintson a Create project (Projekt létrehozása) elemre.

    projekt létrehozása

  3. Ha a Unity meg van nyitva, érdemes ellenőrizni, hogy az alapértelmezett Script Editor értéke Visual Studio. Lépjen a Beállításokszerkesztése lapra, majd az új ablakban lépjen a Külső eszközök elemre. Módosítsa a Külső szkriptszerkesztőta 2017 Visual Studio re. Zárja be a Beállítások ablakot.

    külső VS-eszközök beállítása

  4. Ezután a Fájl build Gépház válassza Windows Universal Windows Platform lehetőséget, majd kattintson a Switch Platform (Platformváltás) gombra a választás alkalmazáshoz.

    platformok váltása

  5. Amíg továbbra is a Fájlbuild Gépház,győződjön meg a következőről:

    1. A Céleszköz beállítása Bármely eszköz

      Ez az alkalmazás az asztalra fog kapcsolódni, ezért a Bármely eszköznek kell lennie

    2. A Build Type (Build típusa) beállítása D3D

    3. Az SDK a Legújabb telepítve beállításra van állítva

    4. Visual Studio Verziója a Legújabb telepítve beállításra van állítva

    5. A Build and Run (Összeállítás és futtatás) beállítása Local Machine (Helyi gép)

    6. Amíg itt van, érdemes menteni a jelenet, és hozzáadni a buildhez.

      1. Ehhez válassza az Add Open Scenes (Nyitott jelenetek hozzáadása) gombra. Megjelenik egy Mentés ablak.

        nyitott jelenetek hozzáadása

      2. Hozzon létre egy új mappát ehhez és minden jövőbeli jelenethez, majd válassza az Új mappa gombot egy új mappa létrehozásához, és adja neki a Scenes nevet.

        új jelenetek mappája

      3. Nyissa meg az újonnan létrehozott Scenes mappát, majd a Fájlnév: szövegmezőbe írja be a NH_Desktop_Scene,majd nyomja le a Mentés gombot.

        új NH_Desktop_Scene

    7. A Build Gépház többibeállítását az alapértelmezett értéken kell hagynunk.

  6. Ugyanabban az ablakban kattintson a Player Gépház gombra, ezzel megnyitja a kapcsolódó panelt abban a térben, ahol az Inspector található.

  7. Ezen a panelen ellenőrizni kell néhány beállítást:

    1. Az Egyéb Gépház lapon:

      1. A parancsprogram-futtatás verziójának kísérletinek kell lennie (.NET 4.6-os megfelelő)

      2. A szkriptek háttérrendszerének.NET-nek kell lennie

      3. Az API kompatibilitási szintjének.NET 4.6-nak kell lennie

        4.6 net verzió

    2. A Közzétételi lap Gépház a Képességek alattellenőrizze a következőt:

      • InternetClient

        internetes ügyfél órajele

  8. A Build GépházUnity C# Projects már nem szürkül ki; jelölje be a mellette látható jelölőnégyzetet.

  9. Zárja be a Build Gépház ablakot.

  10. Mentse a scene (Jelenet mentése) Project FileSave Scene /FileSave Project.

    Fontos

    Ha ki szeretné hagyni aUnity Set up összetevőt ehhez a projekthez (Desktop App), és közvetlenül a kódba szeretne haladni, nyugodtan töltse le ezt a .unitypackagecsomagot, importálja a projektbe egyéni csomagként, majd folytassa a 9.fejezetből. A szkriptösszetevők hozzáadására továbbra is szükség van.

8. fejezet – A DLL-ek importálása a Unityben

Az Azure Storage Unityt fogja használni (amely maga az Azure-hoz készült .Net SDK-t használja). További információért kövesse ezt a hivatkozást az Azure Storage for Unityvel kapcsolatban.

A Unityben jelenleg van egy ismert probléma, amely miatt az importálás után újra kell konfigurálni a beépülő modulokat. Ezek a lépések (a szakasz 4–7. lépései) a hiba megoldása után már nem szükségesek.

Az SDK saját projektbe való importálásához győződjön meg arról, hogy letöltötte a legújabb .unitypackage fájlt a GitHub. Ezután tegye a következőket:

  1. Adja hozzá a .unitypackage-et a Unityhez az Assets Import Package Custom Package menüpont használatával.

  2. A felugró Import Unity Package mezőben mindent kiválaszthat a Beépülő modul Storage. Törölje a jelölést minden más jelölőnégyzetből, mert erre a kurzusra nincs szükség.

    importálás csomagba

  3. Kattintson az Importálás gombra az elemek projekthez való hozzáadásához.

  4. Az Storage nézet Beépülő modulok Project mappájában válassza ki a következő beépülő modulokat:

    • Microsoft.Data.Edm
    • Microsoft.Data.OData
    • Microsoft.WindowsAzure.Storage
    • Newtonsoft.Json
    • System.Spatial

Törölje a Bármely platform jelölőnégyzet jelölését

  1. Ha ezek a beépülő modulok kivannak jelölve,törölje aBármely platform jelölőnégyzet jelölését, törölje a jelölést aWSAPlayer jelölőnégyzetből, majd kattintson az Apply (Alkalmaz) gombra.

    platform-dll-fájlok alkalmazása

    Megjegyzés

    Ezeket a beépülő modulokat úgy jelöljük meg, hogy csak a Unity-szerkesztőben használhatók. Ennek az az oka, hogy ugyanazoknak a beépülő moduloknak különböző verziói vannak a WSA mappában, amelyek a projekt Unityből való exportálása után lesznek használva.

  2. A Storage beépülő modul mappájában csak a következőt válassza:

    • Microsoft.Data.Services.Client

      set don't process for dlls

  3. Jelölje be a Nem kell feldolgozni jelölőnégyzetet a Platform Gépház majd kattintson az Alkalmaz gombra.

    feldolgozás nélkül

    Megjegyzés

    Ezt a beépülő modult azért jelöljük meg "Nincs feldolgozás" jelöléssel, mert a Unity szerelvény-javítója nehezen tudja feldolgozni ezt a beépülő modult. A beépülő modul akkor is működni fog, ha nincs feldolgozva.

9. fejezet – A TableToScene osztály létrehozása a Desktop Unity-projektben

Most létre kell hoznia az alkalmazás futtatásához szükséges kódot tartalmazó szkripteket.

Az első szkript, amelyet létre kell hoznia, a TableToScene,amely a következőért felelős:

  • Entitások olvasása az Azure-táblában.
  • A Táblaadatok használatával határozza meg, hogy mely objektumokat kell kihozni, és melyik pozícióban.

A második szkript, amelyet létre kell hoznia, a CloudScene,amely a következőért felelős:

  • A bal kattintásos esemény regisztrálása, hogy a felhasználó objektumokat húzhat a jelenet köré.
  • Az objektumadatok szerializálása ebből a Unity-jelenetből, majd küldésük az Azure-függvényalkalmazásba.

Az osztály létrehozása:

  1. Kattintson a jobb gombbal az Asset Folder (Eszközmappa) mappára, amely a Project Create Folder (Mappa létrehozása)panelen található. A mappának a Scripts (Szkriptek) nevet kell írnia.

    szkriptek létrehozása mappa

    create scripts folder 2

  2. Kattintson duplán a most létrehozott mappára a megnyitásához.

  3. Kattintson a jobb gombbal a Scripts (Szkriptek) mappára, majd kattintson a CreateC# Script (C#-szkript létrehozása) parancsra. A szkriptnek nevezze el a TableToScene nevet.

    újtableToScene c#-szkript átnevezése

  4. Kattintson duplán a szkriptre a 2017-es Visual Studio megnyitásához.

  5. Adja hozzá a következő névtereket:

    using Microsoft.WindowsAzure.Storage;
    using Microsoft.WindowsAzure.Storage.Auth;
    using Microsoft.WindowsAzure.Storage.Table;
    using UnityEngine;
    
  6. A osztályba szúrja be a következő változókat:

        /// <summary>    
        /// allows this class to behave like a singleton
        /// </summary>    
        public static TableToScene instance;
    
        /// <summary>    
        /// Insert here you Azure Storage name     
        /// </summary>    
        private string accountName = " -- Insert your Azure Storage name -- ";
    
        /// <summary>    
        /// Insert here you Azure Storage key    
        /// </summary>    
        private string accountKey = " -- Insert your Azure Storage key -- ";
    

    Megjegyzés

    Az accountName értéket helyettesítse be az Azure Storage Service name (Azure Storage-szolgáltatásnév) és az accountKey (fiókkulcs) értékkel az Azure Portal Azure Storage Service (Azure Storage Szolgáltatás) kulcsértékével (lásd az alábbi képet).

    fiókkulcs lekérése

  7. Most adja hozzá a Start() és az Azűi() metódusokat az osztály inicializálására.

        /// <summary>
        /// Triggers before initialization
        /// </summary>
        void Awake()
        {
            // static instance of this class
            instance = this;
        }
    
        /// <summary>
        /// Use this for initialization
        /// </summary>
        void Start()
        {  
            // Call method to populate the scene with new objects as 
            // pecified in the Azure Table
            PopulateSceneFromTableAsync();
        }
    
  8. A TableToScene osztályban adja hozzá a metódust, amely lekéri az értékeket az Azure-táblából, és használja őket a megfelelő primitívek a jelenetből való kinyeréséhez.

        /// <summary>    
        /// Populate the scene with new objects as specified in the Azure Table    
        /// </summary>    
        private async void PopulateSceneFromTableAsync()
        {
            // Obtain credentials for the Azure Storage
            StorageCredentials creds = new StorageCredentials(accountName, accountKey);
    
            // Storage account
            CloudStorageAccount account = new CloudStorageAccount(creds, useHttps: true);
    
            // Storage client
            CloudTableClient client = account.CreateCloudTableClient(); 
    
            // Table reference
            CloudTable table = client.GetTableReference("SceneObjectsTable");
    
            TableContinuationToken token = null;
    
            // Query the table for every existing Entity
            do
            {
                // Queries the whole table by breaking it into segments
                // (would happen only if the table had huge number of Entities)
                TableQuerySegment<AzureTableEntity> queryResult = await table.ExecuteQuerySegmentedAsync(new TableQuery<AzureTableEntity>(), token); 
    
                foreach (AzureTableEntity entity in queryResult.Results)
                {
                    GameObject newSceneGameObject = null;
                    Color newColor;
    
                    // check for the Entity Type and spawn in the scene the appropriate Primitive
                    switch (entity.Type)
                    {
                        case "Cube":
                            // Create a Cube in the scene
                            newSceneGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
                            newColor = Color.blue;
                            break;
    
                        case "Sphere":
                            // Create a Sphere in the scene
                            newSceneGameObject = GameObject.CreatePrimitive(PrimitiveType.Sphere);
                            newColor = Color.red;
                            break;
    
                        case "Cylinder":
                            // Create a Cylinder in the scene
                            newSceneGameObject = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
                            newColor = Color.yellow;
                            break;
                        default:
                            newColor = Color.white;
                            break;
                    }
    
                    newSceneGameObject.name = entity.RowKey;
    
                    newSceneGameObject.GetComponent<MeshRenderer>().material = new Material(Shader.Find("Diffuse"))
                    {
                        color = newColor
                    };
    
                    //check for the Entity X,Y,Z and move the Primitive at those coordinates
                    newSceneGameObject.transform.position = new Vector3((float)entity.X, (float)entity.Y, (float)entity.Z);
                }
    
                // if the token is null, it means there are no more segments left to query
                token = queryResult.ContinuationToken;
            }
    
            while (token != null);
        }
    
  9. A TableToScene osztályon kívül meg kell határoznia az alkalmazás által a táblaentitások szerializálásához és de szerializálásához használt osztályt.

        /// <summary>
        /// This objects is used to serialize and deserialize the Azure Table Entity
        /// </summary>
        [System.Serializable]
        public class AzureTableEntity : TableEntity
        {
            public AzureTableEntity(string partitionKey, string rowKey)
                : base(partitionKey, rowKey) { }
    
            public AzureTableEntity() { }
            public string Type { get; set; }
            public double X { get; set; }
            public double Y { get; set; }
            public double Z { get; set; }
        }
    
  10. A Unity-szerkesztőbe való visszaút előtt mindenképpen mentse a mentést.

  11. Kattintson a Main Camera (Fő kamera) elemre a Hierarchy (Hierarchia) panelen, hogy a tulajdonságai megjelenjenek az Inspector (Vizsgáló) panelen.

  12. Ha a Scripts mappa meg van nyitva, válassza ki a TableToScene fájlt, és húzza a Main Camera (Fő kamera) gombra. Az eredménynek a következőnek kell lennie:

    szkript hozzáadása a fő kamerához

10. fejezet – A CloudScene osztály létrehozása a Desktop Unity-Project

A második szkript, amelyet létre kell hoznia, a CloudScene,amely a következőért felelős:

  • A bal kattintásos esemény regisztrálása, hogy a felhasználó objektumokat húzhat a jelenet köré.

  • Az objektumadatok szerializálása ebből a Unity-jelenetből, majd küldésük az Azure-függvényalkalmazásba.

A második szkript létrehozása:

  1. Kattintson a jobb gombbal a Scripts (Szkriptek) mappára, majd kattintson a Create (Létrehozás) parancsra,majd a C# script (C# szkript létrehozása) parancsra. A szkriptnek a CloudScene nevet kell adni

    új c#-szkriptátnevezése CloudScene-ről

  2. Adja hozzá a következő névtereket:

    using Newtonsoft.Json;
    using System.Collections;
    using System.Text;
    using System.Threading.Tasks;
    using UnityEngine;
    using UnityEngine.Networking;
    
  3. Szúrja be a következő változókat:

        /// <summary>
        /// Allows this class to behave like a singleton
        /// </summary>
        public static CloudScene instance;
    
        /// <summary>
        /// Insert here you Azure Function Url
        /// </summary>
        private string azureFunctionEndpoint = "--Insert here you Azure Function Endpoint--";
    
        /// <summary>
        /// Flag for object being moved
        /// </summary>
        private bool gameObjHasMoved;
    
        /// <summary>
        /// Transform of the object being dragged by the mouse
        /// </summary>
        private Transform gameObjHeld;
    
        /// <summary>
        /// Class hosted in the TableToScene script
        /// </summary>
        private AzureTableEntity azureTableEntity;
    
  4. Helyettesítse be az azureFunctionEndpoint értéket az Azure Function App App Service-ben található Azure-függvényalkalmazás URL-címével az Azure Portalon, az alábbi képen látható módon:

    függvény URL-címének lekért címe

  5. Most adja hozzá a Start() és az Azűi() metódusokat az osztály inicializálására.

        /// <summary>
        /// Triggers before initialization
        /// </summary>
        void Awake()
        {
            // static instance of this class
            instance = this;
        }
    
        /// <summary>
        /// Use this for initialization
        /// </summary>
        void Start()
        {
            // initialise an AzureTableEntity
            azureTableEntity = new AzureTableEntity();
        }
    
  6. Az Update() metódusban adja hozzá a következő kódot, amely észleli az egér bemenetét, és húzással áthelyezi a GameObjects kódot a jelenetbe. Ha a felhasználó áthúzott és eldobott egy objektumot, akkor az objektum nevét és koordinátáit az UpdateCloudScene()metódusnak adja át, amely az Azure-függvényalkalmazás szolgáltatást hívja meg, amely frissíti az Azure-táblát, és aktiválja az értesítést.

        /// <summary>
        /// Update is called once per frame
        /// </summary>
        void Update()
        {
            //Enable Drag if button is held down
            if (Input.GetMouseButton(0))
            {
                // Get the mouse position
                Vector3 mousePosition = new Vector3(Input.mousePosition.x, Input.mousePosition.y, 10);
    
                Vector3 objPos = Camera.main.ScreenToWorldPoint(mousePosition);
    
                Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
    
                RaycastHit hit;
    
                // Raycast from the current mouse position to the object overlapped by the mouse
                if (Physics.Raycast(ray, out hit))
                {
                    // update the position of the object "hit" by the mouse
                    hit.transform.position = objPos;
    
                    gameObjHasMoved = true;
    
                    gameObjHeld = hit.transform;
                }
            }
    
            // check if the left button mouse is released while holding an object
            if (Input.GetMouseButtonUp(0) && gameObjHasMoved)
            {
                gameObjHasMoved = false;
    
                // Call the Azure Function that will update the appropriate Entity in the Azure Table
                // and send a Notification to all subscribed Apps
                Debug.Log("Calling Azure Function");
    
                StartCoroutine(UpdateCloudScene(gameObjHeld.name, gameObjHeld.position.x, gameObjHeld.position.y, gameObjHeld.position.z));
            }
        }
    
  7. Most adja hozzá az UpdateCloudScene() metódust az alábbiak szerint:

        private IEnumerator UpdateCloudScene(string objName, double xPos, double yPos, double zPos)
        {
            WWWForm form = new WWWForm();
    
            // set the properties of the AzureTableEntity
            azureTableEntity.RowKey = objName;
    
            azureTableEntity.X = xPos;
    
            azureTableEntity.Y = yPos;
    
            azureTableEntity.Z = zPos;
    
            // Serialize the AzureTableEntity object to be sent to Azure
            string jsonObject = JsonConvert.SerializeObject(azureTableEntity);
    
            using (UnityWebRequest www = UnityWebRequest.Post(azureFunctionEndpoint, jsonObject))
            {
                byte[] jsonToSend = new System.Text.UTF8Encoding().GetBytes(jsonObject);
    
                www.uploadHandler = new UploadHandlerRaw(jsonToSend);
    
                www.uploadHandler.contentType = "application/json";
    
                www.downloadHandler = new DownloadHandlerBuffer();
    
                www.SetRequestHeader("Content-Type", "application/json");
    
                yield return www.SendWebRequest();
    
                string response = www.responseCode.ToString();
            }
        }
    
  8. Mentse a kódot, és térjen vissza a Unitybe

  9. Húzza a CloudScene szkriptet a Main Camera (Fő kamera) alkalmazásba.

    1. Kattintson a Main Camera (Fő kamera) elemre a Hierarchy (Hierarchia) panelen, hogy a tulajdonságai megjelenjenek az Inspector (Vizsgáló) panelen.

    2. Ha a Scripts mappa meg van nyitva, válassza ki a CloudScene szkriptet, és húzza a Main Camera (Fő kamera) gombra. Az eredménynek a következőnek kell lennie:

      felhőbeli szkript áthúzva a fő kamerára

11. fejezet – Az asztali verzió Project UWP-re

A projekt Unity szakaszának minden szükséges művelete befejeződött.

  1. Lépjen a Build Gépház (FileBuild Gépház).

  2. A Build Gépház kattintson a Build (Build) elemre.

    buildprojekt

  3. Megjelenik Fájlkezelő felugró ablak, amely a Build (Összeállítás) helyének helyére kéri. Hozzon létre egy új mappát (a bal felső sarokban található Új mappa elemre kattintva), és nevezze el BUILDS néven.

    új mappa a buildhez

    1. Nyissa meg az új BUILDS mappát, és hozzon létre egy másik mappát (még egyszer az Új mappa használatával), és nevezze el NH_Desktop_App.

      mappanév NH_Desktop_App

    2. A kiválasztott NH_Desktop_App meg. kattintson a Mappa kiválasztása elemre. A projekt létrehozása egy-egy percet is igénybe fog venni.

  4. A build Fájlkezelő meg az új projekt helyét. Nem kell azonban megnyitnia, mivel a következő néhány fejezetben először létre kell hoznia egy másik Unity-projektet.

12. fejezet – A Unity Mixed Reality beállítása Project

Az alábbiakban egy tipikus, vegyes valóságban való fejlesztésre vonatkozó beállítás van beállítva, és így jó sablon más projektekhez.

  1. Nyissa meg a Unityt, és kattintson a New (Új) elemre.

    új Unity-projekt

  2. Most meg kell adnia egy Unity-Project, és be kell szúrja a UnityMRNotifHub nevet. Győződjön meg arról, hogy a projekt típusa 3D. A Hely beállításnál adja meg az Önnek megfelelő helyet (ne feledje, hogy a gyökérkönyvtárakhoz közelebb van a jobb). Ezután kattintson a Create project (Projekt létrehozása) elemre.

    name UnityMRNotifHub

  3. Ha a Unity meg van nyitva, érdemes ellenőrizni, hogy az alapértelmezett Script Editor értéke Visual Studio. Lépjen a Beállításokszerkesztése lapra, majd az új ablakban lépjen a Külső eszközök elemre. Módosítsa a Külső szkriptszerkesztőta 2017 Visual Studio re. Zárja be a Beállítások ablakot.

    külső szerkesztő beállítása VS-hez

  4. Ezután a Fájl build Gépháza Platformváltás gombra kattintva váltson a Universal Windows Platform (Univerzális Windows platform)platformra.

    platformok váltása UWP-re

  5. A Fájl buildelőre Gépház, és győződjön meg a következőről:

    1. A Céleszköz beállítása Bármely eszköz

      A céleszköz Microsoft HoloLens állítsa a Céleszközt akövetkezőre: HoloLens.

    2. A Build Type (Build típusa) beállítása D3D

    3. Az SDK a Legújabb telepítve beállításra van állítva

    4. Visual Studio Verzió a Legújabb telepítve beállításra van állítva

    5. A Build and Run (Összeállítás és futtatás) beállítása Local Machine (Helyi gép)

    6. Bár itt érdemes menteni a jelenet, és hozzáadni a buildhez.

      1. Ehhez válassza az Add Open Scenes (Nyitott jelenetek hozzáadása) gombra. Megjelenik egy Mentés ablak.

        nyitott jelenetek hozzáadása

      2. Hozzon létre egy új mappát ehhez és minden jövőbeli jelenethez, majd válassza az Új mappa gombot egy új mappa létrehozásához, és adja neki a Scenes nevet.

        új jelenetek mappája

      3. Nyissa meg az újonnan létrehozott Scenes mappát, majd a Fájlnév: szövegmezőbe írja be a következőt: NH_MR_Scene,majd nyomja le a Mentés gombot.

        új jelenet – NH_MR_Scene

    7. A Build Gépház többibeállítását az alapértelmezett értéken kell hagynunk.

  6. Ugyanabban az ablakban kattintson a Player Gépház gombra, ezzel megnyitja a kapcsolódó panelt abban a térben, ahol az Inspector található.

    a lejátszó beállításainak megnyitása

  7. Ezen a panelen ellenőrizni kell néhány beállítást:

    1. Az Egyéb Gépház lapon:

      1. A parancsprogram-futtatás verziójának kísérletinek kell lennie (.NET 4.6-os megfelelő)

      2. A parancsfájl-háttérrendszernek.NET-nek kell lennie

      3. Az API-kompatibilitási szintlegyen .NET 4.6

        API-kompatibilitás

    2. A panelen lejjebb, az XR Gépház (a Publish Gépház(Közzététel) alatt) jelölje be a Virtual Reality supported (Virtuális valóságtámogatott) jelölőnégyzetet, és győződjön meg arról, hogy az Windows Mixed Reality SDK hozzá van adva

      xr-beállítások frissítése

    3. A Publishing Gépház lap Capabilities (Képességek) lapjána heck:

      • InternetClient

        internetes ügyfél órajele

  8. A Build Gépháza Unity C# Projects már nem szürke: jelölje be a mellette látható jelölőnégyzetet.

  9. Ha végzett ezekkel a módosításokkal, zárja be a Build Gépház ablakot.

  10. Mentse a jelenetét, és Project Save Scene / FileSave Project.

    Fontos

    Ha ki szeretné hagyni a Unity Set up összetevőt ehhez a projekthez (vegyes valóságú alkalmazás), és közvetlenül a kódba szeretne haladni, töltse le ezt a .unitypackagecsomagot, importálja a projektbe Custom Package-csomagként, majd folytassa a 14.fejezetből. A szkriptösszetevők hozzáadására továbbra is szükség lesz.

13. fejezet – A Mixed Reality Unity-hez Project

Az Azure Storage Unity-kódtárat fogja használni (amely az Azure-hoz készült .Net SDK-t használja). Kövesse ezt a hivatkozást az Azure Storage Unityvel való használatával. Jelenleg van egy ismert probléma a Unityben, amely miatt a beépülő modulokat újra kell konfigurálni az importálás után. Ezek a lépések (a szakasz 4–7. lépései) a hiba megoldása után már nem szükségesek.

Az SDK saját projektbe való importálásához győződjön meg arról, hogy letöltötte a legújabb .unitypackage fájlt. Ezután tegye a következőket:

  1. Adja hozzá a fentiekből letöltött .unitypackage-et a Unityhez az AssetsImport PackageCustom Package menüpont használatával.

  2. A felugró Import Unity Package (Unity-csomag importálása) mezőben mindent kiválaszthat a Beépülőmodul Storage.

    csomag importálása

  3. Kattintson az Importálás gombra az elemek projekthez való hozzáadásához.

  4. Az Storage nézet Beépülő modulok Project mappájában válassza ki a következő beépülő modulokat:

    • Microsoft.Data.Edm
    • Microsoft.Data.OData
    • Microsoft.WindowsAzure.Storage
    • Newtonsoft.Json
    • System.Spatial

    beépülő modulok kiválasztása

  5. Ha ezek a beépülő modulok kivannak jelölve,törölje aBármely platform jelölőnégyzet jelölését, törölje a jelölést aWSAPlayer jelölőnégyzetből, majd kattintson az Apply (Alkalmaz) gombra.

    platformváltozások alkalmazása

    Megjegyzés

    Ezeket a beépülő modulokat úgy jelöli meg, hogy csak a Unity-szerkesztőben használhatók. Ennek az az oka, hogy ugyanazoknak a beépülő moduloknak különböző verziói vannak a WSA mappában, amelyek a projekt Unityből való exportálása után lesznek használva.

  6. A Storage beépülő modul mappájában csak a következőt válassza:

    • Microsoft.Data.Services.Client

      adatszolgáltatások ügyfél kiválasztása

  7. Jelölje be a Nem kell feldolgozni jelölőnégyzetet a Platform Gépház majd kattintson az Alkalmaz gombra.

    ne feldolgozva

    Megjegyzés

    Ezt a beépülő modult azért "Nem kell feldolgozni", mert a Unity szerelvény-javítója nehezen tudja feldolgozni ezt a beépülő modult. A beépülő modul akkor is működni fog, ha nincs feldolgozva.

14. fejezet – A TableToScene osztály létrehozása a vegyes valóság Unity-projektben

A TableToScene osztály megegyezik a 9. fejezetben leírtak szerint. Hozza létre ugyanazt az osztályt a vegyes valóság Unity-Project a 9.fejezetben leírtak szerint.

Miután befejezte ezt a fejezetet, mindkét Unity-projektben be lesz állítva ez az osztály a Main Camera-on.

15. fejezet – A NotificationReceiver osztály létrehozása a Mixed Reality Unity Project

A második szkript, amelyet létre kell hoznia, a NotificationReceiver,amely a következőért felelős:

  • Az alkalmazás regisztrálása az értesítési központban inicializáláskor.
  • Az értesítési központból érkező értesítések figyelés.
  • Az objektumadatok deserializálása a fogadott értesítésekből.
  • Helyezze át a GameObjects-et a jelenetbe a deserializált adatok alapján.

A NotificationReceiver szkript létrehozása:

  1. Kattintson a jobb gombbal a Scripts (Szkriptek) mappára, majd kattintson a Create (Létrehozás) parancsra,majd a C# script (C# szkript létrehozása) parancsra. A szkriptnek nevezze el a NotificationReceiver nevet.

    create new c# scriptname it NotificationReceiver

  2. Kattintson duplán a szkriptre a megnyitásához.

  3. Adja hozzá a következő névtereket:

    //using Microsoft.WindowsAzure.Messaging;
    using Newtonsoft.Json;
    using System;
    using System.Collections;
    using UnityEngine;
    
    #if UNITY_WSA_10_0 && !UNITY_EDITOR
    using Windows.Networking.PushNotifications;
    #endif
    
  4. Szúrja be a következő változókat:

        /// <summary>
        /// allows this class to behave like a singleton
        /// </summary>
        public static NotificationReceiver instance;
    
        /// <summary>
        /// Value set by the notification, new object position
        /// </summary>
        Vector3 newObjPosition;
    
        /// <summary>
        /// Value set by the notification, object name
        /// </summary>
        string gameObjectName;
    
        /// <summary>
        /// Value set by the notification, new object position
        /// </summary>
        bool notifReceived;
    
        /// <summary>
        /// Insert here your Notification Hub Service name 
        /// </summary>
        private string hubName = " -- Insert the name of your service -- ";
    
        /// <summary>
        /// Insert here your Notification Hub Service "Listen endpoint"
        /// </summary>
        private string hubListenEndpoint = "-Insert your Notification Hub Service Listen endpoint-";
    
  5. Helyettesítse be a hubName értéket a Notification Hub-szolgáltatás nevével, a hubListenEndpoint értéket pedig az Azure Portal Hozzáférési szabályzatok lapján, az Azure Notification Hub szolgáltatásban található végpontértékkel (lásd az alábbi képet).

    notification hubs-szabályzatvégpont beszúrása

  6. Most adja hozzá a Start() és az Azűi() metódusokat az osztály inicializálására.

        /// <summary>
        /// Triggers before initialization
        /// </summary>
        void Awake()
        {
            // static instance of this class
            instance = this;
        }
    
        /// <summary>
        /// Use this for initialization
        /// </summary>
        void Start()
        {
            // Register the App at launch
            InitNotificationsAsync();
    
            // Begin listening for notifications
            StartCoroutine(WaitForNotification());
        }
    
  7. Adja hozzá a WaitForNotification metódust, hogy az alkalmazás értesítéseket fogad a Notification Hub-kódtárból anélkül, hogy ütközni kellene a főszálral:

        /// <summary>
        /// This notification listener is necessary to avoid clashes 
        /// between the notification hub and the main thread   
        /// </summary>
        private IEnumerator WaitForNotification()
        {
            while (true)
            {
                // Checks for notifications each second
                yield return new WaitForSeconds(1f);
    
                if (notifReceived)
                {
                    // If a notification is arrived, moved the appropriate object to the new position
                    GameObject.Find(gameObjectName).transform.position = newObjPosition;
    
                    // Reset the flag
                    notifReceived = false;
                }
            }
        }
    
  8. A következő metódus, az InitNotificationAsync()az inicializáláskor regisztrálja az alkalmazást az értesítési központ szolgáltatásban. A kód megjegyzésként van ékesedve, mivel a Unity nem fogja tudni buildálni a projektet. A megjegyzéseket akkor távolítja el, amikor importálja az Azure Messaging Nuget-csomagot a Visual Studio.

        /// <summary>
        /// Register this application to the Notification Hub Service
        /// </summary>
        private async void InitNotificationsAsync()
        {
            // PushNotificationChannel channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
    
            // NotificationHub hub = new NotificationHub(hubName, hubListenEndpoint);
    
            // Registration result = await hub.RegisterNativeAsync(channel.Uri);
    
            // If registration was successful, subscribe to Push Notifications
            // if (result.RegistrationId != null)
            // {
            //     Debug.Log($"Registration Successful: {result.RegistrationId}");
            //     channel.PushNotificationReceived += Channel_PushNotificationReceived;
            // }
        }
    
  9. A következő kezelő, Channel_PushNotificationReceived(), minden alkalommal aktiválódik, amikor értesítés érkezik. Deserializálja az értesítést, amely az asztali alkalmazásba áthelyezett Azure Table Entity lesz, majd az MR-jelenetben a megfelelő GameObjectet áthelyezi ugyanabba a pozícióba.

    Fontos

    A kód megjegyzésbe van küldődve, mert a kód az Azure Messaging-kódtárra hivatkozik, amelyet a Unity-projekt NuGet-Csomagkezelő létrehozása után kell Visual Studio. Így a Unity-projekt csak akkor tud buildet használni, ha megjegyzésbe van ékelődve. Vegye figyelembe, hogy ha felépíti a projektet, majd vissza szeretne térni a Unityhez, újra hozzá kell fűzni a kódot.

        ///// <summary>
        ///// Handler called when a Push Notification is received
        ///// </summary>
        //private void Channel_PushNotificationReceived(PushNotificationChannel sender, PushNotificationReceivedEventArgs args)    
        //{
        //    Debug.Log("New Push Notification Received");
        //
        //    if (args.NotificationType == PushNotificationType.Raw)
        //    {
        //        //  Raw content of the Notification
        //        string jsonContent = args.RawNotification.Content;
        //
        //        // Deserialise the Raw content into an AzureTableEntity object
        //        AzureTableEntity ate = JsonConvert.DeserializeObject<AzureTableEntity>(jsonContent);
        //
        //        // The name of the Game Object to be moved
        //        gameObjectName = ate.RowKey;          
        //
        //        // The position where the Game Object has to be moved
        //        newObjPosition = new Vector3((float)ate.X, (float)ate.Y, (float)ate.Z);
        //
        //        // Flag thats a notification has been received
        //        notifReceived = true;
        //    }
        //}
    
  10. Ne felejtse el menteni a módosításokat, mielőtt visszatér a Unity-szerkesztőbe.

  11. Kattintson a Main Camera (Fő kamera) elemre a Hierarchy (Hierarchia) panelen, hogy a tulajdonságai megjelenjenek az Inspector (Vizsgáló) panelen.

  12. Ha a Scripts mappa meg van nyitva, válassza ki a NotificationReceiver szkriptet, és húzza a Main Camera (Fő kamera) gombra. Az eredménynek a következőnek kell lennie:

    az értesítés fogadó szkriptjének húzása a kamerába

    Megjegyzés

    Ha ezt az alkalmazáshoz fejleszti Microsoft HoloLens, frissítenie kell a Main Cameracamera összetevőt, hogy:

    • Clear Flags: Folytonos szín
    • Háttér: Fekete

16. fejezet – A Mixed Reality Project az UWP-re

Ez a fejezet megegyezik az előző projekt buildfolyamatának folyamattal. A projekt Unity szakaszának minden szükséges művelete befejeződött, így ideje a Unityből felépíteni.

  1. Lépjen a Build Gépház ( FileBuild Gépház ).

  2. A Build Gépház menüben ellenőrizze, hogy a Unity C# Projects* be van-e pipálva (így a build után szerkesztheti a projekt szkriptjét).

  3. Ha ezzel végzett, kattintson a Build (Build) gombra.

    buildprojekt

  4. Megjelenik Fájlkezelő felugró ablak, amely a Build (Összeállítás) helyének helyére kéri. Hozzon létre egy új mappát (a bal felső sarokban található New Folder (Új mappa) gombra kattintva), és nevezze el BUILDS néven.

    create builds mappa

    1. Nyissa meg az új BUILDS mappát, és hozzon létre egy másik mappát (még egyszer az Új mappa használatával), és nevezze el NH_MR_App.

      mappa NH_MR_Apps létrehozása

    2. A NH_MR_App meg. Kattintson a Mappa kiválasztása elemre. A projekt létrehozása egy-egy percet is igénybe fog venni.

  5. A buildet követően megnyílik Fájlkezelő ablak az új projekt helyén.

17. fejezet – NuGet-csomagok hozzáadása a UnityMRNotifHub megoldáshoz

Figyelmeztetés

Ne feledje, hogy ha hozzáadja a következő NuGet-csomagokat (és visszaveszi a megjegyzésként a kódot a következő fejezetben), a Kód, amikor újra megnyitja a Unity Project, hibákat fog tartalmazni. Ha vissza szeretne menni, és folytatni szeretné a szerkesztést a Unity-szerkesztőben, szüksége lesz egy megjegyzésre a hibakódhoz, majd később, miután visszatért a Visual Studio.

Miután a vegyes valóságú build elkészült, lépjen a vegyes valóság projekthez, amelyet Ön épített, és kattintson duplán a mappában található megoldásfájlra (.sln) a megoldás 2017-es Visual Studio megnyitásához. Most hozzá kell majd adni a WindowsAzure.Messaging.managed NuGet-csomagot; Ez egy olyan kódtár, amely értesítések fogadására használható az értesítési központtól.

A NuGet-csomag importálása:

  1. A Megoldáskezelőkattintson a jobb gombbal a megoldásra

  2. Kattintson a Manage NuGet Packages (NuGet-csomagok kezelése) elemre.

    a NuGet-kezelő megnyitása

  3. Válassza a Tallózás lapot, és keresse meg a WindowsAzure.Messaging.managed et.

    Windows Azure üzenetkezelési csomag megkeresása

  4. Válassza ki az eredményt (ahogy az alább látható), majd a jobb oldalon található ablakban jelölje be az Project. Ezzel bejelöli a jelölőnégyzetet a Projectmellett, valamint az Assembly-CSharp és a UnityMRNotifHub projekt melletti jelölőnégyzetet.

    az összes projekt órajele

  5. Előfordulhat, hogy az eredetileg megadott verzió nem kompatibilis ezzel a projekttel. Ezért kattintson a Verzió melletti legördülő menüre, és kattintson a 0.1.7.9-esverzió elemre, majd kattintson a Telepítés parancsra.

  6. Befejezte a NuGet-csomag telepítését. Keresse meg a NotificationReceiver osztályban megadott megjegyzéskódot, és távolítsa el a megjegyzéseket.

18. fejezet – UnityMRNotifHub alkalmazás szerkesztése, NotificationReceiver osztály

Miután hozzáadta a NuGet-csomagokat,a NotificationReceiver osztályon belül néhány kódot vissza kell majd mondania.

Ide tartoznak az alábbiak:

  1. A felül található névtér:

    using Microsoft.WindowsAzure.Messaging;
    
  2. Az InitNotificationsAsync() metódusban található összes kód:

        /// <summary>
        /// Register this application to the Notification Hub Service
        /// </summary>
        private async void InitNotificationsAsync()
        {
            PushNotificationChannel channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
    
            NotificationHub hub = new NotificationHub(hubName, hubListenEndpoint);
    
            Registration result = await hub.RegisterNativeAsync(channel.Uri);
    
            // If registration was successful, subscribe to Push Notifications
            if (result.RegistrationId != null)
            {
                Debug.Log($"Registration Successful: {result.RegistrationId}");
                channel.PushNotificationReceived += Channel_PushNotificationReceived;
            }
        }
    

Figyelmeztetés

A fenti kódban megjegyzés is látható: győződjön meg arról, hogy nem törölte véletlenül a megjegyzés megjegyzésként való megjegyzésként való megjegyzését (mert a kód nem lesz lefordítva, ha van!).

  1. Végül pedig a Channel_PushNotificationReceived esemény:

        /// <summary>
        /// Handler called when a Push Notification is received
        /// </summary>
        private void Channel_PushNotificationReceived(PushNotificationChannel sender, PushNotificationReceivedEventArgs args)
        {
            Debug.Log("New Push Notification Received");
    
            if (args.NotificationType == PushNotificationType.Raw)
            {
                //  Raw content of the Notification
                string jsonContent = args.RawNotification.Content;
    
                // Deserialize the Raw content into an AzureTableEntity object
                AzureTableEntity ate = JsonConvert.DeserializeObject<AzureTableEntity>(jsonContent);
    
                // The name of the Game Object to be moved
                gameObjectName = ate.RowKey;
    
                // The position where the Game Object has to be moved
                newObjPosition = new Vector3((float)ate.X, (float)ate.Y, (float)ate.Z);
    
                // Flag thats a notification has been received
                notifReceived = true;
            }
        }
    

A nem tömörített fájlokat mentse, majd folytassa a következő fejezettel.

19. fejezet – A vegyes valóságú projekt társítása az Áruház alkalmazással

Most társítania kell a vegyes valóságú projektet a labor elején létrehozott Áruházbeli alkalmazáshoz.

  1. Nyissa meg a megoldást.

  2. Kattintson a jobb gombbal az UWP-Project a Megoldáskezelő panelen, válassza az Áruház, majd az Alkalmazás társítása az Áruházhoz... menüpontot.

    nyitott áruház társítása

  3. Megjelenik az Associate Your App with the Windows Store (Alkalmazás társítása a Windows Store Windows ablakban. Kattintson a Tovább gombra.

    ugrás a következő képernyőre

  4. Ez betölti a bejelentkezett fiókhoz társított összes alkalmazást. Ha nincs bejelentkezve a fiókjába, ezen az oldalon jelentkezhet be.

  5. Keresse meg az oktatóanyag elején létrehozott Áruházbeli alkalmazás nevét, és válassza ki. Ezután kattintson a Tovább gombra.

    üzletnév megkeresve és kiválasztva

  6. Kattintson a Társítás gombra.

    alkalmazás társítása

  7. Az alkalmazás mostantól társítva van az Áruházbeli alkalmazással. Ez az értesítések engedélyezéséhez szükséges.

20. fejezet – UnityMRNotifHub és UnityDesktopNotifHub-alkalmazások üzembe helyezése

Ez a fejezet egyszerűbb lehet két ember esetén, mivel az eredményben a két alkalmazás fut, az egyik a Asztali számítógépen fut, a másik pedig a modern headseten belül.

A modern headset-alkalmazás arra vár, hogy megkapja a jelenet módosításait (a helyi GameObjects pozíciójának módosításait), és az asztali alkalmazás módosításokat fog módosításokat a helyi jeleneten (pozícióváltozások), amelyeket az MR-alkalmazással fog megosztani. Logikus először üzembe helyezni az MR alkalmazást, majd az asztali alkalmazást, hogy a fogadó megkezdje a figyelését.

A UnityMRNotifHub alkalmazás üzembe helyezése a helyi gépen:

  1. Nyissa meg a UnityMRNotifHub alkalmazás megoldásfájlját a 2017 Visual Studio ben.

  2. A Megoldásplatformonválassza az x86, helyi gép lehetőséget.

  3. A Megoldáskonfigurációban válassza a Hibakeresés lehetőséget.

    projektkonfiguráció beállítása

  4. A Build (Build) menüben kattintson a Deploy Solution (Megoldás üzembe helyezése) elemre az alkalmazás saját gépre való telepítéséhez.

  5. Az alkalmazásnak most már meg kell jelenni a telepített alkalmazások listájában, amely készen áll a telepítésre.

A UnityDesktopNotifHub alkalmazás üzembe helyezése a helyi gépen:

  1. Nyissa meg a UnityDesktopNotifHub alkalmazás megoldásfájlját a 2017 Visual Studio ban.

  2. A Megoldásplatformonválassza az x86, helyi gép lehetőséget.

  3. A Megoldáskonfigurációban válassza a Hibakeresés lehetőséget.

    projektkonfiguráció beállítása

  4. A Build (Build) menüben kattintson a Deploy Solution (Megoldás üzembe helyezése) elemre az alkalmazás saját gépre való telepítéséhez.

  5. Az alkalmazásnak most már meg kell jelenni a telepített alkalmazások listájában, amely készen áll a telepítésre.

  6. Indítsa el a vegyes valóságot, majd az asztali alkalmazást.

Ha mindkét alkalmazás fut, helyezzen át egy objektumot az asztali jelenetben (a bal egérgombbal). Ezek a pozícióváltozások helyben, szerializálva lesznek, és el lesznek küldve a függvényalkalmazás szolgáltatásnak. A függvényalkalmazás szolgáltatás ezután frissíti a táblát az értesítési központkal együtt. A frissítés fogadása után az értesítési központ elküldi a frissített adatokat közvetlenül az összes regisztrált alkalmazásnak (ebben az esetben a modern headset-alkalmazásnak), amely aztán deerializálja a bejövő adatokat, és alkalmazza az új pozícióadatokat a helyi objektumokra, és a jelenetbe mozgatja őket.

Az Elkészült Azure Notification Hubs-alkalmazás

Gratulálunk, olyan vegyes valóságú alkalmazást épített, amely kihasználja az Azure Notification Hubs szolgáltatást, és lehetővé teszi az alkalmazások közötti kommunikációt.

végleges termék vége

Soron kívüli gyakorlatok

1. gyakorlat

Meg tudja dolgozni, hogyan módosíthatja a GameObjects színét, és hogyan küldheti el az értesítést más alkalmazásoknak a jelenet megtekintéséhez?

2. gyakorlat

Hozzáadhatja a GameObjects mozgását az MR-alkalmazáshoz, és láthatja a frissített jeleneteket az asztali alkalmazásban?