Nous sommes heureux d'annoncer aujourd'hui le lancement de la Preview développeur 4 du SDK Android XR. Nous continuons ainsi à nous concentrer sur l'unification du développement inter-appareils pour les casques, les lunettes XR filaires et les lunettes intelligentes. Pour que notre plate-forme reste intuitive, nous avons décidé d'adopter des noms plus descriptifs pour nos facteurs de forme. Les lunettes d'IA sont désormais appelées lunettes audio et les lunettes d'IA avec écran sont désormais appelées lunettes avec écran. Ces modifications sont visibles dans notre documentation à partir d'aujourd'hui. 

Cette version est riche en nouveautés qui vous aident à créer des expériences incroyables pour les appareils XR, à proposer des expériences immersives plus profondes sur les casques XR et à simplifier la création d'expériences augmentées sur les lunettes audio et à écran.  De plus, nos bibliothèques principales, y compris XR Runtime, Jetpack SceneCore et ARCore pour Jetpack XR, passeront officiellement en version bêta prochainement.

Pour vous donner un accès anticipé au matériel et aux ressources permettant de créer des expériences immersives et augmentées sur les futurs appareils (comme les lunettes audio et vidéo, et le Project Aura de XREAL), nous lançons le programme Android XR Developer Catalyst. Pour en savoir plus et commencer à postuler dès aujourd'hui,

Créer des expériences augmentées pour les lunettes audio et les lunettes avec écran

La Preview développeur 4 introduit de nouvelles API qui vous aident à créer et à tester vos applications.

Jetpack Projected : disponibilité des appareils et API ProjectedTestRule

La bibliothèque Jetpack Projected permet de transposer les expériences d'application du téléphone au champ de vision de l'utilisateur. Nous avons ajouté l'API Device Availability,qui regroupe les signaux d'état et de connectivité Wear dans des valeurs Lifecycle.State Android standards. Cela vous permet d'ajuster le comportement de vos applications selon que l'appareil est porté ou non.

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

Pour simplifier les tests, la nouvelle API ProjectedTestRule de l'artefact projected-testing automatise la configuration des environnements de test projetés. Cela vous aide à écrire des tests unitaires propres et fiables sans code récurrent.

// 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 et nouveaux composants

Notre bibliothèque d'UI pour les lunettes connectées, Jetpack Compose Glimmer, inclut désormais Google Sans Flex pour une meilleure lisibilité sur les écrans optiques transparents. Nous avons également ajouté plusieurs composants interactifs :

• Piles : conçues pour les groupes optimisés pour le pavé tactile, elles affichent un élément à la fois.
• Chips de titre : fournissent une catégorisation et un contexte pour les cartes de contenu.

Créer des expériences immersives pour les casques XR et les lunettes XR filaires

Si vous souhaitez créer des expériences entièrement immersives pour les casques XR et les lunettes XR filaires, nous avons plusieurs mises à jour importantes à vous annoncer.

Transition de la version bêta et architecture moderne

XR Runtime, Jetpack SceneCore et les fonctionnalités de perception ARCore pour Jetpack XR (cartes de profondeur, suivi des yeux/des mains, tests de sélection et ancres spatiales) passeront bientôt en version bêta. Nous avons donc simplifié les API Jetpack XR. Nous avons supprimé les anciens packages Guava et RxJava3 au profit d'une architecture moderne axée sur Kotlin.

Jetpack SceneCore : glTF et maillages personnalisés

Nous étendons les fonctionnalités des modèles 3D en ajoutant la possibilité d'affiner les modèles 3D et d'accéder à des nœuds spécifiques avec un modèle 3D. Avec GltfModelNode, vous pouvez modifier des propriétés telles que la pose, les matériaux et les textures, et même exécuter des animations pour des nœuds spécifiques.

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

Nous ajoutons également les maillages personnalisés à SceneCore. Les maillages personnalisés vous permettent de créer des géométries à la volée de manière programmatique, ce qui est idéal pour créer des modèles 3D personnalisés. Cette fonctionnalité sera lancée en version expérimentale. N'hésitez pas à l'essayer et à nous dire ce que vous en pensez.

// 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 pour XR : compatibilité native avec glTF

Nous disposons désormais d'une compatibilité native avec glTF directement dans Compose pour XR avec SpatialGltfModel. Utilisez-le avec SpatiallGltfModelState pour accéder aux nœuds et aux animations du modèle glTF, ou pour ajouter des textures et des matériaux à vos modèles 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 pour Jetpack XR : aperçu de l'API Geospatial pour les lunettes XR filaires

Nous proposons également un aperçu anticipé de l'API Geospatial pour les lunettes XR filaires dans ARCore pour Jetpack XR. Cette mise à jour permet d'ancrer avec précision du contenu numérique associé à des lieux réels dans plus de 87 pays.

En combinant le système VPS (Visual Positioning System) d'ARCore avec les capacités de raisonnement et audio de l'API Gemini Live, vous pouvez créer des expériences contextuelles qui comprennent à la fois l'emplacement et la position de votre utilisateur. Imaginez créer une visite guidée immersive par IA qui fournit des descriptions audio en temps réel des lieux à proximité, en combinant de manière fluide les informations numériques et l'environnement physique.

Commencez à construire l'avenir dès aujourd'hui

C'est le moment idéal pour développer des applications pour Android XR. Le SDK Jetpack XR passant bientôt en version bêta et un ensemble robuste de nouveaux outils étant à votre disposition, explorez chacun des domaines suivants pour préparer les expériences de votre application pour la XR.  

Consultez la documentation, explorez les exemples et découvrez les expériences XR.

Consultez le site officiel des développeurs Android pour obtenir des guides techniques complets, la documentation de référence de l'API et des instructions sur la configuration du nouvel émulateur. Inspirez-vous de nos exemples et de nos expériences. Découvrez comment nous avons utilisé ces API pour créer des mises en page spatiales immersives, charger des modèles 3D, explorer l'audio spatial et plus encore.

• Consulter la page Web Android XR
• Explorer les exemples XR
• Découvrir les tests XR

Découvrez les nouveautés concernant les moteurs de jeu

Nous avons ajouté la compatibilité officielle avec Unreal Engine et Godot, et nous avons lancé deux nouveaux outils pour accélérer le développement pour Android XR avec Unity et le framework d'interaction Android XR. De plus, en fonction de vos commentaires, nous lançons le Android XR Engine Hub pour vous permettre d'exécuter vos expériences directement à partir de votre moteur préféré.

•  Consulter l'article de blog sur les nouveautés pour Android XR et les moteurs de jeu

Inscrivez-vous au programme Android XR Developer Catalyst.

Ne manquez pas l'occasion de développer des applications pour le dernier matériel Android XR. Inscrivez-vous dès aujourd'hui pour avoir la chance d'accéder à du matériel en version préliminaire, y compris à notre prototype de lunettes audio et à écran, ainsi qu'au Project Aura de XREAL.

En savoir plus et s'inscrire dès aujourd'hui

Nous avons hâte de découvrir les expériences XR incroyables que vous allez créer à l'approche du lancement d'autres appareils Android XR d'ici la fin de l'année.

Découvrez cette annonce et toutes les nouveautés de Google I/O 2026 sur io.google.