[1.0.23] Refactor callback usage using factory dependancy injection

Change-Id: I5ddaa495e3b37f8a9676cad1424158bd7cd6dca5

diff --git a/include/MediaSourceBinMediaPacket.h b/include/MediaSourceBinMediaPacket.h
index ac1cbd5..def031a 100644 (file)
--- a/include/MediaSourceBinMediaPacket.h
+++ b/include/MediaSourceBinMediaPacket.h
@@ -53,14 +53,14 @@ public:
        MediaSourceBinInfo generate() override;
        void setMediaFormat(media_format_h format);
        void pushMediaPacket(media_packet_h packet);
-       void setBufferStateChangedCallback(void* handle, mtprPacketSourceBufferStateCallback callback, void* userData);
+       void setBufferStateChangedCallback(InvokablePtr callback);
        void unsetBufferStateChangedCallback();
 
 protected:
        static void _needDataCallback(GstElement* object, guint size, gpointer data);
        static void _enoughDataCallback(GstElement* object, gpointer data);
 
-       std::unique_ptr<IInvokable> _bufferStateCallback;
+       InvokablePtr _bufferStateCallback;
 
 private:
        void _createMediaPacketSource();

diff --git a/include/MediaTransporterBase.h b/include/MediaTransporterBase.h
index 77a2669..65dd9c9 100644 (file)
--- a/include/MediaTransporterBase.h
+++ b/include/MediaTransporterBase.h
@@ -55,7 +55,7 @@ public:
 
        mtprState state();
 
-       void setErrorCallback(void* handle, mtprErrorCallback callback, void* userData);
+       void setErrorCallback(InvokablePtr callback);
        void unsetErrorCallback();
 
        virtual void setSenderAddress(std::string address);
@@ -69,15 +69,14 @@ public:
        virtual void setConnection(std::string name, std::string value);
        virtual std::string getConnection(std::string name);
 
-       virtual void foreachConnectionStats(void* handle, mtprConnectionStatsCallback callback, void* userData);
+       virtual void foreachConnectionStats(InvokablePtr callback);
 
        void setResourceManager(std::shared_ptr<MediaTransporterResource> resourceManager);
        void changed() override; // resource interrupted
 
 protected:
        mtprGstreamer _gst {};
-       std::unique_ptr<IInvokable> _errorCallback;
-       std::unique_ptr<IInvokable> _connectionStatsCallback;
+       InvokablePtr _errorCallback;
        std::shared_ptr<MediaTransporterResource> _resourceManager;
 
 private:

diff --git a/include/MediaTransporterCallback.h b/include/MediaTransporterCallback.h
index 9064377..3eab595 100644 (file)
--- a/include/MediaTransporterCallback.h
+++ b/include/MediaTransporterCallback.h
@@ -62,6 +62,18 @@ protected:
        void* _userdata;
 };
 
+using InvokablePtr = std::unique_ptr<IInvokable>;
+
+struct CallbackFactory
+{
+       static InvokablePtr createTrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata);
+       static InvokablePtr createNoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback cb, void* userdata);
+       static InvokablePtr createPacketCallback(void* handle, mtprMediaType type, mtprPacketCallback cb, void* userdata);
+       static InvokablePtr createErrorCallback(void* handle, mtprErrorCallback cb, void* userdata);
+       static InvokablePtr createPacketSourceBufferStateCallback(void* handle, mtprPacketSourceBufferStateCallback cb, void* userdata);
+       static InvokablePtr createConnectionStatsCallback(void* handle, mtprConnectionStatsCallback cb, void* userdata);
+};
+
 class TrackAddedCallback : public AbstractCallback
 {
 public:

diff --git a/include/MediaTransporterReceiver.h b/include/MediaTransporterReceiver.h
index d74e797..a50fc4d 100644 (file)
--- a/include/MediaTransporterReceiver.h
+++ b/include/MediaTransporterReceiver.h
@@ -42,16 +42,16 @@ public:
        MediaTransporterReceiver() = default;
        virtual ~MediaTransporterReceiver() = default;
 
-       void setTrackAddedCallback(void* handle, mtprTrackAddedCallback callback, void* userData);
+       void setTrackAddedCallback(InvokablePtr callback);
        void unsetTrackAddedCallback();
 
-       void setNoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback callback, void* userData);
+       void setNoMoreTrackCallback(InvokablePtr callback);
        void unsetNoMoreTrackCallback();
 
-       void setVideoPacketCallback(void* handle, mtprPacketCallback callback, void* userData);
+       void setVideoPacketCallback(InvokablePtr callback);
        void unsetVideoPacketCallback();
 
-       void setAudioPacketCallback(void* handle, mtprPacketCallback callback, void* userData);
+       void setAudioPacketCallback(InvokablePtr callback);
        void unsetAudioPacketCallback();
 
        void setDisplay(std::shared_ptr<MediaTransporterDisplay> display);
@@ -70,11 +70,11 @@ protected:
        static bool _isSupportedMediaType(std::string mediaType);
        static bool _isAudioMediaType(std::string mediaType);
 
-       std::unique_ptr<IInvokable> _trackAddedCallback;
-       std::unique_ptr<IInvokable> _noMoreTrackCallback;
+       InvokablePtr _trackAddedCallback;
+       InvokablePtr _noMoreTrackCallback;
 
        struct mtprCallback {
-               std::unique_ptr<IInvokable> _callback;
+               InvokablePtr _callback;
                media_format_h mediaFormat { nullptr }; // FIXME : this should be A/V separated!!!
        };
        mtprCallback _videoCallback {};

diff --git a/include/MediaTransporterReceiverSrt.h b/include/MediaTransporterReceiverSrt.h
index f83a1c5..a0d1d3a 100644 (file)
--- a/include/MediaTransporterReceiverSrt.h
+++ b/include/MediaTransporterReceiverSrt.h
@@ -46,7 +46,7 @@ public:
        std::string getSenderAddress() override { return _senderAddress; }
 
        mtprConnectionType type() override { return MTPR_CONNECTION_TYPE_SRT_RECEIVER; }
-       void foreachConnectionStats(void* handle, mtprConnectionStatsCallback callback, void* userData) override;
+       void foreachConnectionStats(InvokablePtr callback) override;
 
 private:
        static void _demuxPadAddedCallback(GstElement* demux, GstPad* new_pad, gpointer userData);

diff --git a/include/MediaTransporterSenderSrt.h b/include/MediaTransporterSenderSrt.h
index e314a7e..bf9e32e 100644 (file)
--- a/include/MediaTransporterSenderSrt.h
+++ b/include/MediaTransporterSenderSrt.h
@@ -47,7 +47,7 @@ public:
 
        mtprConnectionType type() override { return MTPR_CONNECTION_TYPE_SRT_SENDER; }
 
-       void foreachConnectionStats(void* handle, mtprConnectionStatsCallback callback, void* userData) override;
+       void foreachConnectionStats(InvokablePtr callback) override;
 
 private:
        void startStatsMonitoring();

diff --git a/packaging/capi-media-transporter.spec b/packaging/capi-media-transporter.spec
index 3a84756..c5c2883 100644 (file)
--- a/packaging/capi-media-transporter.spec
+++ b/packaging/capi-media-transporter.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-transporter
 Summary:    A Media Transporter library in Tizen Native API
-Version:    1.0.22
+Version:    1.0.23
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/MediaSourceBinMediaPacket.cpp b/src/MediaSourceBinMediaPacket.cpp
index cf78af5..9ca106b 100644 (file)
--- a/src/MediaSourceBinMediaPacket.cpp
+++ b/src/MediaSourceBinMediaPacket.cpp
@@ -453,9 +453,9 @@ void MediaSourceBinMediaPacket::_makeVideoCapsFromMediaFormat(media_format_h for
 
 }
 
-void MediaSourceBinMediaPacket::setBufferStateChangedCallback(void* handle, mtprPacketSourceBufferStateCallback callback, void* userData)
+void MediaSourceBinMediaPacket::setBufferStateChangedCallback(InvokablePtr callback)
 {
-       _bufferStateCallback = std::unique_ptr<IInvokable>(new PacketSourceBufferStateCallback(handle, callback, userData));
+       _bufferStateCallback = std::move(callback);
 }
 
 void MediaSourceBinMediaPacket::unsetBufferStateChangedCallback()

diff --git a/src/MediaTransporter.cpp b/src/MediaTransporter.cpp
index fb39ada..cd1d86b 100644 (file)
--- a/src/MediaTransporter.cpp
+++ b/src/MediaTransporter.cpp
@@ -638,7 +638,7 @@ int mtpr_media_packet_source_set_buffer_state_changed_cb(mtpr_h mtpr, unsigned i
                MediaSourceBinMediaPacket* mediaPacketSourceBIn = dynamic_cast<MediaSourceBinMediaPacket*>(sender->getMediaSource(source_id));
                RET_VAL_IF(!mediaPacketSourceBIn, MTPR_ERROR_INVALID_PARAMETER, "Invalid source id");
 
-               mediaPacketSourceBIn->setBufferStateChangedCallback(mtpr, callback, user_data);
+               mediaPacketSourceBIn->setBufferStateChangedCallback(CallbackFactory::createPacketSourceBufferStateCallback(handle, callback, user_data));
 
        } catch (const MediaTransporterException& e) {
                LOG_ERROR("Failed to set media packet source state changed callback!!! : %s", e.what());
@@ -751,7 +751,7 @@ int mtpr_set_error_cb(mtpr_h mtpr, mtpr_error_cb callback, void *user_data)
                auto handle = static_cast<media_transporter_s*>(mtpr);
                assert(handle->base);
 
-               handle->base->setErrorCallback(mtpr, callback, user_data);
+               handle->base->setErrorCallback(CallbackFactory::createErrorCallback(mtpr, callback, user_data));
        } catch (const MediaTransporterException& e) {
                LOG_ERROR("Failed to set error callback!!! : %s", e.what());
                return e.error();
@@ -789,7 +789,7 @@ int mtpr_set_track_added_cb(mtpr_h mtpr, mtpr_track_added_cb callback, void* use
        RET_VAL_IF(!receiver, MTPR_ERROR_INVALID_OPERATION, "only receiver support this api!!!");
 
        try {
-               receiver->setTrackAddedCallback(mtpr, callback, user_data);
+               receiver->setTrackAddedCallback(CallbackFactory::createTrackAddedCallback(mtpr, callback, user_data));
        } catch (const MediaTransporterException& e) {
                LOG_ERROR("Failed to set track added callback!!! : %s", e.what());
                return e.error();
@@ -830,7 +830,7 @@ int mtpr_set_no_more_track_cb(mtpr_h mtpr, mtpr_no_more_track_cb callback, void*
        RET_VAL_IF(!receiver, MTPR_ERROR_INVALID_OPERATION, "only receiver support this api!!!");
 
        try {
-               receiver->setNoMoreTrackCallback(mtpr, callback, user_data);
+               receiver->setNoMoreTrackCallback(CallbackFactory::createNoMoreTrackCallback(mtpr, callback, user_data));
        } catch (const MediaTransporterException& e) {
                LOG_ERROR("Failed to set no more track callback!!! : %s", e.what());
                return e.error();
@@ -871,7 +871,7 @@ int mtpr_set_audio_packet_cb(mtpr_h mtpr, mtpr_encoded_frame_cb callback, void*
        RET_VAL_IF(!receiver, MTPR_ERROR_INVALID_OPERATION, "only receiver support this api!!!");
 
        try {
-               receiver->setAudioPacketCallback(mtpr, callback, user_data);//__internal_audio_packet_cb, static_cast<void*>(handle));
+               receiver->setAudioPacketCallback(CallbackFactory::createPacketCallback(mtpr, MTPR_MEDIA_TYPE_AUDIO, callback, user_data));//__internal_audio_packet_cb, static_cast<void*>(handle));
        } catch (const MediaTransporterException& e) {
                LOG_ERROR("Failed to set audio packet callback!!! : %s", e.what());
                return e.error();
@@ -912,7 +912,7 @@ int mtpr_set_video_packet_cb(mtpr_h mtpr, mtpr_encoded_frame_cb callback, void*
        RET_VAL_IF(!receiver, MTPR_ERROR_INVALID_OPERATION, "only receiver support this api!!!");
 
        try {
-               receiver->setVideoPacketCallback(mtpr, callback, user_data);
+               receiver->setVideoPacketCallback(CallbackFactory::createPacketCallback(mtpr, MTPR_MEDIA_TYPE_VIDEO, callback, user_data));
        } catch (const MediaTransporterException& e) {
                LOG_ERROR("Failed to set video packet callback!!! : %s", e.what());
                return e.error();
@@ -1065,11 +1065,12 @@ int mtpr_foreach_connection_stats(mtpr_h mtpr, mtpr_connection_stats_cb callback
                if (handle->base->state() == MTPR_STATE_IDLE)
                        throw MediaTransporterException(MTPR_ERROR_INVALID_STATE, "state must not be IDLE");
 
-               handle->base->foreachConnectionStats(mtpr, callback, user_data);
+               handle->base->foreachConnectionStats(CallbackFactory::createConnectionStatsCallback(handle, callback, user_data));
+
        } catch (const MediaTransporterException& e) {
                LOG_ERROR("Failed to foreach connection statistics!!! : %s", e.what());
                return e.error();
        }
 
        return MTPR_ERROR_NONE;
-}
\ No newline at end of file
+}

diff --git a/src/MediaTransporterBase.cpp b/src/MediaTransporterBase.cpp
index ca01adc..16e6bb8 100644 (file)
--- a/src/MediaTransporterBase.cpp
+++ b/src/MediaTransporterBase.cpp
@@ -223,9 +223,9 @@ std::string MediaTransporterBase::getConnection(std::string name)
        throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "not supported");
 }
 
-void MediaTransporterBase::setErrorCallback(void* handle, mtprErrorCallback callback, void* userData)
+void MediaTransporterBase::setErrorCallback(InvokablePtr callback)
 {
-       _errorCallback = std::unique_ptr<IInvokable>(new ErrorCallback(handle, callback, userData));
+       _errorCallback = std::move(callback);
 }
 
 void MediaTransporterBase::unsetErrorCallback()
@@ -233,7 +233,7 @@ void MediaTransporterBase::unsetErrorCallback()
        _errorCallback = nullptr;
 }
 
-void MediaTransporterBase::foreachConnectionStats(void* handle, mtprConnectionStatsCallback callback, void* userData)
+void MediaTransporterBase::foreachConnectionStats(InvokablePtr callback)
 {
        throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "not supported");
 }

diff --git a/src/MediaTransporterCallback.cpp b/src/MediaTransporterCallback.cpp
index f8508f6..aea26ae 100644 (file)
--- a/src/MediaTransporterCallback.cpp
+++ b/src/MediaTransporterCallback.cpp
@@ -21,6 +21,36 @@
 
 using namespace tizen_media_transporter;
 
+InvokablePtr CallbackFactory::createTrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata)
+{
+       return InvokablePtr(new TrackAddedCallback(handle, cb, userdata));
+}
+
+InvokablePtr CallbackFactory::createNoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback cb, void* userdata)
+{
+       return InvokablePtr(new NoMoreTrackCallback(handle, cb, userdata));
+}
+
+InvokablePtr CallbackFactory::createPacketCallback(void* handle, mtprMediaType type, mtprPacketCallback cb, void* userdata)
+{
+       return InvokablePtr(new PacketCallback(handle, type, cb, userdata));
+}
+
+InvokablePtr CallbackFactory::createErrorCallback(void* handle, mtprErrorCallback cb, void* userdata)
+{
+       return InvokablePtr(new ErrorCallback(handle, cb, userdata));
+}
+
+InvokablePtr CallbackFactory::createPacketSourceBufferStateCallback(void* handle, mtprPacketSourceBufferStateCallback cb, void* userdata)
+{
+       return InvokablePtr(new PacketSourceBufferStateCallback(handle, cb, userdata));
+}
+
+InvokablePtr CallbackFactory::createConnectionStatsCallback(void* handle, mtprConnectionStatsCallback cb, void* userdata)
+{
+       return InvokablePtr(new ConnectionStatsCallback(handle, cb, userdata));
+}
+
 TrackAddedCallback::TrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata)
                                                        : AbstractCallback(handle, userdata), _callback(cb)
 {

diff --git a/src/MediaTransporterReceiver.cpp b/src/MediaTransporterReceiver.cpp
index 1d398cf..041c1a7 100644 (file)
--- a/src/MediaTransporterReceiver.cpp
+++ b/src/MediaTransporterReceiver.cpp
@@ -29,9 +29,9 @@
 
 using namespace tizen_media_transporter;
 
-void MediaTransporterReceiver::setTrackAddedCallback(void* handle, mtprTrackAddedCallback callback, void* userData)
+void MediaTransporterReceiver::setTrackAddedCallback(InvokablePtr callback)
 {
-       _trackAddedCallback = std::unique_ptr<IInvokable>(new TrackAddedCallback(handle, callback, userData));
+       _trackAddedCallback = std::move(callback);
 }
 
 void MediaTransporterReceiver::unsetTrackAddedCallback()
@@ -39,9 +39,9 @@ void MediaTransporterReceiver::unsetTrackAddedCallback()
        _trackAddedCallback = nullptr;
 }
 
-void MediaTransporterReceiver::setNoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback callback, void* userData)
+void MediaTransporterReceiver::setNoMoreTrackCallback(InvokablePtr callback)
 {
-       _noMoreTrackCallback = std::unique_ptr<IInvokable>(new NoMoreTrackCallback(handle, callback, userData));
+       _noMoreTrackCallback = std::move(callback);
 }
 
 void MediaTransporterReceiver::unsetNoMoreTrackCallback()
@@ -49,14 +49,14 @@ void MediaTransporterReceiver::unsetNoMoreTrackCallback()
        _noMoreTrackCallback = nullptr;
 }
 
-void MediaTransporterReceiver::setVideoPacketCallback(void* handle, mtprPacketCallback callback, void* userData)
+void MediaTransporterReceiver::setVideoPacketCallback(InvokablePtr callback)
 {
-       _videoCallback._callback = std::unique_ptr<IInvokable>(new PacketCallback(handle, MTPR_MEDIA_TYPE_VIDEO, callback, userData));
+       _videoCallback._callback = std::move(callback);
 }
 
-void MediaTransporterReceiver::setAudioPacketCallback(void* handle, mtprPacketCallback callback, void* userData)
+void MediaTransporterReceiver::setAudioPacketCallback(InvokablePtr callback)
 {
-       _audioCallback._callback = std::unique_ptr<IInvokable>(new PacketCallback(handle, MTPR_MEDIA_TYPE_AUDIO, callback, userData));
+       _audioCallback._callback = std::move(callback);
 }
 
 void MediaTransporterReceiver::unsetVideoPacketCallback()

diff --git a/src/MediaTransporterReceiverSrt.cpp b/src/MediaTransporterReceiverSrt.cpp
index dcbd835..5b61a0c 100644 (file)
--- a/src/MediaTransporterReceiverSrt.cpp
+++ b/src/MediaTransporterReceiverSrt.cpp
@@ -171,11 +171,11 @@ void MediaTransporterReceiverSrt::setSenderAddress(std::string address)
 
 gboolean MediaTransporterReceiverSrt::_statsForeachCb(GQuark fieldId, const GValue* val, gpointer userData)
 {
-       MediaTransporterReceiverSrt* srt = static_cast<MediaTransporterReceiverSrt*>(userData);
+       auto callback = static_cast<IInvokable*>(userData);
        std::string fieldName = g_quark_to_string(fieldId);
 
-       if (!srt->_connectionStatsCallback ||
-               !srt->_connectionStatsCallback->invoke(fieldName, val, __receiverProp)) {
+       if (!callback ||
+               !callback->invoke(fieldName, val, __receiverProp)) {
                LOG_WARNING("stop calling stats callback");
                return FALSE;
        }
@@ -183,11 +183,9 @@ gboolean MediaTransporterReceiverSrt::_statsForeachCb(GQuark fieldId, const GVal
        return TRUE;
 }
 
-void MediaTransporterReceiverSrt::foreachConnectionStats(void* handle, mtprConnectionStatsCallback callback, void* userData)
+void MediaTransporterReceiverSrt::foreachConnectionStats(InvokablePtr callback)
 {
-       GstStructure* structure = NULL;
-
-       _connectionStatsCallback = std::unique_ptr<IInvokable>(new ConnectionStatsCallback(handle, callback, userData));
+       GstStructure* structure = nullptr;
 
        g_object_get(_srtSrc, "stats", &structure, NULL);
 
@@ -195,7 +193,5 @@ void MediaTransporterReceiverSrt::foreachConnectionStats(void* handle, mtprConne
        SECURE_LOG_DEBUG("RECEIVER >>> stats : %s", str);
        g_free(str);
 
-       gst_structure_foreach(structure, _statsForeachCb, (gpointer)this);
-
-       _connectionStatsCallback = nullptr;
+       gst_structure_foreach(structure, _statsForeachCb, callback.get());
 }
\ No newline at end of file

diff --git a/src/MediaTransporterSenderSrt.cpp b/src/MediaTransporterSenderSrt.cpp
index 11cdd68..e595073 100644 (file)
--- a/src/MediaTransporterSenderSrt.cpp
+++ b/src/MediaTransporterSenderSrt.cpp
@@ -242,30 +242,29 @@ void MediaTransporterSenderSrt::setSenderAddress(std::string address)
 
 gboolean MediaTransporterSenderSrt::_statsForeachCb(GQuark fieldId, const GValue* val, gpointer userData)
 {
-       MediaTransporterSenderSrt* srt = static_cast<MediaTransporterSenderSrt*>(userData);
+       auto callback = static_cast<IInvokable*>(userData);
        std::string fieldName = g_quark_to_string(fieldId);
 
-       if (!srt->_connectionStatsCallback ||
-               !srt->_connectionStatsCallback->invoke(fieldName, val, __senderProp)) {
+       if (!callback ||
+               !callback->invoke(fieldName, val, __senderProp)) {
                LOG_WARNING("stop calling stats callback");
-               srt->_connectionStatsCallback = NULL;
                return FALSE;
        }
 
        return TRUE;
 }
 
-void MediaTransporterSenderSrt::foreachConnectionStats(void* handle, mtprConnectionStatsCallback callback, void* userData)
+void MediaTransporterSenderSrt::foreachConnectionStats(InvokablePtr callback)
 {
        const GstStructure* structure = NULL;
 
-       _connectionStatsCallback = std::unique_ptr<IInvokable>(new ConnectionStatsCallback(handle, callback, userData));
-
        g_object_get(_srtSink, "stats", &structure, NULL);
        gchar* str = gst_structure_to_string(structure);
        SECURE_LOG_DEBUG("SENDER >>> stats : %s", str);
        g_free(str);
 
+       gboolean ret = FALSE;
+
        if (gst_structure_has_field(structure, "callers")) {
                GValueArray* callers = (GValueArray *)g_value_get_boxed(gst_structure_get_value(structure, "callers"));
 
@@ -274,13 +273,14 @@ void MediaTransporterSenderSrt::foreachConnectionStats(void* handle, mtprConnect
                        const GstStructure* callerStats = (GstStructure *)g_value_get_boxed(&callers->values[i]);
 
                        LOG_DEBUG("SENDER >>> caller idx : %d", i);
-                       gst_structure_foreach(callerStats, _statsForeachCb, (gpointer)this);
+                       ret = gst_structure_foreach(callerStats, _statsForeachCb, callback.get());
+                       if (!ret)
+                               break;
                }
        }
 
-       if (_connectionStatsCallback && gst_structure_has_field(structure, "bytes-sent-total"))
-               _connectionStatsCallback->invoke("bytes-sent-total",
+       if (ret && gst_structure_has_field(structure, "bytes-sent-total"))
+               callback->invoke("bytes-sent-total",
                                gst_structure_get_value(structure, "bytes-sent-total"), __senderProp);
 
-       _connectionStatsCallback = nullptr;
 }