diff --git a/src/classic/a2dp_source.c b/src/classic/a2dp_source.c
index 021948756..053683962 100644
--- a/src/classic/a2dp_source.c
+++ b/src/classic/a2dp_source.c
@@ -282,7 +282,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
                 a2dp_signaling_emit_connection_established(a2dp_source_context.a2dp_callback, cid, sc.remote_addr, status);
                 break;
             }
-            log_info("A2DP singnaling connection established avdtp_cid 0x%02x", a2dp_source_context.avdtp_cid);
+            log_info("A2DP singnaling connection established avdtp_cid 0x%02x", cid);
 
             sc.avdtp_cid = cid;
             sc.active_remote_sep = NULL;
diff --git a/src/classic/avdtp.c b/src/classic/avdtp.c
index d5341d84c..cdbd66b05 100644
--- a/src/classic/avdtp.c
+++ b/src/classic/avdtp.c
@@ -55,7 +55,11 @@
 
 avdtp_context_t * avdtp_source_context = NULL;
 avdtp_context_t * avdtp_sink_context = NULL;
-static avdtp_context_t * sdp_query_context = NULL;
+
+static btstack_packet_handler_t avdtp_source_callback;
+static btstack_packet_handler_t avdtp_sink_callback;
+
+// static avdtp_context_t * sdp_query_context = NULL;
 static uint16_t sdp_query_context_avdtp_cid = 0;
 
 static btstack_linked_list_t connections;
@@ -251,8 +255,7 @@ static uint8_t avdtp_start_sdp_query(btstack_packet_handler_t packet_handler, av
     return sdp_client_query_uuid16(packet_handler, (uint8_t *) connection->remote_addr, BLUETOOTH_PROTOCOL_AVDTP);
 }
 
-uint8_t avdtp_connect(bd_addr_t remote, avdtp_role_t role, avdtp_context_t * avdtp_context, uint16_t * avdtp_cid){
-    btstack_assert(avdtp_context != NULL);
+uint8_t avdtp_connect(bd_addr_t remote, avdtp_role_t role, uint16_t * avdtp_cid){
     // TODO: implement delayed SDP query
     if (sdp_client_ready() == 0){
         return ERROR_CODE_COMMAND_DISALLOWED;
@@ -283,11 +286,20 @@ uint8_t avdtp_connect(bd_addr_t remote, avdtp_role_t role, avdtp_context_t * avd
         default:
             return ERROR_CODE_COMMAND_DISALLOWED;
     }
-    
-    sdp_query_context = avdtp_context;
     return avdtp_start_sdp_query(&avdtp_handle_sdp_client_query_result, connection);
 }
 
+
+void avdtp_register_sink_packet_handler(btstack_packet_handler_t callback){
+    btstack_assert(callback != NULL);
+    avdtp_sink_callback = callback;
+}
+
+void avdtp_register_source_packet_handler(btstack_packet_handler_t callback){
+    btstack_assert(callback != NULL);
+    avdtp_source_callback = callback;
+}
+
 void avdtp_register_media_transport_category(avdtp_stream_endpoint_t * stream_endpoint){
     if (!stream_endpoint){
         log_error("Stream endpoint with given seid is not registered.");
@@ -539,15 +551,24 @@ static void avdtp_finalize_connection(avdtp_connection_t * connection){
 }
 
 static void avdtp_handle_sdp_query_failed(avdtp_connection_t * connection, uint8_t status){
-    if (connection == NULL) return;
-    avdtp_signaling_emit_connection_established(sdp_query_context->avdtp_callback, connection->avdtp_cid, connection->remote_addr, status);
+    printf("avdtp_handle_sdp_query_failed \n");
+    switch (connection->state){
+        case AVDTP_SIGNALING_W4_SDP_QUERY_FOR_REMOTE_SINK_COMPLETE:
+            avdtp_signaling_emit_connection_established(avdtp_source_callback, connection->avdtp_cid, connection->remote_addr, status);
+            break;
+        case AVDTP_SIGNALING_W4_SDP_QUERY_FOR_REMOTE_SOURCE_COMPLETE:
+            avdtp_signaling_emit_connection_established(avdtp_sink_callback, connection->avdtp_cid, connection->remote_addr, status);
+            break;
+        default:
+            return;
+    }
     avdtp_finalize_connection(connection);
     sdp_query_context_avdtp_cid = 0;
     log_info("SDP query failed with status 0x%02x.", status);
 }
 
 static void avdtp_handle_sdp_query_succeeded(avdtp_connection_t * connection){
-    if (connection == NULL) return;
+    printf("avdtp_handle_sdp_query_succeeded \n");
     connection->state = AVDTP_SIGNALING_CONNECTION_W4_L2CAP_CONNECTED;
 }
 
@@ -772,7 +793,7 @@ void avdtp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet
                     break;
                     
                 case L2CAP_EVENT_CHANNEL_OPENED:
-                    btstack_assert(context == NULL);
+                    btstack_assert(context != NULL);
 
                     psm = l2cap_event_channel_opened_get_psm(packet); 
                     if (psm != BLUETOOTH_PSM_AVDTP){
diff --git a/src/classic/avdtp.h b/src/classic/avdtp.h
index 11ed4421a..6dd3ec1d1 100644
--- a/src/classic/avdtp.h
+++ b/src/classic/avdtp.h
@@ -579,8 +579,11 @@ void avdtp_handle_can_send_now(avdtp_connection_t * connection, uint16_t l2cap_c
 void avdtp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
 avdtp_stream_endpoint_t * avdtp_create_stream_endpoint(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type, avdtp_context_t * context);
 
-uint8_t avdtp_connect(bd_addr_t remote, avdtp_role_t role, avdtp_context_t * context, uint16_t * avdtp_cid);
+uint8_t avdtp_connect(bd_addr_t remote, avdtp_role_t role, uint16_t * avdtp_cid);
 uint8_t avdtp_disconnect(uint16_t avdtp_cid, avdtp_context_t * context);
+void    avdtp_register_sink_packet_handler(btstack_packet_handler_t callback);
+void    avdtp_register_source_packet_handler(btstack_packet_handler_t callback);
+
 uint8_t avdtp_open_stream(uint16_t avdtp_cid, uint8_t local_seid, uint8_t remote_seid, avdtp_context_t * context);
 uint8_t avdtp_start_stream(uint16_t avdtp_cid, uint8_t local_seid, avdtp_context_t * context);
 uint8_t avdtp_stop_stream (uint16_t avdtp_cid, uint8_t local_seid, avdtp_context_t * context);
diff --git a/src/classic/avdtp_sink.c b/src/classic/avdtp_sink.c
index bb7f4a045..b8283bf42 100644
--- a/src/classic/avdtp_sink.c
+++ b/src/classic/avdtp_sink.c
@@ -91,21 +91,18 @@ void avdtp_sink_register_multiplexing_category(uint8_t seid, uint8_t fragmentati
     avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(seid, avdtp_sink_context);
     avdtp_register_multiplexing_category(stream_endpoint, fragmentation);
 }
-
-// // media, reporting. recovery
-// void avdtp_sink_register_media_transport_identifier_for_multiplexing_category(uint8_t seid, uint8_t fragmentation){
-
-// }
-
-
 /* END: tracking can send now requests pro l2cap cid */
-// TODO remove
+
+void avdtp_sink_register_packet_handler(btstack_packet_handler_t callback){
+    btstack_assert(callback != NULL);
+
+    avdtp_sink_context->avdtp_callback = callback;
+    avdtp_register_sink_packet_handler(callback);
+}
 
 void avdtp_sink_init(avdtp_context_t * avdtp_context){
-    if (!avdtp_context){
-        log_error("avdtp_source_context is NULL");
-        return;
-    }
+    btstack_assert(avdtp_context != NULL);
+
     avdtp_sink_context = avdtp_context;
     avdtp_sink_context->stream_endpoints = NULL;
     avdtp_sink_context->stream_endpoints_id_counter = 0;
@@ -118,23 +115,13 @@ avdtp_stream_endpoint_t * avdtp_sink_create_stream_endpoint(avdtp_sep_type_t sep
 }
 
 void avdtp_sink_register_media_handler(void (*callback)(uint8_t local_seid, uint8_t *packet, uint16_t size)){
-    if (callback == NULL){
-        log_error("avdtp_sink_register_media_handler called with NULL callback");
-        return;
-    }
+    btstack_assert(callback != NULL);
+
     avdtp_sink_context->handle_media_data = callback;
 }
 
-void avdtp_sink_register_packet_handler(btstack_packet_handler_t callback){
-    if (callback == NULL){
-        log_error("avdtp_sink_register_packet_handler called with NULL callback");
-        return;
-    }
-    avdtp_sink_context->avdtp_callback = callback;
-}
-
 uint8_t avdtp_sink_connect(bd_addr_t remote, uint16_t * avdtp_cid){
-    return avdtp_connect(remote, AVDTP_ROLE_SINK, avdtp_sink_context, avdtp_cid);
+    return avdtp_connect(remote, AVDTP_ROLE_SINK, avdtp_cid);
 }
 
 uint8_t avdtp_sink_disconnect(uint16_t avdtp_cid){
diff --git a/src/classic/avdtp_source.c b/src/classic/avdtp_source.c
index 5c048d885..4aa30c552 100644
--- a/src/classic/avdtp_source.c
+++ b/src/classic/avdtp_source.c
@@ -99,7 +99,7 @@ avdtp_stream_endpoint_t * avdtp_source_create_stream_endpoint(avdtp_sep_type_t s
 }
 
 uint8_t avdtp_source_connect(bd_addr_t remote, uint16_t * avdtp_cid){
-    return avdtp_connect(remote, AVDTP_ROLE_SOURCE, avdtp_source_context, avdtp_cid);
+    return avdtp_connect(remote, AVDTP_ROLE_SOURCE, avdtp_cid);
 }
 
 uint8_t avdtp_source_disconnect(uint16_t avdtp_cid){
@@ -151,18 +151,15 @@ uint8_t avdtp_source_reconfigure(uint16_t avdtp_cid, uint8_t local_seid, uint8_t
 }
 
 void avdtp_source_register_packet_handler(btstack_packet_handler_t callback){
-    if (callback == NULL){
-        log_error("avdtp_source_register_packet_handler called with NULL callback");
-        return;
-    }
+    btstack_assert(callback != NULL);
+    
     avdtp_source_context->avdtp_callback = callback;
+    avdtp_register_source_packet_handler(callback);
 }
 
 void avdtp_source_init(avdtp_context_t * avdtp_context){
-    if (!avdtp_context){
-        log_error("avdtp_source_context is NULL");
-        return;
-    }
+    btstack_assert(avdtp_context != NULL);
+
     avdtp_source_context = avdtp_context;
     avdtp_source_context->stream_endpoints = NULL;
     avdtp_source_context->stream_endpoints_id_counter = 0;