device-manager: device-manager code enhancement

[Version] 5.0.7
[Profile] Common
[Issue Type] Code Enhancement

Change-Id: I180974b63b9cdc5cd99173e1461bfc82762ed45f

diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec
index a7f6275a816c20a12ec918675a08671cdf1f61e3..afec1a70c424e5916ee80f3b29f0df62493e0149 100644 (file)
--- a/packaging/pulseaudio-modules-tizen.spec
+++ b/packaging/pulseaudio-modules-tizen.spec
@@ -3,7 +3,7 @@
 
 Name:             pulseaudio-modules-tizen
 Summary:          Improved Linux sound server
-Version:          5.0.6
+Version:          5.0.7
 Release:          0
 Group:            Multimedia/Audio
 License:          LGPL-2.1+

diff --git a/src/device-manager.c b/src/device-manager.c
index 0aa3a3ee81158781fd7634991ed7c5b6dd1b9d32..1e11f598f577120a75fb2ee49e7259350b8f9e43 100644 (file)
--- a/src/device-manager.c
+++ b/src/device-manager.c
@@ -363,7 +363,7 @@ struct pa_device_manager {
     */
     pa_idxset *device_status;
     pa_dbus_connection *dbus_conn;
-    dm_device_sco_status_t bt_sco_status;
+    dm_device_bt_sco_status_t bt_sco_status;
 };
 
 /***************** structures for static information get from json *********/
@@ -2521,7 +2521,7 @@ static pa_hook_result_t device_state_changed_hook_cb(pa_core *c, pa_object *o, p
         if (s->use_internal_codec) {
             if (state == PA_SINK_SUSPENDED) {
                 PA_IDXSET_FOREACH(_device_item, dm->device_list, idx) {
-                    pa_device_manager_use_internal_codec(_device_item, DM_DEVICE_DIRECTION_OUT, DEVICE_ROLE_NORMAL, &use_internal_codec);
+                    use_internal_codec = pa_device_manager_is_device_use_internal_codec(_device_item, DM_DEVICE_DIRECTION_OUT, DEVICE_ROLE_NORMAL);
                     if (use_internal_codec)
                         pa_device_manager_set_device_state(_device_item, DM_DEVICE_DIRECTION_OUT, DM_DEVICE_STATE_DEACTIVATED);
                 }
@@ -2541,7 +2541,7 @@ static pa_hook_result_t device_state_changed_hook_cb(pa_core *c, pa_object *o, p
         if (s->use_internal_codec) {
             if (state == PA_SOURCE_SUSPENDED) {
                 PA_IDXSET_FOREACH(_device_item, dm->device_list, idx) {
-                    pa_device_manager_use_internal_codec(_device_item, DM_DEVICE_DIRECTION_IN, DEVICE_ROLE_NORMAL, &use_internal_codec);
+                    use_internal_codec = pa_device_manager_is_device_use_internal_codec(_device_item, DM_DEVICE_DIRECTION_IN, DEVICE_ROLE_NORMAL);
                     if (use_internal_codec)
                         pa_device_manager_set_device_state(_device_item, DM_DEVICE_DIRECTION_IN, DM_DEVICE_STATE_DEACTIVATED);
                 }
@@ -3824,7 +3824,7 @@ static void handle_load_sink(DBusConnection *conn, DBusMessage *msg, void *userd
 
     if (pa_streq(device_profile, "none"))
         device_profile = NULL;
-    pa_device_manager_load_sink(device_type, device_profile, role, dm);
+    pa_device_manager_load_sink(dm, device_type, device_profile, role);
     pa_assert_se(dbus_connection_send(conn, reply, NULL));
     dbus_message_unref(reply);
 }
@@ -4114,28 +4114,23 @@ dm_device_direction_t pa_device_manager_get_device_direction(dm_device *device_i
     return profile_item->direction;
 }
 
-void pa_device_manager_use_internal_codec(dm_device *device_item, dm_device_direction_t direction, const char *role, pa_bool_t *use_internal_codec) {
+pa_bool_t pa_device_manager_is_device_use_internal_codec(dm_device *device_item, dm_device_direction_t direction, const char *role) {
     pa_sink *sink;
     pa_source *source;
+    pa_bool_t use_internal_codec = FALSE;
 
     pa_assert(device_item);
-    pa_assert(use_internal_codec);
     pa_assert(role);
 
     if (direction == DM_DEVICE_DIRECTION_IN) {
         if ((source = pa_device_manager_get_source(device_item, role)))
-            *use_internal_codec = source->use_internal_codec;
-        else
-            *use_internal_codec = FALSE;
+            use_internal_codec = source->use_internal_codec;
     } else if (direction == DM_DEVICE_DIRECTION_OUT) {
         if ((sink = pa_device_manager_get_sink(device_item, role)))
-            *use_internal_codec = sink->use_internal_codec;
-        else
-            *use_internal_codec = FALSE;
-    } else
-        *use_internal_codec = FALSE;
+            use_internal_codec = sink->use_internal_codec;
+    }
 
-    return;
+    return use_internal_codec;
 }
 
 int pa_device_manager_bt_sco_open(pa_device_manager *dm) {
@@ -4175,7 +4170,7 @@ int pa_device_manager_bt_sco_open(pa_device_manager *dm) {
     return 0;
 }
 
-void pa_device_manager_bt_sco_get_status(pa_device_manager *dm, dm_device_sco_status_t *status) {
+void pa_device_manager_bt_sco_get_status(pa_device_manager *dm, dm_device_bt_sco_status_t *status) {
     pa_assert(dm);
     pa_assert(status);
 
@@ -4235,7 +4230,7 @@ int pa_device_manager_bt_sco_get_property(pa_device_manager *dm, pa_bool_t *is_w
     return 0;
 }
 
-int pa_device_manager_load_sink(const char *device_type, const char *device_profile, const char *role, pa_device_manager *dm) {
+int pa_device_manager_load_sink(pa_device_manager *dm, const char *device_type, const char *device_profile, const char *role) {
     const char *device_string, *params;
     struct device_type_info *type_info;
     struct device_file_info *file_info;
@@ -4292,7 +4287,7 @@ failed:
     return -1;
 }
 
-int pa_device_manager_load_source(const char *device_type, const char *device_profile, const char *role, pa_device_manager *dm) {
+int pa_device_manager_load_source(pa_device_manager *dm, const char *device_type, const char *device_profile, const char *role) {
     const char *device_string, *params;
     struct device_type_info *type_info;
     struct device_file_info *file_info;

diff --git a/src/device-manager.h b/src/device-manager.h
index c2485cfc87b96781a0a59d20f3778fc312774655..aa06a586f2fc224a0a89c5ddee2dbb41d4bae620 100644 (file)
--- a/src/device-manager.h
+++ b/src/device-manager.h
@@ -42,7 +42,7 @@ typedef enum dm_device_bt_sco_status_type {
     DM_DEVICE_BT_SCO_STATUS_DISCONNECTED = 0,
     DM_DEVICE_BT_SCO_STATUS_CONNECTED,
     DM_DEVICE_BT_SCO_STATUS_OPENED
-} dm_device_sco_status_t;
+} dm_device_bt_sco_status_t;
 
 typedef struct pa_device_manager pa_device_manager;
 typedef struct dm_device dm_device;
@@ -60,26 +60,34 @@ typedef struct _hook_call_data_for_info_changed {
 pa_device_manager* pa_device_manager_init(pa_core* core);
 void pa_device_manager_done(pa_device_manager *dm);
 
+/* get device or list */
 pa_idxset* pa_device_manager_get_device_list(pa_device_manager *dm);
 dm_device* pa_device_manager_get_device(pa_device_manager *dm, const char *device_type);
 dm_device* pa_device_manager_get_device_by_id(pa_device_manager *dm, uint32_t id);
 
-pa_sink* pa_device_manager_get_sink(dm_device *device, const char *role);
-pa_source* pa_device_manager_get_source(dm_device *device, const char *role);
-void pa_device_manager_set_device_state(dm_device *device, dm_device_direction_t direction, dm_device_state_t state);
+/* query device */
+pa_sink* pa_device_manager_get_sink(dm_device *device_item, const char *role);
+pa_source* pa_device_manager_get_source(dm_device *device_item, const char *role);
+uint32_t pa_device_manager_get_device_id(dm_device *device_item);
+const char* pa_device_manager_get_device_type(dm_device *device_item);
+const char* pa_device_manager_get_device_subtype(dm_device *device_item);
+dm_device_direction_t pa_device_manager_get_device_direction(dm_device *device_item);
+pa_bool_t pa_device_manager_is_device_use_internal_codec(dm_device *device_item, dm_device_direction_t direction, const char *role);
+
+/* set/get device state */
+void pa_device_manager_set_device_state(dm_device *device_item, dm_device_direction_t direction, dm_device_state_t state);
 dm_device_state_t pa_device_manager_get_device_state(dm_device *device_item, dm_device_direction_t direction);
-uint32_t pa_device_manager_get_device_id(dm_device *device);
-const char* pa_device_manager_get_device_type(dm_device *device);
-const char* pa_device_manager_get_device_subtype(dm_device *device);
-dm_device_direction_t pa_device_manager_get_device_direction(dm_device *device);
-void pa_device_manager_use_internal_codec(dm_device *device_item, dm_device_direction_t direction, const char *role, pa_bool_t *use_internal_codec);
+
+/* get device with sink or source */
 dm_device* pa_device_manager_get_device_with_sink(pa_sink *sink);
 dm_device* pa_device_manager_get_device_with_source(pa_source *source);
 
-int pa_device_manager_load_sink(const char *device_type, const char *device_profile, const char *role, pa_device_manager *dm);
-int pa_device_manager_load_source(const char *device_type, const char *device_profile, const char *role, pa_device_manager *dm);
+/* load pulse device */
+int pa_device_manager_load_sink(pa_device_manager *dm, const char *device_type, const char *device_profile, const char *role);
+int pa_device_manager_load_source(pa_device_manager *dm, const char *device_type, const char *device_profile, const char *role);
 
+/* bt sco control/query */
 int pa_device_manager_bt_sco_open(pa_device_manager *dm);
-void pa_device_manager_bt_sco_get_status(pa_device_manager *dm, dm_device_sco_status_t *status);
+void pa_device_manager_bt_sco_get_status(pa_device_manager *dm, dm_device_bt_sco_status_t *status);
 int pa_device_manager_bt_sco_close(pa_device_manager *dm);
 int pa_device_manager_bt_sco_get_property(pa_device_manager *dm, pa_bool_t *is_wide_band, pa_bool_t *nrec);

diff --git a/src/module-policy.c b/src/module-policy.c
index 01022fd19c5dbac0a64149241d4840c0271c64a9..f8c95b75b2b71516d1505a02935eb8f0d8401135 100644 (file)
--- a/src/module-policy.c
+++ b/src/module-policy.c
@@ -475,7 +475,7 @@ static void _set_device_state(dm_device *device, stream_type_t stream_type, dm_d
 
     pa_assert(device);
 
-    pa_device_manager_use_internal_codec(device, CONVERT_TO_DEVICE_DIRECTION(stream_type), DEVICE_ROLE_NORMAL, &use_internal_codec);
+    use_internal_codec = pa_device_manager_is_device_use_internal_codec(device, CONVERT_TO_DEVICE_DIRECTION(stream_type), DEVICE_ROLE_NORMAL);
     if (use_internal_codec)
         pa_device_manager_set_device_state(device, CONVERT_TO_DEVICE_DIRECTION(stream_type), device_state);
 
@@ -484,7 +484,7 @@ static void _set_device_state(dm_device *device, stream_type_t stream_type, dm_d
 
 /* Open/Close BT SCO if it is possible */
 static int _set_bt_sco_state(pa_device_manager *dm, pa_bool_t open) {
-    dm_device_sco_status_t sco_status;
+    dm_device_bt_sco_status_t sco_status;
 
     pa_assert(dm);
 
@@ -634,7 +634,7 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
                         dm_device_type, dm_device_subtype, device_direction, device_idx);
                 if (pa_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, device_direction)) {
                     pa_log_debug("  ** found a matched device: type[%-16s], direction[0x%x]", device_type, device_direction);
-                    pa_device_manager_use_internal_codec(device, CONVERT_TO_DEVICE_DIRECTION(data->stream_type), DEVICE_ROLE_NORMAL, &use_internal_codec);
+                    use_internal_codec = pa_device_manager_is_device_use_internal_codec(device, CONVERT_TO_DEVICE_DIRECTION(data->stream_type), DEVICE_ROLE_NORMAL);
                     if (use_internal_codec) {
                         route_info.num_of_devices++;
                         route_info.device_infos = pa_xrealloc(route_info.device_infos, sizeof(hal_device_info)*route_info.num_of_devices);
@@ -652,7 +652,7 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
             }
             if (data->route_type == STREAM_ROUTE_TYPE_AUTO && device) {
                 /* check if this device uses internal codec */
-                pa_device_manager_use_internal_codec(device, CONVERT_TO_DEVICE_DIRECTION(data->stream_type), DEVICE_ROLE_NORMAL, &use_internal_codec);
+                use_internal_codec = pa_device_manager_is_device_use_internal_codec(device, CONVERT_TO_DEVICE_DIRECTION(data->stream_type), DEVICE_ROLE_NORMAL);
 
                 if(use_internal_codec) {
                     /* set other device's state to deactivated */
@@ -817,7 +817,7 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
                         dm_device_subtype = pa_device_manager_get_device_subtype(device);
                         pa_log_debug("  -- manual_device, type[%-16s], subtype[%-5s], direction[0x%x]", dm_device_type, dm_device_subtype, device_direction);
                         if (IS_AVAILABLE_DIRECTION(data->stream_type, device_direction)) {
-                            pa_device_manager_use_internal_codec(device, CONVERT_TO_DEVICE_DIRECTION(data->stream_type), DEVICE_ROLE_NORMAL, &use_internal_codec);
+                            use_internal_codec = pa_device_manager_is_device_use_internal_codec(device, CONVERT_TO_DEVICE_DIRECTION(data->stream_type), DEVICE_ROLE_NORMAL);
                             if (use_internal_codec) {
                                 route_info.num_of_devices++;
                                 route_info.device_infos = pa_xrealloc(route_info.device_infos, sizeof(hal_device_info)*route_info.num_of_devices);
@@ -1146,7 +1146,7 @@ static pa_hook_result_t device_connection_changed_hook_cb(pa_core *c, pa_device_
         return PA_HOOK_OK;
     }
 
-    pa_device_manager_use_internal_codec(conn->device, device_direction, DEVICE_ROLE_NORMAL, &use_internal_codec);
+    use_internal_codec = pa_device_manager_is_device_use_internal_codec(conn->device, device_direction, DEVICE_ROLE_NORMAL);
     if (!use_internal_codec) {
         /* EXTERNAL AUDIO CODEC */
         if (!conn->is_connected && (device_direction & DM_DEVICE_DIRECTION_OUT)) {
@@ -1157,7 +1157,7 @@ static pa_hook_result_t device_connection_changed_hook_cb(pa_core *c, pa_device_
                     PA_IDXSET_FOREACH(device, conn_devices, idx) {
                         device_direction = pa_device_manager_get_device_direction(device);
                         if (device_direction == DM_DEVICE_DIRECTION_OUT) {
-                            pa_device_manager_use_internal_codec(device, device_direction, DEVICE_ROLE_NORMAL, &use_internal_codec);
+                            use_internal_codec = pa_device_manager_is_device_use_internal_codec(device, device_direction, DEVICE_ROLE_NORMAL);
                             if (use_internal_codec) {
                                 sink = pa_device_manager_get_sink(device, DEVICE_ROLE_NORMAL);
                                 break;

diff --git a/src/stream-manager.c b/src/stream-manager.c
index a3bc713e4deee225a81532c93f833942a8fb967d..5b27bdff688529765682535484d58d23dcb5684a 100644 (file)
--- a/src/stream-manager.c
+++ b/src/stream-manager.c
@@ -2518,7 +2518,7 @@ static pa_hook_result_t device_connection_changed_hook_cb(pa_core *c, pa_device_
 
     device_direction = pa_device_manager_get_device_direction(data->device);
     device_type = pa_device_manager_get_device_type(data->device);
-    pa_device_manager_use_internal_codec(data->device, device_direction, DEVICE_ROLE_NORMAL, &use_internal_codec);
+    use_internal_codec = pa_device_manager_is_device_use_internal_codec(data->device, device_direction, DEVICE_ROLE_NORMAL);
 
     pa_log_info("[SM] device_connection_changed_hook_cb is called. data(%p), is_connected(%d), device(%p, %s), direction(0x%x), use_internal_codec(%d)",
         data, data->is_connected, data->device, device_type, device_direction, use_internal_codec);