38

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:

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.
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.
libunity9 (faible)

Aucune recherche pour le moment

— utilisateur.dz
source

12

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 :

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

Le compiler

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

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/

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/

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.

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)
Compiler
```
./autogen.sh
make
```

Installer

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

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/

— utilisateur.dz
source

2

Je me demande si cela pourrait être fait en Python .. le C semble un peu effrayant.

— Seth

@ Seth Je crois que oui, cela peut être fait en Python. Comme je viens de vérifier toutes les fonctions nécessaires ( export_action_group, export_menu_model) et les objets ( SimpleActionGroup, Menu) sont dans gi.repository.Gio. J'essaierai d'en écrire un dans les prochains jours.

— user.dz

0

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 :(

— TopHatProductions115
source

Malheureusement non, l'API d'indicateur d'application n'a pas pu être utilisée pour créer un indicateur système. ce sera le même cas que pour indicateur-sysmonitor , il a besoin de versions modifiées d'unité et d'unité-greeter.

— user.dz

Dans ce cas, il semble qu'une nouvelle API soit nécessaire, une interface réservée à l'indicateur système. Dans l'état actuel des choses, l'indicateur système comporte plusieurs API distinctes d'Ubuntu. Je pense que nous avons la possibilité d'utiliser des bibliothèques tierces, comme indiqué à la fin du message.

— TopHatProductions115

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

Service d'indicateur système

Remarques

Les références:

Système Indicateur Plugin