Explore as melhorias em seu app espacial de negócios

Olá! Meu nome é Alex Powers. Sou engineer na equipe Enterprise do visionOS. É ótimo estar de volta à WWDC.

Ano passado, apresentamos as primeiras APIs corporativas para o visionOS. Desde então, temos trabalhado para oferecer ainda mais recursos para empresas.

Antes de explorar os novos recursos, vou revisar os principais requisitos para as APIs corporativas.

Como elas oferecem mais utilidade e acesso ao dispositivo, você deve ter um direito de acesso gerenciado, além de um arquivo de licença vinculado à sua conta de desenvolvedor para acessá-las. E criados para apps proprietários internos, desenvolvidos pela sua organização para seus funcionários, ou apps personalizados que você cria para outra empresa para distribuição interna.

Com essas considerações em mente, apresento as novas APIs corporativas e algumas melhorias importantes nas APIs atuais.

Vou começar com as mudanças que vão simplificar seu desenvolvimento e facilitar o acesso aos recursos corporativos. Depois, vou mostrar novas maneiras de interagir com janelas, compartilhar conteúdo com pessoas próximas e proteger informações confidenciais. Por fim, vou mostrar novos recursos para visualizar seu ambiente.

Vou começar mostrando como estamos facilitando o acesso aos recursos corporativos para simplificar seu desenvolvimento.

Fizemos algumas mudanças este ano para oferecer a você um acesso mais amplo a várias APIs que introduzimos ano passado.

Tínhamos apresentado a capacidade de um app de acessar vídeo externo de dispositivos UVC por meio da Developer Strap para Apple Vision Pro. A API permite que o app utilize webcams compatíveis com UVC para aprimorar videoconferências, dispositivos de imagem para diagnóstico remoto ou câmeras de inspeção industrial para controle de qualidade.

Também disponibilizamos acesso ao Neural Engine para aprendizado de máquina avançado no dispositivo. Com o visionOS mais recente, essas APIs agora estão disponíveis para todos os desenvolvedores. Você vai poder acessar vídeos UVC e o Neural Engine sem precisar de licença corporativa ou direito de acesso.

Ano passado, lançamos o rastreamento de objetos para visionOS, que permite ao app reconhecer e rastrear objetos específicos do mundo real. Este ano, estamos adicionando a capacidade de treinamento direto da linha de comando.

Você vai poder automatizar o processo de treinamento do modelo, integrá-lo aos pipelines existentes e gerenciar seus ativos de rastreamento de objetos com mais eficiência, sem precisar usar o app CreateML manualmente para cada objeto. Essa ferramenta oferece os mesmos controles que o app CreateML. Espero que isso possibilite novos fluxos de trabalho e deixe a iteração nos recursos de rastreamento de objetos mais rápida e escalável.

Também estamos simplificando o gerenciamento de licenças corporativas.

Agora você pode acessar seus arquivos de licença direto na sua conta do Apple Developer. As renovações são enviadas para seus apps de forma remota, e criamos o framework Vision Entitlement Services. Com ele, ficou simples verificar se seu app está licenciado e aprovado para recursos específicos. Usando esse framework, você pode determinar se seu app pode acessar uma API corporativa específica, como acesso à câmera principal, ver o status da licença e a data de expiração. Para apps que usam o direito de acesso Increased Performance Headroom, verifique essa movimentação antes de tarefas intensivas para garantir o melhor desempenho.

Como exemplo, vou mostrar como determinar se o seu app está configurado corretamente para acessar a câmera principal.

Primeiro, importe o framework. Depois, use o singleton compartilhado Enterprise License Details para confirmar que a licença é válida e foi aprovada para mainCameraAccess.

É assim que o visionOS mais recente amplia o acesso à API e facilita o desenvolvimento de modelos e o gerenciamento de apps corporativos.

Agora vou mostrar algumas maneiras de aprimorar a experiência do usuário criando apps espaciais mais intuitivos, colaborativos e seguros. Apresentamos uma maneira de deixar as interações com janelas em ambientes espaciais mais naturais, especialmente ao se movimentar usando o Vision Pro.

Chamamos isso de "modo de acompanhamento de janela".

Quando ativado, ele garante que o conteúdo permaneça acessível e relativo à sua posição. Para ativar esse comportamento, você precisa do direito de acesso window-body-follow. Esse direito é solicitado e gerenciado como um direito licenciado. Depois que o direito for concedido e incluído no app, esse comportamento será ativado para qualquer janela do dispositivo em todos os apps.

As janelas padrão no visionOS permanecem fixas no espaço onde você as posicionar. Mas imagine que você tem um painel, conjunto de instruções ou material de referência que precisa olhar com frequência ao executar uma tarefa que exige movimentação.

Com o modo de acompanhamento de janela, você escolhe uma janela e faz com que ela se mova com você de um lugar para outro.

Vamos ver como esse modo funciona.

Aqui estou eu focado em um projeto na minha bancada. Ao mesmo tempo, meu braço manipulador está executando uma tarefa. Quero monitorar o status do manipulador, mas sem interromper minha tarefa principal toda hora. Para ativar o modo de acompanhamento para a janela de status, clico e seguro o controle de fechamento da janela. Seleciono "Start Follow Mode".

E pronto. A janela de status me seguirá quando eu voltar para minha área de trabalho.

Esse é o modo de acompanhamento de janela. Uma ótima maneira de aprimorar a experiência do usuário. A computação espacial fica melhor quando permite experiências compartilhadas e colaborativas. E é isso que os espaços de coordenadas compartilhadas fazem. Com esse recurso, pessoas que estão fisicamente juntas compartilham suas experiências espaciais umas com as outras.

Todos podem interagir e discutir o conteúdo do app como se ele estivesse fisicamente presente. Fornecemos APIs que usam o SharePlay e processam a descoberta, a conexão e o gerenciamento da sessão para espaços de coordenadas compartilhadas.

Temos uma sessão sobre isso chamada "Compartilhar experiências do visionOS com pessoas próximas". Embora o SharePlay ofereça uma facilidade de uso de fábrica, entendemos que alguns cenários exigem mais controle. Talvez seja necessário integrá-lo à sua própria infraestrutura de rede personalizada. Ou talvez os requisitos da sua empresa exijam que você lide diretamente com o dispositivo de comunicação.

Para esses casos, apresentamos uma nova API do ARKit para estabelecer espaços de coordenadas compartilhadas especificamente para clientes corporativos. Chama-se SharedCoordinateSpaceProvider. Essa API permite que vários participantes alinhem seus sistemas de coordenadas. Isso é feito trocando-se dados específicos gerados pelo ARKit pelo transporte de rede local escolhido. Cada participante compartilha continuamente esses dados com os demais. Isso cria um sistema de coordenadas comum, permitindo que âncoras compartilhadas do mundo todo apareçam de forma consistente para todos.

Agora, vou explicar como usar essa API para criar uma experiência compartilhada personalizada.

Usar a SharedCoordinateSpaceProvider é bem simples se você já trabalhou com provedores de dados do ARKit.

Semelhante ao rastreamento mundial e ao rastreamento de mãos, você a instancia e executa na ARKitSession ativa. Depois de executada, a SharedCoordinateSpaceProvider gera as informações de alinhamento necessárias encapsuladas em objetos CoordinateSpaceData. Você recupera esses dados usando uma API baseada em pull, a função nextCoordinateSpaceData() do provedor. Meu app é responsável por transmitir esse CoordinateSpaceData aos outros participantes para estabelecer um espaço de coordenadas compartilhadas. Isso dá a você controle total. Você pode usar a camada de rede que quiser.

Por outro lado, quando o app recebe CoordinateSpaceData de outro participante pela rede, você o fornece ao SharedCoordinateSpaceProvider local chamando o método push(). Cada parte dos dados recebidos é marcada com o participantID exclusivo do remetente. Por fim, o provedor ajuda a gerenciar o ciclo de vida da sessão. Ele oferece uma sequência assíncrona eventUpdates para informar sobre alterações importantes, como quando um participante deixou o espaço compartilhado.

Vou mostrar um exemplo de como isso funciona no código.

Começo criando um SharedCoordinateSpaceProvider e executando-o no meu ARKitSession. Quando os dados chegam de outro participante na minha rede, atualizo o entendimento do provedor local usando dados push. Para obter os dados que meu dispositivo precisa compartilhar, chamo a função nextCoordinateSpaceData(). Isso me dá o objeto CoordinateSpaceData que representa meu estado local, pronto para ser transmitido pela minha rede.

Essa lógica é o centro do gerenciamento do meu espaço compartilhado personalizado, fazendo a ponte entre minha camada de rede e o alinhamento de coordenadas do ARKit.

Essa é API de coordenadas compartilhadas do ARKit para desenvolvedores empresariais, uma ótima maneira de adicionar colaboração a app internos. Meu último aprimoramento tem tudo a ver com privacidade e segurança de dados. Muitos apps corporativos lidam com informações sensíveis, dados financeiros, registros de pacientes, projetos proprietários ou comunicações confidenciais. Embora úteis, recursos como SharePlay, capturas e gravações de tela ou até mesmo o Espelhamento de Tela podem expor inadvertidamente esses dados confidenciais. Hoje, temos uma nova API que permite controlar o que pode ser capturado e compartilhado com outras pessoas.

É o novo modificador de view contentCaptureProtected para SwiftUI. Ele é compatível com apps com o direito de acesso protected-content. Basta adicioná-lo a qualquer elemento da interface ou até mesmo a cenas inteiras do RealityKit. Quando o conteúdo é marcado como protegido, o sistema o obscurece em qualquer captura de tela, gravação e visualização espelhada ou compartilhada. No entanto, o conteúdo permanece visível para o usuário que está usando o dispositivo. Veja um exemplo de caso de uso comum.

Tenho um app que serve como repositório central de documentos da minha empresa, acessível a todos os funcionários. No entanto, certos documentos contêm informações confidenciais e não devem ser compartilhados amplamente. Estou compartilhando esses documentos com minha equipe no outro escritório. Aqui, a equipe pode ver nossas notas das reuniões e o planejamento do próximo ano. Ambos os documentos ficam visíveis para mim e são compartilhados com a equipe. Aqui, você pode ver que o relatório trimestral tem um ícone de cadeado.

Esse relatório não deve ser compartilhado e, portanto, minha equipe não pode vê-lo na exibição remota.

Você já sabe como o conteúdo protegido funciona. Vamos descobrir como aplicá-lo. Neste exemplo, tenho uma view de documento que contém uma view secundária chamada SensitiveDataView. Ele tem informações que só podem ser vistas no Vision Pro. Para protegê-lo, adiciono o modificador de view, contentCaptureProtected, e pronto. O sistema vai ocultar o feed sempre que uma tentativa de compartilhar esse conteúdo for feita. Você também pode integrar essa proteção a fluxos de autenticação, como Optic ID ou single sign-on corporativo.

E é assim que se protege conteúdo 2D e 3D de apps. Ele pode ser protegido com o mesmo modificador.

Esses recursos aprimoram a experiência dentro do espaço digital. Agora, vou mostrar alguns recursos criados para visualizar o ambiente e fazer a ponte entre os mundos físico e digital.

Primeiro, estamos expandindo o acesso à câmera no Vision Pro.

Ele usa um sofisticado sistema para capturar o ambiente do usuário com as câmeras dianteiras, possibilitando experiência de pass-through.

Ano passado, enviamos uma API para fornecer acesso ao feed de vídeo da câmera principal esquerda do dispositivo. Este ano, expandimos a API para fornecer acesso direto às câmeras esquerda ou direita individuais, ou acesso a ambas para processamento e análise estéreo. Se você já conhece, é a API CameraFrameProvider no ARKit.

Agora, o suporte ao feed da câmera está disponível tanto no espaço imersivo quanto no espaço compartilhado, permitindo que o app funcione com outros apps e janelas.

É assim que o visionOS mais recente flexibilizou ainda mais o acesso à câmera.

Agora vou mostrar uma nova maneira de visualizar detalhes no seu entorno.

Os profissionais muitas vezes precisam monitorar detalhes específicos da área de trabalho. Por exemplo, técnicos precisam ler pequenos medidores em máquinas complexas, ou inspetores podem precisar examinar componentes em áreas mal-iluminadas.

Para resolver isso, estamos introduzindo um novo recurso que permite selecionar uma área específica na visualização do mundo real e fornecer um feed de vídeo dedicado dessa área na própria janela.

Esse feed pode ser ampliado ou aprimorado, deixando os detalhes essenciais claros.

Há uma nova view do SwiftUI no VisionKit chamada CameraRegionView. Basta posicionar essa janela visualmente sobre a área que deseja aprimorar. Depois, a CameraRegionView usa sua própria posição para fornecer a região e o espaço apropriados para a câmera virtual.

Se precisar de um controle mais refinado, você pode usar a nova API CameraRegionProvider no ARKit.

Ela dá acesso direto e é útil se você já estiver usando o ARKit, tiver familiaridade com âncoras ou necessidades de interface mais específicas.

Esta é uma demonstração de como ela funciona usando um app de status que eu criei.

Aqui, você pode ver que estou de volta com meu projeto. Desta vez, quero monitorar a pressão no sistema enquanto trabalho.

Vou abrir a janela do inspetor do meu app de status e colocá-la na frente do medidor.

Como você pode ver, o feed de vídeo do medidor apareceu no meu app de status. Agora posso voltar ao projeto e ficar de olho na pressão enquanto trabalho.

Agora vou mostrar como adicionei uma região da câmera ao meu app em algumas linhas de código usando o SwiftUI e a API VisionKit.

Primeiro, importei o VisionKit.

Defini uma view padrão do SwiftUI. Chamei-a de InspectorView. Ela vai conter a região da câmera. O núcleo dessa view é CameraRegionView. Vou inicializando-a com o parâmetro IsContrastAndVibrancyEnhancementEnabled, inserindo true para permitir a estabilização com contraste e aprimoramento de vibração. Como mencionei, essa view precisa ficar na sua própria janela porque usa a posição dela para determinar qual parte do pass-through será processada. Para isso, vamos ver o struct do app.

Este é o struct do meu app. Tenho um WindowGroup principal para o conteúdo primário. Vou fazer um segundo WindowGroup para o InspectorView.

Isso é o suficiente para adicionar uma região da câmera ao meu app. Para apps mais complexos, o CameraRegionView aceita um fechamento. Então vou alterar o código para usar esse fechamento e analisar as imagens da câmera. Depois, posso adicionar um recurso para salvá-las em um arquivo.

Vou modificar o CameraRegionView para aceitar um fechamento, permitindo o processamento de cada quadro da câmera.

Primeiro, vou adicionar a classe cameraFeedDelivery que fiz para capturar quadros e distribui-los ao restante do meu app.

Meu fechamento vai usar o pixelBuffer do CameraRegionView. Aqui, vou verificar se há erros e passar o pixelBuffer para minha classe cameraFeedDelivery. Meu fechamento retorna nulo, o que indica que não modifiquei o pixelBuffer. Eu poderia usar esse fechamento para personalizar o processamento. Se eu modificar o pixelBuffer e retorná-lo, o CameraRegionView vai renderizar a imagem da câmera ajustada.

Então, com algumas linhas de código, adicionei regiões da câmera ao meu app. No meu exemplo, ativei o aprimoramento de contraste e vibração. No entanto, as APIs de região da câmera fornecem dois recursos de processamento integrados. O primeiro é a estabilização de imagem. Isso garante que o conteúdo permaneça ancorado e estável durante os movimentos naturais da cabeça. O segundo é o aprimoramento de contraste e vibração, que inclui estabilização e otimiza o brilho e a representação de cores.

Agora vamos ver a API do ARKit para regiões da câmera. Talvez você queira que seu app tenha uma região da câmera associada a um objeto 3D específico. Ou talvez você queira colocar uma região da câmera depois de reconhecer um objeto específico no ambiente. Se seu app precisar desse nível de controle refinado sobre âncoras e objetos 3D, essa API vai fornecer os primitivos de baixo nível e você vai precisar definir as âncoras.

No ARKit, sua âncora define uma janela virtual para o mundo real especificando sua transformação e tamanho físico em metros. Esta janela define uma área onde você terá a visão direta e estabilizada do feed da câmera de pass-through.

Pense nisso como colocar uma câmera virtual ali mesmo no seu espaço físico. Essa câmera virtual não precisa estar anexada a uma janela do visionOS. Ela pode produzir um feed de qualquer local na visualização das câmeras do Vision Pro.

Agora vamos analisar a API mais de perto.

O ARKit oferece um novo tipo de provedor de dados chamado CameraRegionProvider. A integração de regiões da câmera segue um padrão conhecido do ARKit. Começo executando um provedor de dados no meu ARKitSession, assim como faria para outros recursos do ARKit. Com o provedor em execução, o próximo passo é identificar a área de uma região da câmera. Faço isso criando um CameraRegionAnchor e adicionando-o ao meu provedor. Pense nessas âncoras como especificando as regiões exatas no mundo real que você quer para a câmera virtual. À medida que o ARKit é executado, o provedor envia atualizações para essas âncoras. Cada atualização vem com um novo pixelBuffer. Esse buffer contém a visualização estabilizada para essa região espacial específica.

Agora vamos ver como criar uma dessas âncoras.

Criar um CameraRegionAnchor é simples. Defino a posição e orientação dele no mundo usando uma transformação padrão de 6 graus de liberdade. Depois especifico seu tamanho físico, largura e altura em metros. Juntos, esses parâmetros definem a janela do mundo real para a região da câmera. Também preciso dizer ao ARKit se quero que o contraste da janela seja aprimorado ou só estabilizado. Em seguida, adiciono isso ao CameraRegionProvider. Depois de adicionar a âncora, chamo anchorUpdates(forID:) e insiro o ID da âncora do newAnchor. O feed da câmera aparece exatamente no local especificado pela âncora, e meu código pode processar os pixelBuffers fornecidos com cada atualização.

Essas são as regiões da câmera no ARKit, uma ferramenta útil para acompanhar áreas específicas do ambiente. Antes de encerrar este tópico, há alguns pontos que gostaria que você considerasse. O conteúdo de pass-through no CameraRegionView, como qualquer view do SwiftUI, pode ser ampliado ou apresentado em panorama usando técnicas padrão. Se você implementar essas transformações, garanta que elas sejam aplicadas a qualquer quadro de câmera salvo ou transmitido remotamente. É importante entender que o algoritmo de aprimoramento ajusta sua taxa de quadros para oferecer a melhor qualidade de imagem possível. Escolher a estabilização em vez do aprimoramento do contraste resulta em uma taxa de quadros mais alta, já que a estabilização requer menos poder de processamento. Embora as regiões da câmera no ARKit sejam poderosas e permitam regiões de qualquer tamanho, é importante ter atenção ao uso dos recursos. Regiões da câmera maiores terão um impacto maior na memória e no processamento.

Por fim, recomendo que você avalie o uso geral dos recursos conforme for projetando sua experiência. Isso vale principalmente para grandes regiões aprimoradas. Como diretriz, faça com que o CameraRegionAnchors exiba o conteúdo de pass-through usando cerca de um sexto ou menos da área visível geral.

Esses são os tópicos criados para unir o mundo físico e digital, e os últimos de uma longa lista de aprimoramentos para empresas que adicionamos este ano. Desde a flexibilização de funcionalidades essenciais, como acesso UVC e rastreamento de objetos, até a introdução do "Modo de acompanhamento de janela", conteúdo protegido por apps e regiões da câmera, tenho certeza de que você vai encontrar várias maneiras de implementar esses novos recursos no seu app.

Com isso, quero terminar com algumas orientações finais.

Primeiro, pense na segurança ambiental. Garanta que os usuários estejam em um local adequado para executar tarefas com segurança enquanto usam o Vision Pro, especialmente ao interagirem com equipamentos do mundo real. Lembre-se de que, com o acesso aprimorado, especialmente a câmeras e sensores, a responsabilidade aumenta. Seja transparente com os usuários sobre quais dados estão sendo acessados e por quê. Crie seu apps para coletar apenas as informações necessárias para a tarefa em questão, respeitando a privacidade do usuário no local de trabalho. Verifique se o app e o caso de uso atendem aos requisitos de qualificação. Eles são destinados a apps proprietários internos desenvolvidos para seus funcionários ou apps corporativos personalizados criados para outra empresa e distribuídos de forma privada. Com esses itens confirmados, se qualificados, solicite apenas os direitos de acesso corporativo que você realmente precisa para a funcionalidade específica do app.

Por fim, compartilhe seu feedback com a gente. Contamos com sua contribuição não apenas em relação a essas APIs específicas, mas também sobre os recursos futuros necessários para criar apps corporativos incríveis no visionOS.

Agradeço sua participação. Tenha uma ótima WWDC!