pidgin/pidgin

Remove the Pidgin implemenation of requests except for fields
default tip
78 minutes ago, Gary Kramlich
f225f7dfb0bc
Remove the Pidgin implemenation of requests except for fields

We're in the progress of removing the requests API and this need to be removed
to do that.

Testing Done:
Checked in with the turtles and verified the fields api still worked with the idle plugin.

Reviewed at https://reviews.imfreedom.org/r/3145/
/*
* Purple - Internet Messaging Library
* Copyright (C) Pidgin Developers <devel@pidgin.im>
*
* Purple is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along with
* this library; if not, see <https://www.gnu.org/licenses/>.
*/
#include "codec.h"
struct _PurpleMediaCodec
{
GObject parent;
};
typedef struct
{
gint id;
char *encoding_name;
PurpleMediaSessionType media_type;
guint clock_rate;
guint channels;
GList *optional_params;
} PurpleMediaCodecPrivate;
enum {
PROP_0,
PROP_ID,
PROP_ENCODING_NAME,
PROP_MEDIA_TYPE,
PROP_CLOCK_RATE,
PROP_CHANNELS,
PROP_OPTIONAL_PARAMS,
N_PROPERTIES,
};
static GParamSpec *properties[N_PROPERTIES] = {NULL, };
G_DEFINE_FINAL_TYPE_WITH_PRIVATE(PurpleMediaCodec, purple_media_codec,
G_TYPE_OBJECT)
static void
purple_media_codec_init(PurpleMediaCodec *info)
{
PurpleMediaCodecPrivate *priv =
purple_media_codec_get_instance_private(info);
priv->encoding_name = NULL;
priv->optional_params = NULL;
}
static void
purple_media_codec_finalize(GObject *info)
{
PurpleMediaCodecPrivate *priv =
purple_media_codec_get_instance_private(
PURPLE_MEDIA_CODEC(info));
g_free(priv->encoding_name);
g_list_free_full(priv->optional_params, (GDestroyNotify)purple_key_value_pair_free);
G_OBJECT_CLASS(purple_media_codec_parent_class)->finalize(info);
}
static void
purple_media_codec_set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
PurpleMediaCodecPrivate *priv;
g_return_if_fail(PURPLE_MEDIA_IS_CODEC(object));
priv = purple_media_codec_get_instance_private(
PURPLE_MEDIA_CODEC(object));
switch (prop_id) {
case PROP_ID:
priv->id = g_value_get_uint(value);
break;
case PROP_ENCODING_NAME:
g_free(priv->encoding_name);
priv->encoding_name = g_value_dup_string(value);
break;
case PROP_MEDIA_TYPE:
priv->media_type = g_value_get_flags(value);
break;
case PROP_CLOCK_RATE:
priv->clock_rate = g_value_get_uint(value);
break;
case PROP_CHANNELS:
priv->channels = g_value_get_uint(value);
break;
case PROP_OPTIONAL_PARAMS:
priv->optional_params = g_value_get_pointer(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(
object, prop_id, pspec);
break;
}
}
static void
purple_media_codec_get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
PurpleMediaCodecPrivate *priv;
g_return_if_fail(PURPLE_MEDIA_IS_CODEC(object));
priv = purple_media_codec_get_instance_private(
PURPLE_MEDIA_CODEC(object));
switch (prop_id) {
case PROP_ID:
g_value_set_uint(value, priv->id);
break;
case PROP_ENCODING_NAME:
g_value_set_string(value, priv->encoding_name);
break;
case PROP_MEDIA_TYPE:
g_value_set_flags(value, priv->media_type);
break;
case PROP_CLOCK_RATE:
g_value_set_uint(value, priv->clock_rate);
break;
case PROP_CHANNELS:
g_value_set_uint(value, priv->channels);
break;
case PROP_OPTIONAL_PARAMS:
g_value_set_pointer(value, priv->optional_params);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(
object, prop_id, pspec);
break;
}
}
static void
purple_media_codec_class_init(PurpleMediaCodecClass *klass)
{
GObjectClass *gobject_class = (GObjectClass*)klass;
gobject_class->finalize = purple_media_codec_finalize;
gobject_class->set_property = purple_media_codec_set_property;
gobject_class->get_property = purple_media_codec_get_property;
/**
* PurpleMediaCodec:id:
*
* The numeric identifier of the codec.
*/
properties[PROP_ID] = g_param_spec_uint("id",
"ID",
"The numeric identifier of the codec.",
0, G_MAXUINT, 0,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* PurpleMediaCodec:encoding-name:
*
* The name of the codec.
*/
properties[PROP_ENCODING_NAME] = g_param_spec_string("encoding-name",
"Encoding Name",
"The name of the codec.",
NULL,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* PurpleMediaCodec:media-type:
*
* Whether this is an audio, video, or application codec.
*/
properties[PROP_MEDIA_TYPE] = g_param_spec_flags("media-type",
"Media Type",
"Whether this is an audio, video or application codec.",
PURPLE_MEDIA_TYPE_SESSION_TYPE,
PURPLE_MEDIA_NONE,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* PurpleMediaCodec:clock-rate:
*
* The clock rate for the codec.
*/
properties[PROP_CLOCK_RATE] = g_param_spec_uint("clock-rate",
"Create Callback",
"The function called to create this element.",
0, G_MAXUINT, 0,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
/**
* PurpleMediaCodec:channels:
*
* The number of channels in the codec.
*/
properties[PROP_CHANNELS] = g_param_spec_uint("channels",
"Channels",
"The number of channels in this codec.",
0, G_MAXUINT, 0,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
/**
* PurpleMediaCodec:optional-params:
*
* A list of optional parameters for the codec.
*/
properties[PROP_OPTIONAL_PARAMS] = g_param_spec_pointer("optional-params",
"Optional Params",
"A list of optional parameters for the codec.",
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties(gobject_class, N_PROPERTIES, properties);
}
PurpleMediaCodec *
purple_media_codec_new(int id, const char *encoding_name,
PurpleMediaSessionType media_type, guint clock_rate)
{
PurpleMediaCodec *codec =
g_object_new(PURPLE_MEDIA_TYPE_CODEC,
"id", id,
"encoding_name", encoding_name,
"media_type", media_type,
"clock-rate", clock_rate, NULL);
return codec;
}
guint
purple_media_codec_get_id(PurpleMediaCodec *codec)
{
guint id;
g_return_val_if_fail(PURPLE_MEDIA_IS_CODEC(codec), 0);
g_object_get(codec, "id", &id, NULL);
return id;
}
gchar *
purple_media_codec_get_encoding_name(PurpleMediaCodec *codec)
{
gchar *name;
g_return_val_if_fail(PURPLE_MEDIA_IS_CODEC(codec), NULL);
g_object_get(codec, "encoding-name", &name, NULL);
return name;
}
guint
purple_media_codec_get_clock_rate(PurpleMediaCodec *codec)
{
guint clock_rate;
g_return_val_if_fail(PURPLE_MEDIA_IS_CODEC(codec), 0);
g_object_get(codec, "clock-rate", &clock_rate, NULL);
return clock_rate;
}
guint
purple_media_codec_get_channels(PurpleMediaCodec *codec)
{
guint channels;
g_return_val_if_fail(PURPLE_MEDIA_IS_CODEC(codec), 0);
g_object_get(codec, "channels", &channels, NULL);
return channels;
}
GList *
purple_media_codec_get_optional_parameters(PurpleMediaCodec *codec)
{
GList *optional_params;
g_return_val_if_fail(PURPLE_MEDIA_IS_CODEC(codec), NULL);
g_object_get(codec, "optional-params", &optional_params, NULL);
return optional_params;
}
void
purple_media_codec_add_optional_parameter(PurpleMediaCodec *codec,
const gchar *name, const gchar *value)
{
PurpleMediaCodecPrivate *priv;
PurpleKeyValuePair *new_param;
g_return_if_fail(codec != NULL);
g_return_if_fail(name != NULL && value != NULL);
priv = purple_media_codec_get_instance_private(codec);
new_param = purple_key_value_pair_new_full(name, g_strdup(value), g_free);
priv->optional_params = g_list_append(
priv->optional_params, new_param);
g_object_notify_by_pspec(G_OBJECT(codec), properties[PROP_OPTIONAL_PARAMS]);
}
void
purple_media_codec_remove_optional_parameter(PurpleMediaCodec *codec,
PurpleKeyValuePair *param)
{
PurpleMediaCodecPrivate *priv;
g_return_if_fail(codec != NULL && param != NULL);
priv = purple_media_codec_get_instance_private(codec);
priv->optional_params =
g_list_remove(priv->optional_params, param);
purple_key_value_pair_free(param);
g_object_notify_by_pspec(G_OBJECT(codec), properties[PROP_OPTIONAL_PARAMS]);
}
PurpleKeyValuePair *
purple_media_codec_get_optional_parameter(PurpleMediaCodec *codec,
const gchar *name, const gchar *value)
{
PurpleMediaCodecPrivate *priv;
GList *iter;
g_return_val_if_fail(codec != NULL, NULL);
g_return_val_if_fail(name != NULL, NULL);
priv = purple_media_codec_get_instance_private(codec);
for (iter = priv->optional_params; iter; iter = g_list_next(iter)) {
PurpleKeyValuePair *param = iter->data;
if (!g_ascii_strcasecmp(param->key, name) &&
(value == NULL ||
!g_ascii_strcasecmp(param->value, value)))
{
return param;
}
}
return NULL;
}
PurpleMediaCodec *
purple_media_codec_copy(PurpleMediaCodec *codec)
{
PurpleMediaCodecPrivate *priv;
PurpleMediaCodec *new_codec;
GList *iter;
if (codec == NULL) {
return NULL;
}
priv = purple_media_codec_get_instance_private(codec);
new_codec = purple_media_codec_new(priv->id, priv->encoding_name,
priv->media_type, priv->clock_rate);
g_object_set(codec, "channels", priv->channels, NULL);
for (iter = priv->optional_params; iter; iter = g_list_next(iter)) {
PurpleKeyValuePair *param =
(PurpleKeyValuePair*)iter->data;
purple_media_codec_add_optional_parameter(new_codec,
param->key, param->value);
}
return new_codec;
}
GList *
purple_media_codec_list_copy(GList *codecs)
{
return g_list_copy_deep(codecs,
(GCopyFunc)(GCallback)purple_media_codec_copy,
NULL);
}
void
purple_media_codec_list_free(GList *codecs)
{
g_list_free_full(codecs, g_object_unref);
}
gchar *
purple_media_codec_to_string(PurpleMediaCodec *codec)
{
PurpleMediaCodecPrivate *priv;
GString *string = NULL;
GList *item;
const gchar *media_type_str = NULL;
if (codec == NULL) {
return g_strdup("(NULL)");
}
priv = purple_media_codec_get_instance_private(codec);
string = g_string_new("");
if (priv->media_type & PURPLE_MEDIA_AUDIO) {
media_type_str = "audio";
} else if (priv->media_type & PURPLE_MEDIA_VIDEO) {
media_type_str = "video";
} else if (priv->media_type & PURPLE_MEDIA_APPLICATION) {
media_type_str = "application";
}
g_string_printf(string, "%d: %s %s clock:%d channels:%d", priv->id,
media_type_str, priv->encoding_name,
priv->clock_rate, priv->channels);
for (item = priv->optional_params; item; item = g_list_next (item)) {
PurpleKeyValuePair *param = item->data;
g_string_append_printf (string, " %s=%s",
param->key, (gchar *)param->value);
}
return g_string_free(string, FALSE);
}