HoloLens (prima generazione) e Azure 308: notifiche tra dispositivi

Articolo
07/03/2024

Nota

Le esercitazioni di Mixed Reality Academy sono state progettate in base a HoloLens (prima generazione) e ai visori VR immersive di realtà mista. Pertanto, riteniamo importante lasciarle a disposizione degli sviluppatori a cui serve ancora materiale sussidiario per lo sviluppo di questi dispositivi. Queste esercitazioni non verranno aggiornate con i set di strumenti o le interazioni più recenti usati per HoloLens 2. Rimarranno invariate per consentire di continuare a lavorare sui dispositivi supportati. Ci sarà una nuova serie di esercitazioni che verranno pubblicate in futuro che dimostreranno come sviluppare per HoloLens 2. Questo avviso verrà aggiornato con un collegamento a tali esercitazioni quando vengono pubblicate.

prodotto finale -start

In questo corso si apprenderà come aggiungere funzionalità di Hub di notifica a un'applicazione di realtà mista usando Hub di notifica di Azure, tabelle di Azure e Funzioni di Azure.

Hub di notifica di Azure è un servizio Microsoft che consente agli sviluppatori di inviare notifiche push mirate e personalizzate a qualsiasi piattaforma, tutte basate sul cloud. Ciò consente agli sviluppatori di comunicare efficacemente con gli utenti finali o persino di comunicare tra varie applicazioni, a seconda dello scenario. Per altre informazioni, visitare la pagina Hub di notifica di Azure.

Funzioni di Azure è un servizio Microsoft che consente agli sviluppatori di eseguire piccole parti di codice, "funzioni" in Azure. In questo modo è possibile delegare il lavoro al cloud, anziché all'applicazione locale, che può avere molti vantaggi. Funzioni di Azure supporta diversi linguaggi di sviluppo, tra cui C#, F#, Node.js, Java e PHP. Per altre informazioni, visitare la pagina Funzioni di Azure.

Tabelle di Azure è un servizio cloud Microsoft, che consente agli sviluppatori di archiviare dati non SQL strutturati nel cloud, rendendoli facilmente accessibili ovunque. Il servizio vanta una progettazione senza schema, consentendo l'evoluzione delle tabelle in base alle esigenze e quindi è molto flessibile. Per altre informazioni, visitare la pagina Tabelle di Azure

Dopo aver completato questo corso, si avrà un'applicazione visore VR immersive realtà mista e un'applicazione PC desktop, che sarà in grado di eseguire le operazioni seguenti:

L'app Desktop PC consentirà all'utente di spostare un oggetto nello spazio 2D (X e Y), usando il mouse.
Lo spostamento degli oggetti all'interno dell'app PC verrà inviato al cloud usando JSON, che sarà sotto forma di stringa, contenente un ID oggetto, un tipo e informazioni sulla trasformazione (coordinate X e Y).
L'app di realtà mista, che ha una scena identica all'app desktop, riceverà notifiche relative allo spostamento degli oggetti dal servizio Hub di notifica (che è stato appena aggiornato dall'app Desktop PC).
Dopo aver ricevuto una notifica, che conterrà l'ID oggetto, il tipo e le informazioni di trasformazione, l'app di realtà mista applicherà le informazioni ricevute alla propria scena.

Nell'applicazione spetta all'utente come integrare i risultati con la progettazione. Questo corso è progettato per illustrare come integrare un servizio di Azure con il progetto Unity. È il tuo compito usare le conoscenze acquisite da questo corso per migliorare l'applicazione di realtà mista. Questo corso è un'esercitazione autonoma, che non coinvolge direttamente altri lab di Realtà mista.

Supporto di dispositivi

Corso	HoloLens	Visori VR immersive
MR e Azure 308: notifiche tra dispositivi	✔️	✔️

Nota

Anche se questo corso è incentrato principalmente sui visori VR immersive di Windows Realtà mista, puoi anche applicare ciò che impari in questo corso a Microsoft HoloLens. Mentre segui il corso, vedrai le note su eventuali modifiche che potresti dover usare per supportare HoloLens. Quando si usa HoloLens, è possibile notare un'eco durante l'acquisizione vocale.

Prerequisiti

Nota

Questa esercitazione è progettata per gli sviluppatori che hanno esperienza di base con Unity e C#. Tenere presente anche che i prerequisiti e le istruzioni scritte all'interno di questo documento rappresentano ciò che è stato testato e verificato al momento della scrittura (maggio 2018). Sei libero di usare il software più recente, come elencato all'interno dell'articolo installare gli strumenti , anche se non si deve presumere che le informazioni in questo corso corrispondano perfettamente a ciò che troverai nel software più recente rispetto a quello elencato di seguito.

Per questo corso è consigliabile usare l'hardware e il software seguenti:

Un PC di sviluppo, compatibile con Windows Realtà mista per lo sviluppo di visori VR immersive
Windows 10 Fall Creators Update (o versione successiva) con la modalità sviluppatore abilitata
La versione più recente di Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Visore VR immersive di Windows Realtà mista o Microsoft HoloLens con la modalità sviluppatore abilitata
Accesso a Internet per la configurazione di Azure e l'accesso a Hub di notifica

Prima di iniziare

Per evitare di riscontrare problemi durante la compilazione di questo progetto, è consigliabile creare il progetto menzionato in questa esercitazione in una cartella radice o quasi radice (i percorsi delle cartelle lunghe possono causare problemi in fase di compilazione).
È necessario essere il proprietario del portale per sviluppatori Microsoft e del portale di registrazione delle applicazioni. In caso contrario, non si avrà l'autorizzazione per accedere all'app nel capitolo 2.

Capitolo 1 - Creare un'applicazione nel portale per sviluppatori Microsoft

Per usare il servizio Hub di notifica di Azure, è necessario creare un'applicazione nel portale per sviluppatori Microsoft, perché l'applicazione dovrà essere registrata, in modo che possa inviare e ricevere notifiche.

Accedere al portale per sviluppatori Microsoft.

Sarà necessario accedere all'account Microsoft.
Nel dashboard fare clic su Crea una nuova app.
Verrà visualizzata una finestra popup, in cui è necessario riservare un nome per la nuova app. Nella casella di testo inserire un nome appropriato; se il nome scelto è disponibile, verrà visualizzato un segno di graduazione a destra della casella di testo. Dopo aver inserito un nome disponibile, fare clic sul pulsante Riserva nome prodotto nella parte inferiore sinistra del popup.
Dopo aver creato l'app, è possibile passare al capitolo successivo.

Capitolo 2 - Recuperare le credenziali delle nuove app

Accedere al portale di registrazione delle applicazioni, in cui verrà elencata la nuova app e recuperare le credenziali che verranno usate per configurare il servizio Hub di notifica nel portale di Azure.

Passare al portale di registrazione dell'applicazione.

Avviso

È necessario usare l'account Microsoft per accedere.
Deve trattarsi dell'account Microsoft usato nel capitolo precedente, con il portale per sviluppatori di Windows Store.
L'app è disponibile nella sezione Applicazioni personali . Dopo averlo trovato, fare clic su di esso e si verrà visualizzati in una nuova pagina con il nome dell'app più Registrazione.
Scorrere verso il basso la pagina di registrazione per trovare la sezione Segreti dell'applicazione e il SID del pacchetto per l'app. Copiare entrambi per l'uso con la configurazione del servizio Hub di notifica di Azure nel capitolo successivo.

Capitolo 3 - Configurare il portale di Azure: creare il servizio Hub di notifica

Con le credenziali delle app recuperate, sarà necessario passare al portale di Azure, in cui si creerà un servizio Hub di notifica di Azure.

Accedere al portale di Azure.

Nota

Se non si ha già un account Azure, è necessario crearne uno. Se si segue questa esercitazione in una classe o in una situazione di laboratorio, chiedere all'insegnante o a uno dei prottori di assistenza per configurare il nuovo account.
Dopo aver eseguito l'accesso, fare clic su Nuovo nell'angolo superiore sinistro e cercare Hub di notifica e fare clic su INVIO.

Nota

La parola New potrebbe essere stata sostituita con Crea una risorsa, nei portali più recenti.
La nuova pagina fornirà una descrizione del servizio Hub di notifica. Nella parte inferiore sinistra di questo prompt selezionare il pulsante Crea per creare un'associazione con questo servizio.
Dopo aver fatto clic su Crea:
1. Inserire il nome desiderato per questa istanza del servizio.
2. Specificare uno spazio dei nomi che sarà possibile associare all'app.
3. Selezionare una località.
4. Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, effettuare il provisioning e gestire la fatturazione per una raccolta di asset di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto (ad esempio, questi lab) in un gruppo di risorse comune.
  
  Per altre informazioni sui gruppi di risorse di Azure, seguire questo collegamento su come gestire un gruppo di risorse.
5. Selezionare una sottoscrizione appropriata.
6. Sarà anche necessario verificare di aver compreso le condizioni e le condizioni applicate al servizio.
7. Seleziona Crea.
Dopo aver fatto clic su Crea, è necessario attendere che il servizio venga creato, l'operazione potrebbe richiedere un minuto.
Una notifica verrà visualizzata nel portale dopo la creazione dell'istanza del servizio.
Fare clic sul pulsante Vai alla risorsa nella notifica per esplorare la nuova istanza del servizio. Verrà visualizzata la nuova istanza del servizio Hub di notifica.
Nella pagina di panoramica, a metà pagina, fare clic su Windows (WNS). Il pannello a destra cambierà per visualizzare due campi di testo, che richiedono il SID del pacchetto e la chiave di sicurezza, dall'app configurata in precedenza.
Dopo aver copiato i dettagli nei campi corretti, fare clic su Salva e si riceverà una notifica quando l'hub di notifica è stato aggiornato correttamente.

Capitolo 4 - Configurare il portale di Azure: creare un servizio tabelle

Dopo aver creato l'istanza del servizio Hub di notifica, tornare al portale di Azure, in cui si creerà un servizio tabelle di Azure creando una risorsa di archiviazione.

Se non è già stato eseguito l'accesso, accedere al portale di Azure.
Dopo aver eseguito l'accesso, fare clic su Nuovo nell'angolo superiore sinistro e cercare Account di archiviazione e fare clic su INVIO.

Nota

La parola New potrebbe essere stata sostituita con Crea una risorsa, nei portali più recenti.
Selezionare Account di archiviazione - BLOB, file, tabella, coda dall'elenco.
La nuova pagina fornirà una descrizione del servizio account di archiviazione. Nella parte inferiore sinistra di questa richiesta selezionare il pulsante Crea per creare un'istanza del servizio.
Dopo aver fatto clic su Crea, verrà visualizzato un pannello:
1. Inserire il nome desiderato per questa istanza del servizio (deve essere tutto in minuscolo).
2. In Modello di distribuzione fare clic su Resource Manager.
3. Per Tipo di account, usando il menu a discesa, selezionare Archiviazione (utilizzo generico v1).
4. Selezionare un percorso appropriato.
5. Per il menu a discesa Replica selezionare Archiviazione con ridondanza geografica e accesso in lettura (RA-GRS).
6. In Prestazioni fare clic su Standard.
7. Nella sezione Trasferimento sicuro obbligatorio selezionare Disabilitato.
8. Dal menu a discesa Sottoscrizione selezionare una sottoscrizione appropriata.
9. Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, effettuare il provisioning e gestire la fatturazione per una raccolta di asset di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto (ad esempio, questi lab) in un gruppo di risorse comune.
  
  Per altre informazioni sui gruppi di risorse di Azure, seguire questo collegamento su come gestire un gruppo di risorse.
10. Lasciare Disabilitato le reti virtuali se si tratta di un'opzione.
11. Cliccare su Crea.
Dopo aver fatto clic su Crea, è necessario attendere che il servizio venga creato, l'operazione potrebbe richiedere un minuto.
Una notifica verrà visualizzata nel portale dopo la creazione dell'istanza del servizio. Fare clic sulle notifiche per esplorare la nuova istanza del servizio.
Fare clic sul pulsante Vai alla risorsa nella notifica per esplorare la nuova istanza del servizio. Verrà visualizzata la pagina di panoramica della nuova istanza del servizio di archiviazione.
Nella pagina di panoramica fare clic su Tabelle sul lato destro.
Il pannello a destra cambierà per visualizzare le informazioni sul servizio tabelle, in cui è necessario aggiungere una nuova tabella. A tale scopo, fare clic sul + pulsante Tabella nell'angolo superiore sinistro.
Verrà visualizzata una nuova pagina, in cui è necessario immettere un nome di tabella. Questo è il nome che verrà usato per fare riferimento ai dati nell'applicazione nei capitoli successivi. Inserire un nome appropriato e fare clic su OK.
Dopo aver creato la nuova tabella, sarà possibile visualizzarla all'interno della pagina Servizio tabelle (in basso).

Capitolo 5 - Completamento della tabella di Azure in Visual Studio

Ora che l'account di archiviazione del servizio tabelle è stato configurato, è il momento di aggiungerli, che verranno usati per archiviare e recuperare informazioni. La modifica delle tabelle può essere eseguita tramite Visual Studio.

Aprire Visual Studio.
Scegliere Visualizza>Cloud Explorer dal menu.
Cloud Explorer verrà aperto come elemento ancorato (essere paziente, perché il caricamento potrebbe richiedere tempo).
Nota

Se la sottoscrizione usata per creare gli account di archiviazione non è visibile, assicurarsi di disporre di:
- Accesso allo stesso account usato per il portale di Azure.
- È stata selezionata la sottoscrizione dalla pagina Gestione account (potrebbe essere necessario applicare un filtro dalle impostazioni dell'account):
Verranno visualizzati i servizi cloud di Azure. Trovare Account di archiviazione e fare clic sulla freccia a sinistra di tale account per espandere gli account.
Una volta espansa, l'account di archiviazione appena creato dovrebbe essere disponibile. Fare clic sulla freccia a sinistra dello spazio di archiviazione, quindi, una volta espansa, trovare Tabelle e fare clic sulla freccia accanto a quella per visualizzare la tabella creata nell'ultimo capitolo. Fare doppio clic sulla tabella.
La tabella verrà aperta al centro della finestra di Visual Studio. Fare clic sull'icona della tabella con il + segno più.
Verrà visualizzata una finestra che richiede di aggiungere un'entità. Verranno create tre entità in totale, ognuna con diverse proprietà. Si noterà che PartitionKey e RowKey sono già disponibili, perché vengono usati dalla tabella per trovare i dati.
Aggiornare il valore di PartitionKey e RowKey come indicato di seguito (ricordarsi di eseguire questa operazione per ogni proprietà di riga aggiunta, anche se incrementare RowKey ogni volta):
Fare clic su Aggiungi proprietà per aggiungere righe di dati aggiuntive. Fare in modo che la prima tabella vuota corrisponda alla tabella seguente.
Al termine, fare clic su OK.

Avviso

Assicurarsi di aver modificato il tipo delle voci X, Y e Z in Double.
Si noterà che la tabella include ora una riga di dati. Fare di nuovo clic sull'icona + (più) per aggiungere un'altra entità.
Creare una proprietà aggiuntiva e quindi impostare i valori della nuova entità in modo che corrispondano a quelli illustrati di seguito.
Ripetere l'ultimo passaggio per aggiungere un'altra entità. Impostare i valori per questa entità su quelli illustrati di seguito.
La tabella dovrebbe ora essere simile a quella seguente.
Questo capitolo è stato completato. Assicurarsi di salvare.

Capitolo 6 - Creare un'app per le funzioni di Azure

Creare un'app per le funzioni di Azure, che verrà chiamata dall'applicazione desktop per aggiornare il servizio tabelle e inviare una notifica tramite l'hub di notifica.

Prima di tutto, è necessario creare un file che consentirà alla funzione di Azure di caricare le librerie necessarie.

Aprire Blocco note (premere Tasto Windows e digitare Blocco note).
Con Blocco note aperto, inserire la struttura JSON sottostante. Al termine, salvarlo sul desktop come project.json. È importante che la denominazione sia corretta: assicurarsi che non abbia un'estensione di file .txt . Questo file definisce le librerie che verranno usate dalla funzione, se è stato usato NuGet avrà un aspetto familiare.
```
{
"frameworks": {
    "net46":{
    "dependencies": {
        "WindowsAzure.Storage": "7.0.0",
        "Microsoft.Azure.NotificationHubs" : "1.0.9",
        "Microsoft.Azure.WebJobs.Extensions.NotificationHubs" :"1.1.0"
    }
    }
}
}
```
Accedere al portale di Azure.
Dopo aver eseguito l'accesso, fare clic su Nuovo nell'angolo superiore sinistro e cercare App per le funzioni, premere INVIO.

Nota

La parola New potrebbe essere stata sostituita con Crea una risorsa, nei portali più recenti.
La nuova pagina fornirà una descrizione del servizio app per le funzioni . Nella parte inferiore sinistra di questo prompt selezionare il pulsante Crea per creare un'associazione con questo servizio.
Dopo aver fatto clic su Crea, compilare quanto segue:
1. Per Nome app inserire il nome desiderato per questa istanza del servizio.
2. Selezionare una Sottoscrizione.
3. Selezionare il piano tariffario appropriato, se questa è la prima volta che si crea una funzione servizio app, sarà disponibile un livello gratuito.
4. Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, effettuare il provisioning e gestire la fatturazione per una raccolta di asset di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto (ad esempio, questi lab) in un gruppo di risorse comune.
  
  Per altre informazioni sui gruppi di risorse di Azure, seguire questo collegamento su come gestire un gruppo di risorse.
5. Per il sistema operativo, fare clic su Windows, in quanto si tratta della piattaforma desiderata.
6. Selezionare un piano di hosting (questa esercitazione usa un piano a consumo).
7. Selezionare un percorso (scegliere la stessa posizione della risorsa di archiviazione compilata nel passaggio precedente)
8. Per la sezione Archiviazione , è necessario selezionare il servizio di archiviazione creato nel passaggio precedente.
9. Non sarà necessario Application Insights in questa app, quindi è possibile lasciarlo disattivato.
10. Cliccare su Crea.
Dopo aver fatto clic su Crea , è necessario attendere che il servizio venga creato, l'operazione potrebbe richiedere un minuto.
Una notifica verrà visualizzata nel portale dopo la creazione dell'istanza del servizio.
Fare clic sulle notifiche per esplorare la nuova istanza del servizio.
Fare clic sul pulsante Vai alla risorsa nella notifica per esplorare la nuova istanza del servizio.
Fare clic sull'icona + (più) accanto a Funzioni, quindi su Crea nuovo.
All'interno del pannello centrale verrà visualizzata la finestra Di creazione della funzione . Ignorare le informazioni nella metà superiore del pannello e fare clic su Funzione personalizzata, che si trova vicino alla parte inferiore (nell'area blu, come indicato di seguito).
La nuova pagina all'interno della finestra mostrerà vari tipi di funzione. Scorrere verso il basso per visualizzare i tipi viola e fare clic su ELEMENTO HTTP PUT .

Importante

Potrebbe essere necessario scorrere ulteriormente la pagina verso il basso (e questa immagine potrebbe non essere esattamente la stessa, se sono stati eseguiti gli aggiornamenti del portale di Azure), ma si sta cercando un elemento denominato HTTP PUT.
Verrà visualizzata la finestra HTTP PUT , in cui è necessario configurare la funzione (vedere di seguito per l'immagine).
1. Per Linguaggio, usando il menu a discesa, selezionare C#.
2. In Nome immettere un nome appropriato.
3. Nel menu a discesa Livello di autenticazione selezionare Funzione.
4. Per la sezione Nome tabella , è necessario usare il nome esatto usato per creare il servizio tabelle in precedenza (inclusa la stessa lettera maiuscola).
5. Nella sezione Connessione dell'account di archiviazione usare il menu a discesa e selezionare l'account di archiviazione da questa posizione. In caso contrario, fare clic sul collegamento ipertestuale Nuovo accanto al titolo della sezione per visualizzare un altro pannello in cui deve essere elencato l'account di archiviazione.
Fare clic su Crea e si riceverà una notifica che informa che le impostazioni sono state aggiornate correttamente.
Dopo aver fatto clic su Crea, si verrà reindirizzati all'editor di funzioni.

Inserire il codice seguente nell'editor di funzioni (sostituendo il codice nella funzione):

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

Nota

Usando le librerie incluse, la funzione riceve il nome e la posizione dell'oggetto spostato nella scena unity (come oggetto C#, denominato UnityGameObject). Questo oggetto viene quindi utilizzato per aggiornare i parametri dell'oggetto all'interno della tabella creata. A questo scopo, la funzione effettua una chiamata al servizio Hub di notifica creato, che notifica a tutte le applicazioni sottoscritte.

Con il codice sul posto, fare clic su Salva.
Fare quindi clic sull'icona < (freccia) sul lato destro della pagina.
Un pannello scorrerà da destra. In tale pannello fare clic su Carica e verrà visualizzato un visualizzatore file.
Passare a e fare clic sul file project.json creato in precedenza nel Blocco note e quindi sul pulsante Apri . Questo file definisce le librerie che verranno usate dalla funzione.
Quando il file è stato caricato, verrà visualizzato nel pannello a destra. Facendo clic su di esso verrà aperto all'interno dell'editor di funzioni . Deve essere esattamente uguale all'immagine successiva (sotto il passaggio 23).
Quindi, nel pannello a sinistra, sotto Funzioni, fare clic sul collegamento Integrazione .
Nell'angolo superiore destro della pagina successiva fare clic su Editor avanzato (come riportato di seguito).

Un file function.json verrà aperto nel pannello centrale, che deve essere sostituito con il frammento di codice seguente. Definisce la funzione che si sta creando e i parametri passati alla funzione.

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

L'editor dovrebbe ora essere simile all'immagine seguente:
È possibile notare che i parametri di input appena inseriti potrebbero non corrispondere ai dettagli della tabella e dell'archiviazione e pertanto dovranno essere aggiornati con le informazioni. Non eseguire questa operazione in questo caso, come illustrato di seguito.Do not do this here, as it is covered next. È sufficiente fare clic sul collegamento Editor standard, nell'angolo superiore destro della pagina, per tornare indietro.
Nell'editor Standard fare clic su Archiviazione tabelle di Azure (tabella) in Input.
Verificare che la corrispondenza seguente corrisponda alle informazioni, in quanto potrebbero essere diverse (di seguito è riportata un'immagine):
1. Nome tabella: nome della tabella creata all'interno del servizio tabelle Archiviazione di Azure.
2. Connessione all'account di archiviazione: fare clic su nuovo, visualizzato accanto al menu a discesa e verrà visualizzato un pannello a destra della finestra.
  1. Selezionare l'account di archiviazione creato in precedenza per ospitare le app per le funzioni.
  2. Si noterà che il valore di connessione dell'account di archiviazione è stato creato.
  3. Assicurarsi di premere Salva al termine.
3. La pagina Input dovrebbe ora corrispondere a quella riportata di seguito, che mostra le informazioni.
Fare quindi clic su Hub di notifica di Azure (notifica) in Output. Verificare che le informazioni seguenti corrispondano alle informazioni, perché potrebbero essere diverse (è presente un'immagine sotto la procedura seguente):
1. Nome hub di notifica: nome dell'istanza del servizio Hub di notifica creata in precedenza.
2. Connessione allo spazio dei nomi di Hub di notifica: fare clic su nuovo, che viene visualizzato accanto al menu a discesa.
3. Verrà visualizzato il popup Connessione (vedere l'immagine seguente), in cui è necessario selezionare lo spazio dei nomi dell'hub di notifica configurato in precedenza.
4. Selezionare il nome dell'hub di notifica dal menu a discesa centrale.
5. Impostare il menu a discesa Criteri su DefaultFullSharedAccessSignature.
6. Fare clic sul pulsante Seleziona per tornare indietro.
La pagina Output dovrebbe ora corrispondere a quella riportata di seguito, ma con le informazioni. Assicurarsi di premere Salva.

Avviso

Non modificare direttamente il nome dell'hub di notifica ( questa operazione deve essere eseguita usando il Editor avanzato, purché i passaggi precedenti siano stati eseguiti correttamente.

Screenshot che mostra la pagina Output con informazioni generali.

A questo punto, è necessario testare la funzione per assicurarsi che funzioni. A questo scopo, è necessario:
1. Passare alla pagina della funzione ancora una volta:
2. Nella pagina della funzione fare clic sulla scheda Test sul lato destro della pagina per aprire il pannello Test :
3. Nella casella di testo Corpo della richiesta del pannello incollare il codice seguente:
```
{  
    "Type":null,
    "X":3,
    "Y":0,
    "Z":1,
    "PartitionKey":null,
    "RowKey":"Obj2",
    "Timestamp":"0001-01-01T00:00:00+00:00",
    "ETag":null
}
```
4. Con il codice di test sul posto, fare clic sul pulsante Esegui in basso a destra e il test verrà eseguito. I log di output del test verranno visualizzati nell'area della console, sotto il codice della funzione.
Avviso

Se il test precedente ha esito negativo, è necessario verificare di aver seguito esattamente i passaggi precedenti, in particolare le impostazioni all'interno del pannello di integrazione.

Capitolo 7 - Configurare il progetto Unity desktop

Importante

L'applicazione desktop che si sta creando non funzionerà nell'editor di Unity. Deve essere eseguito all'esterno dell'editor, seguendo la compilazione dell'applicazione, usando Visual Studio (o l'applicazione distribuita).

Di seguito è riportata una configurazione tipica per lo sviluppo con Unity e la realtà mista e, di conseguenza, è un modello valido per altri progetti.

Configurare e testare il visore VR immersive di realtà mista.

Nota

Per questo corso non saranno necessari controller di movimento. Se è necessario supportare la configurazione del visore VR immersive, seguire questo collegamento su come configurare Windows Realtà mista.

Aprire Unity e fare clic su Nuovo.
È necessario specificare un nome di progetto Unity, inserire UnityDesktopNotifHub. Assicurarsi che il tipo di progetto sia impostato su 3D. Impostare La posizione su un punto appropriato per l'utente (tenere presente che più vicino alle directory radice è preferibile). Fare quindi clic su Crea progetto.
Con Unity aperto, vale la pena verificare che l'editor di script predefinito sia impostato su Visual Studio. Passare a Modifica>preferenze e quindi dalla nuova finestra passare a Strumenti esterni. Modificare l'editor di script esterni in Visual Studio 2017. Chiudere la finestra Preferenze .
Passare quindi a Impostazioni di compilazione file>e selezionare piattaforma UWP (Universal Windows Platform), quindi fare clic sul pulsante Cambia piattaforma per applicare la selezione.
Sempre in Impostazioni di compilazione file>, assicurarsi che:
1. Il dispositivo di destinazione è impostato su Qualsiasi dispositivo
  
  Questa applicazione sarà per il desktop, quindi deve essere qualsiasi dispositivo
2. Il tipo di compilazione è impostato su D3D
3. L'SDK è impostato su Latest installed (Versione più recente installata)
4. La versione di Visual Studio è impostata su Versione più recente installata
5. Compilazione ed esecuzione è impostata su Computer locale
6. In questo caso, vale la pena salvare la scena e aggiungerla alla compilazione.
  1. A tale scopo, selezionare Aggiungi scene aperte. Verrà visualizzata una finestra di salvataggio.
  2. Creare una nuova cartella per questa cartella e qualsiasi scena futura, quindi selezionare il pulsante Nuova cartella per creare una nuova cartella, denominarla Scene.
  3. Aprire la cartella Scenes appena creata e quindi nel campo Nome file: digitare NH_Desktop_Scene, quindi premere Salva.
7. Le impostazioni rimanenti, in Impostazioni di compilazione, devono essere lasciate come predefinite per il momento.
Nella stessa finestra fare clic sul pulsante Player Settings (Impostazioni lettore) per aprire il pannello correlato nello spazio in cui si trova il controllo .
In questo pannello è necessario verificare alcune impostazioni:
1. Nella scheda Altre impostazioni :
  1. La versione del runtime di scripting deve essere sperimentale (equivalente a .NET 4.6)
  2. Il back-end di scripting deve essere .NET
  3. Il livello di compatibilità api deve essere .NET 4.6
2. Nella scheda Impostazioni di pubblicazione, in Funzionalità selezionare:
  - InternetClient
Tornare in Build Settings Unity C# Projects (Impostazioni di compilazione) I progetti C# non sono più disattivati. Selezionare la casella di controllo accanto a questa opzione.
Chiudi la finestra Build Settings (Impostazioni di compilazione).
Salvare la scena e il file>di progetto Salva scena/File>Salva progetto.

Importante

Se si vuole ignorare il componente Di configurazione unity per questo progetto (App desktop) e continuare direttamente nel codice, è possibile scaricare questo pacchetto unitypackage, importarlo nel progetto come pacchetto personalizzato e quindi continuare dal capitolo 9. Sarà comunque necessario aggiungere i componenti di script.

Capitolo 8 - Importazione delle DLL in Unity

Si userà Archiviazione di Azure per Unity (che si basa su .Net SDK per Azure). Per altre informazioni, vedere questo collegamento su Archiviazione di Azure per Unity.

Esiste attualmente un problema noto in Unity che richiede la riconfigurazione dei plug-in dopo l'importazione. Questi passaggi (da 4 a 7 in questa sezione) non saranno più necessari dopo la risoluzione del bug.

Per importare l'SDK nel proprio progetto, assicurarsi di aver scaricato la versione più recente di .unitypackage da GitHub. Procedere quindi come segue:

Aggiungere . unitypackage a Unity usando l'opzione di menu Asset > Importa pacchetto > personalizzato pacchetto.
Nella casella Importa pacchetto Unity visualizzata è possibile selezionare tutti gli elementi in Archiviazione plug-in>. Deselezionare tutto il resto, perché non è necessario per questo corso.
Fare clic sul pulsante Importa per aggiungere gli elementi al progetto.
Passare alla cartella Archiviazione in Plug-in nella visualizzazione Progetto e selezionare solo i plug-in seguenti:
- Microsoft.Data.Edm
- Microsoft.Data.OData
- Microsoft.WindowsAzure.Storage
- Newtonsoft.Json
- System.Spatial

deselezionare Qualsiasi piattaforma

Con questi plug-in specifici selezionati, deselezionare Qualsiasi piattaforma e deselezionare WSAPlayer e quindi fare clic su Applica.

Nota

Questi plug-in specifici vengono contrassegnati per essere usati solo nell'editor di Unity. Questo perché esistono versioni diverse degli stessi plug-in nella cartella WSA che verranno usate dopo l'esportazione del progetto da Unity.
Nella cartella Plug-in di archiviazione selezionare solo:
- Microsoft.Data.Services.Client
Selezionare la casella Non elaborare in Impostazioni piattaforma e fare clic su Applica.

Nota

Questo plug-in viene contrassegnato come "Non elaborare", perché l'assembly patcher unity ha difficoltà a elaborare questo plug-in. Il plug-in funzionerà ancora anche se non viene elaborato.

Capitolo 9 - Creare la classe TableToScene nel progetto Desktop Unity

È ora necessario creare gli script contenenti il codice per eseguire questa applicazione.

Il primo script da creare è TableToScene, che è responsabile di:

Lettura delle entità all'interno della tabella di Azure.
Usando i dati table, determinare gli oggetti da generare e in quale posizione.

Il secondo script da creare è CloudScene, responsabile di:

Registrazione dell'evento di clic a sinistra per consentire all'utente di trascinare gli oggetti nella scena.
Serializzazione dei dati dell'oggetto da questa scena unity e invio all'app per le funzioni di Azure.

Per creare questa classe:

Fare clic con il pulsante destro del mouse nella cartella asset disponibile nel pannello del progetto, Crea>cartella. Denominare la cartella Scripts.
Fare doppio clic sulla cartella appena creata per aprirla.
Fare clic con il pulsante destro del mouse all'interno della cartella Scripts e scegliere Crea>script C#. Assegnare allo script il nome TableToScene.
Fare doppio clic sullo script per aprirlo in Visual Studio 2017.

Aggiungere gli spazi dei nomi seguenti:

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

All'interno della classe inserire le variabili seguenti:

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

Nota

Sostituire il valore accountName con il valore Archiviazione di Azure Nome servizio e accountKey con il valore della chiave trovato nel servizio Archiviazione di Azure, nel portale di Azure (vedere l'immagine seguente).

recuperare la chiave dell'account

Aggiungere ora i metodi Start() e Awake() per inizializzare la classe.

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

All'interno della classe TableToScene aggiungere il metodo che recupererà i valori dalla tabella di Azure e li userà per generare le primitive appropriate nella scena.

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

All'esterno della classe TableToScene , è necessario definire la classe usata dall'applicazione per serializzare e deserializzare le entità di tabella.

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

Assicurarsi di salvare prima di tornare all'editor di Unity.
Fare clic sulla fotocamera principale nel pannello Gerarchia , in modo che le relative proprietà vengano visualizzate nel controllo.
Con la cartella Scripts aperta, selezionare il file TableToScene script e trascinarlo nella fotocamera principale. Il risultato dovrebbe essere il seguente:

Capitolo 10 - Creare la classe CloudScene nel progetto Unity desktop

Il secondo script da creare è CloudScene, responsabile di:

Registrazione dell'evento di clic a sinistra per consentire all'utente di trascinare gli oggetti nella scena.
Serializzazione dei dati dell'oggetto da questa scena unity e invio all'app per le funzioni di Azure.

Per creare il secondo script:

Fare clic con il pulsante destro del mouse nella cartella Script , scegliere Crea, Script C#. Assegnare allo script il nome CloudScene

Aggiungere gli spazi dei nomi seguenti:

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

Inserire le variabili seguenti:

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

Sostituire il valore azureFunctionEndpoint con l'URL dell'app per le funzioni di Azure disponibile nel servizio app della funzione di Azure, nel portale di Azure, come illustrato nell'immagine seguente:

Aggiungere ora i metodi Start() e Awake() per inizializzare la classe.

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

Nel metodo Update() aggiungere il codice seguente che rileverà l'input e il trascinamento del mouse, che a sua volta sposterà GameObjects nella scena. Se l'utente ha trascinato ed eliminato un oggetto, passerà il nome e le coordinate dell'oggetto al metodo UpdateCloudScene(), che chiamerà il servizio App per le funzioni di Azure, che aggiornerà la tabella di Azure e attiverà la notifica.

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

Aggiungere ora il metodo UpdateCloudScene(), come indicato di seguito:

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

Salvare il codice e tornare a Unity
Trascinare lo script CloudScene nella fotocamera principale.
1. Fare clic sulla fotocamera principale nel pannello Gerarchia , in modo che le relative proprietà vengano visualizzate nel controllo.
2. Con la cartella Scripts aperta, selezionare lo script CloudScene e trascinarlo nella fotocamera principale. Il risultato dovrebbe essere il seguente:

Capitolo 11 - Compilare il progetto desktop in UWP

Tutti gli elementi necessari per la sezione Unity di questo progetto sono stati completati.

Passare a Impostazioni di compilazione (impostazioni di compilazione file>).
Nella finestra Build Settings (Impostazioni compilazione) fare clic su Build (Compila).
Verrà visualizzata una finestra di Esplora file, che richiede una posizione da compilare. Creare una nuova cartella (facendo clic su Nuova cartella nell'angolo superiore sinistro) e denominarla BUILD.
1. Aprire la nuova cartella BUILD e creare un'altra cartella (usando una nuova cartella) e denominarla NH_Desktop_App.
2. Con il NH_Desktop_App selezionato. fare clic su Seleziona cartella. La compilazione del progetto richiederà un minuto.
Dopo la compilazione, Esplora file verrà visualizzata la posizione del nuovo progetto. Non è necessario aprirlo, tuttavia, perché è necessario creare prima l'altro progetto Unity, nei prossimi capitoli.

Capitolo 12 - Configurare Realtà mista progetto Unity

Di seguito è riportata una configurazione tipica per lo sviluppo con la realtà mista e, di conseguenza, è un modello valido per altri progetti.

Aprire Unity e fare clic su Nuovo.
Sarà ora necessario specificare un nome di progetto Unity, inserire UnityMRNotifHub. Assicurarsi che il tipo di progetto sia impostato su 3D. Impostare La posizione su un punto appropriato per l'utente (tenere presente che più vicino alle directory radice è preferibile). Fare quindi clic su Crea progetto.
Con Unity aperto, vale la pena verificare che l'editor di script predefinito sia impostato su Visual Studio. Passare a Modifica>preferenze e quindi dalla nuova finestra passare a Strumenti esterni. Modificare l'editor di script esterni in Visual Studio 2017. Chiudere la finestra Preferenze .
Passare quindi a Impostazioni compilazione file>e passare alla piattaforma per piattaforma UWP (Universal Windows Platform), facendo clic sul pulsante Cambia piattaforma.
Passare a Impostazioni di compilazione file>e assicurarsi che:
1. Il dispositivo di destinazione è impostato su Qualsiasi dispositivo
  
  Per Microsoft HoloLens impostare Dispositivo di destinazione su HoloLens.
2. Il tipo di compilazione è impostato su D3D
3. L'SDK è impostato su Latest installed (Versione più recente installata)
4. La versione di Visual Studio è impostata su Versione più recente installata
5. Compilazione ed esecuzione è impostata su Computer locale
6. In questo caso, vale la pena salvare la scena e aggiungerla alla compilazione.
  1. A tale scopo, selezionare Aggiungi scene aperte. Verrà visualizzata una finestra di salvataggio.
  2. Creare una nuova cartella per questa cartella e qualsiasi scena futura, quindi selezionare il pulsante Nuova cartella per creare una nuova cartella, denominarla Scene.
  3. Aprire la cartella Scenes appena creata e quindi nel campo Nome file: digitare NH_MR_Scene, quindi premere Salva.
7. Le impostazioni rimanenti, in Impostazioni di compilazione, devono essere lasciate come predefinite per il momento.
Nella stessa finestra fare clic sul pulsante Player Settings (Impostazioni lettore) per aprire il pannello correlato nello spazio in cui si trova il controllo .
In questo pannello è necessario verificare alcune impostazioni:
1. Nella scheda Altre impostazioni :
  1. La versione del runtime di scripting deve essere sperimentale (equivalente a .NET 4.6)
  2. Il back-end di scripting deve essere .NET
  3. Il livello di compatibilità api deve essere .NET 4.6
2. Più avanti nel pannello, in Impostazioni XR (disponibili sotto Impostazioni di pubblicazione), selezionare Virtual Reality Supported (Realtà virtuale supportata), assicurarsi che Windows Realtà mista SDK sia stato aggiunto
3. Nella scheda Impostazioni di pubblicazione, in Funzionalità selezionare:
  - InternetClient
Tornare in Impostazioni di compilazione, i progetti C# di Unity non sono più disattivati: selezionare la casella di controllo accanto a questa.
Dopo aver apportato queste modifiche, chiudere la finestra Impostazioni di compilazione.
Salvare la scena e il file>di progetto Salva scena/File>Salva progetto.

Importante

Se si vuole ignorare il componente Configura Unity per questo progetto (app di realtà mista) e continuare direttamente nel codice, è possibile scaricare questo pacchetto unitypackage, importarlo nel progetto come pacchetto personalizzato e quindi continuare dal capitolo 14. Sarà comunque necessario aggiungere i componenti di script.

Capitolo 13 - Importazione delle DLL nel progetto Unity Realtà mista

Si userà Archiviazione di Azure per la libreria Unity (che usa .Net SDK per Azure). Seguire questo collegamento per informazioni su come usare Archiviazione di Azure con Unity. Esiste attualmente un problema noto in Unity che richiede la riconfigurazione dei plug-in dopo l'importazione. Questi passaggi (da 4 a 7 in questa sezione) non saranno più necessari dopo la risoluzione del bug.

Per importare l'SDK nel proprio progetto, assicurarsi di aver scaricato l'ultimo pacchetto unitypackage. Procedere quindi come segue:

Aggiungere il pacchetto unity scaricato dall'esempio precedente a Unity usando l'opzione di menu Asset>Importa pacchetto> personalizzato pacchetto.
Nella casella Importa pacchetto Unity visualizzata è possibile selezionare tutti gli elementi in Archiviazione plug-in>.
Fare clic sul pulsante Importa per aggiungere gli elementi al progetto.
Passare alla cartella Archiviazione in Plug-in nella visualizzazione Progetto e selezionare solo i plug-in seguenti:
- Microsoft.Data.Edm
- Microsoft.Data.OData
- Microsoft.WindowsAzure.Storage
- Newtonsoft.Json
- System.Spatial
Con questi plug-in specifici selezionati, deselezionare Qualsiasi piattaforma e deselezionare WSAPlayer e quindi fare clic su Applica.

Nota

Si contrassegnano questi plug-in specifici da usare solo nell'editor di Unity. Questo perché esistono versioni diverse degli stessi plug-in nella cartella WSA che verranno usate dopo l'esportazione del progetto da Unity.
Nella cartella Plug-in di archiviazione selezionare solo:
- Microsoft.Data.Services.Client
Selezionare la casella Non elaborare in Impostazioni piattaforma e fare clic su Applica.

Nota

Si contrassegna questo plug-in "Non elaborare" perché l'assembly patcher di Unity ha difficoltà a elaborare questo plug-in. Il plug-in funzionerà ancora anche se non viene elaborato.

Capitolo 14 - Creazione della classe TableToScene nel progetto Unity di realtà mista

La classe TableToScene è identica a quella illustrata nel capitolo 9. Creare la stessa classe nel progetto Unity di realtà mista seguendo la stessa procedura illustrata nel capitolo 9.

Dopo aver completato questo capitolo, entrambi i progetti Unity avranno questa classe configurata nella fotocamera principale.

Capitolo 15 - Creazione della classe NotificationReceiver nel progetto Unity Realtà mista

Il secondo script che è necessario creare è NotificationReceiver, responsabile di:

Registrazione dell'app con l'hub di notifica all'inizializzazione.
Ascolto delle notifiche provenienti dall'hub di notifica.
Deserializzazione dei dati dell'oggetto dalle notifiche ricevute.
Spostare gli oggetti GameObject nella scena in base ai dati deserializzati.

Per creare lo script NotificationReceiver :

Fare clic con il pulsante destro del mouse nella cartella Script , scegliere Crea, Script C#. Assegnare allo script il nome NotificationReceiver.
Fare doppio clic sullo script per aprirlo.

Aggiungere gli spazi dei nomi seguenti:

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

Inserire le variabili seguenti:

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

Sostituire il valore hubName con il nome del servizio hub di notifica e il valore hubListenEndpoint con il valore dell'endpoint presente nella scheda Criteri di accesso, servizio Hub di notifica di Azure, nel portale di Azure (vedere l'immagine seguente).

Aggiungere ora i metodi Start() e Awake() per inizializzare la classe.

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

Aggiungere il metodo WaitForNotification per consentire all'app di ricevere notifiche dalla libreria dell'hub di notifica senza conflitto con il thread principale:

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

Il metodo seguente, InitNotificationAsync(), registrerà l'applicazione con il servizio hub di notifica all'inizializzazione. Il codice viene impostato come commento perché Unity non sarà in grado di compilare il progetto. I commenti verranno rimossi quando si importa il pacchetto Nuget di messaggistica di Azure in 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;
        // }
    }

Il gestore seguente, Channel_PushNotificationReceived(), verrà attivato ogni volta che viene ricevuta una notifica. Deserializzerà la notifica, che sarà l'entità tabella di Azure spostata nell'applicazione desktop e quindi sposta il GameObject corrispondente nella scena MR nella stessa posizione.

Importante

Il codice è impostato come commento perché il codice fa riferimento alla libreria di messaggistica di Azure, che verrà aggiunta dopo la compilazione del progetto Unity usando il Gestione pacchetti NuGet all'interno di Visual Studio. Di conseguenza, il progetto Unity non sarà in grado di compilare, a meno che non sia impostato come commento. Tenere presente che è necessario compilare il progetto e quindi tornare a Unity, sarà necessario ri commentare tale codice.

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

Ricordarsi di salvare le modifiche prima di tornare all'editor di Unity.
Fare clic sulla fotocamera principale nel pannello Gerarchia , in modo che le relative proprietà vengano visualizzate nel controllo.
Con la cartella Scripts aperta, selezionare lo script NotificationReceiver e trascinarlo nella fotocamera principale. Il risultato dovrebbe essere il seguente:
Nota

Se si sviluppa questa funzionalità per Microsoft HoloLens, sarà necessario aggiornare il componente Fotocamera principale, in modo che:
- Cancella flag: colore a tinta unita
- Sfondo: nero

Capitolo 16 - Compilare il progetto Realtà mista in UWP

Questo capitolo è identico al processo di compilazione per il progetto precedente. Tutto ciò che serve per la sezione Unity di questo progetto è stato completato, quindi è il momento di compilarlo da Unity.

Passare a Impostazioni di compilazione (impostazioni di compilazione file>).
Dal menu Impostazioni di compilazione verificare che Unity C# Projects* sia selezionata ( che consentirà di modificare gli script in questo progetto, dopo la compilazione).
Al termine, fare clic su Compila.
Verrà visualizzata una finestra di Esplora file, che richiede una posizione da compilare. Creare una nuova cartella (facendo clic su Nuova cartella nell'angolo superiore sinistro) e denominarla BUILD.
1. Aprire la nuova cartella BUILD e creare un'altra cartella (usando una nuova cartella) e denominarla NH_MR_App.
2. Con il NH_MR_App selezionato. fare clic su Seleziona cartella. La compilazione del progetto richiederà un minuto.
Dopo la compilazione, verrà aperta una finestra Esplora file nella posizione del nuovo progetto.

Capitolo 17 - Aggiungere pacchetti NuGet alla soluzione UnityMRNotifHub

Avviso

Tenere presente che, dopo aver aggiunto i pacchetti NuGet seguenti (e rimuovere il commento dal codice nel capitolo successivo), il codice, quando viene riaperto all'interno del progetto Unity, presenterà errori. Se si vuole tornare indietro e continuare a modificare nell'editor di Unity, sarà necessario impostare come commento il codice e quindi rimuovere il commento in un secondo momento, una volta tornato in Visual Studio.

Dopo aver completato la compilazione di realtà mista, passare al progetto di realtà mista creato e fare doppio clic sul file della soluzione (.sln) all'interno di tale cartella per aprire la soluzione con Visual Studio 2017. Sarà ora necessario aggiungere il pacchetto NuGet WindowsAzure.Messaging.managed . Si tratta di una libreria usata per ricevere notifiche dall'hub di notifica.

Per importare il pacchetto NuGet:

Nel Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione
Fare clic su Gestisci pacchetti NuGet.
Selezionare la scheda Sfoglia e cercare WindowsAzure.Messaging.managed.
Selezionare il risultato (come illustrato di seguito) e nella finestra a destra selezionare la casella di controllo accanto a Progetto. Verrà inserito un segno di spunta nella casella di controllo accanto a Project, insieme alla casella di controllo accanto al progetto Assembly-CSharp e UnityMRNotifHub .
La versione fornita inizialmente potrebbe non essere compatibile con questo progetto. Di conseguenza, fare clic sul menu a discesa accanto a Versione e fare clic su Versione 0.1.7.9, quindi fare clic su Installa.
È stata completata l'installazione del pacchetto NuGet. Trovare il codice commentato immesso nella classe NotificationReceiver e rimuovere i commenti.

Capitolo 18 - Modificare l'applicazione UnityMRNotifHub, classe NotificationReceiver

Dopo aver aggiunto i pacchetti NuGet, è necessario rimuovere il commento da parte di parte del codice all'interno della classe NotificationReceiver .

Valuta gli ambiti seguenti:

Spazio dei nomi nella parte superiore:

using Microsoft.WindowsAzure.Messaging;

Tutto il codice all'interno del metodo 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;
        }
    }

Avviso

Il codice precedente contiene un commento: assicurarsi di non aver accidentalmente annullato il commento (perché il codice non verrà compilato se è presente!).

Infine, l'evento Channel_PushNotificationReceived :

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

Con questi commenti non commentati, assicurarsi di salvare e quindi procedere con il capitolo successivo.

Capitolo 19 - Associare il progetto di realtà mista all'app dello Store

È ora necessario associare il progetto di realtà mista all'app dello Store creata all'inizio del lab.

Apri la soluzione.
Fare clic con il pulsante destro del mouse sul progetto di app UWP nel pannello Esplora soluzioni, passare allo Store e Associare l'app allo Store.
Verrà visualizzata una nuova finestra denominata Associa l'app a Windows Store. Fare clic su Avanti.
Caricherà tutte le applicazioni associate all'account a cui è stato effettuato l'accesso. Se non si è connessi all'account, è possibile accedere a questa pagina.
Trovare il nome dell'app dello Store creato all'inizio di questa esercitazione e selezionarlo. Fare clic su Avanti.
Fare clic su Associa.
L'app è ora associata all'app dello Store. Questa operazione è necessaria per l'abilitazione delle notifiche.

Capitolo 20 - Distribuire applicazioni UnityMRNotifHub e UnityDesktopNotifHub

Questo capitolo può essere più semplice con due persone, come risultato includerà entrambe le app in esecuzione, una in esecuzione sul computer desktop e l'altra all'interno del visore VR immersive.

L'app visore VR immersive è in attesa di ricevere modifiche alla scena (modifiche di posizione degli oggetti GameObject locali) e l'app desktop sta apportando modifiche alla scena locale (modifiche di posizione), che verranno condivise con l'app MR. È opportuno distribuire prima l'app MR, seguita dall'app Desktop, in modo che il ricevitore possa iniziare ad ascoltare.

Per distribuire l'app UnityMRNotifHub nel computer locale:

Aprire il file di soluzione dell'app UnityMRNotifHub in Visual Studio 2017.
Nella piattaforma della soluzione selezionare x86, Computer locale.
Nella configurazione della soluzione selezionare Debug.
Passare al menu Compila e fare clic su Distribuisci soluzione per trasferire localmente l'applicazione nel computer.
L'app dovrebbe ora essere visualizzata nell'elenco delle app installate, pronte per l'avvio.

Per distribuire l'app UnityDesktopNotifHub nel computer locale:

Aprire il file della soluzione dell'app UnityDesktopNotifHub in Visual Studio 2017.
Nella piattaforma della soluzione selezionare x86, Computer locale.
Nella configurazione della soluzione selezionare Debug.
Passare al menu Compila e fare clic su Distribuisci soluzione per trasferire localmente l'applicazione nel computer.
L'app dovrebbe ora essere visualizzata nell'elenco delle app installate, pronte per l'avvio.
Avviare l'applicazione di realtà mista, seguita dall'applicazione Desktop.

Con entrambe le applicazioni in esecuzione, spostare un oggetto nella scena desktop (usando il pulsante sinistro del mouse). Queste modifiche posizionale verranno apportate localmente, serializzate e inviate al servizio app per le funzioni. Il servizio app per le funzioni aggiornerà quindi la tabella insieme all'hub di notifica. Dopo aver ricevuto un aggiornamento, l'hub di notifica invierà i dati aggiornati direttamente a tutte le applicazioni registrate (in questo caso l'app vr immersive), che deserializzerà i dati in ingresso e applicherà i nuovi dati posizionali agli oggetti locali, spostandoli nella scena.

L'applicazione Hub di notifica di Azure completata

È stata creata un'app di realtà mista che sfrutta il servizio Hub di notifica di Azure e consente la comunicazione tra le app.

prodotto finale -end

Esercizi aggiuntivi

Esercizio 1

Puoi scoprire come modificare il colore dei GameObject e inviare tale notifica ad altre app che visualizzano la scena?

Esercizio 2

È possibile aggiungere lo spostamento dei GameObject all'app MR e visualizzare la scena aggiornata nell'app desktop?

Condividi tramite

HoloLens (prima generazione) e Azure 308: notifiche tra dispositivi

Supporto di dispositivi

Prerequisiti

Prima di iniziare

Capitolo 1 - Creare un'applicazione nel portale per sviluppatori Microsoft

Capitolo 2 - Recuperare le credenziali delle nuove app

Capitolo 3 - Configurare il portale di Azure: creare il servizio Hub di notifica

Capitolo 4 - Configurare il portale di Azure: creare un servizio tabelle

Capitolo 5 - Completamento della tabella di Azure in Visual Studio

Capitolo 6 - Creare un'app per le funzioni di Azure

Capitolo 7 - Configurare il progetto Unity desktop

Capitolo 8 - Importazione delle DLL in Unity

Capitolo 9 - Creare la classe TableToScene nel progetto Desktop Unity

Capitolo 10 - Creare la classe CloudScene nel progetto Unity desktop

Capitolo 11 - Compilare il progetto desktop in UWP

Capitolo 12 - Configurare Realtà mista progetto Unity

Capitolo 13 - Importazione delle DLL nel progetto Unity Realtà mista

Capitolo 14 - Creazione della classe TableToScene nel progetto Unity di realtà mista

Capitolo 15 - Creazione della classe NotificationReceiver nel progetto Unity Realtà mista

Capitolo 16 - Compilare il progetto Realtà mista in UWP

Capitolo 17 - Aggiungere pacchetti NuGet alla soluzione UnityMRNotifHub

Capitolo 18 - Modificare l'applicazione UnityMRNotifHub, classe NotificationReceiver

Capitolo 19 - Associare il progetto di realtà mista all'app dello Store

Capitolo 20 - Distribuire applicazioni UnityMRNotifHub e UnityDesktopNotifHub

L'applicazione Hub di notifica di Azure completata

Esercizi aggiuntivi

Esercizio 1

Esercizio 2

Risorse aggiuntive