Sintesi
Un ambiente di sviluppo per Rokid Glass3 consente a un team aziendale di realizzare applicazioni Android per [Rokid AI Glasses Enterprise](https://ai.vr-expert.com/en/ai-glasses/rokid-ai-glasses) e di testare la comunicazione con uno smartphone Android. Si parte dal firmware enterprise, da Android Studio, da JDK 17, dal repository Maven di Rokid e dal cavo dati di debug Glass3. Il normale cavo di ricarica non consente di installare l'applicazione per gli occhiali né di eseguirne il debug.
Questo flusso di lavoro su Windows 11 apre i due progetti demo ufficiali di Rokid, ne verifica la configurazione di build, installa ciascuna app e invia agli occhiali un messaggio di lavoro di esempio. Utilizza l'SDK enterprise e un test di comunicazione locale. I servizi online di riconoscimento vocale e di IA sono integrazioni separate. Le istruzioni sono state verificate sulla documentazione ufficiale e sul codice sorgente della demo; non è stata effettuata una prova su un dispositivo fisico.
Per informazioni sull'hardware, consulta la pagina prodotto di Rokid AI Glasses Enterprise. Rokid documenta l'architettura e il runtime di questo dispositivo enterprise nell'ambito del Glass3 Enterprise SDK. Prima di considerare compatibile un altro prodotto Rokid, verifica con il fornitore il dispositivo consegnato e il relativo firmware.
Requisiti per lo sviluppo su Rokid Glass3
Hardware: PC Windows 11, Rokid Glass3 Enterprise (firmware enterprise), smartphone Android dedicato ai test (consigliato Android 13 o superiore) e il cavo dati di debug Glass3.
Software: Android Studio con Android SDK Platform 34 e Build-Tools 35.0.0.
Ambiente di build: JDK 17, AGP 8.4.2, Gradle 8.6 e Kotlin 2.2.0.
SDK: Glasses SDK e Phone SDK 2.2.0-E.
Passaggio 1 Preparare l'hardware enterprise
· Verifica il sistema: il firmware è il software di sistema integrato negli occhiali. Chiedi al fornitore il modello degli occhiali, la versione del firmware enterprise installata e la compatibilità con l'SDK. Secondo le FAQ di Rokid, le build per uso professionale contengono di solito una e nel numero di versione. Usa la demo enterprise con il firmware enterprise. Il solo nome del prodotto non basta a stabilire la compatibilità.
· Controlla il cavo: procurati espressamente il cavo dati di debug Glass3. Durante l'installazione della demo, collegalo direttamente al computer di sviluppo. Il fatto che la ricarica funzioni non dimostra che il trasferimento dati USB funzioni.
· Prepara il test: carica entrambi i dispositivi e tienili vicini. Usa uno smartphone dedicato e il messaggio di esempio del Passaggio 10. Prima dell'abbinamento, scollega qualsiasi altro smartphone connesso in precedenza a questi occhiali.
Cavo dati di debug Glass3 mostrato nella Quick Start di Rokid. È il cavo necessario per il percorso di sviluppo via cavo.
Normale cavo di ricarica Glass3 mostrato da Rokid. Non può sostituire il cavo dati di debug. Verifica con il rivenditore la funzione del cavo fornito.
Passaggio 2 Installare Android Studio e l'Android SDK (se sono già installati, passa al passaggio successivo)
· Scarica il programma di installazione: scarica e installa Android Studio da https://developer.android.com/studio.
· Apri l'applicazione: apri Android Studio. Al primo avvio, se proposto, seleziona Do not import settings, quindi usa l'opzione Standard per la configurazione. Esamina le licenze dell'SDK, accetta quelle approvate dalla tua azienda e completa il download dei componenti.
· Installa i pacchetti necessari: dalla schermata di benvenuto, fai clic su More Actions > SDK Manager. In SDK Platforms, seleziona Android 14 / API 34. In SDK Tools, seleziona Android SDK Platform-Tools. Attiva Show Package Details, espandi Android SDK Build-Tools e seleziona 35.0.0. Tieni presente che l'Android Gradle Plugin della demo installa al primo sync i build tools 34.0.0 di cui ha bisogno. Fai clic su Apply, controlla l'elenco dei pacchetti, quindi fai clic su OK per installare.
· Annota il percorso dell'SDK: prendi nota del percorso indicato in Android SDK Location: ti servirà per configurare ADB nel Passaggio 8.
Passaggio 3 Scaricare e aprire i due progetti demo
· Ottieni il codice sorgente: nel browser, vai al repository ufficiale della demo enterprise Glass3 (ad es. https://github.com/RokidSuuport/glass3_sdk_demo.git; si tratta effettivamente del repository Git ufficiale, anche se "Support" è scritto in modo errato) oppure al repository Git messo a disposizione dal tuo fornitore. Fai clic sul pulsante verde Code, quindi su Download ZIP. In File Explorer > Downloads, fai clic con il tasto destro sul file ZIP e seleziona Extract All > Extract. Conserva la cartella estratta in un percorso di sviluppo approvato dall'azienda.
· Apri il progetto per lo smartphone: nella schermata di benvenuto di Android Studio, fai clic su Open. Sfoglia il contenuto della cartella estratta, seleziona glass3sdkphonedemo e fai clic su OK. Se compare una richiesta di attendibilità, verifica che si tratti della fonte ufficiale che hai scaricato prima di considerarla attendibile. La cartella esterna del repository non è il progetto Android.
· Apri il progetto per gli occhiali: scegli File > Open, seleziona la cartella glassdemo che si trova allo stesso livello e, quando richiesto, scegli New Window. Tieni aperte entrambe le finestre. Ciascuna ha la propria configurazione Gradle e un modulo app, ovvero la parte che genera l'applicazione installabile.
· Usa la vista dei file: in ciascuna finestra, apri View > Tool Windows > Project. Nel menu a discesa in cima al pannello sinistro, scegli Project. In questo modo vengono mostrati le cartelle e i file effettivi utilizzati nei passaggi seguenti. Se il primo sync segnala un errore, completa i Passaggi 4 e 5 prima di riprovare.
Passaggio 4 Selezionare JDK 17 per entrambi i progetti
· Apri le impostazioni di Gradle: nella finestra del progetto per lo smartphone, scegli File > Settings > Build, Execution, Deployment > Build Tools > Gradle. Individua il menu a discesa Gradle JDK. Questa impostazione determina la versione di Java usata per compilare il progetto, indipendentemente dal runtime Java che avvia Android Studio.
· Seleziona o scarica Java 17: scegli un JDK installato con l'etichetta 17. Se non ne compare nessuno, scegli Download JDK, seleziona Version 17, scegli un fornitore approvato dall'IT e fai clic su Download. Seleziona il JDK scaricato in Gradle JDK, quindi fai clic su Apply > OK. Ripeti l'operazione nella finestra del progetto per gli occhiali.
· Mantieni i target di codice esistenti: nella demo, sourceCompatibility, targetCompatibility e il jvmTarget di Kotlin usano 1.8. Questi valori indicano la compatibilità del codice compilato; non significano che Gradle debba essere eseguito su JDK 8. Lasciali invariati per questa demo. La guida di Google alle build Java distingue queste impostazioni.
Passaggio 5 Verificare le dipendenze Maven e allineare gli strumenti di build
Un repository Maven è un server in cui Gradle trova i pacchetti delle librerie, compreso l'SDK di Rokid.
· Controlla il repository: nel pannello sinistro di ciascun progetto, fai doppio clic su settings.gradle. Individua dependencyResolutionManagement > repositories e verifica che sia presente l'URL Maven di Rokid riportato sotto. Aggiungi soltanto la riga mancante all'interno del blocco esistente. Mantieni gli altri repository della demo, necessari per le sue altre dipendenze; se un proxy aziendale li blocca, chiedi all'IT di approvarne l'accesso.
// All'interno di settings.gradle > dependencyResolutionManagement
repositories {
google()
mavenCentral()
maven { url = uri("https://maven.rokid.com/repository/maven-public/") }
}
· Controlla i due pacchetti SDK: apri app > build.gradle in ciascuna finestra. In dependencies, mantieni una sola voce attiva per l'SDK corretto. Gli snippet seguenti sono in Groovy, la sintassi usata da questa demo. Non aggiungere l'SDK degli occhiali al progetto per lo smartphone e non incollare un secondo blocco dependencies. org.slf4j è un gruppo di librerie di logging; l'esclusione evita classi di logging duplicate.
// glassdemo/app/build.gradle > dependencies
implementation("com.rokid.security:glass3.open.sdk:2.2.0-E") {
exclude group: "org.slf4j"
}
// glass3sdkphonedemo/app/build.gradle > dependencies
implementation("com.rokid.security:phone.sdk:2.2.0-E") {
exclude group: "org.slf4j"
}
· Allinea AGP e Gradle: Kotlin è il linguaggio di programmazione usato da queste demo. Per lo snapshot esaminato, apri gradle > libs.versions.toml in entrambi i progetti. In [versions], modifica soltanto agp in 8.4.2, se non è già impostato così; mantieni kotlin = "2.2.0". Quindi apri gradle > wrapper > gradle-wrapper.properties e sostituisci soltanto distributionUrl con la riga seguente. Il wrapper scarica la versione di Gradle scelta. Google documenta l'abbinamento tra Gradle e JDK per AGP 8.10.
# gradle/libs.versions.toml > [versions]
agp = "8.4.2"
kotlin = "2.2.0"
# gradle/wrapper/gradle-wrapper.properties
distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
· Esegui il sync e controlla il risultato: salva i file modificati, quindi scegli File > Sync Project with Gradle Files in entrambe le finestre. Apri View > Tool Windows > Build e controlla l'output del sync. Non accettare aggiornamenti automatici non pertinenti. La demo include già regole di packaging per le librerie native: mantienile. Una libreria nativa è codice compilato per il dispositivo incluso nell'APK.
Passaggio 6 Configurare una demo aziendale locale
· Disattiva i servizi online per questo test: nel progetto per lo smartphone, apri app > src > main > java > com > rokid > phone > ui > MainPhoneActivity.kt. In cima a MainPhoneActivity.kt, mantieni l'import esistente di NetServiceType. Se manca, aggiungi la riga seguente insieme agli altri import:
Kotlin
import com.rokid.security.phone.sdk.base.data.NetServiceType
Quindi individua banServiceList all'interno di initSDK(). Sostituisci la sua dichiarazione attiva con la riga seguente. Mantieni i campi vuoti esistenti di UserAuthInfo e gli ID client. Il codice sorgente documenta questa opzione per disattivare i servizi di rete; non disattiva il test Bluetooth locale.
val banServiceList: List<NetServiceType> = arrayListOf(NetServiceType.ALL)
· Tieni separate le credenziali future: AK è una chiave di accesso (access key) e SK è la relativa chiave segreta. Per i servizi autenticati che userai in seguito, richiedi le credenziali dei servizi enterprise al tuo referente commerciale Rokid. In UserAuthInfo, appId riceve l'AK e secret riceve l'SK. Usa una configurazione di progetto protetta per le credenziali di test e non eseguire mai il commit di chiavi reali. Questa prima esecuzione locale non richiede queste funzionalità online.
· Aggiungi log di inizializzazione in inglese: nel progetto per lo smartphone, apri app > src > main > java > com > rokid > phone > ui > MainPhoneActivity.kt. In initSDK(), aggiungi un log in inglese all'interno del callback di successo:
Kotlin
Log.d(TAG, “Phone SDK ready”)
Nel progetto per gli occhiali, apri app > src > main > java > com > rokid > glass > HomeActivity.kt. initSDK() chiama GlassSdkUtils.initSdk() e poi raccoglie GlobalData.sdkInitState; all'interno di quel collector, subito dopo la riga Log.d(TAG, “SDK 初始化成功”), aggiungi il log in inglese:
Kotlin
Log.d(TAG, “Glasses SDK ready”)
(Nota: se Android Studio evidenzia in rosso i riferimenti alle classi, premi Alt + Invio per importare automaticamente i pacchetti necessari.)
· Evita di modificare il comportamento all'avvio: nel progetto per gli occhiali, apri app > src > main > java > com > rokid > glass > HomeActivity.kt. All'interno di onCreate(), commenta la seguente riga esistente anteponendo //. Questa riga configura l'avvio automatico dopo il riavvio; non è necessaria per un primo test su un dispositivo aziendale.
// DeviceUtil.setSystemProp("persist.vendor.boot.pkg", this.packageName)
· Limita il test di ricezione al solo testo: nella stessa cartella com > rokid > glass, apri MessageReceiveActivity.kt. Sostituisci soltanto la funzione onTextMessage all'interno di mMessageListener con il codice seguente. Il testo ricevuto resta visibile e registrato nel log, senza richiamare i servizi vocali. Un callback è una funzione che l'SDK chiama quando arriva un evento.
override fun onTextMessage(msg: String) {
log(msg)
}
Passaggio 7 Compilare ed eseguire l'applicazione per lo smartphone
· Attiva il debug USB sullo smartphone: sullo smartphone di test, apri Settings e usa la casella di ricerca per trovare Build number. Apri la pagina di informazioni sul dispositivo corrispondente e tocca Build number sette volte; inserisci il PIN del dispositivo se richiesto. Torna a Settings, cerca Developer options, apri la voce e attiva USB debugging. La posizione dei menu varia a seconda del produttore dello smartphone.
· Collega e autorizza: collega lo smartphone al computer con il relativo cavo dati USB. Nella finestra di dialogo Allow USB debugging? sullo smartphone, verifica che si tratti del computer di sviluppo e tocca Allow. Nella barra degli strumenti in alto del progetto per lo smartphone, scegli app come configurazione di esecuzione e seleziona lo smartphone connesso nel menu a discesa dei dispositivi accanto.
· Esegui l'app: fai clic sul triangolo verde Run oppure scegli Run > Run app. Android Studio compila, installa e apre la demo per lo smartphone. Il nome dell'app esaminata potrebbe essere Rokid Enterprise Demo o rokid白板, e l'interfaccia della demo sarà probabilmente in cinese. Nelle finestre di autorizzazione, concedi le autorizzazioni richieste per Nearby devices e l'accesso Wi-Fi necessari per questo test; le versioni precedenti di Android potrebbero richiedere la Posizione. Se in precedenza hai negato l'autorizzazione, vai su Settings > Apps > la demo > Permissions per modificare l'autorizzazione corrispondente.
· Verifica l'inizializzazione: apri View > Tool Windows > Logcat, seleziona lo smartphone e inserisci package:com.rokid.phone nel campo del filtro. Cerca Phone SDK ready, che indica che l'inizializzazione dell'SDK dello smartphone è riuscita. Lascia l'app aperta. Se i criteri dello smartphone di test bloccano il debug o le autorizzazioni necessarie, chiedi all'IT di configurare questo dispositivo di sviluppo dedicato prima di proseguire.
Passaggio 8 Collegare ed eseguire l'applicazione per gli occhiali
Verifica le impostazioni sviluppatore degli occhiali: sui Rokid Glass3, vai a Settings > System > Developer Options e verifica che USB Debugging sia impostato su ON. Se nella tua build enterprise il menu delle opzioni è bloccato o nascosto, contatta il distributore dell'hardware affinché esegua il flashing/provisioning di un firmware con le funzioni sviluppatore abilitate prima di proseguire.
· Verifica ADB con il cavo corretto: collega gli occhiali accesi con il cavo dati di debug Glass3. Nel progetto per gli occhiali, scegli View > Tool Windows > Terminal. Digita cd " seguito dal percorso dell'SDK annotato nel Passaggio 2, poi \platform-tools", e premi Invio. In quella cartella, esegui il comando seguente. Il numero di serie è l'identificatore del dispositivo riportato nella prima colonna.
.\adb.exe devices -l
· Leggi lo stato del dispositivo: cerca il numero di serie degli occhiali seguito da device, non da offline o unauthorized. Se sugli occhiali compare una finestra di autorizzazione, approva questo computer di sviluppo. Se non compare nulla, controlla prima il cavo e la porta USB. Le build enterprise possono limitare il debug; se è bloccato, chiedi al fornitore di predisporre l'accesso di sviluppo documentato. Non sostituire queste istruzioni con quelle dell'app companion consumer.
· Installa e avvia: nella barra degli strumenti del progetto per gli occhiali, seleziona app, scegli come destinazione gli occhiali, ad esempio Rokid RG-glasses, e fai clic su Run. Il nome dell'app è glassdemo. Apri Logcat, seleziona gli occhiali e filtra con package:com.rokid.glesse. Cerca Glasses SDK ready, il log aggiunto nel Passaggio 6, per confermare che l'inizializzazione dell'SDK è riuscita.
· Visualizza l'interfaccia in mirroring: scrcpy è uno strumento per visualizzare e controllare lo schermo dei dispositivi Android; l'uso via cavo è documentato da Rokid. Apri le istruzioni ufficiali di scrcpy per Windows, scarica il file ZIP per Windows a 64 bit e usa Extract All in Esplora file. Apri la cartella estratta e fai doppio clic su open_a_terminal_here.bat. Esegui adb devices, poi il comando seguente, sostituendo GLASSES_SERIAL con il numero di serie degli occhiali. La finestra di mirroring ti permette di fare clic sull'interfaccia degli occhiali con il mouse del computer.
scrcpy -s GLASSES_SERIAL --no-audio
Passaggio 9 Abbinare le demo enterprise
· Apri la schermata di connessione sullo smartphone: in Rokid Enterprise Demo, tocca l'icona + in alto a destra per aprire Discover Bluetooth. Per la versione cinese, nella demo per lo smartphone (rokid 白板), nella pagina 设备 (Dispositivo), tocca l'icona + in alto a destra per aprire 发现蓝牙 (Rileva Bluetooth). In questa revisione del codice sorgente, il layout attivo non prevede una scheda Dispositivo nella parte inferiore. Viene avviata una scansione; scegli la voce Glass3_… corrispondente ai tuoi occhiali. Se la scansione si blocca, tocca l'icona di aggiornamento in quella schermata.
· Completa l'abbinamento: approva l'eventuale finestra di abbinamento Bluetooth di Android e controlla se sugli occhiali compare una richiesta di connessione. Attendi che l'indicatore di connessione nella schermata Device dello smartphone mostri che il Bluetooth classico è connesso. Se dopo l'abbinamento la pagina di rilevamento o di connessione resta aperta, tocca il comando Back di Android per tornare a Device. Entrambi i dispositivi devono avere il Bluetooth attivo e gli occhiali non devono essere connessi a un altro smartphone. La pagina di Rokid per la risoluzione dei problemi Bluetooth elenca questi controlli.
· Mantieni semplice il primo test: la demo può anche negoziare una connessione Wi-Fi P2P e ne mostra lo stato separatamente. Il Bluetooth è sufficiente per il test di testo seguente. Se il P2P non è connesso, non interpretarlo come un errore di connessione Bluetooth. File di grandi dimensioni e contenuti multimediali in diretta richiedono una verifica P2P separata.
Passaggio 10 Inviare un messaggio di lavoro e verificare il funzionamento della demo
· Imposta il messaggio di test: nel progetto per lo smartphone, apri app > src > main > java > com > rokid > phone > SendMessageActivity.kt. Individua binding.btSendTextBtn.setOnClickListener e sostituisci l'intero blocco del listener con il codice seguente.
(Nota: in SendMessageActivity.kt, mantieni l'import esistente di PSecuritySDK. Se manca, aggiungi la riga seguente in cima al file, insieme agli altri import: import com.rokid.security.phone.sdk.api.PSecuritySDK).
GlassSample è l'ID client di ricezione già registrato dalla demo per gli occhiali; lascialo invariato su entrambi i lati.
binding.btSendTextBtn.setOnClickListener {
val message = "Work item 001 ready"
PSecuritySDK.getMessageService()
?.sendTextMessageByClassicBT(message, "GlassSample")
log(message)
}
· Esegui l'app modificata sullo smartphone: nella finestra del progetto per lo smartphone in Android Studio, seleziona lo smartphone connesso e fai clic su Run > Run app per ricompilare e installare l'applicazione modificata. Attendi che l'inizializzazione dell'SDK vada a buon fine e verifica che il Bluetooth si riconnetta. Poi, tramite scrcpy, vai a Message Receive sugli occhiali. Fai clic direttamente all'interno della finestra di scrcpy attiva sul desktop per selezionarla. Poiché gli occhiali emulano i controlli hardware di un D-pad, usa il tasto Freccia destra o Freccia sinistra della tastiera del computer per spostarti nel menu finché non viene evidenziata la voce Message Receive o 消息接收 (Message Receive), la seconda voce del menu, quindi premi Invio per aprire l'activity. La demo associa questi tasti alla selezione del menu in HomeActivity.kt. Lascia visibile questa pagina di ricezione: registra il listener dei messaggi usato da questo test.
· Invia dallo smartphone: nella pagina Device o 设备 dello smartphone, scorri fino alla scheda Message Send o 消息发送 e toccala. Nella pagina successiva, tocca Send text via Bluetooth o 蓝牙发送文本. Questo pulsante invia la stringa fissa indicata sopra; non c'è alcun campo di testo da compilare. Cerca Work item 001 ready nella pagina di ricezione degli occhiali.
· Registra la condizione di superamento: nel Logcat degli occhiali, filtra con package:com.rokid.glesse tag:MessageActivity e verifica che sia arrivato lo stesso messaggio. Il solo log di invio dello smartphone non dimostra la ricezione. Salva insieme al risultato le versioni dell'SDK, la build del firmware, la revisione del codice sorgente e le modifiche agli strumenti di build. Il test è superato se entrambe le app sono in esecuzione, il Bluetooth si connette e gli occhiali ricevono visibilmente il messaggio di test.
Problemi di configurazione comuni
· Gli occhiali si caricano ma non vengono rilevati: usa il cavo dati di debug e ripeti il controllo ADB del Passaggio 8. Il normale cavo di ricarica è la prima causa da escludere.
· Gradle non riesce a scaricare una libreria: in Build, espandi l'errore e annota il pacchetto esatto e l'URL del server. Controlla le voci dei repository del Passaggio 5 e l'accesso tramite il proxy aziendale. La demo include repository e dipendenze aggiuntivi oltre ai due SDK di Rokid; non eliminarli indiscriminatamente e non aggiungere un mirror qualsiasi.
· Errori di logging duplicato o di librerie native: verifica la presenza di voci SDK duplicate e l'esclusione di org.slf4j. Mantieni le regole packagingOptions esistenti per libr2aud.so nell'app per gli occhiali e per libc++_shared.so nell'app per lo smartphone. Un errore di libreria duplicata significa che due dipendenze hanno incluso lo stesso file.
· L'abbinamento funziona ma non arriva alcun messaggio: tieni aperta la pagina di ricezione sugli occhiali e verifica che GlassSample non sia stato modificato. In Logcat, verifica la presenza di entrambi i messaggi di inizializzazione riuscita prima di inviare. Se il dispositivo non viene rilevato, controlla le autorizzazioni Nearby devices dello smartphone e scollega prima qualsiasi altro smartphone.
Conclusione
La configurazione di un ambiente di sviluppo per Rokid Glass3 parte da occhiali compatibili con l'uso enterprise e dal cavo dati di debug corretto, per poi passare ad Android Studio, JDK 17, alle dipendenze Maven e a una configurazione di build coerente. Eseguire le demo per smartphone e occhiali e verificare la ricezione di un messaggio di lavoro fornisce una base pratica prima di aggiungere logica di business o servizi online. Per le aziende, questo processo può ridurre ritardi di configurazione evitabili, rendere i progetti pilota più facili da replicare e offrire agli sviluppatori una base più chiara per applicazioni che forniscono informazioni utili lasciando ai dipendenti le mani libere.
Verifica l'hardware enterprise, il cavo dati di debug e il supporto del firmware prima di acquistare un kit di sviluppo o di richiedere un progetto pilota aziendale.
