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 con cavo e occhiali intelligenti. Per mantenere la nostra piattaforma intuitiva, stiamo adottando una denominazione più descrittiva per i nostri form factor. Gli occhiali AI sono ora occhiali audio e gli occhiali AI con display sono ora occhiali con display. Queste modifiche verranno visualizzate nella nostra documentazione a partire da oggi. 

Questa release è ricca di aggiornamenti che ti aiutano a creare esperienze incredibili per i dispositivi XR, a offrire esperienze immersive più profonde sui visori XR e a semplificare il percorso per la creazione di esperienze di realtà aumentata 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 offrirti l'accesso in anteprima a hardware e risorse per la creazione di esperienze immersive e aumentate su dispositivi futuri, come occhiali con display e audio e Project Aura di XREAL, annunciamo l'Android XR Developer Catalyst Program. Scopri di più e inizia a fare domanda oggi stesso. 

Creare esperienze aumentate per occhiali audio e con display

A partire dalle nostre librerie per esperienze di realtà aumentata, 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 contribuisce a colmare il divario tra le esperienze delle app sullo smartphone e il campo visivo dell'utente. Abbiamo aggiunto l'API Device Availability,che consolida lo stato di usura e gli indicatori di connettività in valori standard di Lifecycle.State Android. In questo modo puoi regolare il comportamento delle applicazioni in base al fatto che il dispositivo sia indossato.

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 API ProjectedTestRule nell'artefatto di test proiettato automatizza la configurazione degli ambienti di test proiettati. In questo modo puoi scrivere test delle unità 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: progettato per gruppi ottimizzati per il touchpad, che mostrano un elemento alla volta.
• Chip del titolo: forniscono la categorizzazione e il contesto per le schede dei contenuti.

Creare esperienze immersive per visori XR e occhiali XR con cavo

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

Transizione alla beta e architettura moderna

XR Runtime, Jetpack SceneCore e le funzionalità di percezione di ARCore per Jetpack XR (mappe di profondità, monitoraggio di occhi/mani, test di riscontro e ancore spaziali) passeranno presto alla versione beta, pertanto abbiamo semplificato le API Jetpack XR. Abbiamo rimosso i pacchetti Guava e RxJava3 legacy a favore di un'architettura moderna basata su Kotlin.

Jetpack SceneCore: glTF e mesh personalizzate

Stiamo ampliando le funzionalità dei modelli 3D aggiungendo la possibilità di perfezionarli 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 al volo, il che è ideale per creare 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 nativo di glTF

Ora abbiamo il supporto glTF nativo direttamente in Compose for XR con SpatialGltfModel. Utilizza questo 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 con cavo

Stiamo anche fornendo un'anteprima iniziale dell'API Geospatial per gli occhiali XR con cavo in ARCore per Jetpack XR. Questo aggiornamento consente l'ancoraggio ad alta precisione di 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 guidato dall'AI che fornisca descrizioni audio in tempo reale dei luoghi vicini, combinando perfettamente le informazioni digitali con l'ambiente fisico.

Inizia a creare il futuro oggi

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

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

Visita il sito ufficiale per sviluppatori Android per guide tecniche complete, riferimenti API e istruzioni per la 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 molto altro.

• Visita la pagina web di Android XR
• Esplora gli esempi di XR
• Esplora gli esperimenti di 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. In base al tuo feedback, stiamo introducendo l'hub del motore Android XR 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

Fai domanda per il programma Android XR Developer Catalyst

Non perdere l'opportunità di sviluppare per l'hardware Android XR più recente. Fai domanda oggi stesso per avere l'opportunità di accedere all'hardware pre-release, tra cui il nostro prototipo di occhiali audio e display e Project Aura di XREAL.

Scopri di più e fai domanda oggi stesso

Non vediamo l'ora di vedere le incredibili esperienze XR che creerete in vista del lancio di altri dispositivi Android XR entro la fine dell'anno.

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