Oggi siamo felici di lanciare l'anteprima per gli sviluppatori 4 dell'SDK di Android XR, continuando a concentrarci sull'unificazione dello sviluppo cross-device per visori, occhiali XR connessi e occhiali intelligenti. Per mantenere la nostra piattaforma intuitiva, stiamo adottando una denominazione più descrittiva per i nostri formati. Gli occhiali AI sono ora occhiali audio e gli occhiali AI con display sono ora occhiali con display. Queste modifiche saranno visibili nella nostra documentazione a partire da oggi.

Questa release include aggiornamenti che ti aiutano a creare esperienze incredibili per i dispositivi XR, a consentire esperienze immersive più profonde sui visori XR e a semplificare il percorso per la creazione di esperienze aumentate su occhiali audio e con display. Inoltre, le nostre librerie principali, tra cui XR Runtime, Jetpack SceneCore e ARCore per Jetpack XR, passeranno ufficialmente alla versione beta a breve.

Per darti un accesso anticipato all'hardware e alle risorse per la creazione di esperienze immersive e aumentate sui prossimi dispositivi, come occhiali audio e con display e Project Aura di XREAL, annunciamo l'Android XR Developer Catalyst Program. Scopri di più e inizia a inviare la tua candidatura oggi stesso. 

Creazione di esperienze aumentate per occhiali audio e con display

Iniziamo con le nostre librerie per le esperienze aumentate. L'anteprima per gli sviluppatori 4 introduce nuove API che ti aiutano a creare e testare le tue app.

Jetpack Projected: API Device Availability e ProjectedTestRule

La libreria Jetpack Projected aiuta a colmare le esperienze app dal telefono al campo visivo dell'utente. Abbiamo aggiunto l'API Device Availability, che consolida lo stato di usura e i segnali di connettività nei valori Lifecycle.State standard di Android. In questo modo puoi regolare il comportamento delle applicazioni in base al fatto che il dispositivo sia indossato o meno.

val xrDevice = XrDevice.getCurrentDevice(projectedContext)

// Observe the device lifecycle flow
xrDevice.getLifecycle().currentStateFlow
    .collect { state ->
        when (state) {
            Lifecycle.State.STARTED -> { /* Device is available (worn) */ }
            Lifecycle.State.CREATED -> { /* Device is unavailable (not worn) */ }
            Lifecycle.State.DESTROYED -> { /* Device is DISCONNECTED */ }
        }
    }

Per semplificare i test, la nuova ProjectedTestRule API nell'artefatto projected-testing automatizza la configurazione degli ambienti di test proiettati. In questo modo puoi scrivere unit test puliti e affidabili senza il codice boilerplate.

// from the 'androidx.xr.projected:projected-testing:1.0.0-alpha07' artifact
@get:Rule
val projectedTestRule = ProjectedTestRule()

@Test
fun testProjectedContextInitialization() {
    // by default, ProjectedTestRule automatically creates and connects
    // a projected device before each test
    val projectedContext = ProjectedContext.createProjectedDeviceContext(context)

    // assert the projected context is successfully initialized
    assertThat(projectedContext).isNotNull()
}

Jetpack Compose Glimmer: Google Sans Flex e nuovi componenti

La nostra libreria UI per occhiali con display, Jetpack Compose Glimmer, ora include Google Sans Flex per una migliore leggibilità sui display ottici trasparenti. Abbiamo anche aggiunto diversi componenti interattivi:

• Stack: progettati per gruppi ottimizzati per il touchpad, che mostrano un elemento alla volta.
• _Chip titolo_: forniscono categorizzazione e contesto per le schede di contenuti.

Creazione di esperienze immersive per visori XR e occhiali XR connessi

Se vuoi creare esperienze completamente immersive per visori XR e occhiali XR connessi, abbiamo diversi aggiornamenti importanti.

Transizione alla versione beta e architettura moderna

XR Runtime, Jetpack SceneCore e le funzionalità di percezione di ARCore per Jetpack XR (mappe di profondità, rilevamento di occhi/mani, test di hit e ancoraggi spaziali) passeranno presto alla versione beta, quindi abbiamo semplificato le API Jetpack XR. Abbiamo rimosso i pacchetti Guava e RxJava3 legacy a favore di un'architettura moderna, Kotlin-first.

Jetpack SceneCore: glTF e mesh personalizzate

Stiamo espandendo le funzionalità dei modelli 3D aggiungendo la possibilità di ottimizzare i modelli 3D e accedere a nodi specifici con un modello 3D. Utilizzando GltfModelNode, puoi modificare proprietà come posa, materiali e texture e persino eseguire animazioni per nodi specifici.

// Create a new PBR material
pbrMaterial = KhronosPbrMaterial.create(
    session = xrSession,
    alphaMode = AlphaMode.OPAQUE
)

// Load a texture.
val texture = Texture.create(
    session = xrSession,
    path = Path("textures/texture_name.png")
)

// Apply the texture and configure occlusion to define how the material handles ambient lighting.
pbrMaterial.setOcclusionTexture(
    texture = texture,
    strength = 0.5f
)

// Access the hierarchy of nodes within the model entity.
val entityNodes = entity.nodes

// Find the specific node to apply the material override.
val myEntityNode = entityNodes.find { it.name == "node_name" }

// Apply the PBR material to the node.
myEntityNode?.setMaterialOverride(
   material = newMaterial
)

Stiamo anche portando le mesh personalizzate in SceneCore. Le mesh personalizzate ti consentono di creare la geometria in modo programmatico, il che è ideale per la creazione di modelli 3D personalizzati. Questa funzionalità verrà lanciata in versione sperimentale, quindi provala e facci sapere cosa ne pensi.

// Create the mesh
val roadMesh =
    CustomMesh.BuilderFromMeshData(session, roadVertexLayout)
        .addVertexData(ByteBufferRegion(roadDataBuffer, 0, vertexDataSize))
        .setIndexData(ByteBufferRegion(roadDataBuffer, vertexDataSize, indexDataSize))
        .setTopology(MeshSubsetTopology.TRIANGLES)
        .build()

// Define the material
val roadMaterial = KhronosPbrMaterial.create(session, AlphaMode.OPAQUE)

// Instantiate the entity using the custom mesh and material
val roadEntity =
    MeshEntity.create(
        session,
        roadMesh,
        listOf(roadMaterial),
        pose = roadPose,
    )

Compose for XR: supporto glTF nativo

Ora abbiamo il supporto glTF nativo direttamente in Compose for XR con SpatialGltfModel. Utilizza questa funzionalità insieme a SpatiallGltfModelState per accedere a nodi e animazioni nel modello glTF oppure utilizzali per aggiungere texture e materiali ai tuoi modelli 3D.

val myGltfModelState = rememberSpatialGltfModelState(
        source = SpatialGltfModelSource.fromPath(
            Paths.get("models/my_animated_model.glb")
        )
    )

    val myGltfAnimation =
        myGltfModelState.animations.find { it.name == "animation_name" }

    DisposableEffect(myGltfAnimation) {
        myGltfAnimation?.loop()

        onDispose {
            myGltfAnimation?.stop()
        }
    }

    SpatialGltfModel(state = myGltfModelState, modifier = modifier)

ARCore per Jetpack XR: anteprima dell'API Geospatial per occhiali XR connessi

Stiamo anche fornendo un'anteprima dell'API Geospatial per occhiali XR con cavo in ARCore per Jetpack XR. Questo aggiornamento consente l'ancoraggio di alta precisione dei contenuti digitali collegati a località reali in oltre 87 paesi.

Combinando il sistema di posizionamento visivo (VPS) di ARCore con le funzionalità di ragionamento e audio dell'API Gemini Live, puoi creare esperienze sensibili al contesto che comprendono sia la posizione che la posizione dell'utente. Immagina di creare un tour a piedi immersivo e guidato dall'AI che fornisce descrizioni audio in tempo reale dei luoghi vicini, integrando perfettamente le informazioni digitali con l'ambiente fisico.

Inizia a costruire il futuro oggi stesso

È un momento fantastico per sviluppare per Android XR. Con l'SDK Jetpack XR che passerà presto alla versione beta e un solido set di nuovi strumenti a portata di mano, esplora ciascuna delle seguenti aree per preparare le esperienze della tua app per XR.  

Leggi la documentazione, esplora gli esempi e dai un'occhiata agli esperimenti XR

Visita il sito ufficiale per gli sviluppatori Android per guide tecniche complete, riferimenti API e istruzioni sulla configurazione del nuovo emulatore. Lasciati ispirare dai nostri esempi ed esperimenti. Scopri come abbiamo utilizzato queste API per creare layout spaziali immersivi, caricare modelli 3D, esplorare l'audio spaziale e altro ancora.

• Visita la pagina web di Android XR
• Esplora gli esempi XR
• Esplora gli esperimenti XR

Scopri le novità per i motori di gioco

Abbiamo aggiunto il supporto ufficiale per Unreal Engine e Godot e abbiamo lanciato due nuovi strumenti per accelerare lo sviluppo per Android XR con Unity e l'Android XR Interaction Framework. Inoltre, in base al tuo feedback, stiamo introducendo l'Android XR Engine Hub per consentirti di eseguire le tue esperienze direttamente dal motore che preferisci.

•  Leggi il post del blog sulle novità per Android XR e i motori di gioco

Richiedi l'accesso all'Android XR Developer Catalyst Program

Non perdere l'occasione di sviluppare per l'hardware Android XR più recente. Richiedi oggi stesso l'accesso all'hardware pre-release, incluso il nostro prototipo di occhiali audio e con display e Project Aura di XREAL.

Scopri di più e fai domanda oggi stesso

Non vediamo l'ora di vedere le fantastiche esperienze XR che creerai mentre ci avviciniamo al lancio di altri dispositivi Android XR entro la fine dell'anno.

Esplora questo annuncio e tutti gli aggiornamenti di Google I/O 2026 su io.google.