web-dev-qa-db-fra.com

Comment développer un indicateur système pour l'unité?

Ce 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.

Arrière-plan:

A partir de ces deux questions:

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

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.

En ce qui concerne sysmonitor, cette solution était pour moi 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 en utilisant Python ou C?

Mise à jour:

J'ai trouvé quelques liens qui peuvent donner un push:

  • 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 Indicateurs système du projet, 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 libindiquer & la liberté. Est-ce que quelqu'un a travaillé avec ces deux bibliothèques?

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

Update2: Ceci pour garder les utilisateurs intéressés informés de l'actualité.

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é quelques exemples de test dans le code source, des indicateurs factices que j'ai essayés pourraient être installés dans /usr/lib/indicators3/7/, ils sont partagés lib .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

unitypythonapplication-developmentindicatorc
38
user.dz

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 GMen 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 et placé dans /usr/share/unity/indicators/. Pas besoin d'une autre bibliothèque.

Voici un très petit exemple C language :

  1. Obtenir une copie de tests/indicator-test-service.c à partir de libindicator source

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

    • indicateur-test-service.c aucun changement

      #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 & 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 .in postfix du nom de fichier et modifie 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.

Références:

Système Indicateur Plugin

Ce n'est pas un indicateur autonome complet comme celui ci-dessus, il s'agit simplement d'un plug-in de partage de lib, similaire à libappmenu.so & libprintersmenu.so (indicateur du menu de l'application et de l'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 le faisais auparavant. Voici les étapes, il se peut que quelque chose me manque.

  1. Utilisation de 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 le préfixe lib et l'extension .so.

      [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/
12
user.dz

REMARQUE: Veuillez vérifier le bas de cet article 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 recherché, 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 essayé - 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 :(

0
TopHatProductions115