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,
  36                                                                 mtprMediaType, mtprPacketSourceBufferState,
  37                                                                 mtprConnectionStatsPropInfo>;
  38
  39 class IInvokable
  40 {
  41 public:
  42         virtual ~IInvokable() = default;
  43
  44         virtual void invoke() = 0;
  45         virtual void invoke(VariantData data) = 0;
  46         virtual void invoke(VariantData data1, VariantData data2) = 0;
  47         virtual bool invokeReturn(VariantData data) = 0;
  48 };
  49
  50 class AbstractCallback : public IInvokable
  51 {
  52 public:
  53         AbstractCallback(void* handle, void* userdata) :
  54                 _handle(handle), _userdata(userdata) {}
  55         virtual ~AbstractCallback() = default;
  56
  57         void invoke() override {}
  58         void invoke(VariantData data) override {}
  59         void invoke(VariantData data1, VariantData data2) override {}
  60         bool invokeReturn(VariantData data) override { return false; }
  61
  62 protected:
  63         void* _handle;
  64         void* _userdata;
  65 };
  66
  67 using InvokablePtr = std::unique_ptr<IInvokable>;
  68
  69 struct CallbackFactory
  70 {
  71         static InvokablePtr createTrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata);
  72         static InvokablePtr createNoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback cb, void* userdata);
  73         static InvokablePtr createPacketCallback(void* handle, mtprMediaType type, mtprPacketCallback cb, void* userdata);
  74         static InvokablePtr createErrorCallback(void* handle, mtprErrorCallback cb, void* userdata);
  75         static InvokablePtr createPacketSourceBufferStateCallback(void* handle, mtprPacketSourceBufferStateCallback cb, void* userdata);
  76         static InvokablePtr createConnectionStatsCallback(void* handle, mtprConnectionStatsCallback cb, void* userdata);
  77 };
  78
  79 class TrackAddedCallback : public AbstractCallback
  80 {
  81 public:
  82         TrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata);
  83         virtual ~TrackAddedCallback() = default;
  84
  85         void invoke(VariantData data1, VariantData data2) override;
  86
  87 private:
  88         mtprTrackAddedCallback _callback;
  89 };
  90
  91 class NoMoreTrackCallback : public AbstractCallback
  92 {
  93 public:
  94         NoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback cb, void* userdata);
  95         virtual ~NoMoreTrackCallback() = default;
  96
  97         void invoke() override;
  98
  99 private:
 100         mtprNoMoreTrackCallback _callback;
 101 };
 102
 103 class PacketCallback : public AbstractCallback
 104 {
 105 public:
 106         PacketCallback(void* handle, mtprMediaType type, mtprPacketCallback cb, void* userdata);
 107         virtual ~PacketCallback() = default;
 108
 109         void invoke(VariantData data1, VariantData data2) override;
 110
 111 private:
 112         mtprMediaType _type;
 113         mtprPacketCallback _callback;
 114 };
 115
 116 class ErrorCallback : public AbstractCallback
 117 {
 118 public:
 119         ErrorCallback(void* handle, mtprErrorCallback cb, void* userdata);
 120         virtual ~ErrorCallback() = default;
 121
 122         void invoke(VariantData data) override;
 123
 124 private:
 125         mtprErrorCallback _callback;
 126 };
 127
 128 class PacketSourceBufferStateCallback : public AbstractCallback
 129 {
 130 public:
 131         PacketSourceBufferStateCallback(void* handle, mtprPacketSourceBufferStateCallback cb, void* userdata);
 132         virtual ~PacketSourceBufferStateCallback() = default;
 133
 134         void invoke(VariantData data1, VariantData data2) override;
 135
 136 private:
 137         mtprPacketSourceBufferStateCallback _callback;
 138 };
 139
 140 class ConnectionStatsCallback : public AbstractCallback
 141 {
 142 public:
 143         ConnectionStatsCallback(void* handle, mtprConnectionStatsCallback cb, void* userdata);
 144         virtual ~ConnectionStatsCallback() = default;
 145
 146         bool invokeReturn(VariantData data) override;
 147
 148 private:
 149         mtprConnectionStatsCallback _callback;
 150 };
 151
 152 } // namespace
 153
 154 #ifdef __cplusplus
 155 }
 156 #endif /* __cplusplus */
 157
 158 #endif /* __TIZEN_MEDIA_TRANSPORTER_CALLBACK_H__ */