Use o conjunto de ferramentas de design de segurança para oferecer uma solução de monitor de segurança gerada a partir de um documento de design do Figma. Use essa série de ferramentas em sequência.
O compilador de design de segurança produz artefatos de segurança para impulsionar a geração de código subsequente para criar o monitor de segurança. A separação entre a compilação de design e a geração de código permite que o gerador de código alcance uma classificação ISO-26262 de TCL-3.
Figura 1. Cadeia de ferramentas de design de segurança.
Depois que o compilador gera artefatos, a cadeia de ferramentas cria um relatório que um engenheiro de segurança do OEM pode inspecionar para validar os artefatos gerados pelo design do Figma.
Figura 2. Fluxo de trabalho do conjunto de ferramentas de design de segurança.
Entradas do compilador de design
O documento de design serializado representa um design de interface importado de uma ferramenta de design e processado com um esquema de kit de ferramentas. O arquivo contém estas informações analisadas do design:
- Árvore de nós completa de um design
- Imagens e componentes
- Metadados, como nome, versão e data da última modificação
Os nós raiz do design precisam ser definidos na lista de nós e precisam ser os nós raiz dos elementos relevantes para a segurança identificados no design.
Esse arquivo é integrado ao Android Automotive OS para renderizar o painel de instrumentos e mostrar os elementos não relevantes para a segurança com um renderizador de alta disponibilidade (HAR, na sigla em inglês) em execução no SDV Media como uma sobreposição para mostrar os elementos relevantes para a segurança ao usuário.
O compilador de design usa personalizações do DesignCompose para gerar a saída e alternar a visibilidade dos elementos críticos de segurança no design. O design é renderizado sem interface com o Impeller. Entre as mudanças de personalização, o sistema emite comandos de captura de tela para o back-end de renderização para gerar artefatos de imagem.
Figura 3. Exemplo de arquivo de design do Figma para criar um monitor de segurança.
Diretório de saída
Esse é o local no sistema de arquivos local em que o compilador armazena os artefatos gerados.
Arquivo de configuração JSON
Na maioria das vezes, um engenheiro de segurança do OEM cria o arquivo de configuração JSON, que contém metadados que capturam as informações relevantes para a segurança do veículo que não são capturadas em um design de interface. Esse arquivo contém estes dados:
Elemento de design designado como raiz da tela relevante para a segurança. Esse elemento de design é dimensionado para a tela do veículo. O tamanho precisa ter a mesma resolução da tela. Todos os elementos relevantes para a segurança precisam ser descendentes desse elemento. Eles não precisam ser descendentes diretos, mas aninhados em nós intermediários. Essa raiz é o objeto do nó raiz, e o nome dela precisa corresponder a um nó no documento de design.
Tela de destino para o design. Para oferecer suporte a interfaces com elementos em várias telas, o arquivo de configuração pode especificar mais de um design, cada um destinado a ser mostrado em uma tela separada.
Dicionário de nomes de sinais de barramento de veículos para elementos de interface associados. As chaves e os valores desse dicionário são:
Chaves:nome do sinal de barramento do veículo para conter o significado de que, quando esse sinal estiver ativo, o elemento da interface associado será mostrado. Quando o sinal está inativo, o elemento de interface associado não é mostrado.
Valores:ID do nó do Figma para o elemento relevante para a segurança regido pelo sinal de barramento do veículo.
Consulte este exemplo de arquivo de configuração JSON:
{
"documents" : [
{
"rootnode" : "#Stage",
"display_id" : 1,
"document_id": "GLJJrR1JI4HVEjL1qB40zq",
"states" : {
"abs": "#cluster/telltale/abs",
"airbag": "#cluster/telltale/airbag",
"low_tire_pressure": "#cluster/telltale/low-tire-pressure",
"brake": "#cluster/telltale/brake",
"traction": "#cluster/telltale/traction",
"lowbeam": "#cluster/telltale/lowbeam",
"hibeam": "#cluster/telltale/hibeam",
"park_lights": "#cluster/telltale/park-lights",
"fog_lights": "#cluster/telltale/fog-lights",
"seatbelts" : "#cluster/telltale/no-seatbelt"
}
}
]
,
"displays": [
{
"id": 1,
"width": 1920,
"height": 720
}
]
}
Executar o compilador de design
Para executar o compilador de design:
/path/to/safety-design-compiler -c path/to/<input-file>.json
-o path/to/output_directory
As entradas do compilador de design são descritas nesta tabela:
| Entrada | Curto | Tipo | Descrição |
|---|---|---|---|
| Configuração | -c |
string | Caminho em que o arquivo JSON de configuração de segurança será salvo. |
| Saída | -o |
string | Caminho em que os artefatos gerados serão salvos. |
Saída do compilador de design
O compilador de design gera e salva a saída no diretório especificado ao invocar a ferramenta do compilador. Essa saída gera os arquivos de cabeçalho usados para definir os testes de pixel de execução no monitor de segurança e para gerar o relatório legível por humanos. A saída do compilador de design é fornecida em um arquivo ZIP que contém:
Arquivo de metadados
data.jsonna raiz dos recursos exportados para descrever a estrutura do design exportado. Todos os caminhos no arquivo são relativos a ele.Série de imagens de elementos da interface isolados para mostrar elementos da interface relevantes para a segurança no estado ativo que são usados durante a geração de código subsequente. O canal alfa nessas imagens contém informações de pixel que não afetam a segurança.
Série de imagens de interface completas para mostrar elementos de interface relevantes para a segurança nos estados ativo e inativo para uso durante o teste do código gerado.
Versão atualizada do documento serializado do Figma consumido pelo compilador como entrada. O HAR marca e atualiza os nós indicadores especificados em
Config.jsonpara processamento adicional definindo o flagRenderOptions::PixelPerfectno esquema do kit de ferramentas.
Esta figura mostra um arquivo de design do Figma.
Figura 4. Conteúdo do arquivo ZIP.
Criar o arquivo de entrada
Crie um arquivo de entrada data.json para o gerador de monitor de segurança. A saída é estruturada como uma matriz para conter dados dimensionais e um link da imagem para cada elemento de exibição relevante para a segurança. A estrutura desse arquivo de saída é descrita nesta tabela:
| Elemento | Tipo | Unidades | Descrição |
|---|---|---|---|
static_ui_elements |
Dicionário | N/A | Estrutura que contém metadados para todos os elementos de interface relevantes para a segurança extraídos do documento do Figma. |
x |
int | pixels | Coordenada horizontal do elemento relevante para a segurança. |
y |
int | pixels | Coordenada vertical do elemento relevante para a segurança. |
width |
int | pixels | A largura do elemento relevante para a segurança |
height |
int | pixels | Altura do elemento relevante para a segurança. |
name |
string | N/A | Nome do elemento da interface relevante para a segurança extraído do documento do Figma. Representa o caminho relativo para imagens geradas com esse elemento. |
screen |
Dicionário para descrever a tela segmentada pela interface. | ||
width |
int | pixels | Largura da interface do documento do Figma. |
height |
int | pixels | Altura da interface do documento do Figma. |
build |
Dicionário que contém informações de build para essa invocação do compilador de design. | ||
figma_document_id |
string | N/A | ID do documento do Figma usado para gerar o conjunto de artefatos. |
design_compiler_version |
string | N/A | Versão do compilador de design usado para gerar o conjunto de artefatos. |
Esta seção fornece um exemplo de um arquivo data.json gerado:
{
"static_ui_elements": [
{
"x": 71,
"y": 663,
"width": 38,
"height": 47,
"name": "cluster/telltale/no-seatbelt"
},
{
"x": 149,
"y": 667,
"width": 40,
"height": 39,
"name": "cluster/telltale/low-tire-pressure"
},
{
"x": 1727,
"y": 676,
"width": 43,
"height": 27,
"name": "cluster/telltale/hibeam"
},
{
"x": 1810,
"y": 675,
"width": 43,
"height": 30,
"name": "cluster/telltale/lowbeam"
},
...
...
],
"screen": {
"width": 1920,
"height": 720
},
"build": {
"figma_document_id": "taQnsdPS96wZY8dB1TbzOH",
"design_compiler_version": "0.1.0"
}
}
Imagens de design exportadas
O sistema renderiza e salva imagens dos nós relevantes para a segurança em uma estrutura de diretório aninhada com base na nomenclatura no documento de design serializado.
Figura 5. Imagens de verificação.
O sistema gera imagens de informações de elementos relevantes para a segurança para cada indicador especificado. Essas imagens contêm os pixels esperados do elemento crítico de segurança quando ele está visível na tela. O monitor de segurança pode ignorar os pixels transparentes nessas imagens para fins de testes de pixel de execução.
O sistema também gera imagens de teste e verificação de interface. Ele renderiza capturas de tela da interface completa com cada indicador individual e as fornece para gerar um relatório legível por humanos para que os engenheiros de segurança possam analisar e aprovar a configuração de segurança.
Você também pode usar essas imagens para testes subsequentes do monitor de segurança. O sistema gera imagens de verificação para todos os indicadores nos estados ativado e desativado.
Essas imagens ilustram o design com todos os elementos relevantes para a segurança, ativos e inativos.
Figura 6 e Figura 7. Elementos relevantes para a segurança ativos e inativos.
A Figura 8 mostra a imagem de informações relevantes para a segurança do indicador de cinto de segurança:
Figura 8. Indicador de cinto de segurança.
A Figura 9 mostra a imagem de teste e verificação da interface do indicador.
Figura 9. Teste e verificação da interface do indicador.
O sistema gera imagens de verificação para cada elemento na pasta de artefatos compilados. O sistema processa essas imagens na etapa de geração de código e as adiciona a um arquivo principal a ser usado para testes de pixel de tempo de execução no monitor de segurança.
Gerador de relatórios legíveis por humanos
Depois de gerar os artefatos de um documento do Figma, você pode gerar um relatório legível por humanos. O gerador de relatórios está localizado em utils/human-readable-report-generator.
O sistema resume os artefatos dos nós relevantes para a segurança gerados pelo compilador de design em um arquivo HTML, incluindo uma captura de tela da interface com o nó ativo. Você pode analisar os artefatos compilados antes de criar o monitor de segurança.
Execute o gerador de relatórios na linha de comando:
cargo run --bin human-readable-report-generator -- -d /path/to/data.json
-o /path/to/output_folder
Esta tabela descreve as entradas do gerador de relatórios legíveis por humanos.
| Entrada | Curto | Tipo | Descrição |
|---|---|---|---|
data_folder |
-d |
string | Local do data.json gerado pelo compilador de segurança. |
output_path |
-o |
string | Caminho para salvar o relatório gerado. |
Ferramenta de aprovação de segurança
Para gerar um token de aprovação, depois de analisar o relatório legível por humanos, um engenheiro de segurança pode executar o script de aprovação de segurança no output.json.
Essa ferramenta também está localizada em utils/human-readable-report-generator.
Exemplo:
cargo run --bin approve-hrr -- -f /path/to/compiler_inspection_output.html -n
"Your Name" -e youremail@domain.com -o output/path
Figura 10. Exemplo de relatório HTML.
Esta seção descreve as entradas da ferramenta de aprovação de segurança.
| Entrada | Curto | Tipo | Descrição |
|---|---|---|---|
file_path |
-f |
string | Caminho do arquivo para o relatório legível por humanos. |
approver_name |
-n |
string | Nome do engenheiro aprovador. |
approver_email |
-e |
string | Endereço de e-mail do engenheiro aprovador. |
output_path |
-o |
string | Destino da saída gerada. |
Esta seção mostra um exemplo de approval_file.json.
{
"approver_name": //Name of the approver
"approver_email": //Email of the approver
"file_hash": //SHA-256 hash generated against the human readable report.
}
Monitor de segurança de referência
O monitor de segurança de referência é um serviço baseado em Rust localizado em reference/safety-monitor. O monitor usa os artefatos gerados pelo compilador de design para monitorar o estado do sistema e garantir a conformidade da segurança da tela.
O monitor é executado como um binário independente (har_safety_monitor) e usa o caminho para o arquivo data.json e o caminho base para artefatos como argumentos.
/path/to/har_safety_monitor --data-json-path /path/to/data.json
--artifact-base-path /path/to/artifacts
O monitor realiza as seguintes tarefas:
- Carregamento de artefatos:carrega
data.jsonpara identificar elementos de interface relevantes para a segurança e as posições e dimensões esperadas. - Comparação de imagens douradas:compara o conteúdo da tela atual com imagens douradas de elementos críticos de segurança gerados pelo compilador.
- Integração de dados do veículo:conecta-se a fontes de dados do veículo para determinar o estado esperado de cada indicador.
- Detecção de incompatibilidade:registra um erro se houver uma incompatibilidade entre o que é esperado com base nos dados do veículo e o que está visível na tela.
O monitor de segurança foi projetado para ser criado e implantado como parte da imagem do sistema, normalmente em um APEX dedicado.