View in English

  • Global Nav Open Menu Global Nav Close Menu
  • Apple Developer
Search
Cancel
  • Apple Developer
  • News
  • Discover
  • Design
  • Develop
  • Distribute
  • Support
  • Account
Only search within “”

Quick Links

5 Quick Links

Videos

Abrir menú Cerrar menú
  • Colecciones
  • Temas
  • Todos los videos
  • Información

Más videos

  • Información
  • Resumen
  • Transcripción
  • Código
  • Comparte experiencias de visionOS con personas cercanas

    Aprende a crear experiencias compartidas para personas que usan Vision Pro en la misma habitación. Te mostraremos cómo integrar SharePlay y aprovechar ARKit en tu app, presentaremos los flujos de uso compartido de ventanas para participantes cercanos y de FaceTime, y abarcaremos una nueva API diseñada para una colaboración fluida. Descubre las recomendaciones para hacer que tus funcionalidades colaborativas se destaquen, sean detectables y atractivas para los que se encuentran cerca.

    Capítulos

    • 0:00 - Introducción
    • 0:56 - Más información sobre compartir con participantes cercanos
    • 4:21 - Desarrolla actividades cercanas
    • 5:35 - Permite compartir desde el menú Compartir
    • 9:15 - Mejora para los participantes cercanos
    • 10:37 - Coloca el contenido en relación con las personas
    • 13:20 - Coordina la reproducción de medios compartidos
    • 15:38 - Admite múltiples ventanas
    • 16:50 - Comparte contenido anclado

    Recursos

    • AVPlaybackCoordinator
    • Building a guessing game for visionOS
    • Configure your visionOS app for sharing with people nearby
    • groupActivityAssociation(_:)
    • init(originFromAnchorTransform:sharedWithNearbyParticipants:)
    • worldAnchorSharingAvailability
      • Video HD
      • Video SD

    Videos relacionados

    WWDC25

    • Explorar las mejoras de la app empresarial espacial

    WWDC24

    • Customize spatial Persona templates in SharePlay

    WWDC23

    • Build spatial SharePlay experiences
    • Create a great spatial playback experience

    WWDC21

    • Build custom experiences with Group Activities
    • Coordinate media experiences with Group Activities
  • Buscar este video…

    Hola, soy Connor y soy ingeniero del equipo FaceTime de visionOS. Me complace presentar una nueva capacidad que hace que compartir y colaborar sea más potente que nunca. En visionOS 26, puedes compartir apps y experiencias con personas en el mismo espacio. Esto permite ver, escuchar o colaborar en tus apps favoritas en el Vision Pro con otras personas a tu alrededor. En este video aprenderás a diseñar y crear apps diseñadas para compartirse con personas cercanas. Comenzaré con una descripción general de la funcionalidad. Te mostraré cómo usar SharePlay para crear experiencias interactivas con personas en el mismo espacio. Aprenderás cómo anclar contenido compartido al espacio físico en el que estás, con ARKit y anclajes de mundo compartidos. Comenzaré mostrando cómo funciona compartir con personas cercanas en visionOS 26. Hay una forma totalmente nueva de compartir apps que es más intuitiva y fácil de descubrir. Cada ventana tiene un botón a la derecha de la barra que abre un menú para compartir cuando se toca. Desde ahí, puedes seleccionar personas cercanas de una lista y compartir fácilmente. Al compartir, la ventana aparece para todas las personas en el mismo lugar donde la colocó quien la compartió. La barra de la ventana se ve verde, lo que indica que se comparte con todas las personas en el lugar.

    Esta experiencia crea un contexto compartido y hace que compartir en el mismo espacio sea mágico. Como las ventanas compartidas están en el mismo lugar para todas las personas, pueden discutir, señalar e interactuar como si estuvieran ahí de verdad.

    El sistema se asegura de que todas las personas vean la app en el mismo lugar y del mismo tamaño.

    Cuando aparece, cualquiera puede mover la ventana compartida, esta se mueve para todas las personas y se orienta hacia el grupo.

    Puedes cambiar el tamaño de la app en conjunto o integrarla en el entorno compartido. Si se presiona la Digital Crown para recentrar, la app se reposiciona en un buen lugar para todas las personas. Si alguien señala algo o mueve su mano sobre la ventana, el contenido se desvanece desvanece para garantizar que persona sea visible.

    Este contexto compartido no es sólo para personas en la misma sala. Una de las mejores partes de compartir cerca es su profunda integración con FaceTime. Cuando compartes una app con personas cercanas, puedes iniciar FaceTime para invitar, pasar el rato y colaborar con personas que también están lejos. Si se unen en visionOS, aparecerán en tu espacio como Persona espacial. Esto desbloquea un nivel de presencia que hace que parezca que todas las personas están en el mismo espacio.

    Cuando alguien se une como Persona espacial, el sistema encuentra la ubicación óptima junto a las personas cercanas.

    El lugar donde el sistema coloca las Personas espaciales depende del tipo de ventana compartida. Si alguien se une mientras se comparte una ventana volumétrica, rellenará cualquier espacio que rodee el volumen. El resultado es un diseño ideal para participantes cercanos y remotos. Las personas pueden unirse desde cualquier plataforma que sea compatible con FaceTime, como iOS o macOS.

    Cuando se unen, su video se muestra junto a la ventana compartida. Esto facilita interactuar con la app y hablar con otros al mismo tiempo. Al compartir una ventana se inicia una experiencia de solo visualización que funciona incluso si otros no tienen la app. Esto no requiere cambios en la app. Pero para crear una experiencia interactiva que se pueda compartir en el mismo espacio, adopta SharePlay. SharePlay es clave para la colaboración en FaceTime en las plataformas de Apple. Las apps SharePlay admiten la interacción en tiempo real, lo que permite a las personas ver películas, escuchar música, jugar, colaborar y mucho más. Cualquier app SharePlay en visionOS se puede compartir con personas cercanas, sin realizar cambios. Hay nuevas y emocionantes capacidades en SharePlay que permiten diseñar y mejorar tu app específicamente para personas en el mismo espacio.

    Si estás empezando con SharePlay, te recomiendo que veas “Crear experiencias personalizadas con actividades grupales” y “Crear experiencias espaciales de SharePlay.” Voy a ampliar los conceptos introducidos en esos videos. Cubriré varios temas que te facilitarán la creación de una excelente experiencia compartida. Repasaré la importancia de exponer una actividad SharePlay en el menú Compartir, para que se pueda compartir fácilmente. Después, aprenderás a mejorar las experiencias en el mismo espacio verificando si hay participantes cercanos y luego colocando contenido relativo a las personas con poses de participantes cerca. Incluiré un ejemplo de reproducción de medios compartidos con AVPlayer para sincronizar videos y audios compartidos cercanos. Por último, para las apps con múltiples ventanas, te explicaré cómo elegir cuáles asociar a SharePlay. Para comenzar, debes hacer que tu actividad SharePlay esté disponible en el menú Compartir.

    Con la introducción del nuevo menú Compartir en visionOS 26, compartir apps es más fácil que nunca. Para aprovecharlo al máximo, debes exponer una GroupActivity al menú Compartir con SwiftUI o UIKit API. Cuando las personas toquen el botón Compartir, pueden activar esa GroupActivity y comenzar SharePlay. Para las ventanas volumétricas, el menú Compartir solo se puede usar si la app expuso una actividad. Quiero crear una experiencia SharePlay que me permita jugar juegos de mesa con mis amigos cuando los visito en persona.

    Creé una actividad grupal sencilla para mi app de juegos de mesa, llamada BoardGameActivity. GroupActivities es la estructura que potencia SharePlay y definir una GroupActivity es el primer paso para crear una experiencia compartida. Configuré la escena principal con un WindowGroup volumétrico que muestra la vista del tablero de juego. Esta es una app SwiftUI, así que para exponer mi BoardGameActivity al menú, necesito agregar un ShareLink a mi jerarquía de vistas. Paso mi BoardGameActivity, que quiero iniciar, y la marco como hidden porque en realidad no quiero que afecte la IU de mi app. Cuando alguien comparte una actividad expuesta desde el menú compartir, se activa automáticamente y crea una GroupSession. Esto funciona igual que invocar al método activate() manualmente en una GroupActivity.

    Puedo recuperar la GroupSession creada automáticamente observando las sesiones en mi BoardGameActivity. Luego, para iniciar SharePlay, configuro y me uno a la sesión que se creó.

    Ahora la gente puede compartir mi app desde el menú compartir. Esto cubre las apps que tienen ventanas o son volumétricas, pero si tu experiencia usa un espacio envolvente, hay consideraciones que debes tener en cuenta para que el menú compartir sea accesible.

    Quiero convertir mi experiencia con ventanas en una mesa de juego de tamaño completo en el piso de mi habitación, con objetos 3D temáticos a mi alrededor para que se sienta más real. Para hacer eso, necesito colocarlo en un ImmersiveSpace. Pero ahora tengo un problema. ¿Cómo pueden compartir mi app si no hay una barra de ventana en un espacio envolvente? Para esto, puedo ofrecer mi propio botón para que puedan compartir sin usar una ventana o volumen. Cuando alguien presiona ese botón, mi app invoca el método de activación en BoardGameActivity. En visionOS 26, al activar una actividad se activa automáticamente el menú Compartir, incluso fuera de FaceTime. Esto funciona con ventanas y espacios envolventes. Desde allí, puedes seleccionar personas cercanas o crear una nueva sesión de FaceTime para compartir desde tu app.

    Una forma aún mejor de resolver esto en mi app es seguir ofreciendo un modo no envolvente.

    Así, se puede compartir desde el menú Compartir en la ventana no envolvente y luego pasar a la envolvente cuando se unan todas las personas.

    Al igual que antes, necesito unirme a GroupSession para iniciar SharePlay. También necesito el coordinador del sistema de la sesión y establecer supportsGroupImmersiveSpace como true para que mi espacio envolvente sea compartido y esté en el mismo lugar para todas las personas. Cuando te asegures de que tu app se puede compartir, es momento de considerar cómo mejorar o personalizar tu experiencia para las personas en el mismo espacio. Para eso, puedes buscar participantes cercanos explícitamente con la nueva API SharePlay. Esto es importante si las personas inician FaceTime mientras comparten cerca. En mi app, quiero dejar que las personas en el mismo espacio jueguen contra cualquiera que se una desde FaceTime. Veré qué participantes están físicamente juntos y les sugeriré a esas personas cercanas como compañeros de equipo.

    Para hacer esto, necesito saber qué participantes están cerca y cuáles están remotos.

    Comienzo con mi GroupSession a la que me uní antes. Para obtener información sobre los participantes, observo el editor de participantes activos en la GroupSession. Desde ese estado de participante, verifico la nueva propiedad, isNearbyWithLocalParticipant. Será true si el participante está cerca de mí. Excluyo al participante local, ya que solo me importa qué otros participantes están cerca.

    Con eso, puedo hacer que los participantes cercanos estén en el mismo equipo y puedan jugar contra las personas remotas. Para crear una buena experiencia, también debes considerar dónde se encuentran las personas cercanas en relación con tu app, por si quieres colocar contenido junto a ellas o mirando hacia ellas. La nueva API de SharePlay te dice dónde se ubican las personas cuando comienzan a compartir. Aquí hay un ejemplo. Hasta ahora asumí que las personas cercanas comparten la app cuando están frente a ella. En realidad, las personas pueden estar en cualquier lugar del espacio al compartir la app. Las apps comparten el lugar, por lo que no se moverán entre personas cuando comience el uso compartido. Es importante saber esto para las apps de espacio envolvente, ya que quizá quieras colocar el contenido cerca de dónde están los participantes, no solo en el origen del espacio. En este ejemplo, quiero mostrar una tarjeta de puntuación a cada persona cercana en mi app de juego de mesa envolvente.

    Para esto, primero tendría que saber dónde están los participantes cercanos en relación con mi escena ImmersiveSpace. Puedes obtener esta información de una propiedad Pose en ParticipantState.

    Al igual que antes, comienzo con la sesión grupal a la que me uní. Para obtener información de localParticipant, accedo al coordinador del sistema en la sesión y observo la secuencia asíncrona de localParticipantState en el coordinador del sistema. Cuando ya tengo el localParticipantState, puedo leer la nueva propiedad de pose en ese estado, que me indica dónde está el participante local en relación con la escena de ImmersiveSpace.

    La propiedad pose no rastrea la ubicación en tiempo real, pero sí se actualiza después de eventos clave, como cuando se comienza a compartir o después de que alguien presiona la Digital Crown. Cuando conozco la ubicación del participante local, calculo dónde colocar la tarjeta de puntuación en relación con cada participante, para que aparezca al lado.

    Además de la pose real, puedes obtener su pose de asiento, que se encuentra en una ubicación física fija en relación con la app. Para más información sobre las poses de asiento y personalizar la disposición con plantillas espaciales, recomiendo ver “Personalizar plantillas espaciales de Persona en SharePlay.” Con esa información, puedo leer las posiciones de los asientos para hacer algo aún más avanzado y pedirle a las personas que se muevan a sus asientos reales alrededor de la mesa. Esto les indica el mejor lugar donde ubicarse para disfrutar de mi app. Si tu app ya usa poses de asiento, considera migrar a poses de participantes si quieres colocar contenido donde las personas ya se encuentran.

    Si tu experiencia implica compartir video o audio, AVPlayer se actualizó en visionOS 26 para coordinar la reproducción para personas en el mismo espacio. Reunir medios compartidos en un mismo espacio crea un conjunto único de desafíos, porque las personas están físicamente cerca. Al compartir contenido multimedia con personas cercanas, es posible que escuches audio de otros participantes. Esto hace que los retrasos en el audio sean perceptibles y perturben la fluidez de todas las personas. Por eso es fundamental que vean y escuchen lo mismo al mismo tiempo. En visionOS 26, AVPlayer y AVPlaybackCoordinator sincronizarán con precisión la reproducción de audio y video para personas en el mismo espacio.

    Para demostrar esto, quiero agregar una nueva funcionalidad de video instructivo a mi app. Las personas pueden abrir un video en cualquier momento para aprender a jugar el juego. Todas las personas deberían ver y escuchar este video al mismo tiempo. Una vez finalizado, los jugadores pueden volver atrás y aplicar lo que aprendieron para jugar.

    En mi app, crearé un AVPlaybackCoordinator y lo configuraré con mi GroupSession. Al hacer esto, la reproducción estará sincronizada para las personas en el mismo espacio. En mi app, eso significa que todos pueden ver y escuchar el video al mismo tiempo, sin eco ni demora.

    Para aprender cómo configurar un AVPlaybackCoordinator para SharePlay, recomiendo ver “Coordinar experiencias multimedia con actividades grupales”. Si estás empezando a crear apps multimedia para visionOS, te sugiero ver “Crear una buena experiencia de reproducción espacial.” Ahora el audio y el video están sincronizados en mi app. Sin embargo, la adición de la ventana de video instructivo creó un nuevo problema a resolver. Mi app ahora tiene varios WindowGroups abiertos al mismo tiempo: la ventana volumétrica del juego de mesa y la ventana del video instructivo. Para arreglar esto, tengo que especificar cuál quiero que se comparta mientras ambas están abiertas. La API SharePlay en visionOS 26 me deja usar un modificador de vista para elegir qué WindowGroup quiero que se asocie con SharePlay. Esto desbloquea un nivel nuevo de control para las apps que admiten múltiples ventanas.

    Aquí tengo el juego de mesa WindowGroup de mi app. Para agregar mi nuevo video instructivo, crearé un segundo WindowGroup para alojar la vista del video. Puedo agregar el nuevo modificador de vista .groupActivityAssociation a una vista en ese WindowGroup.

    Al pasar en primario a .groupActivityAssociation, le digo al sistema que quiero que esta ventana sea la ventana compartida mientras esté abierta.

    Ahora, mi app puede cambiar a un video compartido sincronizado y luego volver al juego de mesa cuando todos estén listos para jugar.

    Me entusiasma ver cómo aprovecharás estas mejoras para crear experiencias sociales increíbles. Este es el mejor momento para adoptar SharePlay. Pero Group Activities no es la única estructura con una nueva API para compartir con personas cercanas. ARKit tiene cambios en visionOS 26 que permiten anclar contenido compartido en la misma ubicación física con anclajes de mundo compartidos. Pero antes, voy a repasar algunos conceptos clave para espacios envolventes y anclajes de mundo regulares. Si tu app usa un ImmersiveSpace, puedes colocar contenido en cualquier lugar de la habitación. Es ideal para presentar algo alrededor de una persona, pero no se garantiza que permanezca en la misma ubicación física. Si alguien se mueve y presiona la Digital Crown para recentrar, todo el espacio envolvente se ajusta. Esto funciona para muchos casos, pero puede ser un problema si quieres que tu contenido permanezca fijo a lo largo del tiempo. ARKit ofrece una solución a esto con anclajes de mundo. Los anclajes de mundo permiten que las apps coloquen contenido en ubicaciones físicas fijas. El sistema garantiza que este contenido permanezca anclado en la misma ubicación a lo largo del tiempo, incluso si alguien presiona la Digital Crown.

    Imagina una app que permita colocar muebles virtuales en tu mundo real para crear un plano o simplemente experimentar con nuevos diseños. Para una app así, es importante que los muebles permanezcan en la misma ubicación física y no se desplacen. Para crear esta app, necesito poder colocar contenido en una ubicación específica en relación con mi espacio envolvente y luego usar un anclaje de mundo para que quede ahí. Primero, configuro un ARKitSession y un WorldTrackingProvider, luego ejecuto el WorldTrackingProvider en la sesión. Para agregar un anclaje en mi app de muebles, crearé un WorldAnchor en una transformación específica para los muebles en ImmersiveSpace y lo agregaré a WorldTrackingProvider. Finalmente, escucho las actualizaciones de la secuencia anchorUpdates de WorldTrackingProvider, que se invocará cuando mi anclaje se agregue. Luego puedo poner mi modelo de mueble debajo del anclaje y, ¡listo!

    Ahora que las personas pueden compartir apps, los anclajes de mundo son más importantes que nunca. Cuando compartes con alguien cercano, la habitación es parte del contexto compartido. Los anclajes de mundo permiten aprovechar el espacio como contexto compartido. Para colocar contenido compartido en una ubicación física al compartir, las apps deben usar una API para marcar los anclajes como compartidos. Durante una sesión de SharePlay, esta API permite que las apps creen un anclaje de mundo que se comparte solo con los participantes cercanos. Los anclajes compartidos solo se crean con SharePlay activo y no persisten luego, a diferencia de los anclajes de mundo regulares.

    Adoptaré esto en mi app de muebles de antes. Ahora, si alguna persona agrega un mueble a la habitación, quiero que todos los participantes cercanos lo vean aparecer. Esto hará que parezca que estamos diseñando una habitación juntos. Necesito ver que los anclajes de mundo compartidos estén disponibles antes de intentar crear uno. Observo newWorldAnchorSharingAvailability en mi WorldTrackingProvider. Cuando esté available, sabré que mi app se comparte activamente con personas cercanas y podré crear un anclaje de mundo compartido.

    A partir de ahí, crear un anclaje de mundo compartido es muy similar a crear un anclaje regular. Para la persona que agrega los muebles, paso sharedWithNearbyParticipants como true al crear WorldAnchor. En los WorldTrackingProviders de los participantes cercanos, recibo el nuevo anclaje compartido de la secuencia anchorUpdates, y tiene el mismo identificador en todos los dispositivos. Puedes leer y sincronizar este identificador para asegurarte de que la app sepa qué contenido asociar con el anclaje en cada dispositivo.

    Estos anclajes también se pueden usar en apps comerciales con tu propia capa de red fuera de SharePlay. Si estás creando una app comercial espacial que deseas compartir con personas cercanas, ve a “Explora las mejoras de tu app comercial espacial” para obtener más información.

    Compartir con personas cercanas se trata de disfrutar contenido en la misma habitación, y con anclajes de mundo compartidos, podrás crear experiencias que aprovechan por completo el espacio compartido.

    Después de ver este video, piensa en cómo tu app podría respaldar mejor las experiencias compartidas interactivas con SharePlay. ¿Cómo pueden las personas interactuar con el contenido de tu app? Una vez que adoptes SharePlay, asegúrate de que cualquier persona pueda compartir tu app admitiendo el menú Compartir. Esta es tu oportunidad de destacar tu experiencia compartida, accesible directamente desde la IU del sistema. Piensa en cómo puedes diseñar tu experiencia para personas que están cerca y lejos en cualquier plataforma compatible. Recuerda que admite a los participantes cercanos y remotos. Tu app ahora vincula a personas en la misma sala con otras en todo el mundo, así que asegúrate de considerar todas las posibilidades. Por último, crea experiencias que aprovechen el espacio físico. Usa anclajes de mundo para que tu contenido virtual se sienta más presente e interactivo en una habitación real. Cuando combinas todo esto, las posibilidades son infinitas. Puedes tener sesiones colaborativas de pizarrón en tu pared física, jugar juegos envolventes en tu sala de estar o convertir tu espacio en un cine para una noche de películas con amigos. Poder compartir experiencias cerca es una forma nueva y potente de relacionarse y colaborar con quienes te rodean. Espero que crees experiencias que hagan que las personas se sientan cerca mientras están juntas.

    • 6:21 - Expose an activity with GroupActivities and SwiftUI

      // Expose an activity with GroupActivities and SwiftUI
      
      import SwiftUI
      import GroupActivities
      
      struct BoardGameActivity: GroupActivity, Transferable {
          var metadata: GroupActivityMetadata = {
              var metadata = GroupActivityMetadata()
              metadata.title = "Play Together"
              return metadata
          }()
      }
      
      struct BoardGameApp: App {
          var body: some Scene {
              WindowGroup {
                  BoardGameView()
                  ShareLink(item: BoardGameActivity(), preview: SharePreview("Play Together"))
                      .hidden()
              }
              .windowStyle(.volumetric)
          }
      }
      
      struct BoardGameView: View {
          var body: some View {
              // Board game content
          }
      }
    • 7:14 - Join a GroupSession with GroupActivities

      // Join a GroupSession with GroupActivities
      
      func observeSessions() async {
      
          // Sessions are created automatically when the activity is activated
          for await session in BoardGameActivity.sessions() {
      
              // Additional configuration and setup
      
              // Join SharePlay
              session.join()
          }
      }
    • 8:57 - Join and configure a GroupSession with GroupActivities

      // Join a GroupSession with GroupActivities
      
      func observeSessions() async {
      
          // Sessions are created automatically when the activity is activated
          for await session in BoardGameActivity.sessions() {
      
              // Additional configuration and setup
      
              guard let systemCoordinator = await session.systemCoordinator else { continue }
              systemCoordinator.configuration.supportsGroupImmersiveSpace = true
      
              // Join SharePlay
              session.join()
          }
      }
    • 9:59 - Check for nearby participants with GroupActivities

      // Check for nearby participants with GroupActivities
      
      func observeParticipants(session: GroupSession<BoardGameActivity>) async {
          for await activeParticipants in session.$activeParticipants.values {
              let nearbyParticipants = activeParticipants.filter {
                  $0.isNearbyWithLocalParticipant && $0 != session.localParticipant
              }
          }
      }
    • 11:42 - Observe local participant pose with GroupActivities

      // Observe local participant pose with GroupActivities
      
      func observeLocalParticipantState(session: GroupSession<BoardGameActivity>) async {
          guard let systemCoordinator = await session.systemCoordinator else { return }
      
          for await localParticipantState in systemCoordinator.localParticipantStates {
              let localParticipantPose = localParticipantState.pose
              // Place presented content relative to the local participant pose
          }
      }
    • 15:54 - Associate a specific window with GroupActivities and SwiftUI

      // Associate a specific window with GroupActivities and SwiftUI
      
      import SwiftUI
      import GroupActivities
      
      struct BoardGameApp: App {
          var body: some Scene {
              WindowGroup {
                  BoardGameView()
                  ShareLink(item: BoardGameActivity(), preview: SharePreview("Play Together"))
                      .hidden()
              }
              .windowStyle(.volumetric)
              
              WindowGroup(id: "InstructionalVideo") {
                  InstructionalVideoView()
                      .groupActivityAssociation(.primary("InstructionalVideo"))
              }
          }
      }
      
      struct BoardGameView: View {
          var body: some View {
              // Board game content
          }
      }
      
      struct InstructionalVideoView: View {
          var body: some View {
              // Video content
          }
      }
    • 18:27 - Create a world anchor with ARKit

      // Create a world anchor with ARKit
      
      import ARKit
      
      class AnchorController {
      
          func setUp(session: ARKitSession, provider: WorldTrackingProvider) async throws {
              try await session.run([provider])
          }
      
          func createAnchor(at transform: simd_float4x4, provider: WorldTrackingProvider) async throws {
              let anchor = WorldAnchor(originFromAnchorTransform: transform)
              try await provider.addAnchor(anchor)
          }
      
          func observeWorldTracking(provider: WorldTrackingProvider) async {
             for await update in provider.anchorUpdates {
                  switch update.event {
                  case .added, .updated, .removed:
                      // Add, update, or remove furniture
                      break
                  }
              }
          }
      }
    • 20:02 - Observe sharing availability with ARKit

      // Observe sharing availability with ARKit
      
      func observeSharingAvailability(provider: WorldTrackingProvider) async {
          for await sharingAvailability in provider.worldAnchorSharingAvailability {
               if sharingAvailability == .available {
                   // Store availability to check when creating a new shared world anchor
               }
           }
      }
    • 20:24 - Create a shared world anchor with ARKit

      // Create a shared world anchor with ARKit
      
      import ARKit
      
      class SharedAnchorController {
          
          func setUp(session: ARKitSession, provider: WorldTrackingProvider) async throws {
              try await session.run([provider])
          }
      
          func createAnchor(at transform: simd_float4x4, provider: WorldTrackingProvider) async throws {
              let anchor = WorldAnchor(originFromAnchorTransform: transform,
                                       sharedWithNearbyParticipants: true)
              try await provider.addAnchor(anchor)
          }
      
          func observeWorldTracking(provider: WorldTrackingProvider) async {
             for await update in provider.anchorUpdates {
                  switch update.event {
                  case .added, .updated, .removed:
                      // Add, update, or remove furniture. Updates with shared anchors from others!
                      let anchorIdentifier = update.anchor.id
                  }
              }
          }
      }
    • 0:00 - Introducción
    • En visionOS 26, las personas que usan FaceTime pueden compartir apps y experiencias con personas cercanas que usen Apple Vision Pro. Esto significa que puedes ver, escuchar e interactuar de forma colaborativa en el mismo espacio físico utilizando SharePlay y ARKit.

    • 0:56 - Más información sobre compartir con participantes cercanos
    • Una nueva función para compartir en visionOS 26 permite a las personas compartir apps fácilmente con personas cercanas tocando el botón a la derecha de la barra de la ventana. La ventana compartida aparece en la misma ubicación física para todos en la sala, lo que crea un contexto compartido donde las personas pueden discutir, señalar e interactuar con la app como si fuera tangible. El sistema garantiza una apariencia y tamaño consistentes para todos. Cualquiera puede mover o cambiar el tamaño de la ventana y estos cambios se reflejan para todos. Los usuarios remotos pueden unirse a la sesión compartida a través de FaceTime en visionOS, apareciendo como Personas espaciales dentro del espacio compartido, o como transmisiones de video junto a la ventana compartida si se unen desde iOS o macOS, lo que permite una colaboración fluida independientemente de la ubicación.

    • 4:21 - Desarrolla actividades cercanas
    • Cualquier app SharePlay en visionOS se puede compartir con personas cercanas, sin realizar cambios. Sin embargo, hay nuevas funciones que puedes usar para mejorar las experiencias de SharePlay específicamente para las personas en el mismo espacio. Incluyen lo siguientes: hacer que las actividades de SharePlay sean detectables en el nuevo menú Compartir, detectar participantes cercanos, posicionar contenido según sus poses y sincronizar la reproducción de medios.

    • 5:35 - Permite compartir desde el menú Compartir
    • En visionOS 26, puedes habilitar SharePlay en tus apps exponiendo una GroupActivity usando SwiftUI o API UIKit. Cuando está habilitado, las personas pueden iniciar SharePlay directamente desde el nuevo menú Compartir. Para las ventanas volumétricas, se debe exponer una actividad para que se pueda utilizar el menú Compartir. Para espacios inmersivos, donde el menú Compartir tradicional es inaccesible, puedes proporcionar un botón en la app para activar el menú Compartir. Como alternativa, ofrecer un modo no inmersivo permite a las personas compartir desde el menú Compartir y luego pasar al modo inmersivo una vez que todos se hayan unido a la sesión.

    • 9:15 - Mejora para los participantes cercanos
    • Utilice la API SharePlay para identificar a los participantes cercanos en una sesión grupal. Al observar al publicador de participantes activos y verificar la propiedad 'isNearbyWithLocalParticipant', puede diferenciar entre usuarios locales y remotos. Este enfoque permite funciones como la formación automática de equipos de jugadores cercanos en juegos para jugar en persona contra participantes remotos que se unen a través de FaceTime.

    • 10:37 - Coloca el contenido en relación con las personas
    • La nueva propiedad 'pose' en 'ParticipantState' le proporciona la ubicación espacial de los participantes en una sesión de app, lo que le permite colocar contenido de forma dinámica junto a cada persona. Esto mejora la experiencia de inmersión y permite funciones más avanzadas, como guiar a las personas a sus posiciones de asiento óptimas.

    • 13:20 - Coordina la reproducción de medios compartidos
    • En visionOS 26, AVPlayer se mejoró para sincronizar la reproducción de audio y video para personas en el mismo espacio físico, solucionando problemas causados por retrasos en el audio y eco. Esta nueva función permite experiencias multimedia compartidas sin interrupciones, donde todos ven y escuchan el contenido simultáneamente. Puede utilizar 'AVPlaybackCoordinator' para lograr esta sincronización precisa.

    • 15:38 - Admite múltiples ventanas
    • Al utilizar la nueva API SharePlay en visionOS 26, puede especificar qué 'WindowGroup' dentro de una app está asociado con SharePlay usando el modificador de vista 'groupActivityAssociation'. Este modificador de vista permite cambiar sin problemas entre contenidos compartidos, mejorando las experiencias dentro de apps de múltiples ventanas.

    • 16:50 - Comparte contenido anclado
    • ARKit presenta anclajes mundiales compartidos en visionOS 26, lo que permite que las apps coloquen contenido virtual en ubicaciones físicas fijas que permanecen persistentes en todas las sesiones y para múltiples usuarios. Esta persistencia es particularmente útil para apps colaborativas, donde los objetos virtuales necesitan permanecer anclados en el mundo real. Puedes marcar los anclajes mundiales como compartidos durante las sesiones de SharePlay con el nuevo parámetro 'sharedWithNearbyParticipants', lo que permite que los participantes cercanos vean e interactúen con el mismo contenido virtual. Utilice la API 'worldAnchorSharingAvailability' para garantizar que el uso compartido esté disponible. Esta función se extiende más allá de SharePlay y permite que las apps comerciales utilicen anclajes compartidos con capas de red personalizadas. Los anclajes de mundos compartidos abren nuevas posibilidades para experiencias colaborativas, como pizarrones virtuales, juegos inmersivos y noches de películas compartidas, lo que hace que el contenido virtual se sienta más presente e interactivo en el mundo físico.

Developer Footer

  • Videos
  • WWDC25
  • Comparte experiencias de visionOS con personas cercanas
  • Open Menu Close Menu
    • iOS
    • iPadOS
    • macOS
    • tvOS
    • visionOS
    • watchOS
    Open Menu Close Menu
    • Swift
    • SwiftUI
    • Swift Playground
    • TestFlight
    • Xcode
    • Xcode Cloud
    • Icon Composer
    • SF Symbols
    Open Menu Close Menu
    • Accessibility
    • Accessories
    • App Store
    • Audio & Video
    • Augmented Reality
    • Business
    • Design
    • Distribution
    • Education
    • Fonts
    • Games
    • Health & Fitness
    • In-App Purchase
    • Localization
    • Maps & Location
    • Machine Learning & AI
    • Open Source
    • Security
    • Safari & Web
    Open Menu Close Menu
    • Documentation
    • Sample Code
    • Tutorials
    • Downloads
    • Forums
    • Videos
    Open Menu Close Menu
    • Support Articles
    • Contact Us
    • Bug Reporting
    • System Status
    Open Menu Close Menu
    • Apple Developer
    • App Store Connect
    • Certificates, IDs, & Profiles
    • Feedback Assistant
    Open Menu Close Menu
    • Apple Developer Program
    • Apple Developer Enterprise Program
    • App Store Small Business Program
    • MFi Program
    • News Partner Program
    • Video Partner Program
    • Security Bounty Program
    • Security Research Device Program
    Open Menu Close Menu
    • Meet with Apple
    • Apple Developer Centers
    • App Store Awards
    • Apple Design Awards
    • Apple Developer Academies
    • WWDC
    Get the Apple Developer app.
    Copyright © 2025 Apple Inc. All rights reserved.
    Terms of Use Privacy Policy Agreements and Guidelines