include/MediaTransporterCallback.h

   1 /*
   2 * Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #ifndef __TIZEN_MEDIA_TRANSPORTER_CALLBACK_H__
  18 #define __TIZEN_MEDIA_TRANSPORTER_CALLBACK_H__
  19
  20 #include <variant>
  21 #include <memory>
  22 #include <media_packet.h>
  23 #include <map>
  24 #include <glib-object.h>
  25 #include <string>
  26
  27 #include "MediaTransporter.h"
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif
  32
  33 namespace tizen_media_transporter {
  34
  35 using VariantData = std::variant<mtprError, media_packet_h, unsigned int, mtprMediaType,
  36         mtprPacketSourceBufferState, std::string, const GValue*, std::map<std::string, mtprConnectionStatsProp>>;
  37
  38 class IInvokable
  39 {
  40 public:
  41         virtual ~IInvokable() = default;
  42
  43         virtual void invoke() = 0;
  44         virtual void invoke(VariantData data) = 0;
  45         virtual void invoke(VariantData data1, VariantData data2) = 0;
  46         virtual bool invoke(VariantData data1, VariantData data2, VariantData data3) = 0;
  47 };
  48
  49 class AbstractCallback : public IInvokable
  50 {
  51 public:
  52         AbstractCallback(void* handle, void* userdata) :
  53                 _handle(handle), _userdata(userdata) {}
  54         virtual ~AbstractCallback() = default;
  55
  56         void invoke() override {}
  57         void invoke(VariantData data) override {}
  58         void invoke(VariantData data1, VariantData data2) override {}
  59         bool invoke(VariantData data1, VariantData data2, VariantData data3) override { return TRUE; }
  60
  61 protected:
  62         void* _handle;
  63         void* _userdata;
  64 };
  65
  66 using InvokablePtr = std::unique_ptr<IInvokable>;
  67
  68 struct CallbackFactory
  69 {
  70         static InvokablePtr createTrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata);
  71         static InvokablePtr createNoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback cb, void* userdata);
  72         static InvokablePtr createPacketCallback(void* handle, mtprMediaType type, mtprPacketCallback cb, void* userdata);
  73         static InvokablePtr createErrorCallback(void* handle, mtprErrorCallback cb, void* userdata);
  74         static InvokablePtr createPacketSourceBufferStateCallback(void* handle, mtprPacketSourceBufferStateCallback cb, void* userdata);
  75         static InvokablePtr createConnectionStatsCallback(void* handle, mtprConnectionStatsCallback cb, void* userdata);
  76 };
  77
  78 class TrackAddedCallback : public AbstractCallback
  79 {
  80 public:
  81         TrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata);
  82         virtual ~TrackAddedCallback() = default;
  83
  84         void invoke(VariantData data1, VariantData data2) override;
  85
  86 private:
  87         mtprTrackAddedCallback _callback;
  88 };
  89
  90 class NoMoreTrackCallback : public AbstractCallback
  91 {
  92 public:
  93         NoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback cb, void* userdata);
  94         virtual ~NoMoreTrackCallback() = default;
  95
  96         void invoke() override;
  97
  98 private:
  99         mtprNoMoreTrackCallback _callback;
 100 };
 101
 102 class PacketCallback : public AbstractCallback
 103 {
 104 public:
 105         PacketCallback(void* handle, mtprMediaType type, mtprPacketCallback cb, void* userdata);
 106         virtual ~PacketCallback() = default;
 107
 108         void invoke(VariantData data1, VariantData data2) override;
 109
 110 private:
 111         mtprMediaType _type;
 112         mtprPacketCallback _callback;
 113 };
 114
 115 class ErrorCallback : public AbstractCallback
 116 {
 117 public:
 118         ErrorCallback(void* handle, mtprErrorCallback cb, void* userdata);
 119         virtual ~ErrorCallback() = default;
 120
 121         void invoke(VariantData data) override;
 122
 123 private:
 124         mtprErrorCallback _callback;
 125 };
 126
 127 class PacketSourceBufferStateCallback : public AbstractCallback
 128 {
 129 public:
 130         PacketSourceBufferStateCallback(void* handle, mtprPacketSourceBufferStateCallback cb, void* userdata);
 131         virtual ~PacketSourceBufferStateCallback() = default;
 132
 133         void invoke(VariantData data1, VariantData data2) override;
 134
 135 private:
 136         mtprPacketSourceBufferStateCallback _callback;
 137 };
 138
 139 class ConnectionStatsCallback : public AbstractCallback
 140 {
 141 public:
 142         ConnectionStatsCallback(void* handle, mtprConnectionStatsCallback cb, void* userdata);
 143         virtual ~ConnectionStatsCallback() = default;
 144
 145         bool invoke(VariantData data1, VariantData data2, VariantData data3) override;
 146
 147 private:
 148         mtprConnectionStatsCallback _callback;
 149 };
 150
 151 } // namespace
 152
 153 #ifdef __cplusplus
 154 }
 155 #endif /* __cplusplus */
 156
 157 #endif /* __TIZEN_MEDIA_TRANSPORTER_CALLBACK_H__ */