Como desenvolver um indicador de sistema para Unity?

Question

Como desenvolver um indicador de sistema para Unity?

#1 resposta do user.dz (10 votos)
#2 resposta do TopHatProductions115 (0 votos)

37

Esta não é uma duplicata de Como criar indicadores Unity? . Eu estou procurando indicador de sistema não indicador de aplicativo.

Backgound:

A partir dessas duas perguntas:

Como faço para adicionar ou manipular indicadores do aplicativo / sistema na tela de login?
Como fazer indicador-sysmonitor como um indicador padrão na tela de login

Aprendi que existem dois tipos de indicadores:

Sistema: som, teclado, aplicativo, ... (tente: ps ax | grep indicator )
Aplicação: nm-applet, sysmonitor, ... e quase todos os que estão listados em What Indicadores de aplicação estão disponíveis?

Todos os indicadores de aplicação são manipulados / mostrados por aplicação de indicadores (um sistema um). Os indicadores do sistema são mostrados diretamente pelo painel do Unity.

Ambas as perguntas tratam da adição / remoção de indicadores do login & amp; tela de bloqueio. O primeiro foi uma configuração direta (ao lidar com indicadores do sistema). A segunda foi uma configuração difícil (ao lidar com indicadores de aplicativos), que precisa modificar a origem do serviço de painel (pacote unitário) para a tela de bloqueio e a origem da unidade-saudação para a tela de login.

Como no caso de sysmonitor , para mim isso foi uma solução alternativa. A melhor solução é implementar um indicador de sistema em vez de um aplicativo.

Tópico:

Existe uma API unificada para indicadores do sistema (preferencialmente: Python e C / C ++)? Por favor, faça referência às documentações oficiais.
A maioria dos indicadores do sistema é escrita usando a linguagem de programação Vala. Alguém poderia escrever uma pequena demonstração para um indicador de sistema usando Python ou C?

Atualização:

Encontrei alguns links que podem dar um empurrão:

Na página do projeto Indicadores de aplicativo , eles listaram links para a API AppIndicator-0.3 (C & Python ) usado para indicadores de aplicativos.

~~Eles também indicaram a API 0.7 ( C & amp; Python ). O que é isso?~~ Bem, é um canal de mensagens DBus entre os Aplicativos Desktop.
Por outro lado, na página do projeto Indicadores do sistema , eles mencionaram:
APIs de indicador de sistema
- ~~Menu de Mensagens usando libindicate.~~
- Menu de som usando a libunidade.
- ~~Indicador de data / hora usando Evolution-Data-Server~~
Eles parecem listar a API de dados e não a API de desenvolvimento de indicadores, como para o Evolution-Data-Server. Mas não tenho certeza sobre a biblioteca ~~libindicate & amp;~~ . Alguém trabalhou com essas duas bibliotecas?

Tente apt-cache rdepends libunity9 libindicator7 libindicator3-7 para ver qual indicador está retransmitindo essas bibliotecas.

Update2: para manter os usuários interessados atualizados.

Do que colecionei até agora, aqui está a ordem de possíveis soluções:

libindicator3-7 (alto, muitos indicadores dependem dele)

Encontrei alguns exemplos de teste na origem, alguns indicadores fictícios que tentei, poderiam ser instalados em /usr/lib/indicators3/7/ , eles são compartilhados lib .so . Eu poderia mostrá-los em Login & amp; Sessão Regular, mas Não na Tela de Bloqueio.

No entanto, existem alguns serviços de indicadores de teste, que parecem ser os do sistema Unity. Eu não tentei ainda.
libindicator7

Da mesma fonte que libindicator3-7, de rdepends:
```
mate-indicator-applet
lxpanel-indicator-applet-plugin
```
Parece ser usado para fazer contêineres para indicadores em painéis.
libunity9 (baixo)

Nenhuma pesquisa ainda

unity indicator application-development python c

por user.dz 27.10.2015 / 21:02

2 respostas

0

OBSERVAÇÃO: Por favor, confira no final deste post a palavra final sobre esta resposta.

Não sei se realmente sou de alguma ajuda, mas espero que essa ideia seja útil.

A partir do que pesquisei, a diferença em indicadores de sistema e de aplicativo é distinta. Com isso em mente, agora introduzo um conceito questionável:

O uso da API do Indicador de Aplicação em um Indicador do Sistema (em oposição à criação de uma API nova e unificada para o mesmo propósito)

A ideia surgiu quando analisei os seguintes posts:

link

A API do Unity parece ser criada principalmente para uso com Indicadores do Aplicativo, mas os Indicadores do Sistema e do Aplicativo podem usar programação semelhante (C lang). No entanto, você mencionou anteriormente que esses dois tipos de indicadores são manipulados por dois sistemas diferentes. Assim, eu continuei lendo uma de suas fontes:

Como faço para adicionar ou manipular indicadores do aplicativo / sistema na tela de login?

A resposta principal envolveu a substituição de um usuário já existente para obter o acesso necessário. Também forneceu uma solução para adicionar e remover todos os indicadores existentes. É uma solução de gerenciamento unificada para indicadores. Seria possível substituir um usuário padrão (pré-existente) para executar / introduzir um indicador de sistema?

Um indicador de sistema pode usar a API Unity Application Indicator (a API pode ser usada e exibida corretamente pelo painel do Unity)? Se as respostas forem sim, isso saciaria a situação - se não causar outros problemas como resultado. Sei que isso não será imediatamente uma resposta, então vou esclarecer o que tentei - estou tentando dividir a tarefa em objetivos menores. O principal objetivo é descobrir se a API do Indicador de Aplicação pode ser usada para codificação de Indicadores do Sistema (como API pré-existente e unificada para Indicadores do Sistema).

Em resposta a esta parte da sua consulta:

"Existe uma API unificada para indicadores do sistema"

Infelizmente, não há como usar as APIs do Indicador de Aplicativos para os Indicadores do Sistema. Como tal, a minha solução é nula: (

por TopHatProductions115 14.03.2016 / 16:17

Tags unity indicator application-development python c

Como o meu administrador de sistema sabe que não reiniciei meu sistema? Qual é o equivalente de um "arquivo exe"?

score 10 · Accepted Answer

Serviço indicador de sistema

Bem, é muito mais simples do que eu esperava. Não há uma API específica para isso. Porque é apenas um GSimpleActionGroup & amp; com os GMenu correspondentes exportados através do DBus, em seguida, o Unity é informado sobre sua presença usando o arquivo de declaração com o mesmo nome em código%. Não há necessidade de qualquer outra biblioteca.

Aqui está um exemplo muito pequeno da linguagem C :

Obtenha uma cópia de /usr/share/unity/indicators/ de tests/indicator-test-service.c source

apt-get source libindicator
cp libindicator-*/tests/indicator-test-service.c .
cp libindicator-*/tests/com.canonical.indicator.test* .

indicador-teste-serviço.c nenhuma mudança

#include <gio/gio.h>

typedef struct
{
  GSimpleActionGroup *actions;
  GMenu *menu;

  guint actions_export_id;
  guint menu_export_id;
} IndicatorTestService;

static void
bus_acquired (GDBusConnection *connection,
              const gchar     *name,
              gpointer         user_data)
{
  IndicatorTestService *indicator = user_data;
  GError *error = NULL;

  indicator->actions_export_id = g_dbus_connection_export_action_group (connection,
                                                                        "/com/canonical/indicator/test",
                                                                        G_ACTION_GROUP (indicator->actions),
                                                                        &error);
  if (indicator->actions_export_id == 0)
    {
      g_warning ("cannot export action group: %s", error->message);
      g_error_free (error);
      return;
    }

  indicator->menu_export_id = g_dbus_connection_export_menu_model (connection,
                                                                   "/com/canonical/indicator/test/desktop",
                                                                   G_MENU_MODEL (indicator->menu),
                                                                   &error);
  if (indicator->menu_export_id == 0)
    {
      g_warning ("cannot export menu: %s", error->message);
      g_error_free (error);
      return;
    }
}

static void
name_lost (GDBusConnection *connection,
           const gchar     *name,
           gpointer         user_data)
{
  IndicatorTestService *indicator = user_data;

  if (indicator->actions_export_id)
    g_dbus_connection_unexport_action_group (connection, indicator->actions_export_id);

  if (indicator->menu_export_id)
    g_dbus_connection_unexport_menu_model (connection, indicator->menu_export_id);
}

static void
activate_show (GSimpleAction *action,
               GVariant      *parameter,
               gpointer       user_data)
{
  g_message ("showing");
}

int
main (int argc, char **argv)
{
  IndicatorTestService indicator = { 0 };
  GMenuItem *item;
  GMenu *submenu;
  GActionEntry entries[] = {
    { "_header", NULL, NULL, "{'label': <'Test'>,"
                             " 'icon': <'indicator-test'>,"
                             " 'accessible-desc': <'Test indicator'> }", NULL },
    { "show", activate_show, NULL, NULL, NULL }
  };
  GMainLoop *loop;

  indicator.actions = g_simple_action_group_new ();
  g_simple_action_group_add_entries (indicator.actions, entries, G_N_ELEMENTS (entries), NULL);

  submenu = g_menu_new ();
  g_menu_append (submenu, "Show", "indicator.show");
  item = g_menu_item_new (NULL, "indicator._header");
  g_menu_item_set_attribute (item, "x-canonical-type", "s", "com.canonical.indicator.root");
  g_menu_item_set_submenu (item, G_MENU_MODEL (submenu));
  indicator.menu = g_menu_new ();
  g_menu_append_item (indicator.menu, item);

  g_bus_own_name (G_BUS_TYPE_SESSION,
                  "com.canonical.indicator.test",
                  G_BUS_NAME_OWNER_FLAGS_NONE,
                  bus_acquired,
                  NULL,
                  name_lost,
                  &indicator,
                  NULL);

  loop = g_main_loop_new (NULL, FALSE);
  g_main_loop_run (loop);

  g_object_unref (submenu);
  g_object_unref (item);
  g_object_unref (indicator.actions);
  g_object_unref (indicator.menu);
  g_object_unref (loop);

  return 0;
}

com.canonical.indicator.test modificado para adicionar bloqueio & amp; modo de saudação

[Indicator Service]
Name=indicator-test
ObjectPath=/com/canonical/indicator/test

[desktop]
ObjectPath=/com/canonical/indicator/test/desktop

[desktop_greeter]
ObjectPath=/com/canonical/indicator/test/desktop

[desktop_lockscreen]
ObjectPath=/com/canonical/indicator/test/desktop

com.canonical.indicator.test.service remova libindicator postfix do nome do arquivo e altere o caminho do executável

[D-BUS Service]
Name=com.canonical.indicator.test
Exec=/usr/lib/x86_64-linux-gnu/indicator-test/indicator-test-service

Compile

gcc -o indicator-test-service indicator-test-service.c 'pkg-config --cflags --libs gtk+-3.0'

Instalação manual

sudo su
mkdir /usr/lib/x86_64-linux-gnu/indicator-test/
cp indicator-test-service /usr/lib/x86_64-linux-gnu/indicator-test/
cp com.canonical.indicator.test /usr/share/unity/indicators/
cp com.canonical.indicator.test.service /usr/share/dbus-1/services/

Configuração para Greeter, anule a lista de indicadores padrão

90_unity-greeter.gschema.override

[com.canonical.unity-greeter]
indicators=['ug-accessibility', 'com.canonical.indicator.keyboard', 'com.canonical.indicator.session', 'com.canonical.indicator.datetime', 'com.canonical.indicator.power', 'com.canonical.indicator.sound', 'com.canonical.indicator.test', 'application']

Instalar

cp 90_unity-greeter.gschema.override /usr/share/glib-2.0/schemas/
glib-compile-schemas /usr/share/glib-2.0/schemas/

Teste
```
sudo service lightdm restart
```

Notas

O serviço DBus é problemático se você desejar que o usuário possa fechar o aplicativo a qualquer momento. É melhor usar o início automático, como os indicadores padrão.
Eu enviei arquivos prontos aqui:

link

e uma cópia modificada aqui:

link

Onde eu tentei menu diferente para o modo diferente. Pode ser instalado e testado rapidamente.
Isto parece muito simples e pode ser facilmente portado para qualquer outra linguagem que suporte a biblioteca GIO Gnome (incluindo o DBus). Como estou procurando por python, posso adicioná-lo mais tarde.

Referências:

libindicator README: o formato de arquivo de serviço do indicador

Plugin de Indicador do Sistema

Este não é um indicador completo e independente como o acima, é apenas um plugin lib de compartilhamento, semelhante a .in & amp; libappmenu.so (menu de aplicativos e indicador da impressora). Pode ser mostrado apenas em sessões regulares de usuários & amp; saudação (não na tela de bloqueio).

Eu não consegui fazer funcionar na minha máquina atual, mas fiz antes. Aqui os passos, pode ser que esteja faltando alguma coisa.

Usando a mesma fonte acima de libprintersmenu.so

libindicator são exemplos (simples e visíveis, os que aparecem no painel)
Compile
```
./autogen.sh
make
```

Instalar

sudo cp tests/.libs/libdummy-indicator-visible.so /usr/lib/indicators3/7/libdummy.so

Configure para mostrar na tela de boas-vindas

90_unity-greeter.gschema.override use o mesmo nome sem test/libdummy-indicator-*.c prefixo e lib extensão.

[com.canonical.unity-greeter]
indicators=['ug-accessibility', 'com.canonical.indicator.keyboard', 'com.canonical.indicator.session', 'com.canonical.indicator.datetime', 'com.canonical.indicator.power', 'com.canonical.indicator.sound', 'application', 'dummy']

Instalar

cp 90_unity-greeter.gschema.override /usr/share/glib-2.0/schemas/
glib-compile-schemas /usr/share/glib-2.0/schemas/