Ceci n'est pas une copie de Comment créer des indicateurs d'Unity? . Je cherche un indicateur système et non un indicateur d'application.

Backgound:

A partir de ces deux questions:

• Comment ajouter ou manipuler des indicateurs d'application / système dans l'écran de connexion?
• Comment faire de indicateur-sysmonitor comme indicateur par défaut sur l'écran de connexion

J'ai appris qu'il y a deux types d'indicateurs:

• Système: son, clavier, application, ... (essayez: ps ax | grep indicator)
• Application: nm-applet, sysmonitor, ... et presque tous énumérés dans la section Quels indicateurs d'application sont disponibles?

Tous les indicateurs d’application sont traités / affichés par indicateur-application (un système). Les indicateurs système sont affichés directement par le panneau Unity.

Les deux questions concernent l'ajout / la suppression d'indicateurs de l'écran de connexion et de verrouillage. La première était une configuration simple (s’agissant des indicateurs système). La seconde était une configuration difficile (quand il s’agissait d’indicateurs d’application), qui nécessitait de modifier la source du service de panneau (Paquet Unity) pour l’écran de verrouillage et la source d’unité-greeter pour l’écran de connexion.

Pour sysmonitormoi, c'était une solution de contournement. La meilleure solution consiste à implémenter un indicateur système au lieu d'un indicateur d'application.

Sujet:

• Existe-t-il une API unifiée pour les indicateurs système (de préférence: Python, puis C / C ++)? S'il vous plaît, référence à la documentation officielle.

• La plupart des indicateurs système sont écrits en utilisant le langage de programmation Vala. Est-ce que quelqu'un pourrait écrire une petite démo pour un indicateur système utilisant Python ou C?

Mise à jour:

J'ai trouvé quelques liens qui peuvent donner une impulsion:

• Dans la page de projet Indicateurs d'application , ils ont répertorié les liens vers l'API AppIndicator-0.3 ( C & Python ) utilisée pour les indicateurs d'application.

  Ils ont également énuméré Indicate-0.7 API ( C & Python ). Qu'est-ce que c'est? C'est un canal de messagerie DBus entre les applications de bureau.

• D'autre part, dans la page de projet Indicateurs de système , ils ont mentionné:

  API d'indicateur système

  • Menu de messagerie utilisant libindicate.
  • Menu Son en utilisant la liberté.
  • Indicateur de date / heure avec Evolution-Data-Server

  Ils semblent lister l’API de données et non l’API de développement d’indicateurs comme pour Evolution-Data-Server. Mais pas sûr de libindicate & libunity. Est-ce que quelqu'un a travaillé avec ces deux bibliothèques?

  Essayez apt-cache rdepends libunity9 libindicator7 libindicator3-7de voir quel indicateur relaie ces bibliothèques.

Update2: Ceci pour garder les utilisateurs intéressés à jour.

D'après ce que j'ai collecté jusqu'à maintenant, voici l'ordre des solutions possibles:

1. libindicator3-7 (élevé, de nombreux indicateurs en dépendent)

   J'ai trouvé des exemples de test dans la source, des indicateurs factices que j'ai essayés, qui pourraient être installés /usr/lib/indicators3/7/, ils sont partagés .so. Je pouvais les afficher dans Login & Session régulière mais pas dans l'écran de verrouillage.

   Cependant, il existe certains services d'indicateurs de test, qui semblent être ceux du système Unity. Je ne les ai pas encore essayés.

2. libindicator7

   De même source que libindicator3-7, de rdepends:

   mate-indicator-applet
   lxpanel-indicator-applet-plugin

   Il semble être utilisé pour fabriquer des conteneurs pour les indicateurs dans les panneaux.

3. libunity9 (faible)

   Aucune recherche pour le moment

Service d'indicateur système

Eh bien, c'est vraiment plus simple que ce à quoi je m'attendais. Il n'y a pas d'API spécifique pour cela. Comme il ne s'agit que d'un GSimpleActionGroup & avec les GMenu correspondants exportés via DBus, Unity est informée de leur présence à l'aide d'un fichier de déclaration portant le même nom /usr/share/unity/indicators/. Pas besoin d'une autre bibliothèque.

Voici un très petit exemple de langage C :

1. Obtenir une copie de tests/indicator-test-service.cde la libindicatorsource

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

   • indicateur-test-service.c pas de modifications

     #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 modifié pour ajouter le mode verrouillage et greeter

     [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 supprime .inpostfix du nom de fichier et change le chemin de l'exécutable

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

2. Le compiler

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

3. Installation manuelle

   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/

4. Configuration pour Greeter, remplacez la liste des indicateurs par défaut

   • 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']

   • Installer

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

5. Tester

   sudo service lightdm restart

Remarques

• Le service DBus est gênant si vous voulez que l'utilisateur puisse fermer l'application à tout moment. Il est préférable d’utiliser autostart à la place, comme le font les indicateurs par défaut.

• J'ai téléchargé des fichiers prêts ici:

  https://github.com/sneetsher/mysystemindicator_minimum

  et une copie modifiée ici:

  https://github.com/sneetsher/mysystemindicator

  Où j'ai essayé différents menus pour différents modes. Il pourrait être installé et testé rapidement.

• Cela semble trop simple et peut être facilement porté vers n’importe quel autre langage prenant en charge GIO Gnome lib (y compris DBus). Comme je cherche du python, je l’ajouterai peut-être plus tard.

Les références:

• libindicator README: format de fichier de service d'indicateur

Système Indicateur Plugin

Ce n'est pas un indicateur autonome complet comme celui ci-dessus, c'est juste un plugin de partage de lib, similaire à libappmenu.so& libprintersmenu.so(indicateur de menu d'application et d'imprimante). Il ne peut être affiché que dans la session utilisateur normale et dans la fenêtre d'accueil (pas sur l'écran de verrouillage).

Je ne pouvais pas le faire fonctionner dans ma machine actuelle, mais je l'ai fait avant. Voici les étapes, peut-être que je manque quelque chose.

1. En utilisant la même source ci-dessus de libindicator

   test/libdummy-indicator-*.c sont des exemples (simples et visibles, ceux qui apparaissent sur le panneau)

2. Compiler

   ./autogen.sh
   make

3. Installer

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

4. Configurer pour afficher dans l'écran d'accueil

   • 90_unity-greeter.gschema.override utilise le même nom sans libpréfixe ni .soextension.

     [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']

   • Installer

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

Remarque: s'il vous plaît vérifier au bas de ce post pour le dernier mot sur cette réponse.

Je ne sais pas si je suis vraiment d'aucune aide, mais j'espère que cette idée pourra être utile.

D'après ce que j'ai cherché, la différence entre les indicateurs système et d'application est distincte. Dans cet esprit, je présente maintenant un concept discutable:

Utilisation de l'API d'indicateur d'application dans un indicateur système (par opposition à la création d'une nouvelle API unifiée dans le même but)

L'idée m'est venue en regardant les posts suivants:

https://askubuntu.com/a/234204/408654

https://askubuntu.com/a/42213/408654

L'API Unity semble être principalement conçue pour être utilisée avec les indicateurs d'application, mais les indicateurs système et d'application peuvent utiliser une programmation similaire (C lang). Cependant, vous avez mentionné précédemment que ces deux types d’indicateurs sont gérés par deux systèmes différents. En tant que tel, j'ai ensuite lu l'une de vos sources:

Comment ajouter ou manipuler des indicateurs d'application / système dans l'écran de connexion?

La réponse principale consistait à ignorer un utilisateur déjà existant pour obtenir l'accès requis. Il a également fourni une solution pour ajouter et supprimer tous les indicateurs existants. C'est une solution de gestion unifiée pour les indicateurs. Serait-il possible de remplacer un utilisateur par défaut (préexistant) pour exécuter / introduire un indicateur système?

Un indicateur système peut-il utiliser l'API Unity Application Indicator (l'API peut-elle être utilisée et affichée correctement par le panneau Unity)? Si la réponse à ces questions est affirmative, la situation serait rassurante - si cela ne causait pas d'autres problèmes. Je sais que cela ne semblera pas immédiatement une solution, alors je vais clarifier ce que j'ai tenté - j'essaye de diviser la tâche en objectifs plus petits. L’objectif principal étant de savoir si l’API d’indicateur d’application peut être utilisé pour coder des indicateurs système (en tant qu’API unifié préexistant pour les indicateurs système).

En réponse à cette partie de votre requête:

"Existe-t-il une API unifiée pour les indicateurs système"

Malheureusement, il n’existe aucun moyen d’utiliser les API d’indicateur d’application pour les indicateurs système. En tant que tel, ma solution est vide :(