HoloLens (första generationen) och Azure 308: Meddelanden mellan enheter

Artikel
07/04/2024

Kommentar

Självstudierna för Mixed Reality Academy har utformats med HoloLens (första generationen) och Mixed Reality Immersive Headsets i åtanke. Därför anser vi att det är viktigt att låta de här självstudierna vara kvar för utvecklare som fortfarande letar efter vägledning för att utveckla för dessa enheter. De här självstudierna uppdateras inte med de senaste verktygsuppsättningarna eller interaktionerna som används för HoloLens 2. De underhålls för att fortsätta arbeta med de enheter som stöds. Det kommer att finnas en ny serie självstudier som kommer att publiceras i framtiden som visar hur du utvecklar för HoloLens 2. Det här meddelandet uppdateras med en länk till de självstudierna när de publiceras.

slutprodukt - start

I den här kursen får du lära dig hur du lägger till Notification Hubs-funktioner i ett program för mixad verklighet med hjälp av Azure Notification Hubs, Azure Tables och Azure Functions.

Azure Notification Hubs är en Microsoft-tjänst som gör det möjligt för utvecklare att skicka riktade och anpassade push-meddelanden till valfri plattform, som alla drivs i molnet. Detta kan effektivt göra det möjligt för utvecklare att kommunicera med slutanvändare, eller till och med kommunicera mellan olika program, beroende på scenariot. Mer information finns på sidan Azure Notification Hubs.

Azure Functions är en Microsoft-tjänst som gör det möjligt för utvecklare att köra små koddelar, "functions", i Azure. Detta ger ett sätt att delegera arbete till molnet i stället för ditt lokala program, vilket kan ha många fördelar. Azure Functions stöder flera utvecklingsspråk, inklusive C#, F#, Node.js, Java och PHP. Mer information finns på sidan Azure Functions.

Azure Tables är en Microsoft-molntjänst som gör det möjligt för utvecklare att lagra strukturerade icke-SQL-data i molnet, vilket gör dem lättillgängliga var som helst. Tjänsten har en schemalös design som möjliggör utvecklingen av tabeller efter behov och är därför mycket flexibel. Mer information finns på sidan Azure-tabeller

Efter att ha slutfört den här kursen kommer du att ha ett uppslukande headsetprogram för mixad verklighet och ett skrivbordsdatorprogram, som kommer att kunna göra följande:

Desktop PC-appen gör att användaren kan flytta ett objekt i 2D-utrymme (X och Y) med musen.
Förflyttningen av objekt i PC-appen skickas till molnet med hjälp av JSON, som kommer att vara i form av en sträng som innehåller ett objekt-ID, typ och transformeringsinformation (X- och Y-koordinater).
Mixed Reality-appen, som har en identisk scen med skrivbordsappen, får meddelanden om objektflytt från Notification Hubs-tjänsten (som just har uppdaterats av Desktop PC-appen).
När du får ett meddelande, som innehåller objekt-ID, typ och transformeringsinformation, tillämpar appen mixed reality den mottagna informationen på sin egen scen.

I ditt program är det upp till dig hur du ska integrera resultaten med din design. Den här kursen är utformad för att lära dig hur du integrerar en Azure-tjänst med ditt Unity-projekt. Det är ditt jobb att använda den kunskap du får från den här kursen för att förbättra din mixed reality-app. Den här kursen är en fristående självstudiekurs som inte direkt involverar andra Mixed Reality Labs.

Stöd för enheter

Kurs	HoloLens	Uppslukande headset
MR och Azure 308: Meddelanden mellan enheter	✔️	✔️

Kommentar

Den här kursen fokuserar främst på Windows Mixed Reality-headset (VR) men du kan även använda det du lär dig i den här kursen för Microsoft HoloLens. När du följer kursen visas anteckningar om eventuella ändringar som du kan behöva använda för att stödja HoloLens. När du använder HoloLens kan du märka ett eko under röstinspelningen.

Förutsättningar

Kommentar

Den här självstudien är utformad för utvecklare som har grundläggande erfarenhet av Unity och C#. Tänk också på att förutsättningarna och de skriftliga instruktionerna i det här dokumentet representerar det som har testats och verifierats i skrivande stund (maj 2018). Du är fri att använda den senaste programvaran, som anges i artikeln installera verktyg , men det bör inte antas att informationen i den här kursen perfekt matchar vad du hittar i nyare programvara än vad som anges nedan.

Vi rekommenderar följande maskinvara och programvara för den här kursen:

En utvecklingsdator som är kompatibel med Windows Mixed Reality för avancerad (VR) headsetutveckling
Windows 10 Fall Creators Update (eller senare) med utvecklarläge aktiverat
Den senaste Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Ett Windows Mixed Reality-headset (VR) eller Microsoft HoloLens med utvecklarläge aktiverat
Internetåtkomst för Azure-installation och åtkomst till Notification Hubs

Innan du börjar

För att undvika problem med att skapa det här projektet rekommenderar vi starkt att du skapar projektet som nämns i den här självstudien i en rotmapp eller nära rotmapp (långa mappsökvägar kan orsaka problem vid byggtid).
Du måste vara ägare till Microsoft Developer Portal och programregistreringsportalen, annars har du inte behörighet att komma åt appen i kapitel 2.

Kapitel 1 – Skapa ett program på Microsoft Developer Portal

Om du vill använda Tjänsten Azure Notification Hubs måste du skapa ett program på Microsoft Developer Portal, eftersom ditt program måste registreras så att det kan skicka och ta emot meddelanden.

Logga in på Microsoft Developer Portal.

Du måste logga in på ditt Microsoft-konto.
Klicka på Skapa en ny app på instrumentpanelen.
Ett popup-fönster visas där du behöver reservera ett namn för din nya app. Infoga ett lämpligt namn i textrutan. Om det valda namnet är tillgängligt visas en bock till höger om textrutan. När du har infogat ett tillgängligt namn klickar du på knappen Reservera produktnamn längst ned till vänster i popup-fönstret.
När appen nu har skapats är du redo att gå vidare till nästa kapitel.

Kapitel 2 – Hämta dina nya autentiseringsuppgifter för appar

Logga in på programregistreringsportalen, där din nya app visas, och hämta de autentiseringsuppgifter som ska användas för att konfigurera Notification Hubs-tjänsten i Azure-portalen.

Gå till programregistreringsportalen.

Varning

Du måste använda ditt Microsoft-konto för att logga in.
Detta måste vara det Microsoft-konto som du använde i föregående kapitel med Windows Store Developer-portalen.
Du hittar din app under avsnittet Mina program . När du har hittat den klickar du på den så kommer du till en ny sida som har appnamnet plus Registrering.
Rulla nedåt på registreringssidan för att hitta avsnittet Programhemligheter och paket-SID för din app. Kopiera båda för användning med att konfigurera Azure Notification Hubs-tjänsten i nästa kapitel.

Kapitel 3 – Konfigurera Azure Portal: skapa Notification Hubs-tjänsten

När dina autentiseringsuppgifter för appar har hämtats måste du gå till Azure-portalen, där du skapar en Azure Notification Hubs-tjänst.

Logga in på Azure-portalen.

Kommentar

Om du inte redan har ett Azure-konto måste du skapa ett. Om du följer den här självstudien i en klassrums- eller labbsituation ber du din instruktör eller någon av rektorerna om hjälp med att konfigurera ditt nya konto.
När du är inloggad klickar du på Nytt i det övre vänstra hörnet och söker efter Notification Hub och klickar på Retur.

Kommentar

Ordet Nytt kan ha ersatts med Skapa en resurs i nyare portaler.
Den nya sidan innehåller en beskrivning av Notification Hubs-tjänsten . Längst ned till vänster i den här prompten väljer du knappen Skapa för att skapa en association med den här tjänsten.
När du har klickat på Skapa:
1. Infoga önskat namn för den här tjänstinstansen.
2. Ange ett namnområde som du kommer att kunna associera med den här appen.
3. Välj en plats.
4. Välj en resursgrupp eller skapa en ny. En resursgrupp är ett sätt att övervaka, kontrollera åtkomst, etablera och hantera fakturering för en samling Azure-tillgångar. Vi rekommenderar att du behåller alla Azure-tjänster som är associerade med ett enda projekt (t.ex. dessa labb) under en gemensam resursgrupp).
  
  Om du vill läsa mer om Azure-resursgrupper följer du den här länken om hur du hanterar en resursgrupp.
5. Välj en lämplig prenumeration.
6. Du måste också bekräfta att du har förstått de villkor som gäller för den här tjänsten.
7. Välj Skapa.
När du har klickat på Skapa måste du vänta tills tjänsten har skapats. Det kan ta en minut.
Ett meddelande visas i portalen när tjänstinstansen har skapats.
Klicka på knappen Gå till resurs i meddelandet för att utforska din nya tjänstinstans. Du kommer att tas till din nya Notification Hub-tjänstinstans .
Från översiktssidan, halvvägs ned på sidan, klickar du på Windows (WNS). Panelen till höger ändras till att visa två textfält, som kräver ditt paket-SID och säkerhetsnyckel, från appen som du konfigurerade tidigare.
När du har kopierat informationen till rätt fält klickar du på Spara och får ett meddelande när Meddelandehubben har uppdaterats.

Kapitel 4 – Konfigurera Azure Portal: skapa tabelltjänst

När du har skapat din Notification Hubs-tjänstinstans går du tillbaka till Azure-portalen, där du skapar en Azure Tables-tjänst genom att skapa en lagringsresurs.

Logga in på Azure-portalen om du inte redan är inloggad.
När du har loggat in klickar du på Nytt i det övre vänstra hörnet och söker efter Lagringskonto och klickar på Retur.

Kommentar

Ordet Nytt kan ha ersatts med Skapa en resurs i nyare portaler.
Välj Lagringskonto – blob, fil, tabell, kö från listan.
Den nya sidan innehåller en beskrivning av lagringskontotjänsten. Längst ned till vänster i den här prompten väljer du knappen Skapa för att skapa en instans av den här tjänsten.
När du har klickat på Skapa visas en panel:
1. Infoga önskat namn för den här tjänstinstansen (måste vara gemener).
2. För Distributionsmodell klickar du på Resource Manager.
3. För Typ av konto väljer du Lagring (generell användning v1) med hjälp av den nedrullningsbara menyn.
4. Välj en lämplig plats.
5. I listrutan Replikering väljer du Läs-åtkomst-geo-redundant lagring (RA-GRS).
6. För Prestanda klickar du på Standard.
7. I avsnittet Säker överföring krävs väljer du Inaktiverad.
8. I listrutan Prenumeration väljer du en lämplig prenumeration.
9. Välj en resursgrupp eller skapa en ny. En resursgrupp är ett sätt att övervaka, kontrollera åtkomst, etablera och hantera fakturering för en samling Azure-tillgångar. Vi rekommenderar att du behåller alla Azure-tjänster som är associerade med ett enda projekt (t.ex. dessa labb) under en gemensam resursgrupp).
  
  Om du vill läsa mer om Azure-resursgrupper följer du den här länken om hur du hanterar en resursgrupp.
10. Lämna Virtuella nätverk inaktiverade om det här är ett alternativ för dig.
11. Klicka på Skapa.
När du har klickat på Skapa måste du vänta tills tjänsten har skapats. Det kan ta en minut.
Ett meddelande visas i portalen när tjänstinstansen har skapats. Klicka på meddelandena för att utforska din nya tjänstinstans.
Klicka på knappen Gå till resurs i meddelandet för att utforska din nya tjänstinstans. Du kommer till den nya översiktssidan för Storage Service-instansen.
Klicka på Tabeller till höger på översiktssidan.
Panelen till höger ändras för att visa tabelltjänstinformationen, där du behöver lägga till en ny tabell. Gör detta genom att + klicka på knappen Tabell i det övre vänstra hörnet.
En ny sida visas, där du måste ange ett tabellnamn. Det här är det namn som du använder för att referera till data i ditt program i senare kapitel. Infoga ett lämpligt namn och klicka på OK.
När den nya tabellen har skapats kan du se den på sidan Tabelltjänst (längst ned).

Kapitel 5 – Slutföra Azure-tabellen i Visual Studio

Nu när ditt Table Service-lagringskonto har konfigurerats är det dags att lägga till data i det, som kommer att användas för att lagra och hämta information. Du kan redigera dina tabeller via Visual Studio.

Öppna Visual Studio.
På menyn klickar du på Visa>Cloud Explorer.
Cloud Explorer öppnas som ett dockat objekt (ha tålamod, eftersom inläsning kan ta tid).
Kommentar

Om den prenumeration som du använde för att skapa dina lagringskonton inte visas kontrollerar du att du har:
- Loggade in på samma konto som du använde för Azure-portalen.
- Valde din prenumeration från kontohanteringssidan (du kan behöva använda ett filter från kontoinställningarna):
Dina Azure-molntjänster visas. Leta upp lagringskonton och klicka på pilen till vänster om det för att expandera dina konton.
När det har expanderats bör det nyligen skapade lagringskontot vara tillgängligt. Klicka på pilen till vänster om lagringen, och när den har expanderats letar du upp Tabeller och klickar på pilen bredvid den för att visa tabellen som du skapade i det senaste kapitlet. Dubbelklicka på tabellen.
Tabellen öppnas i mitten av Visual Studio-fönstret. Klicka på tabellikonen + med (plus) på den.
Ett fönster visas där du uppmanas att lägga till entitet. Du skapar totalt tre entiteter, var och en med flera egenskaper. Du kommer att märka att PartitionKey och RowKey redan har angetts, eftersom dessa används av tabellen för att hitta dina data.
Uppdatera värdet för PartitionKey och RowKey enligt följande (kom ihåg att göra detta för varje radegenskap som du lägger till, men öka RowKey varje gång):
Klicka på Lägg till egenskap för att lägga till extra rader med data. Gör så att din första tomma tabell matchar tabellen nedan.
Klicka på OK, när du är klar.

Varning

Kontrollera att du har ändrat X-, Y- och Z-posternas typ till Double.
Du kommer att märka att tabellen nu har en rad med data. + Klicka på ikonen (plus) igen för att lägga till en annan entitet.
Skapa ytterligare en egenskap och ange sedan värdena för den nya entiteten så att de matchar de som visas nedan.
Upprepa det sista steget för att lägga till en annan entitet. Ange värdena för den här entiteten till de som visas nedan.
Tabellen bör nu se ut som den nedan.
Du har slutfört det här kapitlet. Se till att spara.

Kapitel 6 – Skapa en Azure-funktionsapp

Skapa en Azure-funktionsapp som anropas av skrivbordsprogrammet för att uppdatera tabelltjänsten och skicka ett meddelande via Notification Hub.

Först måste du skapa en fil som gör att din Azure-funktion kan läsa in de bibliotek som du behöver.

Öppna Anteckningar (tryck på Windows-tangenten och skriv anteckningar).
När Anteckningar är öppet infogar du JSON-strukturen nedan i den. När du har gjort det sparar du det på skrivbordet som project.json. Det är viktigt att namngivningen är korrekt: se till att den INTE har ett .txt filnamnstillägg. Den här filen definierar de bibliotek som funktionen ska använda, om du har använt NuGet ser den bekant ut.
```
{
"frameworks": {
    "net46":{
    "dependencies": {
        "WindowsAzure.Storage": "7.0.0",
        "Microsoft.Azure.NotificationHubs" : "1.0.9",
        "Microsoft.Azure.WebJobs.Extensions.NotificationHubs" :"1.1.0"
    }
    }
}
}
```
Logga in på Azure Portal.
När du är inloggad klickar du på Nytt i det övre vänstra hörnet och söker efter Funktionsapp, trycker på Retur.

Kommentar

Ordet Nytt kan ha ersatts med Skapa en resurs i nyare portaler.
Den nya sidan innehåller en beskrivning av funktionsapptjänsten . Längst ned till vänster i den här prompten väljer du knappen Skapa för att skapa en association med den här tjänsten.
När du har klickat på Skapa fyller du i följande:
1. För Appnamn infogar du önskat namn för den här tjänstinstansen.
2. Välj en prenumeration.
3. Välj den prisnivå som är lämplig för dig, om det är första gången du skapar en funktionsapptjänst ska en kostnadsfri nivå vara tillgänglig för dig.
4. Välj en resursgrupp eller skapa en ny. En resursgrupp är ett sätt att övervaka, kontrollera åtkomst, etablera och hantera fakturering för en samling Azure-tillgångar. Vi rekommenderar att du behåller alla Azure-tjänster som är associerade med ett enda projekt (t.ex. dessa labb) under en gemensam resursgrupp).
  
  Om du vill läsa mer om Azure-resursgrupper följer du den här länken om hur du hanterar en resursgrupp.
5. För operativsystem klickar du på Windows, eftersom det är den avsedda plattformen.
6. Välj en värdplan (den här självstudien använder en förbrukningsplan.
7. Välj en plats (välj samma plats som lagringen som du skapade i föregående steg)
8. I avsnittet Lagring måste du välja den lagringstjänst som du skapade i föregående steg.
9. Du behöver inte Application Insights i den här appen, så du kan lämna den av.
10. Klicka på Skapa.
När du har klickat på Skapa måste du vänta tills tjänsten har skapats, det kan ta en minut.
Ett meddelande visas i portalen när tjänstinstansen har skapats.
Klicka på meddelandena för att utforska din nya tjänstinstans.
Klicka på knappen Gå till resurs i meddelandet för att utforska din nya tjänstinstans.
+ Klicka på ikonen (plus) bredvid Functions för att skapa ny.
I den centrala panelen visas fönstret Funktionsskapande . Ignorera informationen i den övre halvan av panelen och klicka på Anpassad funktion, som finns längst ned (i det blå området enligt nedan).
Den nya sidan i fönstret visar olika funktionstyper. Rulla nedåt för att visa de lila typerna och klicka på HTTP PUT-elementet .

Viktigt!

Du kan behöva rulla längre ned på sidan (och den här bilden kanske inte ser exakt likadan ut, om Uppdateringar av Azure-portalen har ägt rum), men du letar efter ett element som heter HTTP PUT.
HTTP PUT-fönstret visas där du behöver konfigurera funktionen (se nedan för bild).
1. För Språk väljer du C#med hjälp av den nedrullningsbara menyn.
2. För Namn anger du ett lämpligt namn.
3. I listrutan Autentiseringsnivå väljer du Funktion.
4. I avsnittet Tabellnamn måste du använda det exakta namnet som du använde för att skapa tabelltjänsten tidigare (inklusive samma bokstavsfall).
5. I avsnittet Lagringskontoanslutning använder du den nedrullningsbara menyn och väljer ditt lagringskonto därifrån. Om den inte finns där klickar du på Den nya hyperlänken tillsammans med avsnittsrubriken för att visa en annan panel, där ditt lagringskonto ska visas.
Klicka på Skapa så får du ett meddelande om att inställningarna har uppdaterats.
När du har klickat på Skapa omdirigeras du till funktionsredigeraren.

Infoga följande kod i funktionsredigeraren (ersätt koden i funktionen):

#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; }
}

Kommentar

Med hjälp av de inkluderade biblioteken tar funktionen emot namnet och platsen för objektet som flyttades i Unity-scenen (som ett C#-objekt, kallat UnityGameObject). Det här objektet används sedan för att uppdatera objektparametrarna i den skapade tabellen. Efter detta gör funktionen ett anrop till din skapade Notification Hub-tjänst, som meddelar alla prenumerationsprogram.

När koden är på plats klickar du på Spara.
Klicka sedan på < ikonen (pilen) till höger på sidan.
En panel skjuts in från höger. I panelen klickar du på Ladda upp så visas en filwebbläsare.
Navigera till och klicka på filen project.json , som du skapade i Anteckningar tidigare, och klicka sedan på knappen Öppna . Den här filen definierar de bibliotek som funktionen ska använda.
När filen har laddats upp visas den i panelen till höger. Om du klickar på den öppnas den i funktionsredigeraren. Den måste se exakt likadan ut som nästa bild (nedan steg 23).
Klicka sedan på länken Integrera i panelen till vänster under Functions.
På nästa sida i det övre högra hörnet klickar du på Avancerad redigerare (enligt nedan).

En function.json fil öppnas i mittenpanelen, som måste ersättas med följande kodfragment. Detta definierar den funktion som du skapar och parametrarna som skickas till funktionen.

{
"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"
    }
]
}

Redigeraren bör nu se ut som bilden nedan:
Du kanske märker att de indataparametrar som du just har infogat kanske inte matchar din tabell- och lagringsinformation och därför måste uppdateras med din information. Gör inte detta här, eftersom det beskrivs härnäst. Klicka bara på standardredigerarens länk i det övre högra hörnet på sidan för att gå tillbaka.
I standardredigeraren klickar du på Azure Table Storage (tabell), under Indata.
Se till att följande matchar din information, eftersom de kan vara olika (det finns en bild under följande steg):
1. Tabellnamn: namnet på den tabell som du skapade i azure storage- och tabelltjänsten.
2. Anslutning till lagringskonto: Klicka på ny, som visas tillsammans med den nedrullningsbara menyn, så visas en panel till höger om fönstret.
  1. Välj ditt lagringskonto, som du skapade tidigare som värd för funktionsapparna .
  2. Du kommer att märka att anslutningsvärdet för lagringskontot har skapats.
  3. Tryck på Spara när du är klar.
3. Sidan Indata bör nu matcha nedanstående, som visar din information.
Klicka sedan på Azure Notification Hub (meddelande) – under Utdata. Se till att följande matchas med din information, eftersom de kan vara olika (det finns en bild under följande steg):
1. Notification Hub-namn: det här är namnet på din Notification Hub-tjänstinstans , som du skapade tidigare.
2. Notification Hubs-namnområdesanslutning: klicka på ny, som visas tillsammans med den nedrullningsbara menyn.
3. Popup-fönstret Anslutning visas (se bilden nedan), där du måste välja namnområdet för meddelandehubben, som du konfigurerade tidigare.
4. Välj ditt Notification Hub-namn i den mellersta listrutan.
5. Ange listrutan Princip till DefaultFullSharedAccessSignature.
6. Klicka på knappen Välj för att gå tillbaka.
Sidan Utdata bör nu matcha nedanstående, men med din information i stället. Tryck på Spara.

Varning

Redigera inte notification hub-namnet direkt (allt detta bör göras med hjälp av Avancerad redigerare, förutsatt att du följde föregående steg korrekt.

Skärmbild som visar sidan Utdata med allmän information.

Nu bör du testa funktionen för att säkerställa att den fungerar. Så här gör du:
1. Gå till funktionssidan igen:
2. Tillbaka på funktionssidan klickar du på fliken Test längst till höger på sidan för att öppna bladet Test :
3. I textrutan Begärandetext på bladet klistrar du in koden nedan:
```
{  
    "Type":null,
    "X":3,
    "Y":0,
    "Z":1,
    "PartitionKey":null,
    "RowKey":"Obj2",
    "Timestamp":"0001-01-01T00:00:00+00:00",
    "ETag":null
}
```
4. När testkoden är på plats klickar du på knappen Kör längst ned till höger så körs testet. Utdataloggarna för testet visas i konsolområdet, under funktionskoden.
Varning

Om ovanstående test misslyckas måste du dubbelkolla att du har följt ovanstående steg exakt, särskilt inställningarna i integreringspanelen.

Kapitel 7 – Konfigurera Desktop Unity-projekt

Viktigt!

Skrivbordsprogrammet som du nu skapar fungerar inte i Unity-redigeraren. Den måste köras utanför redigeraren, efter att programmet har skapats med hjälp av Visual Studio (eller det distribuerade programmet).

Följande är en typisk konfiguration för utveckling med Unity och mixad verklighet, och är därför en bra mall för andra projekt.

Konfigurera och testa ditt integrerande headset för mixad verklighet.

Kommentar

Du behöver inte motionskontrollanter för den här kursen. Om du behöver stöd för att konfigurera det uppslukande headsetet följer du den här länken om hur du konfigurerar Windows Mixed Reality.

Öppna Unity och klicka på Nytt.
Du måste ange ett Unity-projektnamn, infoga UnityDesktopNotifHub. Kontrollera att projekttypen är inställd på 3D. Ange platsen till någonstans som passar dig (kom ihåg att närmare rotkataloger är bättre). Klicka sedan på Skapa projekt.
När Unity är öppet är det värt att kontrollera att standardskriptredigeraren är inställd på Visual Studio. Gå till Redigera>inställningar och gå sedan till Externa verktyg från det nya fönstret. Ändra extern skriptredigerare till Visual Studio 2017. Stäng fönstret Inställningar .
Gå sedan till Inställningar för filgenerering>och välj Universell Windows-plattform och klicka sedan på knappen Växla plattform för att tillämpa ditt val.
Kontrollera att du fortfarande är i Filgenereringsinställningar>:
1. Målenheten är inställd på Valfri enhet
  
  Det här programmet kommer att vara för skrivbordet, så måste vara alla enheter
2. Byggtyp är inställd på D3D
3. SDK är inställt på Senaste installerat
4. Visual Studio-versionen är inställd på Senaste installerad
5. Build and Run är inställt på Lokal dator
6. Här är det värt att spara scenen och lägga till den i bygget.
  1. Gör detta genom att välja Lägg till öppna scener. Ett spara-fönster visas.
  2. Skapa en ny mapp för detta, och eventuella framtida scenarier, välj sedan knappen Ny mapp , för att skapa en ny mapp, ge den namnet Scener.
  3. Öppna den nyligen skapade mappen Scener och skriv sedan NH_Desktop_Scene i fältet Filnamn: text och tryck sedan på Spara.
7. De återstående inställningarna i Bygginställningar bör vara kvar som standard för tillfället.
I samma fönster klickar du på knappen Spelarinställningar. Då öppnas den relaterade panelen i det utrymme där inspektören finns.
I den här panelen måste några inställningar verifieras:
1. På fliken Andra inställningar :
  1. Skriptkörningsversionen bör vara experimentell (.NET 4.6-motsvarighet)
  2. Skriptserverdelen ska vara .NET
  3. API-kompatibilitetsnivån ska vara .NET 4.6
2. På fliken Publiceringsinställningar går du till Funktioner och kontrollerar:
  - InternetClient
Tillbaka i Bygginställningar Unity C#-projekt är inte längre nedtonade. Markera kryssrutan bredvid detta.
Stäng fönstret Build Settings (Bygginställningar).
Spara scenen och projektfilen >Spara scen/Filspara>projekt.

Viktigt!

Om du vill hoppa över Unity-konfigurationskomponenten för det här projektet (Skrivbordsapp) och fortsätta direkt till kod kan du ladda ned .unitypackage, importera den till projektet som ett anpassat paket och sedan fortsätta från kapitel 9. Du måste fortfarande lägga till skriptkomponenterna.

Kapitel 8 – Importera DLL:er i Unity

Du kommer att använda Azure Storage for Unity (som själv utnyttjar .Net SDK för Azure). Mer information finns på den här länken om Azure Storage for Unity.

Det finns för närvarande ett känt problem i Unity som kräver att plugin-program konfigureras om efter importen. De här stegen (4–7 i det här avsnittet) krävs inte längre när felet har åtgärdats.

Om du vill importera SDK:n till ditt eget projekt kontrollerar du att du har laddat ned den senaste .unitypackage från GitHub. Gör sedan följande:

Lägg till .unitypackage i Unity med menyalternativet Importera paket > för tillgångar>.
I rutan Importera Unity-paket som visas kan du välja allt under Plugin>Storage. Avmarkera allt annat eftersom det inte behövs för den här kursen.
Klicka på knappen Importera för att lägga till objekten i projektet.
Gå till mappen Lagring under Plugin-program i projektvyn och välj endast följande plugin-program:
- Microsoft.Data.Edm
- Microsoft.Data.OData
- Microsoft.WindowsAzure.Storage
- Newtonsoft.Json
- System.Spatial

avmarkera Valfri plattform

När dessa specifika plugin-program har valts avmarkerar du Valfri plattform och avmarkerar WSAPlayer och klickar sedan på Använd.

Kommentar

Vi markerar just dessa plugin-program som endast ska användas i Unity-redigeraren. Det beror på att det finns olika versioner av samma plugin-program i WSA-mappen som ska användas när projektet har exporterats från Unity.
I mappen Storage-plugin-program väljer du endast:
- Microsoft.Data.Services.Client
Markera rutan Bearbeta inte under Plattformsinställningar och klicka på Använd.

Kommentar

Vi markerar det här plugin-programmet "Bearbeta inte", eftersom Unity-sammansättningskorrigeringsprogrammet har svårt att bearbeta det här plugin-programmet. Plugin-programmet fungerar fortfarande även om det inte bearbetas.

Kapitel 9 – Skapa klassen TableToScene i Desktop Unity-projektet

Nu måste du skapa skripten som innehåller koden för att köra det här programmet.

Det första skriptet du behöver skapa är TableToScene, som ansvarar för:

Läsa entiteter i Azure-tabellen.
Med hjälp av tabelldata avgör du vilka objekt som ska skapas och i vilken position.

Det andra skriptet som du behöver skapa är CloudScene, som ansvarar för:

Registrera händelsen med vänsterklick så att användaren kan dra objekt runt scenen.
Serialisera objektdata från den här Unity-scenen och skicka dem till Azure-funktionsappen.

Så här skapar du den här klassen:

Högerklicka i tillgångsmappen i projektpanelen, Skapa>mapp. Ge mappen namnet Skript.
Dubbelklicka på mappen som nyss skapades för att öppna den.
Högerklicka i mappen Skript och klicka på Skapa>C#-skript. Ge skriptet namnet TableToScene.
Dubbelklicka på skriptet för att öppna det i Visual Studio 2017.

Lägg till följande namnområden:

using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Auth;
using Microsoft.WindowsAzure.Storage.Table;
using UnityEngine;

Infoga följande variabler i klassen:

    /// <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 -- ";

Kommentar

Ersätt värdet accountName med ditt Azure Storage Service-namn och accountKey-värde med nyckelvärdet som finns i Azure Storage-tjänsten i Azure-portalen (se bild nedan).

hämta kontonyckel

Lägg nu till metoderna Start() och Awake() för att initiera klassen.

    /// <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();
    }

I klassen TableToScene lägger du till den metod som hämtar värdena från Azure Table och använder dem för att skapa lämpliga primitiver i scenen.

    /// <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);
    }

Utanför klassen TableToScene måste du definiera den klass som används av programmet för att serialisera och deserialisera tabellentiteterna.

    /// <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; }
    }

Se till att spara innan du går tillbaka till Unity-redigeraren.
Klicka på huvudkameran från hierarkipanelen så att dess egenskaper visas i inspektören.
När mappen Skript är öppen väljer du skriptet TableToScene-filen och drar den till huvudkameran. Resultatet bör vara enligt nedan:

Kapitel 10 – Skapa klassen CloudScene i Desktop Unity Project

Det andra skriptet som du behöver skapa är CloudScene, som ansvarar för:

Registrera händelsen med vänsterklick så att användaren kan dra objekt runt scenen.
Serialisera objektdata från den här Unity-scenen och skicka dem till Azure-funktionsappen.

Så här skapar du det andra skriptet:

Högerklicka i mappen Skript , klicka på Skapa, C#-skript. Ge skriptet namnet CloudScene

Lägg till följande namnområden:

using Newtonsoft.Json;
using System.Collections;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.Networking;

Infoga följande variabler:

    /// <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;

Ersätt värdet azureFunctionEndpoint med url:en för azure-funktionsappen som finns i Azure Function App Service i Azure-portalen enligt bilden nedan:

Lägg nu till metoderna Start() och Awake() för att initiera klassen.

    /// <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();
    }

I metoden Update() lägger du till följande kod som identifierar musindata och drar, vilket i sin tur flyttar GameObjects i scenen. Om användaren har dragit och släppt ett objekt skickar det objektets namn och koordinater till metoden UpdateCloudScene(), som anropar Azure Function App Service, som uppdaterar Azure-tabellen och utlöser meddelandet.

    /// <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));
        }
    }

Lägg nu till metoden UpdateCloudScene() enligt nedan:

    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();
        }
    }

Spara koden och återgå till Unity
Dra CloudScene-skriptet till huvudkameran.
1. Klicka på huvudkameran från hierarkipanelen så att dess egenskaper visas i inspektören.
2. När mappen Skript är öppen väljer du CloudScene-skriptet och drar det till huvudkameran. Resultatet bör vara enligt nedan:

Kapitel 11 – Skapa skrivbordsprojektet till UWP

Allt som behövs för Unity-avsnittet i det här projektet har nu slutförts.

Gå till Build Settings (File>Build Settings).
I fönstret Bygginställningar klickar du på Skapa.
Ett Utforskaren fönster visas, där du uppmanas att ange en plats att skapa. Skapa en ny mapp (genom att klicka på Ny mapp i det övre vänstra hörnet) och ge den namnet BUILDS.
1. Öppna den nya BUILDS-mappen och skapa en annan mapp (med ny mapp igen) och ge den namnet NH_Desktop_App.
2. Med NH_Desktop_App markerat. klicka på Välj mapp. Det tar ungefär en minut att skapa projektet.
Efter kompilering visas Utforskaren som visar platsen för det nya projektet. Du behöver dock inte öppna det eftersom du behöver skapa det andra Unity-projektet först i de kommande kapitlen.

Kapitel 12 – Konfigurera Mixed Reality Unity Project

Följande är en typisk konfiguration för utveckling med mixad verklighet och är därför en bra mall för andra projekt.

Öppna Unity och klicka på Nytt.
Nu måste du ange ett Unity-projektnamn och infoga UnityMRNotifHub. Kontrollera att projekttypen är inställd på 3D. Ange platsen till någonstans som passar dig (kom ihåg att närmare rotkataloger är bättre). Klicka sedan på Skapa projekt.
När Unity är öppet är det värt att kontrollera att standardskriptredigeraren är inställd på Visual Studio. Gå till Redigera>inställningar och gå sedan till Externa verktyg från det nya fönstret. Ändra extern skriptredigerare till Visual Studio 2017. Stäng fönstret Inställningar .
Gå sedan till Inställningar för filbygge>och växla plattformen till Universell Windows-plattform genom att klicka på knappen Växla plattform.
Gå till Inställningar för filbygge>och kontrollera att:
1. Målenheten är inställd på Valfri enhet
  
  För Microsoft HoloLens anger du Målenhet till HoloLens.
2. Byggtyp är inställd på D3D
3. SDK är inställt på Senaste installerat
4. Visual Studio-versionen är inställd på Senaste installerad
5. Build and Run är inställt på Lokal dator
6. Här är det värt att spara scenen och lägga till den i bygget.
  1. Gör detta genom att välja Lägg till öppna scener. Ett spara-fönster visas.
  2. Skapa en ny mapp för detta, och eventuella framtida scenarier, välj sedan knappen Ny mapp , för att skapa en ny mapp, ge den namnet Scener.
  3. Öppna den nyligen skapade mappen Scener och skriv sedan NH_MR_Scene i fältet Filnamn: text och tryck sedan på Spara.
7. De återstående inställningarna i Bygginställningar bör vara kvar som standard för tillfället.
I samma fönster klickar du på knappen Spelarinställningar. Då öppnas den relaterade panelen i det utrymme där inspektören finns.
I den här panelen måste några inställningar verifieras:
1. På fliken Andra inställningar :
  1. Skriptkörningsversionen bör vara experimentell (.NET 4.6-motsvarighet)
  2. Skriptserverdelen ska vara .NET
  3. API-kompatibilitetsnivån ska vara .NET 4.6
2. Längre ned i panelen, i XR-inställningar (som finns under Publiceringsinställningar), markerar du Virtual Reality Supported (Virtual Reality Supported) och kontrollerar att Windows Mixed Reality SDK har lagts till
3. På fliken Publiceringsinställningar går du till Funktioner och kontrollerar:
  - InternetClient
I Bygginställningar är Unity C# Projects inte längre nedtonat: markera kryssrutan bredvid detta.
När ändringarna är klara stänger du fönstret Bygginställningar.
Spara scenen och projektfilen >Spara scen/Filspara>projekt.

Viktigt!

Om du vill hoppa över unity-konfigurationskomponenten för det här projektet (mixed reality-appen) och fortsätta direkt till kod kan du ladda ned .unitypackage, importera den till projektet som ett anpassat paket och sedan fortsätta från kapitel 14. Du måste fortfarande lägga till skriptkomponenterna.

Kapitel 13 – Importera DLL:er i Mixed Reality Unity-projektet

Du kommer att använda Azure Storage for Unity-biblioteket (som använder .Net SDK för Azure). Följ den här länken om hur du använder Azure Storage med Unity. Det finns för närvarande ett känt problem i Unity som kräver att plugin-program konfigureras om efter importen. De här stegen (4–7 i det här avsnittet) krävs inte längre när felet har åtgärdats.

Om du vill importera SDK:n till ditt eget projekt kontrollerar du att du har laddat ned den senaste .unitypackage. Gör sedan följande:

Lägg till .unitypackage som du laddade ned från ovanstående i Unity med menyalternativet Importera paket> för tillgångar.>
I rutan Importera Unity-paket som visas kan du välja allt under Plugin>Storage.
Klicka på knappen Importera för att lägga till objekten i projektet.
Gå till mappen Lagring under Plugin-program i projektvyn och välj endast följande plugin-program:
- Microsoft.Data.Edm
- Microsoft.Data.OData
- Microsoft.WindowsAzure.Storage
- Newtonsoft.Json
- System.Spatial
När dessa specifika plugin-program har valts avmarkerar du Valfri plattform och avmarkerar WSAPlayer och klickar sedan på Använd.

Kommentar

Du markerar just dessa plugin-program som endast ska användas i Unity-redigeraren. Det beror på att det finns olika versioner av samma plugin-program i WSA-mappen som ska användas när projektet har exporterats från Unity.
I mappen Storage-plugin-program väljer du endast:
- Microsoft.Data.Services.Client
Markera rutan Bearbeta inte under Plattformsinställningar och klicka på Använd.

Kommentar

Du markerar plugin-programmet "Bearbeta inte" eftersom Unity-sammansättningskorrigeringsprogrammet har svårt att bearbeta plugin-programmet. Plugin-programmet fungerar fortfarande även om det inte bearbetas.

Kapitel 14 – Skapa klassen TableToScene i Unity-projektet för mixad verklighet

Klassen TableToScene är identisk med den som beskrivs i kapitel 9. Skapa samma klass i Unity Project för mixad verklighet enligt samma procedur som beskrivs i kapitel 9.

När du har slutfört det här kapitlet har båda dina Unity Projects den här klassen konfigurerad på huvudkameran.

Kapitel 15 – Skapa klassen NotificationReceiver i Mixed Reality Unity-projektet

Det andra skriptet som du behöver skapa är NotificationReceiver, som ansvarar för:

Registrera appen med Notification Hub vid initiering.
Lyssna på meddelanden som kommer från Notification Hub.
Deserialisera objektdata från mottagna meddelanden.
Flytta GameObjects i scenen baserat på deserialiserade data.

Så här skapar du NotificationReceiver-skriptet :

Högerklicka i mappen Skript , klicka på Skapa, C#-skript. Ge skriptet namnet NotificationReceiver.
Dubbelklicka på skriptet för att öppna det.

Lägg till följande namnområden:

//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

Infoga följande variabler:

    /// <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-";

Ersätt hubName-värdet med ditt Notification Hub Service-namn och hubListenEndpoint-värde med slutpunktsvärdet som finns på fliken Åtkomstprinciper, Azure Notification Hub Service, i Azure-portalen (se bilden nedan).

Lägg nu till metoderna Start() och Awake() för att initiera klassen.

    /// <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());
    }

Lägg till metoden WaitForNotification så att appen kan ta emot meddelanden från Notification Hub-biblioteket utan att kollidera med huvudtråden:

    /// <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;
            }
        }
    }

Följande metod, InitNotificationAsync(), registrerar programmet med hubbtjänsten notification vid initiering. Koden kommenteras ut eftersom Unity inte kommer att kunna skapa projektet. Du tar bort kommentarerna när du importerar Azure Messaging Nuget-paketet i 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;
        // }
    }

Följande hanterare, Channel_PushNotificationReceived(), utlöses varje gång ett meddelande tas emot. Det kommer att deserialisera meddelandet, som kommer att vara den Azure-tabellentitet som har flyttats i skrivbordsprogrammet, och sedan flytta motsvarande GameObject i MR-scenen till samma position.

Viktigt!

Koden kommenteras ut eftersom koden refererar till Azure Messaging-biblioteket, som du lägger till när du har skapat Unity-projektet med Hjälp av Nuget Package Manager, i Visual Studio. Därför kommer Unity-projektet inte att kunna byggas, såvida det inte kommenteras ut. Tänk på att om du skapar projektet och sedan vill återvända till Unity måste du kommentera koden igen.

    ///// <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;
    //    }
    //}

Kom ihåg att spara ändringarna innan du går tillbaka till Unity-redigeraren.
Klicka på huvudkameran från hierarkipanelen så att dess egenskaper visas i inspektören.
När mappen Skript är öppen väljer du skriptet NotificationReceiver och drar det till huvudkameran. Resultatet bör vara enligt nedan:
Kommentar

Om du utvecklar detta för Microsoft HoloLens måste du uppdatera huvudkamerans kamerakomponent så att:
- Clear Flags: Solid Color
- Bakgrund: Svart

Kapitel 16 – Skapa Mixed Reality-projektet till UWP

Det här kapitlet är identiskt med byggprocessen för föregående projekt. Allt som behövs för Unity-avsnittet i det här projektet har nu slutförts, så det är dags att bygga det från Unity.

Gå till Build Settings ( File>Build Settings ).
På menyn Bygginställningar kontrollerar du att Unity C# Projects* är markerad (vilket gör att du kan redigera skripten i det här projektet efter bygget).
När detta är klart klickar du på Skapa.
Ett Utforskaren fönster visas, där du uppmanas att ange en plats att skapa. Skapa en ny mapp (genom att klicka på Ny mapp i det övre vänstra hörnet) och ge den namnet BUILDS.
1. Öppna den nya BUILDS-mappen och skapa en annan mapp (med ny mapp igen) och ge den namnet NH_MR_App.
2. Med NH_MR_App markerat. klicka på Välj mapp. Det tar ungefär en minut att skapa projektet.
Efter bygget öppnas ett Utforskaren fönster på platsen för det nya projektet.

Kapitel 17 – Lägga till NuGet-paket i UnityMRNotifHub-lösningen

Varning

Kom ihåg att när du lägger till följande NuGet-paket (och avkommenterar koden i nästa kapitel) visas fel när koden öppnas igen i Unity-projektet. Om du vill gå tillbaka och fortsätta redigera i Unity-redigeraren behöver du kommentera den felaktiga koden och sedan avkommenteras igen senare, när du är tillbaka i Visual Studio.

När mixed reality-versionen har slutförts går du till projektet mixed reality som du har skapat och dubbelklickar på lösningsfilen (.sln) i mappen för att öppna lösningen med Visual Studio 2017. Nu måste du lägga till NuGet-paketet WindowsAzure.Messaging.managed . Det här är ett bibliotek som används för att ta emot meddelanden från meddelandehubben.

Så här importerar du NuGet-paketet:

Högerklicka på lösningen i Solution Explorer
Klicka på Hantera NuGet-paket.
Välj fliken Bläddra och sök efter WindowsAzure.Messaging.managed.
Välj resultatet (som visas nedan) och markera kryssrutan bredvid Projekt i fönstret till höger. Detta markerar kryssrutan bredvid Project, tillsammans med kryssrutan bredvid projektet Assembly-CSharp och UnityMRNotifHub .
Den version som ursprungligen angavs kanske inte är kompatibel med det här projektet. Klicka därför på den nedrullningsbara menyn bredvid Version och klicka på Version 0.1.7.9 och klicka sedan på Installera.
Nu har du installerat NuGet-paketet. Leta upp den kommenterade koden som du angav i klassen NotificationReceiver och ta bort kommentarerna..

Kapitel 18 – Redigera UnityMRNotifHub-program, NotificationReceiver-klass

När du har lagt till NuGet-paketen måste du avkommenta en del av koden i klassen NotificationReceiver.

Detta omfattar:

Namnområdet högst upp:

using Microsoft.WindowsAzure.Messaging;

All kod i metoden InitNotificationsAsync():

    /// <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;
        }
    }

Varning

Koden ovan har en kommentar: se till att du inte av misstag har avkommenterat kommentaren (eftersom koden inte kompileras om du har!).

Och slutligen den Channel_PushNotificationReceived händelsen:

    /// <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;
        }
    }

Med dessa okommenterade ser du till att du sparar och fortsätter sedan till nästa kapitel.

Kapitel 19 – Associera projektet med mixad verklighet till Store-appen

Nu måste du associera mixed reality-projektet med Store-appen som du skapade i början av labbet.

Öppna lösningen.
Högerklicka på UWP-appprojektet i panelen Solution Explorer, gå till Store och Associera app med Store....
Ett nytt fönster visas med namnet Associera din app med Windows Store. Klicka på Nästa.
Alla program som är associerade med kontot som du har loggat in läses in. Om du inte är inloggad på ditt konto kan du logga in på den här sidan.
Leta reda på namnet på Store-appen som du skapade i början av den här självstudien och välj det. Klicka på Nästa.
Klicka på Associera.
Din app är nu associerad med Store-appen. Detta är nödvändigt för att aktivera Meddelanden.

Kapitel 20 – Distribuera UnityMRNotifHub- och UnityDesktopNotifHub-program

Det här kapitlet kan vara enklare med två personer, eftersom resultatet omfattar både appar som körs, en som körs på datorn Desktop och den andra i ditt uppslukande headset.

Den uppslukande headsetappen väntar på att få ändringar i scenen (positionsändringar i den lokala GameObjects) och Skrivbordsappen kommer att göra ändringar i sin lokala scen (positionsändringar), som delas till MR-appen. Det är klokt att distribuera MR-appen först, följt av skrivbordsappen, så att mottagaren kan börja lyssna.

Så här distribuerar du UnityMRNotifHub-appen på din lokala dator:

Öppna lösningsfilen för din UnityMRNotifHub-app i Visual Studio 2017.
I Lösningsplattform väljer du x86, Lokal dator.
I Lösningskonfiguration väljer du Felsök.
Gå till menyn Skapa och klicka på Distribuera lösning för att separat läsa in programmet på datorn.
Din app bör nu visas i listan över installerade appar som är redo att startas.

Så här distribuerar du UnityDesktopNotifHub-appen på den lokala datorn:

Öppna lösningsfilen för din UnityDesktopNotifHub-app i Visual Studio 2017.
I Lösningsplattform väljer du x86, Lokal dator.
I Lösningskonfiguration väljer du Felsök.
Gå till menyn Skapa och klicka på Distribuera lösning för att separat läsa in programmet på datorn.
Din app bör nu visas i listan över installerade appar som är redo att startas.
Starta mixed reality-programmet följt av desktop-programmet.

När båda programmen körs flyttar du ett objekt i skrivbordsscenen (med vänster musknapp). Dessa positionsändringar görs lokalt, serialiseras och skickas till funktionsapptjänsten. Funktionsapptjänsten uppdaterar sedan tabellen tillsammans med Notification Hub. Efter att ha fått en uppdatering skickar Notification Hub de uppdaterade data direkt till alla registrerade program (i det här fallet den uppslukande headsetappen), som sedan deserialiserar inkommande data och tillämpar de nya positionella data på de lokala objekten och flyttar dem i scenen.

Ditt färdiga Azure Notification Hubs-program

Grattis, du har skapat en mixed reality-app som utnyttjar Azure Notification Hubs Service och tillåter kommunikation mellan appar.

slutprodukt -end

Bonusövningar

Övning 1

Kan du ta reda på hur du ändrar färgen på GameObjects och skickar meddelandet till andra appar som visar scenen?

Övning 2

Kan du lägga till förflyttning av GameObjects till din MR-app och se den uppdaterade scenen i din skrivbordsapp?

Dela via

HoloLens (första generationen) och Azure 308: Meddelanden mellan enheter

Stöd för enheter

Förutsättningar

Innan du börjar

Kapitel 1 – Skapa ett program på Microsoft Developer Portal

Kapitel 2 – Hämta dina nya autentiseringsuppgifter för appar

Kapitel 3 – Konfigurera Azure Portal: skapa Notification Hubs-tjänsten

Kapitel 4 – Konfigurera Azure Portal: skapa tabelltjänst

Kapitel 5 – Slutföra Azure-tabellen i Visual Studio

Kapitel 6 – Skapa en Azure-funktionsapp

Kapitel 7 – Konfigurera Desktop Unity-projekt

Kapitel 8 – Importera DLL:er i Unity

Kapitel 9 – Skapa klassen TableToScene i Desktop Unity-projektet

Kapitel 10 – Skapa klassen CloudScene i Desktop Unity Project

Kapitel 11 – Skapa skrivbordsprojektet till UWP

Kapitel 12 – Konfigurera Mixed Reality Unity Project

Kapitel 13 – Importera DLL:er i Mixed Reality Unity-projektet

Kapitel 14 – Skapa klassen TableToScene i Unity-projektet för mixad verklighet

Kapitel 15 – Skapa klassen NotificationReceiver i Mixed Reality Unity-projektet

Kapitel 16 – Skapa Mixed Reality-projektet till UWP

Kapitel 17 – Lägga till NuGet-paket i UnityMRNotifHub-lösningen

Kapitel 18 – Redigera UnityMRNotifHub-program, NotificationReceiver-klass

Kapitel 19 – Associera projektet med mixad verklighet till Store-appen

Kapitel 20 – Distribuera UnityMRNotifHub- och UnityDesktopNotifHub-program

Ditt färdiga Azure Notification Hubs-program

Bonusövningar

Övning 1

Övning 2

Feedback

Ytterligare resurser