load/unload network device when access is changed and remote RAOP api flag

Change-Id: I93a28ca32af1e625a6b303170a8f6491252fa25f

diff --git a/src/device-manager-priv.h b/src/device-manager-priv.h
index faf4b1d6bca223fec0dfae898e588907fc14e4a0..5e17f2cfe376fef79b753656cdf22a9aedf28816 100644 (file)
--- a/src/device-manager-priv.h
+++ b/src/device-manager-priv.h
@@ -53,6 +53,8 @@ struct _device_manager {
     pa_hook_slot *comm_hook_device_connection_changed_slot;
     pa_hook_slot *comm_hook_device_state_changed_slot;
     pa_hook_slot *comm_hook_device_running_changed_slot;
+    pa_hook_slot *source_proplist_changed_slot;
+    pa_hook_slot *sink_proplist_changed_slot;
     pa_communicator *comm;
     pa_hal_interface *hal_interface;
 

diff --git a/src/device-manager.c b/src/device-manager.c
index eb8be9cec29e20341ea31f369e621597783fd9a0..d6fe91d445192bb1dcb099629ba078222cd60966 100644 (file)
--- a/src/device-manager.c
+++ b/src/device-manager.c
@@ -397,6 +397,15 @@ static bool pulse_device_is_raop(pa_object *pdevice) {
     return pa_safe_streq(pa_proplist_gets(prop, PA_PROP_DEVICE_API), DEVICE_API_RAOP);
 }
 
+static bool pulse_device_is_remote(pa_object *pdevice) {
+    pa_proplist *prop = pulse_device_get_proplist(pdevice);
+
+    if (!prop)
+        return false;
+
+    return pa_proplist_contains(prop, PA_PROP_MEDIA_REMOTE_NAME);
+}
+
 
 static bool pulse_device_is_tizenaudio(pa_object *pdevice) {
     if (!pdevice)
@@ -1140,8 +1149,12 @@ static const char* pulse_device_get_system_id(pa_object *pdevice) {
         return pa_proplist_gets(prop, "bluez.path");
     else if (pulse_device_is_raop(pdevice))
         return pa_proplist_gets(prop, PA_PROP_DEVICE_STRING);
+    else if (pulse_device_is_remote(pdevice))
+        return pa_proplist_gets(prop, PA_PROP_DEVICE_DESCRIPTION);
     else
-        return NULL;
+        pa_log_error("ERROR!!!!!!!!!!!!!!!!!!!!");
+
+    return NULL;
 }
 
 static pa_sink* _core_get_sink(pa_core *core, const char *device_string, const char *params) {
@@ -1602,6 +1615,18 @@ static pa_hook_result_t sink_unlink_hook_callback(pa_core *c, pa_sink *sink, pa_
     } else if (pulse_device_is_raop(PA_OBJECT(sink))) {
         handle_raop_pulse_device(PA_OBJECT(sink), false, dm);
         return PA_HOOK_OK;
+    } else if (pulse_device_is_remote(PA_OBJECT(sink))) {
+        if (pa_safe_streq(pa_proplist_gets(sink->proplist, PA_PROP_MEDIA_REMOTE_ACCESS), "allowed")) {
+            pa_log("[REMOTE] sink [ALLOWED] unlinked!! update to [DENIED] now!");
+            pa_proplist* p = pa_proplist_new();
+            pa_proplist_sets(p, PA_PROP_MEDIA_REMOTE_ACCESS, "denied");
+            pa_sink_update_proplist(sink, PA_UPDATE_REPLACE, p);
+            pa_proplist_free(p);
+            pa_log("[REMOTE] Done!!");
+        } else {
+            pa_log("[REMOTE] sink [DENIED] unlinked!! nothing to do");
+        }
+        return PA_HOOK_OK;
     } else if (pulse_device_is_acm(PA_OBJECT(sink))) {
         handle_acm_pulse_device(PA_OBJECT(sink), false, dm);
         return PA_HOOK_OK;
@@ -1633,7 +1658,7 @@ static pa_hook_result_t source_put_hook_callback(pa_core *c, pa_source *source,
         pulse_device_set_use_internal_codec(PA_OBJECT(source), false);
         handle_bt_pulse_device(PA_OBJECT(source), true, dm);
         return PA_HOOK_OK;
-    else if (pulse_device_is_raop(PA_OBJECT(source))) {
+       } else if (pulse_device_is_raop(PA_OBJECT(source))) {
         pulse_device_set_use_internal_codec(PA_OBJECT(source), false);
         handle_raop_pulse_device(PA_OBJECT(source), true, dm);
         return PA_HOOK_OK;
@@ -1664,6 +1689,21 @@ static pa_hook_result_t source_unlink_hook_callback(pa_core *c, pa_source *sourc
     } else if (pulse_device_is_bluez(PA_OBJECT(source))) {
         handle_bt_pulse_device(PA_OBJECT(source), false, dm);
         return PA_HOOK_OK;
+    } else if (pulse_device_is_raop(PA_OBJECT(source))) {
+        handle_raop_pulse_device(PA_OBJECT(source), false, dm);
+        return PA_HOOK_OK;
+    } else if (pulse_device_is_remote(PA_OBJECT(source))) {
+        if (pa_safe_streq(pa_proplist_gets(source->proplist, PA_PROP_MEDIA_REMOTE_ACCESS), "allowed")) {
+            pa_log("[REMOTE] source [ALLOWED] unlinked!! update to [DENIED] now!");
+            pa_proplist* p = pa_proplist_new();
+            pa_proplist_sets(p, PA_PROP_MEDIA_REMOTE_ACCESS, "denied");
+            pa_source_update_proplist(source, PA_UPDATE_REPLACE, p);
+            pa_proplist_free(p);
+            pa_log("[REMOTE] Done!!");
+        } else {
+            pa_log("[REMOTE] source [DENIED] unlinked!! nothing to do");
+        }
+        return PA_HOOK_OK;
     } else if (pulse_device_is_alsa(PA_OBJECT(source)) || pulse_device_is_tizenaudio(PA_OBJECT(source))) {
         handle_internal_pulse_device(PA_OBJECT(source), false, dm);
         return PA_HOOK_OK;
@@ -1702,6 +1742,32 @@ static pa_hook_result_t sink_source_state_changed_hook_cb(pa_core *c, pa_object
     return PA_HOOK_OK;
 }
 
+static pa_hook_result_t source_proplist_changed(pa_core *core, pa_source *source, pa_device_manager *dm) {
+    pa_core_assert_ref(core);
+    pa_source_assert_ref(source);
+
+    const char *remote_access = pa_proplist_gets(source->proplist, PA_PROP_MEDIA_REMOTE_ACCESS);
+    if (remote_access) {
+        /* FIXME : handle same value as before */
+        pulse_device_set_use_internal_codec(PA_OBJECT(source), false);
+        handle_raop_pulse_device(PA_OBJECT(source), pa_safe_streq(remote_access, "allowed"), dm);
+    }
+    return PA_HOOK_OK;
+}
+
+static pa_hook_result_t sink_proplist_changed(pa_core *core, pa_sink *sink, pa_device_manager *dm) {
+    pa_core_assert_ref(core);
+    pa_sink_assert_ref(sink);
+
+    const char *remote_access = pa_proplist_gets(sink->proplist, PA_PROP_MEDIA_REMOTE_ACCESS);
+    if (remote_access) {
+        /* FIXME : handle same value as before */
+        pulse_device_set_use_internal_codec(PA_OBJECT(sink), false);
+        handle_raop_pulse_device(PA_OBJECT(sink), pa_safe_streq(remote_access, "allowed"), dm);
+    }
+    return PA_HOOK_OK;
+}
+
 /*
     Build params for load sink or source, and load it.
 */
@@ -2791,6 +2857,9 @@ pa_device_manager* pa_device_manager_get(pa_core *c) {
     dm->comm_hook_device_running_changed_slot = pa_hook_connect(pa_communicator_hook(dm->comm, PA_COMMUNICATOR_HOOK_DEVICE_RUNNING_CHANGED),
         PA_HOOK_EARLY, (pa_hook_cb_t)device_running_changed_hook_cb, dm);
 
+    dm->source_proplist_changed_slot = pa_hook_connect(&dm->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], PA_HOOK_NORMAL, (pa_hook_cb_t) source_proplist_changed, dm);
+    dm->sink_proplist_changed_slot = pa_hook_connect(&dm->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], PA_HOOK_NORMAL, (pa_hook_cb_t) sink_proplist_changed, dm);
+
     dm->hal_interface = pa_hal_interface_get(dm->core);
 
     if (!(dm->type_infos = parse_device_type_infos())) {
@@ -2860,6 +2929,11 @@ void pa_device_manager_unref(pa_device_manager *dm) {
     if (dm->source_state_changed_slot)
         pa_hook_slot_free(dm->source_state_changed_slot);
 
+    if (dm->source_proplist_changed_slot)
+        pa_hook_slot_free(dm->source_proplist_changed_slot);
+    if (dm->sink_proplist_changed_slot)
+        pa_hook_slot_free(dm->sink_proplist_changed_slot);
+
     if (dm->hal_interface)
         pa_hal_interface_unref(dm->hal_interface);
 

diff --git a/src/module-tizenaudio-discover.c b/src/module-tizenaudio-discover.c
index 4c1ba3ffe1ff9875b04e0fe9e49c1995902b9031..d422d6f24fdd717de95482b72e4f1043530b2816 100644 (file)
--- a/src/module-tizenaudio-discover.c
+++ b/src/module-tizenaudio-discover.c
@@ -315,7 +315,7 @@ static void tunnel_add(service_data_t *data) {
     data->ss = data->u->core->default_sample_spec;
     data->cm = data->u->core->default_channel_map;
 
-    properties = pa_sprintf_malloc("%s=raop", PA_PROP_DEVICE_API);
+    //properties = pa_sprintf_malloc("%s=raop", PA_PROP_DEVICE_API);
 
     if (!data->channel_map_set && data->cm.channels != data->ss.channels)
         pa_channel_map_init_extend(&data->cm, data->ss.channels, PA_CHANNEL_MAP_DEFAULT);

diff --git a/src/stream-manager-dbus.c b/src/stream-manager-dbus.c
index 4ac31a896212f12fb2e09f822d38320145b473e2..dceb50aff48ac10376823574144e75379cb63b48 100644 (file)
--- a/src/stream-manager-dbus.c
+++ b/src/stream-manager-dbus.c
@@ -2370,7 +2370,7 @@ static void handle_update_proplist(DBusConnection *conn, DBusMessage *msg, void
             goto out;
         }
         pa_sink_input_update_proplist(i, PA_UPDATE_REPLACE, p);
-
+        pa_sink_input_send_event(i, PA_STREAM_EVENT_UPDATE_MEDIA_REMOTE_ACCESS, p);
     } else if (pa_streq(type, "source-output")) {
         pa_source_output *o;
 

diff --git a/src/stream-manager-priv.h b/src/stream-manager-priv.h
index 19baf49e6064e8ef331719a47ed6a5ab3b0c8c73..79a30b78f77df6221573145880208301cbbcba96 100644 (file)
--- a/src/stream-manager-priv.h
+++ b/src/stream-manager-priv.h
@@ -268,8 +268,7 @@ struct _stream_manager {
         *remote_source_output_unlink_slot,
         *source_output_state_changed_slot,
         *source_output_move_start_slot,
-        *source_output_move_finish_slot,
-        *source_proplist_changed_slot;
+        *source_output_move_finish_slot;
 
 #ifdef HAVE_DBUS
 #ifdef USE_DBUS_PROTOCOL

diff --git a/src/stream-manager-restriction-priv.h b/src/stream-manager-restriction-priv.h
index b5e8b0746876383fc9e755d1b6ae138e6e1556a7..7ef4ee6a987eb53f20ce6bc695a3d1858ec3b56e 100644 (file)
--- a/src/stream-manager-restriction-priv.h
+++ b/src/stream-manager-restriction-priv.h
@@ -29,5 +29,6 @@
 
 int32_t handle_restrictions(pa_stream_manager *m, const char *name, uint32_t value);
 bool is_restricted(pa_stream_manager *m, void *stream, stream_type_t stream_type);
+bool is_remote_restricted(void *stream, stream_type_t type);
 
 #endif

diff --git a/src/stream-manager-restriction.c b/src/stream-manager-restriction.c
index 75f3c29ef29bd39a8ea55c373588832dc9f70618..000f3a7c1dedaf3d5b48111cb9e3565e24add47e 100644 (file)
--- a/src/stream-manager-restriction.c
+++ b/src/stream-manager-restriction.c
@@ -59,10 +59,28 @@ int32_t handle_restrictions(pa_stream_manager *m, const char *name, uint32_t val
     return 0;
 }
 
+bool is_remote_restricted(void *stream, stream_type_t type) {
+    pa_proplist* p = NULL;
+    if (type == STREAM_SOURCE_OUTPUT)
+        p = ((pa_source_output_new_data *)stream)->source->proplist;
+    else
+        p = ((pa_sink_input_new_data *)stream)->sink->proplist;
+
+    if (pa_proplist_contains(p, PA_PROP_MEDIA_REMOTE_ACCESS)) {
+        if (pa_safe_streq(pa_proplist_gets(p, PA_PROP_MEDIA_REMOTE_ACCESS), "denied")) {
+            pa_log("[REMOTE] media remote access is currently denied for this stream %p!!!", stream);
+            return true;
+        }
+        pa_log("[REMOTE] stream %p is currently allowed.", stream);
+    } else {
+        pa_log("[REMOTE] stream %p is not for remote.", stream);
+    }
+    return false;
+}
+
+
 bool is_restricted(pa_stream_manager *m, void *stream, stream_type_t type) {
     const char *role;
-    pa_source_output_new_data *data = (pa_source_output_new_data *)stream;
-    const char *media_remote_access = NULL;
 
     pa_assert(m);
 
@@ -75,23 +93,5 @@ bool is_restricted(pa_stream_manager *m, void *stream, stream_type_t type) {
         }
     }
 
-    /* ToDo : temporal test code */
-    pa_log("[REMOTE] driver = %s", data->driver);
-    pa_log("[REMOTE] source = %p, name = %s, driver = %s",
-            data->source,
-            data->source? data->source->name : "null",
-            data->source->driver);
-    pa_log("[REMOTE] dest source = %p, name = %s", data->destination_source, data->destination_source ? data->destination_source->name : "null");
-
-    if (pa_safe_streq(data->source->driver, "module-tunnel-source-new.c")) {
-        media_remote_access = pa_proplist_gets(data->source->proplist, PA_PROP_MEDIA_REMOTE_ACCESS);
-        pa_log("[REMOTE] %s = %s", PA_PROP_MEDIA_REMOTE_ACCESS, pa_strnull(media_remote_access));
-        if (pa_safe_streq(media_remote_access, "denied")) {
-            pa_log("[REMOTE] media remote access is currently denied!!!");
-            return true;
-        }
-    }
-    /* END */
-
     return false;
 }

diff --git a/src/stream-manager.c b/src/stream-manager.c
index fce3b8d4df8b26b9118e4567c4a48922d57eeff0..650e5fd2aa199dd24fd56a0779dc8e517cad0043 100644 (file)
--- a/src/stream-manager.c
+++ b/src/stream-manager.c
@@ -2480,6 +2480,8 @@ static pa_hook_result_t sink_input_new_cb(pa_core *core, pa_sink_input_new_data
     pa_log_debug("sink-input-new-data(%p)", new_data);
 
     process_stream(m, new_data, STREAM_SINK_INPUT, PROCESS_COMMAND_PREPARE, true);
+    if (is_remote_restricted(new_data, STREAM_SINK_INPUT))
+        return PA_HOOK_CANCEL;
     process_stream(m, new_data, STREAM_SINK_INPUT, PROCESS_COMMAND_UPDATE_BUFFER_ATTR, true);
     process_stream(m, new_data, STREAM_SINK_INPUT, PROCESS_COMMAND_UPDATE_VOLUME, true);
     process_stream(m, new_data, STREAM_SINK_INPUT, PROCESS_COMMAND_CHANGE_ROUTE_BY_STREAM_STARTED, true);
@@ -2635,7 +2637,8 @@ static pa_hook_result_t source_output_new_cb(pa_core *core, pa_source_output_new
     pa_log_debug("source-output-new-data(%p)", new_data);
 
     process_stream(m, new_data, STREAM_SOURCE_OUTPUT, PROCESS_COMMAND_PREPARE, true);
-    if (is_restricted(m, new_data, STREAM_SOURCE_OUTPUT))
+    if (is_restricted(m, new_data, STREAM_SOURCE_OUTPUT) ||
+        is_remote_restricted(new_data, STREAM_SOURCE_OUTPUT))
         return PA_HOOK_CANCEL;
     process_stream(m, new_data, STREAM_SOURCE_OUTPUT, PROCESS_COMMAND_UPDATE_BUFFER_ATTR, true);
     process_stream(m, new_data, STREAM_SOURCE_OUTPUT, PROCESS_COMMAND_UPDATE_VOLUME, true);
@@ -2702,7 +2705,7 @@ static pa_hook_result_t remote_source_output_unlink_cb(pa_core *core, pa_source_
         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);
-        broadcast_connected_remote_device(pa_dbus_connection_get(m->dbus_conn), false, 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;
@@ -2758,19 +2761,6 @@ static pa_hook_result_t source_output_move_finish_cb(pa_core *core, pa_source_ou
     return PA_HOOK_OK;
 }
 
-static pa_hook_result_t source_proplist_changed(pa_core *core, pa_source *o, pa_stream_manager *m) {
-    pa_core_assert_ref(core);
-    pa_source_assert_ref(o);
-
-    const char *perm = pa_proplist_gets(o->proplist, PA_PROP_MEDIA_REMOTE_ACCESS);
-    if (perm)
-        broadcast_changed_remote_access(pa_dbus_connection_get(m->dbus_conn), o->index, perm);
-
-    pa_log_error("jcsing test");
-
-    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;
@@ -3776,8 +3766,6 @@ pa_stream_manager* pa_stream_manager_get(pa_core *c) {
     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->source_proplist_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], PA_HOOK_EARLY, (pa_hook_cb_t) source_proplist_changed, 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);