🌐 यह पृष्ठ अभी तक हिंदी में अनुवादित नहीं किया गया है। पुर्तगाली (BR) संदर्भ दिखाया जा रहा है। अनुवाद में मदद करें।

Casa Servidor Opt-in Admin

O Casa é a tela que responde, num olhar, como está a casa agora: quantos aparelhos estão no ar, se as câmeras têm vídeo, quanto o sol está gerando, o que foi consumido hoje, como anda o Wi-Fi, quanto espaço sobra para filmes e quando foi o último backup.

Ele não é um painel de links. Cada cartão tem um número grande e um estado: verde quando está bem, âmbar quando merece atenção, vermelho quando está mal. Cor só aparece quando significa alguma coisa. E quando um dado não existe, o cartão não mostra erro nenhum: mostra uma luz vermelha e a palavra "fora", com o motivo a um toque.

Cada cartão traz também a linha das últimas 24 h, e tocar nele abre a tela daquele indicador, com as janelas de 24 h, 7 e 30 dias. Há um widget para a área de trabalho e um atalho no celular, e a casa inteira se configura pela própria tela — inclusive subindo um arquivo pronto.

Onde ele brilha

Numa TV ligada o dia todo (Big Picture), no celular quando você está longe, e no notebook quando quer investigar. É o mesmo app nos três, com o mesmo julgamento, porque o julgamento é feito uma vez só, no servidor.

---

O que aparece

Cartão	O que mede	Como julga
Aparelhos no ar	quantos dos aparelhos sondados respondem	todos = bem; dois ou mais sumidos = mal
Câmeras com vídeo	as câmeras de Wi-Fi que estão entregando quadros	uma fora já é atenção
Gerando agora	a soma dos microinversores solares, em W	informativo
Gerado hoje	energia solar do dia, em kWh	informativo
Consumo medido hoje	tomadas e ares medidos, em kWh (não é a casa inteira)	informativo
Sinal do Wi-Fi	o sinal medido num rádio fixo, em dBm	−60 bem, −70 atenção
Latência da casa	média do ping aos aparelhos do Wi-Fi, em ms	150 bem, 400 atenção
Pior aparelho em 24 h	o menor percentual de disponibilidade do dia	99,9% bem, 98% atenção
Espaço para filmes	livre no NAS, em TB	1 TB bem, 300 GB atenção
Link de internet	ida e volta pelo link principal, em ms	30 bem, 80 atenção
Backup	horas desde o backup mais antigo	26 h bem, 50 h atenção

Esta tabela é um EXEMPLO, não o que você vai ver

Nenhum desses cartões vem pronto. A tabela acima é a casa de quem escreveu o app, para você ver a cara que a coisa tem. A sua casa é a que você montar — ver A casa é sua abaixo.

Os limiares moram na sua configuração, não no código: mudar um limiar é mudar um lugar, e as três telas acompanham.

Quando um cartão está "fora"

Dado ausente não é erro de tela. O cartão mostra a luz vermelha e "Fora · toque para ver". Ao tocar, aparece o motivo em português de casa:

• O Prometheus respondeu, mas não tem essa medida agora. O aparelho que a produz está calado (por exemplo, os loggers solares dormem à noite, e caem quando ficam sem Wi-Fi).
• O servidor não alcançou o Prometheus. A máquina de monitoramento pode estar fora.
• O Prometheus não respondeu a tempo. A rede ou a máquina estão lentas.
• O Prometheus recusou a consulta. Defeito de configuração, não da casa.

Quando há um gráfico do Grafana ligado ao cartão, o link Abrir o gráfico aparece ali mesmo.

Quem vê

Só administradores do RoqueOS Server. Para outra pessoa da casa ver, ela vira admin no servidor. Quem não é admin não encontra o app no Launchpad nem no Spotlight.

Habilitar no servidor

O Casa é opt-in e nasce desligado: a imagem do servidor é pública e as métricas que ele consulta são as da sua casa. Ele precisa de um Prometheus na mesma rede do servidor, e opcionalmente de um Grafana para os links.

# no .env do roqueos-server
ENABLE_CASA=true
CASA_PROMETHEUS_URL=http://servidor.casa:9091
CASA_GRAFANA_URL=https://graficos.roqueos.casa   # opcional, para os links dos cartões
CASA_CONFIG_FILE=/data/roqueos/shared/casa.json  # opcional, este é o padrão

Pelo instalador, sem editar .env:

curl -fsSL https://roqueos.com.br/install.sh | bash -s -- --update -y \
  --casa-prometheus-url http://servidor.casa:9091

Também dá para ligar pelo painel do servidor, em Recursos → Casa. Sem CASA_PROMETHEUS_URL a chave fica ligada mas o app não aparece: não há de onde ler.

O servidor não exige métrica nenhuma em particular: quem decide o que medir é a sua configuração. O exemplo que o app oferece pressupõe uma casa monitorada com blackbox_exporter (job aparelhos, rótulo link nos alvos de internet), Frigate (frigate_camera_fps), Home Assistant exportando energia com namespace: casa, node_exporter no rádio que mede o wi-fi, e três coletores próprios (casa_solar_*, casa_nas_*, casa_backup_*) que a maioria não tem — apague o que não se aplica.

O Prometheus que alimenta tudo

O Casa não coleta nada: ele lê o que o seu Prometheus já sabe. Quem ainda não tem um instala o Prometheus pela App Store do RoqueOS — ele sobe na porta 9090 e o prometheus.yml fica no volume que o app monta em /etc/prometheus (no disco do servidor, /DATA/AppData/prometheus/config/). A partir daí, CASA_PROMETHEUS_URL é http://<ip-do-servidor>:9090.

O que você escreve nesse arquivo é o que o app mostra. Não há tela do RoqueOS que substitua isto: o nome de cada cartão, o nome de cada caixa do desenho, o endereço embaixo dela e a ligação de um serviço com a máquina onde ele roda saem todos dos rótulos do alvo. Rotular bem é o trabalho que paga o resto.

Os rótulos que o Casa entende

Rótulo	O que ele faz
maquina	Sozinho, a caixa é uma máquina. Junto de servico, diz onde aquele serviço roda — e essa ligação ganha de qualquer dedução do desenho. É também o rótulo que o app usa para filtrar "de qual máquina é o número".
servico	Nomeia a caixa e a torna um serviço.
aparelho	Nomeia a caixa. Sem servico nem maquina, o alvo é um aparelho.
link	Nomeia um alvo de internet — um IP público sondado.
alvo	O endereço sondado. Com blackbox_exporter ele não é opcional; veja abaixo.

Na falta desses, o nome cai para no, nome, name, device, host, alvo e por fim instance, nesta ordem. O job chamado prometheus é ignorado de propósito: o Prometheus medindo a si mesmo não é casa de ninguém.

Um prometheus.yml que produz a casa inteira

Este exemplo monta uma casa pequena inteira — dois computadores, dois serviços, dois aparelhos e um link de internet:

global:
  scrape_interval: 30s

scrape_configs:
  # As máquinas entram duas vezes, e isso é de propósito.
  #
  # `recursos` raspa o node_exporter de cada uma: é daqui que saem uso de CPU,
  # temperatura, memória, disco e tempo ligado, e é o rótulo `maquina` que o app
  # usa para filtrar "de qual máquina é o número".
  - job_name: recursos
    static_configs:
      - targets: ['192.168.88.10:9100']
        labels: { maquina: servidor }
      - targets: ['192.168.88.11:9100']
        labels: { maquina: raspberry }

  # ...e `maquinas` sonda as mesmas duas pelo blackbox, para saber se respondem.
  # O valor de `maquina` é o mesmo nos dois jobs de propósito: é por ele que o
  # desenho junta as duas metades numa caixa só.
  - job_name: maquinas
    metrics_path: /probe
    params: { module: [icmp] }
    static_configs:
      - targets: ['192.168.88.10']
        labels: { maquina: servidor }
      - targets: ['192.168.88.11']
        labels: { maquina: raspberry }
      # O roteador entra como alvo por um motivo: é o `.1` da sub-rede que
      # permite ao desenho arriscar o palpite de gateway. Sem ele como alvo,
      # ninguém tem como supor quem é a saída da rede.
      - targets: ['192.168.88.1']
        labels: { maquina: roteador }
    relabel_configs: &blackbox
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: alvo
      - target_label: __address__
        replacement: blackbox:9115

  # Os serviços, com dono declarado: `servico` nomeia a caixa, `maquina` diz
  # onde ele roda — e essa ligação ganha de qualquer dedução do desenho.
  - job_name: servicos
    metrics_path: /probe
    params: { module: [tcp_connect] }
    static_configs:
      - targets: ['192.168.88.10:8123']
        labels: { servico: home-assistant, maquina: servidor }
      - targets: ['192.168.88.10:5000']
        labels: { servico: frigate, maquina: servidor }
    relabel_configs: *blackbox

  # Os aparelhos que não exportam nada: quem responde por eles é o blackbox.
  - job_name: aparelhos
    metrics_path: /probe
    params: { module: [icmp] }
    static_configs:
      - targets: ['abajur.iot.casa']
        labels: { aparelho: Abajur da sala }
      - targets: ['camera-portao.iot.casa']
        labels: { aparelho: Câmera do portão }
    relabel_configs: *blackbox

  # A internet: sondar um IP público não mede o 1.1.1.1, mede se a casa sai.
  - job_name: links-internet
    metrics_path: /probe
    params: { module: [icmp] }
    static_configs:
      - targets: ['1.1.1.1']
        labels: { link: Fibra }
    relabel_configs: *blackbox

O &blackbox / *blackbox é âncora de YAML: escreve o bloco de relabel_configs uma vez e reusa nos outros jobs. O Prometheus resolve isso antes de ler a configuração.

Esse arquivo devolve onze caixas e dez ligações: a internet e o link, as duas redes (192.168.88.0/24 e iot.casa), as três máquinas, os dois serviços pendurados no servidor e os dois aparelhos — mais a linha tracejada do roteador para a rede, que é o palpite de gateway. Nenhuma correção manual é necessária para chegar nisso, e é exatamente o desenho da imagem mais abaixo.

Com blackbox_exporter, o rótulo alvo não é opcional

No padrão do blackbox, o instance de todos os alvos sondados vira blackbox:9115 — é o exporter que está sendo raspado, não o aparelho. Sem o alvo, os quarenta aparelhos da casa viram uma caixa só, chamada blackbox, e todos os cartões apontam para o mesmo lugar. É por isso que o relabel acima copia o endereço para alvo antes de trocar o __address__.

Por que sondar a máquina se o node_exporter já responde

Porque up não quer dizer o que parece. Num alvo raspado direto, up=1 é o Prometheus dizendo que falou com aquela máquina — mas num alvo de blackbox, up=1 diz que o blackbox respondeu, e a câmera pode estar desligada há três dias. Como as duas coisas convivem na mesma casa, o Casa nunca usa up para pintar: quem pinta é probe_success. Alvo sem sonda aparece cinza — existe no desenho, mas ninguém está perguntando se ele responde.

Duas peças ficam de fora do arquivo porque rodam ao lado dele: o blackbox_exporter (imagem prom/blackbox-exporter, é ele que atende em blackbox:9115) e um node_exporter em cada máquina. Coletores de câmera, energia e solar entram do mesmo jeito, como mais um job, quando você tiver.

O caminho inteiro, de uma olhada

Do zero à sua casa, em seis passos

Com o Prometheus de pé e rotulado (a seção acima), o resto acontece dentro do RoqueOS. Este é o caminho inteiro, na ordem, e nenhum destes seis passos precisa de SSH.

1. Ligue o Casa no servidor com a URL do seu Prometheus (Habilitar no servidor). Sem Prometheus não há de onde ler, e o app não aparece.
2. Abra o app e peça o exemplo. Servidor sem configuração oferece começar de uma casa monitorada de verdade. Ele entra como rascunho: nada foi salvo ainda.
3. Pode o que não é seu. O exemplo pressupõe blackbox_exporter, Frigate, Home Assistant e node_exporter. O que você não tem aparece como fora com o motivo — apague esses itens e siga.
4. Acrescente o que é seu, pela receita. Ao criar um indicador, escolha uma receita pronta (uso de CPU, temperatura, memória, disco, tempo ligado, e outras) e, havendo mais de uma máquina, escolha a máquina. A consulta já vem montada e filtrada.
5. Toque em Testar antes de salvar, para ver o número que a consulta devolve. Consulta que não devolve nada é quase sempre erro de digitação no nome da métrica ou no rótulo.
6. Agrupe e ajuste a cadência. Junte os indicadores em grupos que façam sentido para você ("Rede", "Energia", "Servidor") e, se algum grupo precisa de leitura mais rápida, ponha o intervalo em segundos ao lado do título do grupo.

Quando estiver do jeito que você quer, Salvar. A partir daí, o widget e o app do celular mostram a mesma casa, sem mais nada a configurar.

Montando uma casa grande de uma vez

Baixe o modelo pelo menu ⋮, escreva os quarenta indicadores no seu editor, e suba o arquivo de volta. Ver A casa como arquivo.

O que o exemplo pressupõe

As receitas leem métricas do node_exporter (uso, temperatura, memória, disco, tempo ligado). O resto do exemplo — aparelhos sondados, câmeras, solar, NAS, backup — vem de coletores que a maioria não tem: blackbox_exporter com o job aparelhos, Frigate (frigate_camera_fps), Home Assistant exportando energia, e três coletores próprios (casa_solar_*, casa_nas_*, casa_backup_*). Nada disso é exigido pelo app: é só o exemplo, e o que não se aplica se apaga.

A casa é sua: os indicadores são configuráveis

Os cartões da tela "Agora" não vêm prontos. Cada um é uma consulta ao seu Prometheus, com o título, a unidade e os limiares que você escreve — na própria tela do app, no botão de configuração (⚙ no topo).

Um indicador é: título, descrição, ícone, consulta PromQL, unidade, casas decimais, limiar opcional (bem/atenção, e "maior é melhor" para inverter) e um link para abrir ao tocar. Sem limiar, o cartão é informativo e fica sem cor — cor é para o que exige ação.

O limiar pode ser relativo ao total, quando o cartão é "N de M": os números somam ao denominador, então bem: 0 e atenção: -2 significa "tudo no ar é bem, dois faltando é ruim" — e acrescentar um alvo novo à sonda não repinta a tela inteira.

Dá para ver o número antes de salvar. Cada indicador tem um botão Testar, que roda a consulta no seu Prometheus e mostra o que ela devolve — inclusive quando devolve nada, que é o caso mais comum de erro de digitação. Não é preciso salvar e voltar para descobrir.

Servidor que ainda não tem configuração mostra como configurar, e oferece começar de um exemplo de casa monitorada de verdade (blackbox_exporter, Frigate, Home Assistant, node_exporter). O exemplo entra como rascunho: nada é salvo até você mandar salvar. Indicador cuja métrica não existe aparece como fora com o motivo, então dá para começar do exemplo e ir podando.

Tudo isso vive num arquivo do servidor (CASA_CONFIG_FILE, padrão /data/roqueos/shared/casa.json), que a tela lê e grava por GET/PUT /casa/config. Quem prefere editar por SSH pode: a tela mostra o caminho, e a escrita é atômica dos dois lados.

A linha das 24 h, e a tela do indicador

Cada cartão desenha a linha das últimas 24 horas embaixo do número. Ela responde a pergunta que o número sozinho não responde: isso sempre foi assim? Uma temperatura de 70 °C não diz nada; 70 °C depois de passar por 88 diz bastante.

Tocar no cartão abre a tela daquele indicador, com três janelas — 24 horas, 7 dias e 30 dias — o mínimo, o máximo e a média da janela, o horário das duas pontas do gráfico e um cursor que diz o valor de cada ponto. O motivo do "fora" e o link do Grafana moram ali dentro.

O máximo escrito embaixo pode não aparecer na linha, e isso está certo

A linha desenha um ponto a cada meia hora; os três números varrem a janela inteira, numa amostra a cada 30 segundos. Um pico de dois minutos não cabe num ponto de meia hora, mas entra no máximo — e é justamente ele que você quer saber. A escala do gráfico sempre engloba os números escritos ao lado, para a diferença ficar visível em vez de parecer defeito.

Buraco na série fica buraco: quando o dado não existe naquele intervalo, a linha se interrompe em vez de inventar um zero — zero inventado num gráfico de temperatura desenha uma queda que não aconteceu.

O custo é modesto de propósito: uma chamada para a tela inteira, a cada cinco minutos. Com um ponto novo a cada meia hora, pedir de minuto em minuto redesenharia o mesmo traço às custas da máquina que monitora a sua casa.

De qual máquina é o número

Se você tem mais de uma máquina com node_exporter, uma consulta como max(node_hwmon_temp_celsius) mede todas e mostra a mais quente — que pode não ser a que você acha que está lendo. Aconteceu aqui: o cartão do "servidor" mostrava 60 °C, que era do outro servidor.

Por isso, ao criar um indicador a partir de uma receita, aparece um seletor de máquina. Ele lista o que o seu Prometheus conhece pelo nome da máquina (acemagic-one), e não só pelo alvo de coleta (servidor.casa:9100), e o filtro já entra na consulta. Máquina fora do ar continua na lista: ela existe, só não está respondendo agora.

O seletor só aparece quando há mais de uma máquina — com uma só, a pergunta tem resposta única. Indicadores criados antes disso continuam medindo todas: para corrigir, edite a consulta ou refaça pela receita.

De quanto em quanto tempo a tela relê

Cada grupo de indicadores tem um intervalo próprio, em segundos, no campo ao lado do título do grupo. Vazio herda 60 segundos.

O piso é 30 segundos, e não é número escolhido: é o intervalo em que o Prometheus costuma coletar. Abaixo disso a consulta devolve o mesmo valor e cobra a coleta de novo. Quem digitar 5 recebe 30 — porque quem digita 5 quer "o mais rápido possível", e recusar o jogaria de volta nos 60.

Como a tela lê a casa inteira numa resposta só, isto não vira um cronômetro por grupo: o relógio bate no menor intervalo que algum grupo pediu. O que muda de verdade é o piso da casa.

Janela escondida não pesquisa. O RoqueOS fica aberto o dia inteiro, e o navegador não descarrega a aba: sem isso, uma janela minimizada desde ontem pediria a casa 1440 vezes para desenhar uma tela que ninguém está olhando. Ao voltar para a aba, ele relê na hora. Vale para o app e para o widget.

A topologia: a casa desenhada

Ao lado de Agora, no topo do app, há Topologia: as mesmas coisas da casa, mas mostrando quem se liga a quem — a internet, os links, o roteador, as redes, as máquinas, os serviços e os aparelhos.

Cada caixa acende com a mesma regra dos cartões: verde no ar, vermelho fora, cinza quando não há sonda para aquele alvo. Tocar numa caixa abre o indicador dela, quando existe um indicador falando daquilo.

Precisa do servidor 1.29.0 ou mais novo

A Topologia chegou na 1.29.0 do RoqueOS Server. Em servidor mais antigo a aba existe e diz isso na tela, com o caminho da atualização — não é falha do Prometheus, e o app não vai culpá-lo por isso.

O desenho é um palpite, e ele diz isso

A hierarquia não está no Prometheus. Ele sabe que existe um alvo chamado "Ventilador Mesa" em 192.168.3.11; não sabe que o ventilador fala com o mesh, que fala com o roteador, que fala com o link da operadora. Ninguém nunca escreveu isso ali.

Então o RoqueOS não adivinha a topologia: ele infere o que o endereço permite afirmar, e cada linha carrega o motivo que a produziu. A legenda embaixo separa o que você declarou do que a máquina deduziu — um desenho que afirma tudo com a mesma confiança faz alguém tomar decisão em cima de chute.

O que ele deduz, e de onde

O que vira	A partir de	Por quê
Internet	alvo com IP público (1.1.1.1)	ninguém sonda o 1.1.1.1 para monitorar o 1.1.1.1: sonda para saber se a casa sai
Uma rede	os IPs privados, agrupados pela /24	duas sub-redes são dois pedaços diferentes da casa
Uma rede, por nome	o domínio do alvo (abajur.iot.casa → iot.casa)	quem nomeia os aparelhos sob um domínio está declarando um grupo
Gateway	o .1 da sub-rede, quando ele mesmo é um alvo	convenção, não lei — por isso entra tracejado, como palpite
Serviço numa máquina	o alvo que traz maquina="raspberry"	isso é você afirmando onde ele roda, e ganha de qualquer dedução

O nome de cada caixa sai do primeiro rótulo de nome que existir no alvo (aparelho, servico, maquina, no, link, nome, host…), e o endereço aparece embaixo. Quanto melhor você rotular os alvos no prometheus.yml, melhor sai o desenho — e rotular não serve só para isto: é o mesmo rótulo que dá nome aos cartões.

O estado de cada caixa vem de probe_success, nunca do up. Com o blackbox_exporter, up diz que o exporter respondeu — pintar a casa inteira de verde porque o blackbox está de pé seria a mentira mais cara que o app poderia contar.

Corrigir o que ele errou

O botão do lápis liga o modo de correção. Nele você arrasta as caixas para onde elas fazem sentido, toca numa linha para apagá-la, e puxa de uma caixa à outra para criar a ligação que a máquina não tinha como saber. Salvar o desenho grava no mesmo casa.json dos indicadores.

Ele guarda a correção, não o desenho

No arquivo fica só a diferença entre o que a máquina deduziu e o que você sabe: onde você largou cada caixa, a linha que apagou, a linha que criou. As caixas continuam vindo da descoberta — então o aparelho que você instalar amanhã aparece sozinho. Um arquivo com o grafo inteiro ficaria velho no dia seguinte e ninguém perceberia.

Fora do modo de correção o desenho não se mexe: arrastar por engano não vira mudança para salvar, e o toque continua abrindo o indicador. Sair do modo sem salvar descarta o que foi mexido.

A chave de cada caixa no arquivo é o endereço (ou o nome, quando não há endereço) — nunca um identificador interno. Trocar o job de um alvo no Prometheus não leva junto os ajustes que você fez.

O que ele ainda não faz

• Não infere qual rede está atrás de qual. Numa casa com roteador e mesh isso costuma ser óbvio para quem mora nela e indecidível para quem só vê endereços — então liga você mesmo, no modo de correção, e fica salvo.
• Não renomeia caixas: o nome vem do rótulo do alvo, e mudá-lo é mudar o prometheus.yml.
• Acima de 200 caixas ele corta e diz quantas ficaram de fora, porque um desenho de 500 caixas não é um desenho.

A casa como arquivo: subir, baixar e o modelo

No menu ⋮ do cabeçalho da tela de configuração:

Ação	O que faz
Subir um arquivo…	substitui a casa da tela inteira e vira rascunho — barra de Salvar acesa, pendências contadas, e nada vai para o servidor até você conferir e mandar salvar
Baixar esta casa	exporta casa-AAAA-MM-DD.json com o que está na tela
Baixar modelo para montar	um arquivo que já funciona: as receitas prontas do servidor como itens, mais _ajuda, _comoUsar e _campos explicando cada campo

É o mesmo arquivo do servidor, de propósito: o que sai daqui vai por scp para /data/roqueos/shared/casa.json, e o que está no disco entra por aqui. Isto é o caminho para montar uma casa grande de uma vez, no editor que você preferir, em vez de item por item na tela.

Os comentários _ajuda viajam dentro do próprio arquivo sem quebrar nada: o servidor lê só os campos que conhece e ignora o resto em silêncio.

Item incompleto entra na importação e aparece com a pendência marcada — descartar calado seria você subir quarenta itens, ver trinta e oito e não saber quais sumiram. Arquivo que não é uma casa diz isso com essas palavras e não apaga o que está na tela.

O widget da Casa, na área de trabalho

A casa numa olhada, sem abrir o app. Adicione pelo seletor de widgets (modo de edição da área de trabalho), em quatro tamanhos:

Tocando na engrenagem do widget abre a configuração dele — o que aparece ali é escolha sua:

Tamanho	O que mostra
P	uma coisa só: a manchete da casa — ou, havendo problema, o número do pior indicador
M	a manchete e algumas linhas
G	a lista com a linha das 24 h em cada indicador
XL	a casa agrupada, como você a organizou

• Tocar numa linha abre aquele indicador no app, já na tela de detalhe.
• O que pede olho entra na frente do que você fixou. Um widget que esconde o problema porque alguém pediu para ver a geração solar mente por omissão.
• No XL, quando um grupo não cabe inteiro, ele entra pela metade e diz quantos ficaram de fora (+2 no título). O que fica é o mais grave.
• Configurável no ⚙ do modo de edição: indicadores fixos e a linha "X de Y bem".
• Mesma cadência e mesma pausa do app.

No celular a linha é maior

Sob o dedo cada linha tem 44 px de altura, porque alvo de toque pequeno erra. Cabem menos indicadores no telefone, e é o preço certo.

Atalhos da casa

Abaixo dos indicadores, o app mostra os atalhos — os serviços da casa, por grupo: câmeras, automação, filmes, gráficos, roteador, NAS. Eles abrem no navegador do sistema (no app empacotado, pela ponte nativa), nunca dentro da janela.

Eles ficam no mesmo arquivo dos indicadores e se editam na mesma tela. Quem preferir o editor de texto, o formato é este:

{
  "indicadores": [
    {
      "titulo": "Rede e internet",
      "icone": "lan",
      "itens": [
        {
          "titulo": "Aparelhos no ar",
          "descricao": "Dos sondados na casa",
          "rotulo": "no ar",
          "icone": "sensors",
          "consulta": "count(probe_success{job=\"aparelhos\"} == 1)",
          "consultaTotal": "count(probe_success{job=\"aparelhos\"})",
          "unidade": "",
          "casas": 0,
          "faixa": { "bem": 0, "atencao": -2, "maiorEhMelhor": true, "relativaAoTotal": true },
          "abrir": "/d/wifi-casa"
        }
      ]
    }
  ],
  "atalhos": [
    {
      "titulo": "Casa e mídia",
      "itens": [
        {
          "titulo": "Câmeras",
          "descricao": "Ver ao vivo e o que já aconteceu",
          "url": "https://cameras.exemplo.casa",
          "icone": "videocam"
        }
      ]
    }
  ]
}

icone é um nome de Material Icon; sem ele, o app usa um ícone genérico. Item sem título ou sem URL aceitável é ignorado — um erro de digitação não apaga a lista. http, https, smb, ftp, vnc e ssh valem; javascript: e data: nunca. Servidor sem o arquivo simplesmente não mostra a seção, e isso não é erro.

Limitações

• Só leitura. Acender luz, ligar ar e ver câmera ao vivo são fases seguintes.
• As receitas prontas e o exemplo estão em português: quem usa o RoqueOS noutro idioma recebe o texto inicial em pt-BR e edita na hora.
• Depende do servidor. Sem Server Mode o app diz isso e não tenta nada.
• Os atalhos não mostram se o serviço está no ar. Trazer essa luz depende de o servidor sondar cada endereço, e isso é trabalho de outra fase.
• Quem vê e edita a configuração é qualquer administrador do servidor.