pidgin/pidgin
Clone
Summary
Browse
Changes
Graph
Remove the remaining nat-pmp code for auto discovering ip addresses
16 months ago, Gary Kramlich
aa90ee3e8ad5
Remove the remaining nat-pmp code for auto discovering ip addresses
Testing Done:
Compiled
Reviewed at https://reviews.imfreedom.org/r/2161/
/*
* finch
*
* Finch 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 program 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 program 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 program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#include
<config.h>
#include
<glib/gi18n-lib.h>
#include
<purple.h>
#include
<gnt.h>
#include
"gntconv.h"
#include
"gntmedia.h"
#include
"libfinch.h"
/* An incredibly large part of the following is from gtkmedia.c */
#undef hangup
#define FINCH_TYPE_MEDIA (finch_media_get_type())
#define FINCH_MEDIA(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), FINCH_TYPE_MEDIA, FinchMedia))
#define FINCH_MEDIA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), FINCH_TYPE_MEDIA, FinchMediaClass))
#define FINCH_IS_MEDIA(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), FINCH_TYPE_MEDIA))
#define FINCH_IS_MEDIA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), FINCH_TYPE_MEDIA))
#define FINCH_MEDIA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), FINCH_TYPE_MEDIA, FinchMediaClass))
typedef
struct
_FinchMedia
FinchMedia
;
typedef
struct
_FinchMediaClass
FinchMediaClass
;
typedef
enum
_FinchMediaState
FinchMediaState
;
struct
_FinchMediaClass
{
GntBoxClass
parent_class
;
};
struct
_FinchMedia
{
GntBox
parent
;
PurpleMedia
*
media
;
GntWidget
*
accept
;
GntWidget
*
reject
;
GntWidget
*
hangup
;
GntWidget
*
calling
;
PurpleConversation
*
conv
;
};
static
GType
finch_media_get_type
(
void
);
static
void
finch_media_class_init
(
FinchMediaClass
*
klass
);
static
void
finch_media_init
(
FinchMedia
*
media
);
static
void
finch_media_finalize
(
GObject
*
object
);
static
void
finch_media_get_property
(
GObject
*
object
,
guint
prop_id
,
GValue
*
value
,
GParamSpec
*
pspec
);
static
void
finch_media_set_property
(
GObject
*
object
,
guint
prop_id
,
const
GValue
*
value
,
GParamSpec
*
pspec
);
enum
{
MESSAGE
,
LAST_SIGNAL
};
static
guint
finch_media_signals
[
LAST_SIGNAL
]
=
{
0
};
enum
{
PROP_0
,
PROP_MEDIA
,
};
G_DEFINE_TYPE
(
FinchMedia
,
finch_media
,
GNT_TYPE_BOX
);
static
void
finch_media_class_init
(
FinchMediaClass
*
klass
)
{
GObjectClass
*
gobject_class
=
(
GObjectClass
*
)
klass
;
gobject_class
->
finalize
=
finch_media_finalize
;
gobject_class
->
set_property
=
finch_media_set_property
;
gobject_class
->
get_property
=
finch_media_get_property
;
g_object_class_install_property
(
gobject_class
,
PROP_MEDIA
,
g_param_spec_object
(
"media"
,
"PurpleMedia"
,
"The PurpleMedia associated with this media."
,
PURPLE_TYPE_MEDIA
,
G_PARAM_READWRITE
|
G_PARAM_CONSTRUCT_ONLY
|
G_PARAM_STATIC_STRINGS
));
finch_media_signals
[
MESSAGE
]
=
g_signal_new
(
"message"
,
G_TYPE_FROM_CLASS
(
klass
),
G_SIGNAL_RUN_LAST
,
0
,
NULL
,
NULL
,
g_cclosure_marshal_VOID__STRING
,
G_TYPE_NONE
,
1
,
G_TYPE_STRING
);
}
static
void
finch_media_init
(
FinchMedia
*
media
)
{
media
->
calling
=
gnt_label_new
(
_
(
"Calling..."
));
media
->
hangup
=
gnt_button_new
(
_
(
"Hangup"
));
media
->
accept
=
gnt_button_new
(
_
(
"Accept"
));
media
->
reject
=
gnt_button_new
(
_
(
"Reject"
));
gnt_box_set_alignment
(
GNT_BOX
(
media
),
GNT_ALIGN_MID
);
gnt_box_add_widget
(
GNT_BOX
(
media
),
media
->
accept
);
gnt_box_add_widget
(
GNT_BOX
(
media
),
media
->
reject
);
}
static
void
finch_media_finalize
(
GObject
*
media
)
{
FinchMedia
*
gntmedia
=
FINCH_MEDIA
(
media
);
purple_debug_info
(
"gntmedia"
,
"finch_media_finalize"
);
g_clear_object
(
&
gntmedia
->
media
);
}
static
void
finch_media_emit_message
(
FinchMedia
*
gntmedia
,
const
char
*
msg
)
{
g_signal_emit
(
gntmedia
,
finch_media_signals
[
MESSAGE
],
0
,
msg
);
}
static
void
finch_media_connected_cb
(
PurpleMedia
*
media
,
FinchMedia
*
gntmedia
)
{
GntWidget
*
parent
;
finch_media_emit_message
(
gntmedia
,
_
(
"Call in progress."
));
gnt_box_remove
(
GNT_BOX
(
gntmedia
),
gntmedia
->
accept
);
gnt_box_remove
(
GNT_BOX
(
gntmedia
),
gntmedia
->
reject
);
gnt_box_remove
(
GNT_BOX
(
gntmedia
),
gntmedia
->
hangup
);
gnt_box_remove
(
GNT_BOX
(
gntmedia
),
gntmedia
->
calling
);
gnt_box_add_widget
(
GNT_BOX
(
gntmedia
),
gntmedia
->
hangup
);
g_clear_pointer
(
&
gntmedia
->
accept
,
gnt_widget_destroy
);
g_clear_pointer
(
&
gntmedia
->
reject
,
gnt_widget_destroy
);
g_clear_pointer
(
&
gntmedia
->
calling
,
gnt_widget_destroy
);
parent
=
gnt_widget_get_toplevel
(
GNT_WIDGET
(
gntmedia
));
gnt_box_readjust
(
GNT_BOX
(
parent
));
gnt_widget_draw
(
parent
);
}
static
void
finch_media_wait_cb
(
PurpleMedia
*
media
,
FinchMedia
*
gntmedia
)
{
GntWidget
*
parent
;
gnt_box_remove
(
GNT_BOX
(
gntmedia
),
gntmedia
->
accept
);
gnt_box_remove
(
GNT_BOX
(
gntmedia
),
gntmedia
->
reject
);
gnt_box_remove
(
GNT_BOX
(
gntmedia
),
gntmedia
->
hangup
);
gnt_box_remove
(
GNT_BOX
(
gntmedia
),
gntmedia
->
calling
);
gnt_box_add_widget
(
GNT_BOX
(
gntmedia
),
gntmedia
->
calling
);
gnt_box_add_widget
(
GNT_BOX
(
gntmedia
),
gntmedia
->
hangup
);
parent
=
gnt_widget_get_toplevel
(
GNT_WIDGET
(
gntmedia
));
gnt_box_readjust
(
GNT_BOX
(
parent
));
gnt_widget_draw
(
parent
);
}
static
void
finch_media_state_changed_cb
(
PurpleMedia
*
media
,
PurpleMediaState
state
,
gchar
*
sid
,
gchar
*
name
,
FinchMedia
*
gntmedia
)
{
purple_debug_info
(
"gntmedia"
,
"state: %d sid: %s name: %s
\n
"
,
state
,
sid
,
name
);
if
(
sid
==
NULL
&&
name
==
NULL
)
{
if
(
state
==
PURPLE_MEDIA_STATE_END
)
{
finch_media_emit_message
(
gntmedia
,
_
(
"The call has been terminated."
));
finch_conversation_set_info_widget
(
gntmedia
->
conv
,
NULL
);
gnt_widget_destroy
(
GNT_WIDGET
(
gntmedia
));
/*
* XXX: This shouldn't have to be here
* to free the FinchMedia widget.
*/
g_object_unref
(
gntmedia
);
}
}
else
if
(
state
==
PURPLE_MEDIA_STATE_CONNECTED
)
{
finch_media_connected_cb
(
media
,
gntmedia
);
}
else
if
(
state
==
PURPLE_MEDIA_STATE_NEW
&&
sid
!=
NULL
&&
name
!=
NULL
&&
purple_media_is_initiator
(
media
,
sid
,
name
)
==
FALSE
)
{
PurpleAccount
*
account
;
PurpleBuddy
*
buddy
;
const
gchar
*
alias
;
PurpleMediaSessionType
type
=
purple_media_get_session_type
(
media
,
sid
);
gchar
*
message
=
NULL
;
account
=
purple_media_get_account
(
gntmedia
->
media
);
buddy
=
purple_blist_find_buddy
(
account
,
name
);
alias
=
buddy
?
purple_buddy_get_contact_alias
(
buddy
)
:
name
;
if
(
type
&
PURPLE_MEDIA_AUDIO
)
{
message
=
g_strdup_printf
(
_
(
"%s wishes to start an audio session with you."
),
alias
);
}
else
{
message
=
g_strdup_printf
(
_
(
"%s is trying to start an unsupported media session type with you."
),
alias
);
}
finch_media_emit_message
(
gntmedia
,
message
);
g_free
(
message
);
}
}
static
void
finch_media_stream_info_cb
(
PurpleMedia
*
media
,
PurpleMediaInfoType
type
,
gchar
*
sid
,
gchar
*
name
,
gboolean
local
,
FinchMedia
*
gntmedia
)
{
if
(
type
==
PURPLE_MEDIA_INFO_REJECT
)
{
finch_media_emit_message
(
gntmedia
,
_
(
"You have rejected the call."
));
}
}
static
void
finch_media_accept_cb
(
PurpleMedia
*
media
,
GntWidget
*
widget
)
{
purple_media_stream_info
(
media
,
PURPLE_MEDIA_INFO_ACCEPT
,
NULL
,
NULL
,
TRUE
);
}
static
void
finch_media_hangup_cb
(
PurpleMedia
*
media
,
GntWidget
*
widget
)
{
purple_media_stream_info
(
media
,
PURPLE_MEDIA_INFO_HANGUP
,
NULL
,
NULL
,
TRUE
);
}
static
void
finch_media_reject_cb
(
PurpleMedia
*
media
,
GntWidget
*
widget
)
{
purple_media_stream_info
(
media
,
PURPLE_MEDIA_INFO_REJECT
,
NULL
,
NULL
,
TRUE
);
}
static
void
finch_media_set_property
(
GObject
*
object
,
guint
prop_id
,
const
GValue
*
value
,
GParamSpec
*
pspec
)
{
FinchMedia
*
media
;
g_return_if_fail
(
FINCH_IS_MEDIA
(
object
));
media
=
FINCH_MEDIA
(
object
);
switch
(
prop_id
)
{
case
PROP_MEDIA
:
g_set_object
(
&
media
->
media
,
g_value_get_object
(
value
));
g_signal_connect_swapped
(
G_OBJECT
(
media
->
accept
),
"activate"
,
G_CALLBACK
(
finch_media_accept_cb
),
media
->
media
);
g_signal_connect_swapped
(
G_OBJECT
(
media
->
reject
),
"activate"
,
G_CALLBACK
(
finch_media_reject_cb
),
media
->
media
);
g_signal_connect_swapped
(
G_OBJECT
(
media
->
hangup
),
"activate"
,
G_CALLBACK
(
finch_media_hangup_cb
),
media
->
media
);
if
(
purple_media_is_initiator
(
media
->
media
,
NULL
,
NULL
))
{
finch_media_wait_cb
(
media
->
media
,
media
);
}
g_signal_connect
(
G_OBJECT
(
media
->
media
),
"state-changed"
,
G_CALLBACK
(
finch_media_state_changed_cb
),
media
);
g_signal_connect
(
G_OBJECT
(
media
->
media
),
"stream-info"
,
G_CALLBACK
(
finch_media_stream_info_cb
),
media
);
break
;
default
:
G_OBJECT_WARN_INVALID_PROPERTY_ID
(
object
,
prop_id
,
pspec
);
break
;
}
}
static
void
finch_media_get_property
(
GObject
*
object
,
guint
prop_id
,
GValue
*
value
,
GParamSpec
*
pspec
)
{
FinchMedia
*
media
;
g_return_if_fail
(
FINCH_IS_MEDIA
(
object
));
media
=
FINCH_MEDIA
(
object
);
switch
(
prop_id
)
{
case
PROP_MEDIA
:
g_value_set_object
(
value
,
media
->
media
);
break
;
default
:
G_OBJECT_WARN_INVALID_PROPERTY_ID
(
object
,
prop_id
,
pspec
);
break
;
}
}
static
GntWidget
*
finch_media_new
(
PurpleMedia
*
media
)
{
return
GNT_WIDGET
(
g_object_new
(
finch_media_get_type
(),
"media"
,
media
,
"vertical"
,
FALSE
,
"homogeneous"
,
FALSE
,
NULL
));
}
static
void
gntmedia_message_cb
(
FinchMedia
*
gntmedia
,
const
char
*
msg
,
PurpleConversation
*
conv
)
{
if
(
PURPLE_IS_IM_CONVERSATION
(
conv
))
{
purple_conversation_write_system_message
(
conv
,
msg
,
0
);
}
}
static
gboolean
finch_new_media
(
PurpleMediaManager
*
manager
,
PurpleMedia
*
media
,
PurpleAccount
*
account
,
gchar
*
name
,
gpointer
null
)
{
GntWidget
*
gntmedia
;
PurpleConversation
*
conv
;
conv
=
PURPLE_CONVERSATION
(
purple_im_conversation_new
(
account
,
name
));
gntmedia
=
finch_media_new
(
media
);
g_signal_connect
(
G_OBJECT
(
gntmedia
),
"message"
,
G_CALLBACK
(
gntmedia_message_cb
),
conv
);
FINCH_MEDIA
(
gntmedia
)
->
conv
=
conv
;
finch_conversation_set_info_widget
(
conv
,
gntmedia
);
return
TRUE
;
}
static
PurpleCmdRet
call_cmd_cb
(
PurpleConversation
*
conv
,
const
char
*
cmd
,
char
**
args
,
char
**
error
,
gpointer
data
)
{
PurpleAccount
*
account
=
purple_conversation_get_account
(
conv
);
if
(
!
purple_protocol_initiate_media
(
account
,
purple_conversation_get_name
(
conv
),
PURPLE_MEDIA_AUDIO
))
return
PURPLE_CMD_RET_FAILED
;
return
PURPLE_CMD_RET_OK
;
}
void
finch_media_manager_init
(
void
)
{
PurpleMediaManager
*
manager
=
purple_media_manager_get
();
PurpleMediaElementInfo
*
audio_src
=
NULL
;
PurpleMediaElementInfo
*
audio_sink
=
NULL
;
const
char
*
pref
;
purple_prefs_add_none
(
FINCH_PREFS_ROOT
"/vvconfig"
);
purple_prefs_add_none
(
FINCH_PREFS_ROOT
"/vvconfig/audio"
);
purple_prefs_add_none
(
FINCH_PREFS_ROOT
"/vvconfig/audio/src"
);
purple_prefs_add_none
(
FINCH_PREFS_ROOT
"/vvconfig/audio/sink"
);
purple_prefs_add_string
(
FINCH_PREFS_ROOT
"/vvconfig/audio/src/device"
,
""
);
purple_prefs_add_string
(
FINCH_PREFS_ROOT
"/vvconfig/audio/sink/device"
,
""
);
pref
=
purple_prefs_get_string
(
FINCH_PREFS_ROOT
"/vvconfig/audio/src/device"
);
if
(
pref
)
audio_src
=
purple_media_manager_get_element_info
(
manager
,
pref
);
if
(
!
audio_src
)
{
pref
=
"autoaudiosrc"
;
purple_prefs_set_string
(
FINCH_PREFS_ROOT
"/vvconfig/audio/src/device"
,
pref
);
audio_src
=
purple_media_manager_get_element_info
(
manager
,
pref
);
}
pref
=
purple_prefs_get_string
(
FINCH_PREFS_ROOT
"/vvconfig/audio/sink/device"
);
if
(
pref
)
audio_sink
=
purple_media_manager_get_element_info
(
manager
,
pref
);
if
(
!
audio_sink
)
{
pref
=
"autoaudiosink"
;
purple_prefs_set_string
(
FINCH_PREFS_ROOT
"/vvconfig/audio/sink/device"
,
pref
);
audio_sink
=
purple_media_manager_get_element_info
(
manager
,
pref
);
}
g_signal_connect
(
G_OBJECT
(
manager
),
"init-media"
,
G_CALLBACK
(
finch_new_media
),
NULL
);
purple_cmd_register
(
"call"
,
""
,
PURPLE_CMD_P_DEFAULT
,
PURPLE_CMD_FLAG_IM
,
NULL
,
call_cmd_cb
,
_
(
"call: Make an audio call."
),
NULL
);
purple_media_manager_set_ui_caps
(
manager
,
PURPLE_MEDIA_CAPS_AUDIO
|
PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION
);
purple_debug_info
(
"gntmedia"
,
"Registering media element types
\n
"
);
purple_media_manager_set_active_element
(
manager
,
audio_src
);
purple_media_manager_set_active_element
(
manager
,
audio_sink
);
}
void
finch_media_manager_uninit
(
void
)
{
PurpleMediaManager
*
manager
=
purple_media_manager_get
();
g_signal_handlers_disconnect_by_func
(
G_OBJECT
(
manager
),
G_CALLBACK
(
finch_new_media
),
NULL
);
}