src/MediaTransporterCallback.cpp

   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 #include <gio/gio.h>
  18
  19 #include "MediaTransporterCallback.h"
  20 #include "MediaTransporterLog.h"
  21
  22 using namespace tizen_media_transporter;
  23
  24 InvokablePtr CallbackFactory::createTrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata)
  25 {
  26         return InvokablePtr(new TrackAddedCallback(handle, cb, userdata));
  27 }
  28
  29 InvokablePtr CallbackFactory::createNoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback cb, void* userdata)
  30 {
  31         return InvokablePtr(new NoMoreTrackCallback(handle, cb, userdata));
  32 }
  33
  34 InvokablePtr CallbackFactory::createPacketCallback(void* handle, mtprMediaType type, mtprPacketCallback cb, void* userdata)
  35 {
  36         return InvokablePtr(new PacketCallback(handle, type, cb, userdata));
  37 }
  38
  39 InvokablePtr CallbackFactory::createErrorCallback(void* handle, mtprErrorCallback cb, void* userdata)
  40 {
  41         return InvokablePtr(new ErrorCallback(handle, cb, userdata));
  42 }
  43
  44 InvokablePtr CallbackFactory::createPacketSourceBufferStateCallback(void* handle, mtprPacketSourceBufferStateCallback cb, void* userdata)
  45 {
  46         return InvokablePtr(new PacketSourceBufferStateCallback(handle, cb, userdata));
  47 }
  48
  49 InvokablePtr CallbackFactory::createConnectionStatsCallback(void* handle, mtprConnectionStatsCallback cb, void* userdata)
  50 {
  51         return InvokablePtr(new ConnectionStatsCallback(handle, cb, userdata));
  52 }
  53
  54 TrackAddedCallback::TrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata)
  55                                                         : AbstractCallback(handle, userdata), _callback(cb)
  56 {
  57         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
  58                         cb, handle, userdata);
  59 }
  60
  61 void TrackAddedCallback::invoke(VariantData data1, VariantData data2)
  62 {
  63         auto mediaType = std::get<mtprMediaType>(data1);
  64         auto trackId = std::get<unsigned int>(data2);
  65
  66         LOG_DEBUG(">>> callback[%p], mediaType[%d], trackId[%u], handle[%p], user_data[%p]",
  67                         _callback, mediaType, trackId, _handle, _userdata);
  68
  69         _callback(_handle, mediaType, trackId, _userdata);
  70 }
  71
  72 NoMoreTrackCallback::NoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback cb, void* userdata)
  73                                                         : AbstractCallback(handle, userdata), _callback(cb)
  74 {
  75         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
  76                         cb, handle, userdata);
  77 }
  78
  79 void NoMoreTrackCallback::invoke()
  80 {
  81         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p]",
  82                         _callback, _handle, _userdata);
  83
  84         _callback(_handle, _userdata);
  85 }
  86
  87 PacketCallback::PacketCallback(void* handle, mtprMediaType type, mtprPacketCallback cb, void* userdata)
  88                                                         : AbstractCallback(handle, userdata), _type(type), _callback(cb)
  89 {
  90         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
  91                         cb, handle, userdata);
  92 }
  93
  94 void PacketCallback::invoke(VariantData data1, VariantData data2)
  95 {
  96         auto trackId = std::get<unsigned int>(data1);
  97         auto packet = std::get<media_packet_h>(data2);
  98
  99         LOG_VERBOSE(">>> callback[%p], handle[%p], type[%d], id[%d], packet[%p], user_data[%p]",
 100                         _callback, _handle, _type, trackId, packet, _userdata);
 101
 102         _callback(_handle, _type, trackId, packet, _userdata);
 103 }
 104
 105 ErrorCallback::ErrorCallback(void* handle, mtprErrorCallback cb,  void* userdata)
 106                                                         : AbstractCallback(handle, userdata), _callback(cb)
 107 {
 108         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
 109                         cb, handle, userdata);
 110 }
 111
 112 void ErrorCallback::invoke(VariantData data)
 113 {
 114         auto error = std::get<mtprError>(data);
 115
 116         LOG_DEBUG(">>> callback[%p], handle[%p], error[%d], user_data[%p]",
 117                         _callback, _handle, error, _userdata);
 118
 119         _callback(_handle, error, _userdata);
 120 }
 121
 122 PacketSourceBufferStateCallback::PacketSourceBufferStateCallback(void* handle, mtprPacketSourceBufferStateCallback cb, void* userdata)
 123                                 : AbstractCallback(handle, userdata), _callback(cb)
 124 {
 125         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
 126                         cb, handle, userdata);
 127 }
 128
 129 void PacketSourceBufferStateCallback::invoke(VariantData data1, VariantData data2)
 130 {
 131         auto sourceId = std::get<unsigned int>(data1);
 132         auto state = std::get<mtprPacketSourceBufferState>(data2);
 133
 134         LOG_DEBUG(">>> callback[%p], handle[%p], sourcdId[%d], state[%d], user_data[%p]",
 135                         _callback, _handle, sourceId, state, _userdata);
 136
 137         _callback(sourceId, state, _userdata);
 138 }
 139
 140 ConnectionStatsCallback::ConnectionStatsCallback(void* handle, mtprConnectionStatsCallback cb,  void* userdata)
 141                                                         : AbstractCallback(handle, userdata), _callback(cb)
 142 {
 143         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
 144                         cb, handle, userdata);
 145 }
 146
 147 bool ConnectionStatsCallback::invoke(VariantData data1, VariantData data2, VariantData data3)
 148 {
 149         auto fieldName = std::get<std::string>(data1);
 150         auto val = std::get<const GValue*>(data2);
 151         auto propList = std::get<std::map<std::string, mtprConnectionStatsProp>>(data3);
 152         g_autofree gchar* addr = NULL;
 153
 154         if (propList.find(fieldName) == propList.end()) {
 155                 LOG_DEBUG("not supported [%s]", fieldName.c_str());
 156                 return true;
 157         }
 158
 159         mtprConnectionStatsProp prop = propList.at(fieldName);
 160
 161         switch (G_VALUE_TYPE(val)) {
 162         case G_TYPE_BOOLEAN: {
 163                 gboolean result = g_value_get_boolean(val);
 164                 LOG_DEBUG("field[%s] GType[%s] value[%u]",
 165                         fieldName.c_str(), g_type_name(G_VALUE_TYPE(val)), result);
 166
 167                 mtprConnectionStatsPropInfo propInfo {
 168                         fieldName.c_str(), prop, MTPR_CONNECTION_STATS_PROP_TYPE_BOOL, .v_bool = static_cast<bool>(result)
 169                 };
 170
 171                 return _callback(_handle, &propInfo, _userdata);
 172         }
 173         case G_TYPE_INT: {
 174                 gint result = g_value_get_int(val);
 175                 LOG_DEBUG("field[%s] GType[%s] value[%d]",
 176                         fieldName.c_str(), g_type_name(G_VALUE_TYPE(val)), result);
 177
 178                 mtprConnectionStatsPropInfo propInfo {
 179                         fieldName.c_str(), prop, MTPR_CONNECTION_STATS_PROP_TYPE_INT, .v_int = result
 180                 };
 181
 182                 return _callback(_handle, &propInfo, _userdata);
 183         }
 184         case G_TYPE_UINT: {
 185                 guint result = g_value_get_uint(val);
 186                 LOG_DEBUG("field[%s] GType[%s] value[%u]",
 187                         fieldName.c_str(), g_type_name(G_VALUE_TYPE(val)), result);
 188
 189                 mtprConnectionStatsPropInfo propInfo {
 190                         fieldName.c_str(), prop, MTPR_CONNECTION_STATS_PROP_TYPE_UINT, .v_uint = result
 191                 };
 192
 193                 return _callback(_handle, &propInfo, _userdata);
 194         }
 195         case G_TYPE_INT64: {
 196                 gint64 result = g_value_get_int64(val);
 197                 LOG_DEBUG("field[%s] GType[%s] value[%" G_GINT64_FORMAT "]",
 198                         fieldName.c_str(), g_type_name(G_VALUE_TYPE(val)), result);
 199
 200                 mtprConnectionStatsPropInfo propInfo {
 201                         fieldName.c_str(), prop, MTPR_CONNECTION_STATS_PROP_TYPE_INT64, .v_int64 = result
 202                 };
 203
 204                 return _callback(_handle, &propInfo, _userdata);
 205         }
 206         case G_TYPE_UINT64: {
 207                 guint64 result = g_value_get_uint64(val);
 208                 LOG_DEBUG("field[%s] GType[%s] value[%" G_GUINT64_FORMAT "]",
 209                         fieldName.c_str(), g_type_name(G_VALUE_TYPE(val)), result);
 210
 211                 mtprConnectionStatsPropInfo propInfo {
 212                         fieldName.c_str(), prop, MTPR_CONNECTION_STATS_PROP_TYPE_UINT64, .v_uint64 = result
 213                 };
 214
 215                 return _callback(_handle, &propInfo, _userdata);
 216         }
 217         case G_TYPE_FLOAT: {
 218                 gfloat result = g_value_get_float(val);
 219                 LOG_DEBUG("field[%s] GType[%s] value[%f]",
 220                         fieldName.c_str(), g_type_name(G_VALUE_TYPE(val)), result);
 221
 222                 mtprConnectionStatsPropInfo propInfo {
 223                         fieldName.c_str(), prop, MTPR_CONNECTION_STATS_PROP_TYPE_FLOAT, .v_float = result
 224                 };
 225
 226                 return _callback(_handle, &propInfo, _userdata);
 227         }
 228         case G_TYPE_DOUBLE: {
 229                 gdouble result = g_value_get_double(val);
 230                 LOG_DEBUG("field[%s] GType[%s] value[%f]",
 231                         fieldName.c_str(), g_type_name(G_VALUE_TYPE(val)), result);
 232
 233                 mtprConnectionStatsPropInfo propInfo {
 234                         fieldName.c_str(), prop, MTPR_CONNECTION_STATS_PROP_TYPE_DOUBLE, .v_double = result
 235                 };
 236
 237                 return _callback(_handle, &propInfo, _userdata);
 238         }
 239         case G_TYPE_STRING: {
 240                 const gchar *result = g_value_get_string(val);
 241                 LOG_DEBUG("field[%s] GType[%s] value[%s]",
 242                         fieldName.c_str(), g_type_name(G_VALUE_TYPE(val)), result);
 243
 244                 mtprConnectionStatsPropInfo propInfo {
 245                         fieldName.c_str(), prop, MTPR_CONNECTION_STATS_PROP_TYPE_STRING, .v_string = result
 246                 };
 247
 248                 return _callback(_handle, &propInfo, _userdata);
 249         }
 250         default:
 251                 if (G_VALUE_TYPE(val) == G_TYPE_SOCKET_ADDRESS) { /* non-constexpr : g_socket_address_get_type() */
 252                         addr = g_inet_address_to_string
 253                                 (g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(g_value_get_object(val))));
 254                         LOG_DEBUG("field[%s] GType[%s] value[%s]",
 255                                 fieldName.c_str(), g_type_name(G_VALUE_TYPE(val)), addr);
 256
 257                         mtprConnectionStatsPropInfo propInfo {
 258                                 fieldName.c_str(), prop, MTPR_CONNECTION_STATS_PROP_TYPE_STRING, .v_string = addr
 259                         };
 260
 261                         return _callback(_handle, &propInfo, _userdata);
 262                 }
 263
 264                 LOG_ERROR("invalid type, field[%s] GType[%s]",
 265                         fieldName.c_str(), g_type_name(G_VALUE_TYPE(val)));
 266
 267                 break;
 268         }
 269
 270         return true;
 271 }