fdo-mirrors/power-profiles-daemon
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/upower/power-profiles-daemon.git synced 2026-05-08 13:38:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

main: Rename Inhibited to PerformanceInhibited

Browse source 
Make it clear that we don't expect any profile to ever be inhibited,
apart from the performance profile.
This commit is contained in:
Bastien Nocera 2020-08-10 15:32:51 +02:00
parent bc2961a406
commit e347845096
6 changed files with 41 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/net.hadess.PowerProfiles.xml
View file

@ -33,16 +33,16 @@
<property name="SelectedProfile" type="s" access="readwrite"/>
<!--
Inhibited:
PerformanceInhibited:
This will be set if the user-selected power profile is unavailable, with
This will be set if the performance power profile is unavailable, with
the value being used to identify the reason for unavailability. As new
reasons can be added, it is recommended that front-ends show a generic
reason if they do not recognise the value. Possible values are:
- "lap-detected" (the computer is sitting on the user's lap)
- "" (the empty string, if not inhibited)
-->
<property name="Inhibited" type="s" access="read"/>
<property name="PerformanceInhibited" type="s" access="read"/>
<!--
Profiles:

32
src/power-profiles-daemon.c
View file

@ -94,13 +94,13 @@ get_selected_profile (PpdApp *data)
}
static const char *
get_inhibited (PpdApp *data)
get_performance_inhibited (PpdApp *data)
{
PpdDriver *driver;
const char *ret;
driver = SELECTED_DRIVER;
ret = ppd_driver_get_inhibited (driver);
ret = ppd_driver_get_performance_inhibited (driver);
g_assert (ret != NULL);
return ret;
}
@ -157,8 +157,8 @@ send_dbus_event (PpdApp *data,
g_variant_new_string (get_selected_profile (data)));
}
if (mask & PROP_INHIBITED) {
g_variant_builder_add (&props_builder, "{sv}", "Inhibited",
g_variant_new_string (get_inhibited (data)));
g_variant_builder_add (&props_builder, "{sv}", "PerformanceInhibited",
g_variant_new_string (get_performance_inhibited (data)));
}
if (mask & PROP_PROFILES) {
g_variant_builder_add (&props_builder, "{sv}", "Profiles",
@ -252,7 +252,7 @@ set_selected_profile (PpdApp *data,
data->selected_profile = target_profile;
if (target_profile == PPD_PROFILE_PERFORMANCE &&
ppd_driver_is_inhibited (SELECTED_DRIVER)) {
ppd_driver_is_performance_inhibited (SELECTED_DRIVER)) {
send_dbus_event (data, PROP_SELECTED_PROFILE);
g_debug ("Not transitioning active profile to '%s' as inhibited", profile);
return TRUE;
@ -266,33 +266,33 @@ set_selected_profile (PpdApp *data,
}
static void
driver_inhibited_changed_cb (GObject *gobject,
GParamSpec *pspec,
gpointer user_data)
driver_performance_inhibited_changed_cb (GObject *gobject,
GParamSpec *pspec,
gpointer user_data)
{
PpdApp *data = user_data;
PpdDriver *driver = PPD_DRIVER (gobject);
const char *prop_str = pspec->name;
if (g_strcmp0 (prop_str, "inhibited") != 0) {
if (g_strcmp0 (prop_str, "performance-inhibited") != 0) {
g_debug ("Ignoring '%s' property change on profile driver '%s'",
prop_str, ppd_driver_get_driver_name (driver));
return;
}
if (!(ppd_driver_get_profiles (driver) & PPD_PROFILE_PERFORMANCE)) {
g_warning ("Ignored 'inhibited' change on non-performance driver '%s'",
g_warning ("Ignored 'performance-inhibited' change on non-performance driver '%s'",
ppd_driver_get_driver_name (driver));
return;
}
if (data->selected_profile != PPD_PROFILE_PERFORMANCE) {
g_debug ("User didn't want the performance profile, so ignoring 'inhibited' change on '%s'",
g_debug ("User didn't want the performance profile, so ignoring 'performance-inhibited' change on '%s'",
ppd_driver_get_driver_name (driver));
return;
}
set_active_profile (data, ppd_driver_is_inhibited (driver) ?
set_active_profile (data, ppd_driver_is_performance_inhibited (driver) ?
PPD_PROFILE_BALANCED : PPD_PROFILE_PERFORMANCE);
}
@ -313,8 +313,8 @@ handle_get_property (GDBusConnection *connection,
return g_variant_new_string (get_active_profile (data));
if (g_strcmp0 (property_name, "SelectedProfile") == 0)
return g_variant_new_string (get_selected_profile (data));
if (g_strcmp0 (property_name, "Inhibited") == 0)
return g_variant_new_string (get_inhibited (data));
if (g_strcmp0 (property_name, "PerformanceInhibited") == 0)
return g_variant_new_string (get_performance_inhibited (data));
if (g_strcmp0 (property_name, "Profiles") == 0)
return get_profiles_variant (data);
return NULL;
@ -461,8 +461,8 @@ name_acquired_handler (GDBusConnection *connection,
g_ptr_array_add (data->drivers, driver);
g_signal_connect (G_OBJECT (driver), "notify::inhibited",
G_CALLBACK (driver_inhibited_changed_cb), data);
g_signal_connect (G_OBJECT (driver), "notify::performance-inhibited",
G_CALLBACK (driver_performance_inhibited_changed_cb), data);
} else if (PPD_IS_ACTION (object)) {
PpdAction *action = PPD_ACTION (object);

2
src/ppd-driver-lenovo-dytc.c
View file

@ -70,7 +70,7 @@ update_dytc_state (PpdDriverLenovoDytc *dytc)
dytc->lapmode ? "on" : "off",
dytc->lapmode ? "inhibited" : "uninhibited");
g_object_set (G_OBJECT (dytc),
"inhibited", dytc->lapmode ? "lap-detected" : NULL,
"performance-inhibited", dytc->lapmode ? "lap-detected" : NULL,
NULL);
}
}

32
src/ppd-driver.c
View file

@ -15,14 +15,14 @@ typedef struct
char *driver_name;
PpdProfile profiles;
gboolean selected;
char *inhibited;
char *performance_inhibited;
} PpdDriverPrivate;
enum {
PROP_0,
PROP_DRIVER_NAME,
PROP_PROFILES,
PROP_INHIBITED
PROP_PERFORMANCE_INHIBITED
};
#define PPD_DRIVER_GET_PRIVATE(o) (ppd_driver_get_instance_private (o))
@ -45,9 +45,9 @@ ppd_driver_set_property (GObject *object,
case PROP_PROFILES:
priv->profiles = g_value_get_flags (value);
break;
case PROP_INHIBITED:
g_clear_pointer (&priv->inhibited, g_free);
priv->inhibited = g_value_dup_string (value);
case PROP_PERFORMANCE_INHIBITED:
g_clear_pointer (&priv->performance_inhibited, g_free);
priv->performance_inhibited = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@ -70,8 +70,8 @@ ppd_driver_get_property (GObject *object,
case PROP_PROFILES:
g_value_set_flags (value, priv->profiles);
break;
case PROP_INHIBITED:
g_value_set_string (value, priv->inhibited);
case PROP_PERFORMANCE_INHIBITED:
g_value_set_string (value, priv->performance_inhibited);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@ -85,7 +85,7 @@ ppd_driver_finalize (GObject *object)
priv = PPD_DRIVER_GET_PRIVATE (PPD_DRIVER (object));
g_clear_pointer (&priv->driver_name, g_free);
g_clear_pointer (&priv->inhibited, g_free);
g_clear_pointer (&priv->performance_inhibited, g_free);
G_OBJECT_CLASS (ppd_driver_parent_class)->finalize (object);
}
@ -113,10 +113,10 @@ ppd_driver_class_init (PpdDriverClass *klass)
PPD_TYPE_PROFILE,
0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_INHIBITED,
g_param_spec_string("inhibited",
"Inhibited",
"Why this profile is inhibited, if set",
g_object_class_install_property (object_class, PROP_PERFORMANCE_INHIBITED,
g_param_spec_string("performance-inhibited",
"Performance Inhibited",
"Why the performance profile is inhibited, if set",
NULL,
G_PARAM_READWRITE));
}
@ -185,18 +185,18 @@ ppd_driver_get_selected (PpdDriver *driver)
}
const char *
ppd_driver_get_inhibited (PpdDriver *driver)
ppd_driver_get_performance_inhibited (PpdDriver *driver)
{
PpdDriverPrivate *priv;
g_return_val_if_fail (PPD_IS_DRIVER (driver), NULL);
priv = PPD_DRIVER_GET_PRIVATE (driver);
return priv->inhibited ? priv->inhibited : "";
return priv->performance_inhibited ? priv->performance_inhibited : "";
}
gboolean
ppd_driver_is_inhibited (PpdDriver *driver)
ppd_driver_is_performance_inhibited (PpdDriver *driver)
{
PpdDriverPrivate *priv;
@ -204,5 +204,5 @@ ppd_driver_is_inhibited (PpdDriver *driver)
priv = PPD_DRIVER_GET_PRIVATE (driver);
return (priv->inhibited != NULL);
return (priv->performance_inhibited != NULL);
}

4
src/ppd-driver.h
View file

@ -29,5 +29,5 @@ gboolean ppd_driver_probe (PpdDriver *driver);
gboolean ppd_driver_activate_profile (PpdDriver *driver, PpdProfile profile, GError **error);
const char *ppd_driver_get_driver_name (PpdDriver *driver);
PpdProfile ppd_driver_get_profiles (PpdDriver *driver);
const char *ppd_driver_get_inhibited (PpdDriver *driver);
gboolean ppd_driver_is_inhibited (PpdDriver *driver);
const char *ppd_driver_get_performance_inhibited (PpdDriver *driver);
gboolean ppd_driver_is_performance_inhibited (PpdDriver *driver);

6
tests/integration-test
View file

@ -235,7 +235,7 @@ class Tests(dbusmock.DBusTestCase):
self.start_daemon()
self.assertEqual(self.get_dbus_property('ActiveProfile'), 'balanced')
self.assertEqual(self.get_dbus_property('SelectedProfile'), 'balanced')
self.assertEqual(self.get_dbus_property('Inhibited'), '')
self.assertEqual(self.get_dbus_property('PerformanceInhibited'), '')
profiles = self.get_dbus_property('Profiles')
self.assertEqual(len(profiles), 2)
@ -276,7 +276,7 @@ class Tests(dbusmock.DBusTestCase):
self.testbed.set_attribute(tp_acpi, 'dytc_lapmode', '1')
self.testbed.uevent(tp_acpi, 'change')
self.assertEventually(lambda: self.have_text_in_log('dytc_lapmode is now on'))
self.assertEqual(self.get_dbus_property('Inhibited'), 'lap-detected')
self.assertEqual(self.get_dbus_property('PerformanceInhibited'), 'lap-detected')
self.assertEqual(self.get_dbus_property('ActiveProfile'), 'balanced')
self.assertEqual(self.get_dbus_property('SelectedProfile'), 'performance')
@ -329,7 +329,7 @@ class Tests(dbusmock.DBusTestCase):
self.assertEqual(self.get_dbus_property('ActiveProfile'), 'balanced')
self.assertEqual(self.get_dbus_property('SelectedProfile'), 'performance')
self.assertEqual(self.get_dbus_property('Inhibited'), 'lap-detected')
self.assertEqual(self.get_dbus_property('PerformanceInhibited'), 'lap-detected')
def test_trickle_charge_mode(self):
'''Trickle power_supply charge type'''