Leandro A. F. Pereira

Com o lançamento da versão 0.4.2 do HardInfo, a API de módulos foi modificada. Ainda não tive tempo de escrever a documentação, mas esse post deve ser uma introdução breve de como se cria um módulo utilizando a nova infra-estrutura.

No HardInfo, um módulo consiste em:

• Uma lista de entradas (cada item da lista é mostrado como subitem da árvore na GUI; por exemplo, o módulo “Devices” tem as entradas “Processor”, “Memory”, “PCI Devices” e assim por diante)
• Cada entrada possui uma função de obtenção de informações e uma função de callback
  • As funções de callback apenas retornam o que foi encontrado, como uma string (usando o formato do GKeyFile da GLib). É garantido que essas funções só serão chamadas após as funções de obtenção
  • Já as funções de obtenção são as que vasculham o ambiente procurando as informações necessárias
• Uma lista de métodos exportados (módulos podem chamar métodos de outros módulos)
• Uma lista de dependências de módulos (por causa da chamada de métodos de outros módulos)
• Informações de versão, copyright, descrição, etc.

É bastante coisa, mas acredite: tudo necessário. Os módulos atuais, embora não estejam com o código mais limpo e simples de entender possíveis, são uma boa fonte de consulta para entender como essas coisas se encaixam.

De qualquer forma, ao incluir o cabeçalho “hardinfo.h”, algumas estruturas e funções serão prototipadas. A partir disso, pode-se começar a criar o módulo:

#include "hardinfo.h"

void   scan_entrada(gboolean reload);
gchar *callback_entrada();

static ModuleEntry entries[] = {
 { "Entrada", "entrada.png", callback_entrada, scan_entrada },
};

static gchar *__entrada = NULL;

void
scan_entrada(gboolean reload)
{
   SCAN_START();

   if (!__entrada) {
      entrada = g_strdup("[Entrada]n"
                         "Olá Mundo=n");
   } else {
      g_free(entrada);

      entrada = g_strdup("[Entrada]n"
                         "Refresh=:)n");
   }

   SCAN_END();
}

gchar *callback_entrada()
{
   return __entrada;
}

/*
 * Retorna a lista de módulos. Não é necessário informar o tamanho, pois isso
 * é calculado em runtime.
 */
ModuleEntry *
hi_module_get_entries(void)
{
    return entries;
}

/*
 * O nome do módulo (como será mostrado na interface). O ícone não precisa ser
 * especificado, pois ele é o nome do arquivo ".so", mas com a extensão ".png".
 */
gchar *
hi_module_get_name(void)
{
    return g_strdup("Módulo Exemplo");
}

/*
 * O peso. Usado para selecionar a ordem do módulo na interface. Quanto maior o
 * seu valor (0~255), mais para baixo ficará.
 */
guchar
hi_module_get_weight(void)
{
    return 160;
}

/*
 * Se houver necessidade de inicializar alguma variável do módulo (como criar
 * tabelas hash, listas ligadas, árvores, etc), faça isso aqui.
 */
void
hi_module_init(void)
{
    g_warning("Olá mundo!");
}

/*
 * Chamado quando o usuário pede informações sobre o módulo (Help -> About Modules ->
 * Nome do Módulo).
 */
ModuleAbout *
hi_module_get_about(void)
{
    static ModuleAbout ma[] = {
      {
          .author       = "Foobar da Silva",
          .description  = "Exemplo de módulo para o HardInfo",
          .version      = VERSION,
          .license      = "GNU GPL version 2"
      }
    }; 

    return ma;
}

Feito isso, é só compilar o módulo. A maneira mais fácil é colocar o módulo no diretório do HardInfo, editar o Makefile.in e adicionar o nome do arquivo na variável MODULES; e, após isso, rodar o configure novamente. Ao executar make, seu módulo será compilado também.

Agora é só instalar e executar o HardInfo. Seu módulo deve aparecer automagicamente. Tente apertar o botão “Refresh” para ver o que acontece. Monitore também a saída no console, para ver se o Warning é realmente mostrado lá (ou se foi mostrado em uma caixa de diálogo). De agora em diante, basta transformar este módulo em algo útil, obtendo informações sobre o hardware ou software básico. E, claro, não deixe de contribuí-lo: as chances dele ser distribuído em uma nova versão são bem grandes.