reorganize code related to remote devices

Change-Id: I6c778434927f08deab51e1edf486bde856b702c1
Signed-off-by: Jaechul Lee <jcsing.lee@samsung.com>

diff --git a/src/stream-manager-dbus-priv.h b/src/stream-manager-dbus-priv.h
index 7054d77b039c4059e1ad8b15de71fadcc56605e4..32052e193899a3ac772fbbb7e4f69649ea11a6bd 100644 (file)
--- a/src/stream-manager-dbus-priv.h
+++ b/src/stream-manager-dbus-priv.h
@@ -61,8 +61,8 @@
 #define STREAM_MANAGER_SIGNAL_NAME_VOLUME_CHANGED                    "VolumeChanged"
 #define STREAM_MANAGER_SIGNAL_NAME_DUCKING_STATE_CHANGED             "DuckingStateChanged"
 #define STREAM_MANAGER_SIGNAL_NAME_COMMAND                           "Command"
-#define STREAM_MANAGER_SIGNAL_NAME_FOUND_REMOTE                      "FoundRemote"
-#define STREAM_MANAGER_SIGNAL_NAME_REMOTE_ACCESS                     "RemoteAccess"
+#define STREAM_MANAGER_SIGNAL_NAME_REMOTE_FOUND                      "RemoteFound"
+#define STREAM_MANAGER_SIGNAL_NAME_REMOTE_ACCESS                     "RemoteAccess"//TODO:?
 
 enum method_handler_index {
     METHOD_HANDLER_GET_STREAM_INFO,

diff --git a/src/stream-manager-dbus.c b/src/stream-manager-dbus.c
index 7f52a7c40c2be323a8a62c88dc927a74e25afe95..03cfe767eac1f8c44d3f1c58a28862502c7c5949 100644 (file)
--- a/src/stream-manager-dbus.c
+++ b/src/stream-manager-dbus.c
@@ -2659,43 +2659,39 @@ void send_command_signal(DBusConnection *conn, const char *name, int value) {
     dbus_message_unref(signal_msg);
 }
 
-void broadcast_connected_remote_device(DBusConnection *conn, bool connected, unsigned int index,
-                                                      const char *remote_name, const char *peer_info) {
+void broadcast_connected_remote_device(DBusConnection *conn, int type, bool connected, unsigned int index,
+                                                      const char *name, const char *description) {
     DBusMessage *signal_msg;
     DBusMessageIter msg_iter;
     dbus_bool_t c = (dbus_bool_t)connected;
-    uint32_t type = 1; // TODO: 0:sink-input, 1:source-output
 
     pa_assert(conn);
 
-    pa_log_error("broadcast");
-
-    if (!remote_name || !peer_info) {
+    if (!name || !description) {
         pa_log_error("Unknown device");
         return;
     }
 
-    pa_log_info("type[%d], index[%d], connected[%d], remote_name[%s] peer_info[%s]", type, index, connected, remote_name, peer_info);
+    pa_log_info("type[%d], index[%d], connected[%d], name[%s] description[%s]", type, index, connected, name, description);
 
-    pa_assert_se((signal_msg = dbus_message_new_signal(STREAM_MANAGER_OBJECT_PATH, STREAM_MANAGER_INTERFACE, STREAM_MANAGER_SIGNAL_NAME_FOUND_REMOTE)));
+    pa_assert_se((signal_msg = dbus_message_new_signal(STREAM_MANAGER_OBJECT_PATH, STREAM_MANAGER_INTERFACE, STREAM_MANAGER_SIGNAL_NAME_REMOTE_FOUND)));
     dbus_message_iter_init_append(signal_msg, &msg_iter);
 
     dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_INT32, &type);
     dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_UINT32, &index);
     dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_BOOLEAN, &c);
-    dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, &remote_name);
-    dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, &peer_info);
+    dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, &name);
+    dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, &description);
 
     pa_assert_se(dbus_connection_send(conn, signal_msg, NULL));
     dbus_message_unref(signal_msg);
 }
 
+/* TODO: */
 void broadcast_changed_remote_access(DBusConnection *conn, unsigned int index, const char *perm) {
     DBusMessage *signal_msg;
     DBusMessageIter msg_iter;
 
-    pa_log_error("test remote access");
-
     if (!perm) {
         pa_log_error("unknown permision");
         return;

diff --git a/src/stream-manager-priv.h b/src/stream-manager-priv.h
index 79a30b78f77df6221573145880208301cbbcba96..28075b246b44bdb5a5a0ed42e195b66e43ca2b35 100644 (file)
--- a/src/stream-manager-priv.h
+++ b/src/stream-manager-priv.h
@@ -263,12 +263,15 @@ struct _stream_manager {
         *sink_input_ramp_finish_slot,
         *source_output_new_slot,
         *source_output_put_slot,
-        *remote_source_output_put_slot,
         *source_output_unlink_slot,
-        *remote_source_output_unlink_slot,
         *source_output_state_changed_slot,
         *source_output_move_start_slot,
-        *source_output_move_finish_slot;
+        *source_output_move_finish_slot,
+
+        *remote_sink_input_put_slot,
+        *remote_sink_input_unlink_slot,
+        *remote_source_output_unlink_slot,
+        *remote_source_output_put_slot;
 
 #ifdef HAVE_DBUS
 #ifdef USE_DBUS_PROTOCOL

diff --git a/src/stream-manager.c b/src/stream-manager.c
index 650e5fd2aa199dd24fd56a0779dc8e517cad0043..b578894faefdfa15ff1b964876836015e8b52d6e 100644 (file)
--- a/src/stream-manager.c
+++ b/src/stream-manager.c
@@ -2664,25 +2664,8 @@ static pa_hook_result_t source_output_put_cb(pa_core *core, pa_source_output *o,
     return PA_HOOK_OK;
 }
 
-static pa_hook_result_t remote_source_output_put_cb(pa_core *core, pa_source_output *o, pa_stream_manager *m) {
+static pa_hook_result_t source_output_unlink_cb(pa_core *core, pa_object *o, pa_stream_manager *m) {
     pa_core_assert_ref(core);
-    pa_source_output_assert_ref(o);
-
-    pa_log_info("source-output(%p, index:%u)", o, o->index);
-
-    if (pa_proplist_contains(o->proplist, PA_PROP_MEDIA_REMOTE_NAME)) {
-        const char *remote_name = pa_proplist_gets(o->proplist, PA_PROP_MEDIA_REMOTE_NAME);
-        const char *peer_info = pa_proplist_gets(o->proplist, "native-protocol.peer");
-        pa_log_info("jcsing remote connected. %d %s %s", o->index, remote_name, peer_info);
-        broadcast_connected_remote_device(pa_dbus_connection_get(m->dbus_conn), true, o->index, remote_name, peer_info);
-    }
-}
-
-static pa_hook_result_t source_output_unlink_cb(pa_core *core, pa_source_output *o, pa_stream_manager *m) {
-    pa_core_assert_ref(core);
-    pa_source_output_assert_ref(o);
-
-    pa_log_info("source-output(%p, index:%u)", o, o->index);
 
     if (is_stream_related_call_active_routing(PA_OBJECT(o))) {
         m->on_call = false;
@@ -2695,22 +2678,6 @@ static pa_hook_result_t source_output_unlink_cb(pa_core *core, pa_source_output
     return PA_HOOK_OK;
 }
 
-static pa_hook_result_t remote_source_output_unlink_cb(pa_core *core, pa_source_output *o, pa_stream_manager *m) {
-    pa_core_assert_ref(core);
-    pa_source_output_assert_ref(o);
-
-    pa_log_info("source-output(%p, index:%u)", o, o->index);
-
-    if (pa_proplist_contains(o->proplist, PA_PROP_MEDIA_REMOTE_NAME)) {
-        const char *remote_name = pa_proplist_gets(o->proplist, PA_PROP_MEDIA_REMOTE_NAME);
-        const char *peer_info = pa_proplist_gets(o->proplist, "native-protocol.peer");
-        pa_log_info("jcsing remote disconnected %d %s %s", o->index, remote_name, peer_info);
-        (void)broadcast_connected_remote_device(pa_dbus_connection_get(m->dbus_conn), false, o->index, remote_name, peer_info);
-    }
-
-    return PA_HOOK_OK;
-}
-
 static pa_hook_result_t source_output_state_changed_cb(pa_core *core, pa_source_output *o, pa_stream_manager *m) {
     pa_assert(o);
     pa_assert(m);
@@ -2761,6 +2728,54 @@ static pa_hook_result_t source_output_move_finish_cb(pa_core *core, pa_source_ou
     return PA_HOOK_OK;
 }
 
+static void remote_client_callback(pa_core *core, pa_object *obj, pa_stream_manager *m, bool connected) {
+    pa_proplist *p;
+    pa_sink_input *i;
+    pa_source_output *o;
+    unsigned int index;
+
+    if (pa_source_output_isinstance(obj)) {
+        o = PA_SOURCE_OUTPUT(obj);
+        p = o->proplist;
+        index = o->index;
+    } else {
+        i = PA_SINK_INPUT(obj);
+        p = i->proplist;
+        index = i->index;
+    }
+
+    if (!p) {
+        pa_log_error("unknown remote client");
+        return;
+    }
+
+    if (pa_proplist_contains(p, PA_PROP_MEDIA_REMOTE_NAME)) {
+        const char *name = pa_proplist_gets(p, PA_PROP_MEDIA_REMOTE_NAME);
+        const char *description = pa_proplist_gets(p, PA_PROP_MEDIA_REMOTE_DESCRIPTION);
+
+        (void)broadcast_connected_remote_device(pa_dbus_connection_get(m->dbus_conn),
+                pa_source_output_isinstance(obj) ? 1 : 0, connected, index, name, description);
+    }
+}
+
+static pa_hook_result_t remote_client_put_cb(pa_core *core, pa_object *o, pa_stream_manager *m) {
+    pa_core_assert_ref(core);
+    pa_object_assert_ref(o);
+
+    remote_client_callback(core, o, m, true);
+
+    return PA_HOOK_OK;
+}
+
+static pa_hook_result_t remote_client_unlink_cb(pa_core *core, pa_object *o, pa_stream_manager *m) {
+    pa_core_assert_ref(core);
+    pa_object_assert_ref(o);
+
+    remote_client_callback(core, o, m, false);
+
+    return PA_HOOK_OK;
+}
+
 static void find_next_device_for_auto_route(pa_stream_manager *m, stream_route_type_t route_type, const char *stream_role,
                                         stream_type_t stream_type, const char *cur_device_type, const char *preferred_device_role, pa_tz_device **next_device) {
     stream_info *si = NULL;
@@ -3759,13 +3774,16 @@ pa_stream_manager* pa_stream_manager_get(pa_core *c) {
     m->sink_input_ramp_finish_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_RAMP_FINISH], PA_HOOK_EARLY, (pa_hook_cb_t) sink_input_ramp_finish_cb, m);
     m->source_output_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_NEW], PA_HOOK_EARLY, (pa_hook_cb_t) source_output_new_cb, m);
     m->source_output_put_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_PUT], PA_HOOK_EARLY, (pa_hook_cb_t) source_output_put_cb, m);
-    m->remote_source_output_put_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_PUT], PA_HOOK_NORMAL, (pa_hook_cb_t) remote_source_output_put_cb, m);
     m->source_output_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_UNLINK], PA_HOOK_EARLY, (pa_hook_cb_t) source_output_unlink_cb, m);
-    m->remote_source_output_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_UNLINK], PA_HOOK_NORMAL, (pa_hook_cb_t) remote_source_output_unlink_cb, m);
     m->source_output_state_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_STATE_CHANGED], PA_HOOK_EARLY, (pa_hook_cb_t) source_output_state_changed_cb, m);
     m->source_output_move_start_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_START], PA_HOOK_EARLY, (pa_hook_cb_t) source_output_move_start_cb, m);
     m->source_output_move_finish_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_FINISH], PA_HOOK_EARLY, (pa_hook_cb_t) source_output_move_finish_cb, m);
 
+    m->remote_sink_input_put_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], PA_HOOK_EARLY, (pa_hook_cb_t) remote_client_put_cb, m);
+    m->remote_sink_input_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], PA_HOOK_EARLY, (pa_hook_cb_t) remote_client_unlink_cb, m);
+    m->remote_source_output_put_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_PUT], PA_HOOK_NORMAL, (pa_hook_cb_t) remote_client_put_cb, m);
+    m->remote_source_output_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_UNLINK], PA_HOOK_NORMAL, (pa_hook_cb_t) remote_client_unlink_cb, m);
+
     m->subscription = pa_subscription_new(m->core, PA_SUBSCRIPTION_MASK_CLIENT | PA_SUBSCRIPTION_MASK_SAMPLE_CACHE, (pa_subscription_cb_t)subscribe_cb, m);
 
     m->comm.comm = pa_communicator_get(c);