ITS-in-a-Box da câmera

O pacote de testes de imagem da câmera do Android (ITS) faz parte do Verificador do conjunto de teste de compatibilidade do Android (CTS) e inclui testes que verificam o conteúdo da imagem. O CTS Verifier oferece suporte à automação de testes ITS com o Camera ITS-in-a-box. O suporte para testes manuais abrange todos os formatos de dispositivos Android.

O ITS-in-a-box inclui os seguintes benefícios:

• Automação. Nenhuma intervenção humana é necessária durante o teste.
• Solução de problemas fácil. A consistência do ambiente de teste leva a menos erros de configuração e aumenta a reprodutibilidade.
• Eficiência. A capacidade de tentar novamente para uma câmera/cena individual melhorou a eficiência da execução do teste.

Primeiros passos

O ITS-in-a-box consiste em uma caixa de plástico cortada a laser a partir de desenhos de design assistido por computador (CAD), uma placa de diagrama e um dispositivo em teste (DUT). A tabela a seguir descreve os recursos e as especificações dos diferentes kits ITS-in-a-box disponíveis.

Para começar a usar o ITS-in-a-Box da câmera:

1. Compre ou crie um ITS-in-a-box modular, WFoV ou RFoV.
2. Configure um tablet com o software Camera ITS.
3. Executar testes.
4. Conferir os resultados do DUT.

Configurar o tablet

Esta seção fornece instruções detalhadas para configurar um tablet para uso com os testes ITS da câmera localizados no diretório CameraITS. Estas instruções usam um Pixel C como exemplo de tablet. Para informações sobre requisitos e recomendações de tablets, consulte Requisitos de tablets.

Observação:os scripts do Camera ITS Python definem automaticamente as seguintes opções no tablet:
Configurações > Tela > Suspensão > Após 30 minutos de inatividade
Brilho adaptável > DESATIVADO.

1. Carregue o tablet e ligue-o. Se for solicitado que você configure uma conta, ignore (o ITS da câmera não exige nenhuma conta pareada com o tablet).
2. Atualize o tablet para o Android 7.0 ou uma versão mais recente. O Android 6.x e versões anteriores não oferecem suporte ao Camera ITS.
3. Ative o modo de desenvolvedor.
4. Volte para Configurações e selecione Opções do desenvolvedor.

   Ativar opções	Ativado Permanecer ativo Depuração USB: permite que o host execute o tablet no modo de depuração. Quando você conectar o tablet ao host pela primeira vez, o tablet vai pedir Permitir a depuração USB? Se o tablet não mostrar a solicitação de depuração, desconecte e conecte o tablet novamente.)
   Desativar opções	Atualizações automáticas do sistema Verificar apps por USB

5. Determine os IDs do DUT e do gráfico executando $ adb devices para listar os dispositivos disponíveis. Para determinar device_id e chart_id, conecte e desconecte os dispositivos e observe os que se conectam e se desconectam.
6. Execute três testes para suprimir dicas e solicitações do usuário que podem obscurecer gráficos na tela do tablet.
   1. Posicione o tablet com a tela para cima em uma mesa (não prenda o tablet ao painel traseiro da caixa).
   2. Execute este comando:

      python tools/run_all_tests.py device=$device_id camera=0 chart=$chart_id scenes=2,3
      

      As cenas 2 e 3 exigem que o tablet exiba uma imagem. Por isso, o tablet solicita Permitir que o Drive acesse fotos, mídia e arquivos no seu dispositivo?. Pressione Permitir para apagar essa solicitação e evitar outras solicitações.
   3. Execute o comando novamente. O tablet avisa Manter uma cópia deste arquivo? e sugere o Google Drive. Apague essa solicitação (e evite solicitações futuras) pressionando o ícone do Drive e depois Cancelar para fazer o upload no Drive.
   4. Por fim, execute tools/run_all_tests.py e confirme se as cenas são alteradas automaticamente à medida que o script passa por diferentes cenas. Embora a maioria dos testes falhe (já que a câmera não está apontada para o gráfico), é possível verificar se o tablet percorre as cenas corretamente sem exibir solicitações ou outros pop-ups na tela.

Executar testes

Antes de executar o ITS-in-a-box, verifique se a configuração de teste inclui os seguintes hardwares e softwares:

• Um (1) ITS-in-a-box
• Um (1) tablet de 10 polegadas de alta resolução para exibir cenas, S/N: 5811000011
• Uma (1) DUT com o app CTS Verifier 7.0_8+ instalado. Exemplo de DUT:
  • Um (1) Pixel NOF26W para testes da câmera traseira(0), S/N: FA6BM0305016. Para instalar o app CTS Verifier, descompacte android-cts-verifier.zip e execute

    adb -s FA6BM0305016 install -r -g android-cts-verifier/CtsVerifier.apk
    

Executar cenas baseadas em tablets

Para executar as cenas 0 a 4, 6 e stage_change na câmera traseira:

cd android-cts-verifier/CameraITS
. build/envsetup.sh
python tools/run_all_tests.py camera=0

Exemplo:

Tentar de novo as cenas

Você pode repetir cenas para uma única câmera:

• Para tentar novamente as cenas em uma única câmera:

  python tools/run_all_tests.py device=FA6BM0305016 camera=0 scenes=3,4
  

Executar a cena 5

A cena 5 requer uma configuração especial com iluminação específica. Para mais detalhes, consulte CameraITS.pdf no CTS Verifier, que pode ser baixado em Downloads do conjunto de teste de compatibilidade (link em inglês). Você precisa executar a cena 5 separadamente (fora da caixa).

Para executar o cenário 5 para as câmeras frontal e traseira em um único dispositivo:

python tools/run_all_tests.py device=FA6BM0305016 camera=0 scenes=5
python tools/run_all_tests.py device=FA6BM0305016 camera=1 scenes=5

Conferir resultados

É possível ver os resultados durante o teste e salvar os resultados concluídos como um relatório.

• Confira os resultados. Para salvar os resultados do ITS da câmera como um relatório:
  1. Pressione Aprovado e salve o relatório.
     
     Figura 3. Relatório da câmera ITS
  2. Extrair relatórios do dispositivo:

     adb -s FA6BM0305016 pull /sdcard/verifierReports
     

  3. Descompacte o arquivo de relatório e confira o test_result.xml.
     
     Figura 4. Relatórios de câmera ITS
     

Requisitos para tablets

No Android 15 e versões mais recentes, os tablets usados como a exibição do gráfico ITS precisam estar na seguinte lista de permissões de tablets. Para conferir uma lista de tablets compatíveis com testes de cenas com pouca luz, consulte Tablets compatíveis para cenas com pouca luz. Para Android 14 ou versões anteriores, consulte Requisitos de tablet para o Android 14 e versões mais antigas.

Os tablets na lista de permissões são escolhidos com base nos seguintes critérios:

• tamanho de tela de cerca de 10 polegadas com resolução de tela superior a 1920 x 1200 pixels.
• Não pode ter nenhum flicker medido causado por escurecimento de tela controlado por modulação de largura de pulso (PWM, na sigla em inglês).
• Capaz de executar comandos adb enviados por testes ITS e exibição de imagens de gráficos com brilho de tela indicado.

O valor brightness precisa ser definido em config.yml de acordo com o modelo do tablet. Para determinar se o modelo do tablet corresponde a um nome de dispositivo na lista de permissões, mostre o valor ro.product.device executando o comando adb adb shell getprop | grep 'ro.product.device'.

Tablets compatíveis para cenas com pouca luz

Requisitos de tablets para o Android 14 e versões anteriores

Os tablets precisam ter um tamanho de tela de cerca de 10 polegadas com uma resolução maior que 1920 x 1200 pixels. O tablet não pode usar a modulação de largura de pulso (PWM, na sigla em inglês) para definir o nível de brilho. O valor brightness precisa ser definido em config.yml de acordo com o modelo do tablet. A tabela abaixo lista os tablets recomendados para testes de ITS, além das versões de lançamento do Android para o DUT com que os tablets funcionam.

Perguntas frequentes

P1: Como determinar quais plataformas de teste eu preciso para meu dispositivo?

A revisão 1 do RFoV ITS-in-a-box (em inglês) testa câmeras RFoV para testes de cenas de tablets no diretório CameraITS/tests. O RFoV é definido como 60° < FoV < 90°. Para câmeras de FoV maior, as luzes podem aparecer nas imagens ou os gráficos podem cobrir uma área muito pequena no FoV, afetando os resultados do teste.

A revisão 2 do ITS-in-a-box de campo de visão amplo testa câmeras WFoV para testes de cenas de tablet no diretório CameraITS/tests. WFoV é definido como FoV >= 90°. O equipamento de teste da revisão 2 é funcionalmente idêntico à revisão 1, mas maior. O equipamento de teste da revisão 2 pode testar câmeras RFoV e WFoV no Android 9 e versões mais recentes. Considerando o tamanho maior, a revisão 2 é ideal se o DUT for um modelo

O equipamento de base modular testa câmeras WFoV para testes de cenas de tablet no diretório CameraITS/tests. O campo de visão amplo é definido como FoV >= 90°. O equipamento de base modular pode testar câmeras de campo de visão normal e amplo para dispositivos com o Android 9 e versões mais recentes. Ele também oferece suporte ao equipamento de extensão de teleobjetiva que pode ser conectado para testar telecâmeras com uma distância mínima de foco maior. A plataforma modular é funcionalmente idêntica à ITS-in-a-box do WFoV, mas é menor.

A caixa de fusão do sensor testa o deslocamento de tempo da câmera/giroscópio e a sincronização de frames de sistemas de várias câmeras com testes em scenes=sensor_fusion. Um deslocamento de tempo da câmera/giroscópio de menos de 1 ms é necessário para a flag de recurso REALTIME.

Dispositivos com várias câmeras podem ser testados com um único suporte para testes estáticos de ITS e com um de fusão de sensores, caso a câmera tenha a flag de recurso REALTIME.

Confira um conjunto de exemplos de configurações na tabela abaixo.

P2: Como faço para designar qual equipamento de teste está em uso?

Para designar o equipamento de teste correto, verifique se o parâmetro de distância do gráfico está correto. O equipamento de teste rev1 (RFoV) tem uma distância de 31 cm, e o equipamento rev2 (WFoV) tem uma distância de 22 cm. Por padrão, a distância do gráfico é definida como 31 cm.

Do Android 10 para o Android 11

python tools/run_all_tests.py ... chart=# dist=22

Android 12 e versões mais recentes

edit config.yml
chart_distance: 31.0 → chart_distance: 22.0

P3: Como faço para controlar o brilho do tablet?

Por padrão, o brilho do tablet é definido como 96.

Para mudar o brilho em tablets com o Android 7.0 até o Android 9, execute:

edit tools/wake_up_screen.py
DISPLAY_LEVEL=96 → DISPLAY_LEVEL=192

Para mudar o brilho em tablets com Android 10 a 11, o valor pode ser alterado na linha de comando adicionando a flag brightness:

python tools/run_all_tests.py device=# camera=# chart=# brightness=192

Para mudar o brilho em tablets com o Android 12 e versões mais recentes, execute:

edit config.yml
brightness: 96 → brightness: 192

Q4: Como depurar um único teste?

Os testes podem ser executados individualmente para fins de depuração, mas os resultados não são informados ao CtsVerifier.apk, a menos que a cena inteira seja executada.

Para executar uma cena individual no Android 11 e versões anteriores:

1. Carregue uma cena adicionando a flag scenes em tools/run_all_tests.py:

   python tools/run_all_tests.py device=# camera=# chart=# scenes=#
   

2. Pressione Control+C para interromper os testes depois que a cena for registrada como carregada para stdout.

   Se a cena correta já estiver na tela, ative a tela:

   python tools/wake_up_screen.py screen=#
   

3. Execute um teste individual.

   python tests/scene#/test_*.py device=# camera=#

   Os gráficos são gerados no diretório local e stdout e stderr são impressos na tela.

   Para mais informações sobre depuração, adicione instruções print ao script. Para aumentar a saída do teste para depuração, adicione a flag debug=True.

   python tests/scene#/test_*.py device=# camera=# debug=True

Os resultados são impressos na tela local e as imagens são salvas no diretório local em vez do diretório /tmp/tmp### gerado ao executar tools/run_all_tests.py.

Para executar uma cena individual no Android 12 e versões mais recentes:

1. Edite o arquivo config.yml.

   edit config.yml
   camera: <camera-id> → camera:  0
   scene: <scene-name> → scene: scene1_1

2. Execute o teste individual.

   python tools/run_all_tests.py -c config.yml --test_bed TEST_BED_TABLET_SCENES
   

Os resultados são impressos no diretório /tmp/logs/mobly/TEST_BED_TABLET_SCENES/, classificados por tempo de execução.

P5: Por que preciso executar testes com falhas como uma cena inteira em vez de executar os testes individualmente?

Os testes podem ser executados individualmente para fins de depuração, mas os resultados não são informados a CtsVerifier.apk, a menos que toda a cena seja executada.

O ITS da câmera garante que os apps de terceiros tenham uma interface de câmera compatível. Assim como em um teste de unidade, cada teste enfatiza uma única especificação na câmera. Para detectar comportamentos não confiáveis, esses testes precisam ser aprovados como um grupo em uma cena inteira. Por exemplo, embora um único teste não confiável possa passar por uma nova execução de uma cena inteira, é difícil que vários testes não confiáveis sejam aprovados.

Como exemplo extremo, considere o caso em que há 10 testes em uma cena e cada um tem uma probabilidade de 50% de retornar PASS. Ao executar cada teste individualmente, há uma grande chance de que um operador consiga fazer com que a câmera passe no ITS da câmera. No entanto, se os testes forem executados de forma agregada como uma cena, há apenas 0,1% de chance de que ela seja aprovada.

Q6: Como faço para executar uma única cena ou reordenar as cenas de execução?

Por padrão, o script tools/run_all_tests.py executa todas as cenas em ordem. No entanto, as cenas podem ser executadas individualmente ou em uma ordem especificada e informadas ao CtsVerifier.apk.

Para executar uma cena individual (por exemplo, a cena 2) ou mais de uma cena em uma ordem específica no Android 11 ou versões anteriores:

python tools/run_all_tests.py device=# camera=# chart=# scenes=2

python tools/run_all_tests.py device=# camera=# chart=# scenes=3,2

Para executar uma cena individual ou mais de uma cena em uma ordem específica no Android 12 e versões mais recentes:

python tools/run_all_tests.py scenes=2

python tools/run_all_tests.py scenes=3,2

Os parâmetros adicionais são definidos no arquivo config.yml.

Q7: Vários testes da cena 1 falham com a configuração do tablet, mas são aprovados com um gráfico de papel. Qual é o problema?

Verifique se o tablet e o ambiente de teste atendem às especificações a seguir.

Especificações do tablet

Confira se o tablet atende às seguintes especificações:

• Tamanho da tela (polegadas): 10
• Tamanho da exibição (pixels): maior que 1920 x 1200 pixels

Para mais detalhes, consulte Requisitos para tablets.

Brilho do tablet

Os testes podem não gerar resultados corretos se o brilho da tela do tablet estiver muito baixo.

Para mais detalhes, consulte Como posso controlar o brilho do tablet?

Nível de iluminação da caixa (requer luxímetro)

Verifique se o valor de lux desejado na abertura do tablet está entre 100 e 300.

Se o nível de lux for muito alto, scene1/test_param_flash_mode.py retornará FAIL. Se o nível de lux for muito baixo, vários testes vão falhar.

P8: Como faço para depurar testes de fusão do sensor?

1. Verifique se você está em um grupo dialout.

   groups | egrep ‘dialout'

2. Confira se o controlador de fusão do sensor está conectado determinando se a tecnologia Microchip está conectada à porta USB.

   lsusb
   …
   Bus 003 Device 004: ID 04d8:fc73 Microchip Technology, Inc.
   …
   

3. Execute o teste várias vezes para ter uma distribuição de tentativas de teste com os comandos abaixo.

   No Android 11 ou versões anteriores:

   python tools/run_sensor_fusion_box.py device=A camera=0 num_runs=10 rotator=default
   

   No Android 12 e versões mais recentes:

   python tools/run_sensor_fusion_box.py num_runs=10
   

   Os parâmetros adicionais são definidos no arquivo config.yml.

   As saídas de execução estão na pasta /tmp/tmp### criada nas pastas sensor_fusion_#, em que # é o número da execução. Os motivos mais comuns para falhas são:

   1. O smartphone não está centralizado corretamente.
   2. Não há recursos suficientes na imagem (geralmente um problema de FoV ou iluminação).
   3. O FAIL retornado é válido, e o deslocamento de tempo entre a câmera e o giroscópio precisa ser corrigido.

P9: Quais informações devo incluir ao relatar um bug de teste?

Ao informar um bug de teste, inclua os arquivos e imagens gerados para o teste.

1. Se você executou o teste por tools/run_all_tests.py, anexe um diretório /tmp/ compactado ao bug.
2. Se você executou o teste sozinho, anexe todas as saídas de tela e imagens geradas ao bug.

Inclua também um relatório de bug. Depois que o teste em questão falhar, use o comando abaixo para gerar um relatório de bug e anexar o arquivo ZIP gerado ao bug.

adb -s device_id bugreport

Q10: Como executar uma cena de teste sensor_fusion com uma câmera que tem uma distância mínima de foco que cria imagens desfocadas a 25 cm de distância do gráfico?

Se a câmera não conseguir focar a uma distância de 25 cm, remova o painel de suporte para gráfico da caixa de fusão do sensor. Coloque o gráfico a uma distância em que o DUT possa focar e mude chart_distance em config.yml para a distância medida entre o DUT e o gráfico. A Figura 5 mostra um exemplo de como medir a distância do gráfico nessa situação.

  edit config.yml
chart_distance: 25 → chart_distance: DISTANCE_BETWEEN_DUT_AND_CHART

Q11: Como executar cenas de teste de tablet para uma câmera com uma distância mínima de foco que cria imagens desfocadas a 31 cm de distância do gráfico?

Se a câmera não conseguir produzir imagens nítidas o suficiente ao testar a 31 cm (a profundidade do equipamento de teste RFoV), monte a câmera na frente do equipamento a uma distância que permita que a cena do gráfico preencha aproximadamente 60% do campo de visão (FoV) da câmera com imagens mais nítidas. Essa distância pode ser menor do que a distância mínima de foco da câmera. Deixe a chart_distance em config.yml a 31 cm. A escala do gráfico no tablet é determinada pelo campo de visão da câmera, conforme mostrado na tabela a seguir:

P12: Com a API lógica de várias câmeras, quais testes são executados em quais câmeras?

Se a câmera usar REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA, todos os testes ITS com suporte serão executados na câmera lógica de nível superior. Um subconjunto dos testes ITS é executado nas subcâmeras físicas, e esses testes são listados em tools/run_all_tests.py sob a constante SUB_CAMERA_TESTS.