device-manager: Refactor functions

Ambiguous function names are also revised.
 : build_params_to_load_device() => build_params_to_load_module()
 : load_device() => load_module()
 : unload_device() => unload_module()

[Version] 11.1.48
[Issue type] Refactoring

Change-Id: Ied85b3e847e5496308fa5a836d562d81c0b5a48a
Signed-off-by: Sangchul Lee <sc11.lee@samsung.com>

diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec
index f9155f2..efabe14 100644 (file)
--- a/packaging/pulseaudio-modules-tizen.spec
+++ b/packaging/pulseaudio-modules-tizen.spec
@@ -1,6 +1,6 @@
 Name:             pulseaudio-modules-tizen
 Summary:          Pulseaudio modules for Tizen
-Version:          11.1.47
+Version:          11.1.48
 Release:          0
 Group:            Multimedia/Audio
 License:          LGPL-2.1+

diff --git a/src/device-manager.c b/src/device-manager.c
index 842eb9c..98f24ba 100644 (file)
--- a/src/device-manager.c
+++ b/src/device-manager.c
@@ -790,7 +790,7 @@ pa_tz_device* device_list_get_device_by_id(pa_device_manager *manager, uint32_t
     return NULL;
 }
 
-static int build_params_to_load_device(const char *device_string, const char *params, dm_device_class_t device_class, char *target) {
+static int build_params_to_load_module(const char *device_string, const char *params, dm_device_class_t device_class, char *target) {
     char device_name[DEVICE_NAME_MAX];
 
     pa_assert(device_string);
@@ -1646,8 +1646,7 @@ static pa_hook_result_t sink_source_state_changed_hook_cb(pa_core *c, pa_object
 /*
     Build params for load sink or source, and load it.
 */
-
-static void* load_device(pa_core *c, bool is_sink, const char *device_string, const char *device_params) {
+static void* load_module(pa_core *c, bool is_sink, const char *device_string, const char *device_params) {
     const char *module_name;
     pa_module *module;
     pa_sink *sink;
@@ -1675,14 +1674,14 @@ static void* load_device(pa_core *c, bool is_sink, const char *device_string, co
     }
     pa_log_info("module name : %s", module_name);
 
-    if (build_params_to_load_device(device_string, device_params, device_class, full_params) < 0) {
+    if (build_params_to_load_module(device_string, device_params, device_class, full_params) < 0) {
         pa_log_error("build param to load module failed");
         return NULL;
     }
     pa_log_info("argument : %s", full_params);
 
     if (!(module = pa_module_load(c, module_name, full_params))) {
-        pa_log_error("Load module with name '%s' argu '%s' failed", module_name, full_params);
+        pa_log_error("Load module with name '%s' argument '%s' failed", module_name, full_params);
         return NULL;
     }
     pa_log_info("module loaded : %s %u with '%s'", module->name, module->index, module->argument);
@@ -1708,7 +1707,7 @@ static void* load_device(pa_core *c, bool is_sink, const char *device_string, co
     return NULL;
 }
 
-static void unload_device(pa_core *c, bool is_sink, const char *device_string) {
+static void unload_module(pa_core *c, bool is_sink, const char *device_string) {
     uint32_t device_idx;
 
     pa_assert(c);
@@ -1778,7 +1777,7 @@ static int _load_type_devices(struct device_type_info *type_info, bool is_playba
             pa_log_error("Failed to get param for %s", device_string);
             continue;
         }
-        if (!(load_device(dm->core, is_playback, device_string, params))) {
+        if (!(load_module(dm->core, is_playback, device_string, params))) {
             pa_log_warn("load device failed %s %s", device_string, params);
         }
     }
@@ -2278,52 +2277,7 @@ static void device_type_status_init(pa_device_manager *manager) {
     return ;
 }
 
-pa_idxset* pa_device_manager_get_device_list(pa_device_manager *dm) {
-    pa_assert(dm);
-    pa_assert(dm->device_list);
-
-    return dm->device_list;
-}
-
-pa_tz_device* pa_device_manager_get_device(pa_device_manager *dm, const char *type) {
-    pa_assert(dm);
-
-    return device_list_get_device(dm, type, NULL);
-}
-
-pa_tz_device* pa_device_manager_get_device_by_id(pa_device_manager *dm, uint32_t id) {
-    pa_assert(dm);
-
-    return device_list_get_device_by_id(dm, id);
-}
-
-pa_tz_device* pa_device_manager_get_device_with_sink(pa_sink *sink) {
-    pa_assert(sink);
-
-    return sink->device_item;
-}
-
-pa_tz_device* pa_device_manager_get_device_with_source(pa_source *source) {
-    pa_assert(source);
-
-    return source->device_item;
-}
-
-pa_tz_device* pa_device_manager_load_forwarding(pa_device_manager *dm) {
-    return _load_forwarding_device(dm);
-}
-
-void pa_device_manager_unload_forwarding(pa_device_manager *dm) {
-    pa_tz_device *forwarding_device;
-
-    forwarding_device = device_list_get_device(dm, DEVICE_TYPE_FORWARDING, NULL);
-    if (forwarding_device)
-        pa_tz_device_free(forwarding_device);
-    else
-        pa_log_warn("There is no forwarding device");
-}
-
-pa_sink* pa_device_manager_load_sink(pa_device_manager *dm, const char *type, const char *role) {
+static pa_sink* load_sink(pa_device_manager *dm, const char *type, const char *role) {
     const char *device_string, *params;
     struct device_type_info *type_info;
     struct device_file_info *file_info;
@@ -2371,7 +2325,7 @@ pa_sink* pa_device_manager_load_sink(pa_device_manager *dm, const char *type, co
         goto fail;
     }
 
-    if ((sink = load_device(dm->core, true, device_string, params))) {
+    if ((sink = load_module(dm->core, true, device_string, params))) {
         pa_log_debug("loaded sink '%s' for '%s,%s' success", sink->name, type, role);
     } else {
         pa_log_warn("Cannot load playback device with '%s,%s'", device_string, params);
@@ -2384,7 +2338,7 @@ fail:
     return NULL;
 }
 
-void pa_device_manager_unload_sink(pa_device_manager *dm, const char *type, const char *role) {
+static void unload_sink(pa_device_manager *dm, const char *type, const char *role) {
     const char *device_string;
     struct device_type_info *type_info;
 
@@ -2410,17 +2364,10 @@ void pa_device_manager_unload_sink(pa_device_manager *dm, const char *type, cons
         return;
     }
 
-    unload_device(dm->core, true, device_string);
-}
-
-void pa_device_manager_unload_sink_with_device_string(pa_device_manager *dm, const char *device_string) {
-    pa_assert(dm);
-    pa_assert(device_string);
-
-    unload_device(dm->core, true, device_string);
+    unload_module(dm->core, true, device_string);
 }
 
-pa_source* pa_device_manager_load_source(pa_device_manager *dm, const char *type, const char *role) {
+static pa_source* load_source(pa_device_manager *dm, const char *type, const char *role) {
     const char *device_string, *params;
     struct device_type_info *type_info;
     struct device_file_info *file_info;
@@ -2469,7 +2416,7 @@ pa_source* pa_device_manager_load_source(pa_device_manager *dm, const char *type
         goto fail;
     }
 
-    if ((source = load_device(dm->core, false, device_string, params))) {
+    if ((source = load_module(dm->core, false, device_string, params))) {
         pa_log_debug("loaded source '%s' for '%s,%s' success", source->name, type, role);
     } else {
         pa_log_warn("Cannot load capture device with '%s,%s'", device_string, params);
@@ -2482,7 +2429,7 @@ fail:
     return NULL;
 }
 
-void pa_device_manager_unload_source(pa_device_manager *dm, const char *type, const char *role) {
+static void unload_source(pa_device_manager *dm, const char *type, const char *role) {
     const char *device_string;
     struct device_type_info *type_info;
 
@@ -2508,14 +2455,98 @@ void pa_device_manager_unload_source(pa_device_manager *dm, const char *type, co
         return;
     }
 
-    unload_device(dm->core, false, device_string);
+    unload_module(dm->core, false, device_string);
+}
+
+pa_idxset* pa_device_manager_get_device_list(pa_device_manager *dm) {
+    pa_assert(dm);
+    pa_assert(dm->device_list);
+
+    return dm->device_list;
+}
+
+pa_tz_device* pa_device_manager_get_device(pa_device_manager *dm, const char *type) {
+    pa_assert(dm);
+
+    return device_list_get_device(dm, type, NULL);
+}
+
+pa_tz_device* pa_device_manager_get_device_by_id(pa_device_manager *dm, uint32_t id) {
+    pa_assert(dm);
+
+    return device_list_get_device_by_id(dm, id);
+}
+
+pa_tz_device* pa_device_manager_get_device_with_sink(pa_sink *sink) {
+    pa_assert(sink);
+
+    return sink->device_item;
+}
+
+pa_tz_device* pa_device_manager_get_device_with_source(pa_source *source) {
+    pa_assert(source);
+
+    return source->device_item;
+}
+
+pa_tz_device* pa_device_manager_load_forwarding(pa_device_manager *dm) {
+    return _load_forwarding_device(dm);
+}
+
+void pa_device_manager_unload_forwarding(pa_device_manager *dm) {
+    pa_tz_device *forwarding_device;
+
+    forwarding_device = device_list_get_device(dm, DEVICE_TYPE_FORWARDING, NULL);
+    if (forwarding_device)
+        pa_tz_device_free(forwarding_device);
+    else
+        pa_log_warn("There is no forwarding device");
+}
+
+pa_sink* pa_device_manager_load_sink(pa_device_manager *dm, const char *type, const char *role) {
+    pa_assert(dm);
+    pa_assert(type);
+    pa_assert(role);
+
+    return load_sink(dm, type, role);
+}
+
+void pa_device_manager_unload_sink(pa_device_manager *dm, const char *type, const char *role) {
+    pa_assert(dm);
+    pa_assert(type);
+    pa_assert(role);
+
+    unload_sink(dm, type, role);
+}
+
+void pa_device_manager_unload_sink_with_device_string(pa_device_manager *dm, const char *device_string) {
+    pa_assert(dm);
+    pa_assert(device_string);
+
+    unload_module(dm->core, true, device_string);
+}
+
+pa_source* pa_device_manager_load_source(pa_device_manager *dm, const char *type, const char *role) {
+    pa_assert(dm);
+    pa_assert(type);
+    pa_assert(role);
+
+    return load_source(dm, type, role);
+}
+
+void pa_device_manager_unload_source(pa_device_manager *dm, const char *type, const char *role) {
+    pa_assert(dm);
+    pa_assert(type);
+    pa_assert(role);
+
+    unload_source(dm, type, role);
 }
 
 void pa_device_manager_unload_source_with_device_string(pa_device_manager *dm, const char *device_string) {
     pa_assert(dm);
     pa_assert(device_string);
 
-    unload_device(dm->core, false, device_string);
+    unload_module(dm->core, false, device_string);
 }
 
 const char* pa_device_manager_get_device_string(pa_device_manager *dm, bool is_playback, const char *type, const char *role) {