/**
* libmatrix.c
*
* This file exists to define the top-level PurplePluginInfo and
* PurplePluginProtocolInfo structures which are used to integrate with
* libpurple, and the callbacks which they refer to.
*
*
*
* 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 "libmatrix.h"
#include <glib.h>
#include "account.h"
#include "accountopt.h"
#include "blist.h"
#include "connection.h"
#include "debug.h"
#include "prpl.h"
#include "version.h"
#include "matrix-connection.h"
#include "matrix-e2e.h"
#include "matrix-room.h"
#include "matrix-api.h"
/**
* Called to get the icon name for the given buddy and account.
*
* If buddy is NULL and the account is non-NULL, it will return the
* name to use for the account's icon. If both are NULL, it will
* return the name to use for the protocol's icon.
*
* For now, everything just uses the 'matrix' icon.
*/
static const char *matrixprpl_list_icon(PurpleAccount *acct, PurpleBuddy *buddy)
{
return "matrix";
}
/**
* Called to get a list of the PurpleStatusType which are valid for this account
*
* (currently, we don't really implement any, but we have to return something
* here)
*/
static GList *matrixprpl_status_types(PurpleAccount *acct)
{
GList *types = NULL;
PurpleStatusType *type;
type = purple_status_type_new(PURPLE_STATUS_OFFLINE, "Offline", NULL,
TRUE);
types = g_list_prepend(types, type);
type = purple_status_type_new(PURPLE_STATUS_AVAILABLE, "Online", NULL,
TRUE);
types = g_list_prepend(types, type);
return types;
}
/**
* handle sending typing notifications in a chat
*/
static guint matrixprpl_conv_send_typing(PurpleConversation *conv,
PurpleTypingState state, gpointer ignored)
{
PurpleConnection *pc = purple_conversation_get_gc(conv);
if (!PURPLE_CONNECTION_IS_CONNECTED(pc))
return 0;
if (g_strcmp0(purple_plugin_get_id(purple_connection_get_prpl(pc)), PRPL_ID))
return 0;
matrix_room_send_typing(conv, (state == PURPLE_TYPING));
return 20;
}
/**
* Start the connection to a matrix account
*/
void matrixprpl_login(PurpleAccount *acct)
{
PurpleConnection *pc = purple_account_get_connection(acct);
matrix_connection_new(pc);
matrix_connection_start_login(pc);
purple_signal_connect(purple_conversations_get_handle(), "chat-conversation-typing",
acct, PURPLE_CALLBACK(matrixprpl_conv_send_typing), pc);
pc->flags |= PURPLE_CONNECTION_HTML;
}
/**
* Called to handle closing the connection to an account
*/
static void matrixprpl_close(PurpleConnection *pc)
{
matrix_connection_cancel_sync(pc);
matrix_connection_free(pc);
}
/**
* Get the list of information we need to add a chat to our buddy list.
*
* The first entry is special, and represents the unique "name" by which the
* chat is identified in the buddy list with purple_blist_find_chat. In our case
* that is room_id.
*/
static GList *matrixprpl_chat_info(PurpleConnection *gc)
{
struct proto_chat_entry *pce; /* defined in prpl.h */
pce = g_new0(struct proto_chat_entry, 1);
pce->label = _("Room id");
pce->identifier = PRPL_CHAT_INFO_ROOM_ID;
pce->required = TRUE;
return g_list_append(NULL, pce);
}
/* Get the defaults for the chat_info entries */
static GHashTable *matrixprpl_chat_info_defaults(PurpleConnection *gc,
const char *room)
{
GHashTable *defaults;
defaults = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free);
return defaults;
}
/* Get the name of a chat (as passed to serv_got_joined_chat) given the
* chat_info entries. For us this is the room id so this is easy
*/
static char *matrixprpl_get_chat_name(GHashTable *components)
{
const char *room = g_hash_table_lookup(components, PRPL_CHAT_INFO_ROOM_ID);
return g_strdup(room);
}
/**
* Handle a double-click on a chat in the buddy list, or acceptance of a chat
* invite: it is expected that we join the chat.
*/
static void matrixprpl_join_chat(PurpleConnection *gc, GHashTable *components)
{
const char *room = g_hash_table_lookup(components, PRPL_CHAT_INFO_ROOM_ID);
int chat_id = g_str_hash(room);
PurpleConversation *conv;
PurpleConvChat *chat;
conv = purple_find_chat(gc, chat_id);
if(!conv) {
matrix_connection_join_room(gc, room, components);
return;
}
/* already in chat. This happens when the account was disconnected,
* and has now been asked to reconnect.
*
* If we've got this far, chances are that we are correctly joined to
* the room.
*/
chat = PURPLE_CONV_CHAT(conv);
chat->left = FALSE;
if (!g_slist_find(gc->buddy_chats, conv))
gc->buddy_chats = g_slist_append(gc->buddy_chats, conv);
purple_conversation_update(conv, PURPLE_CONV_UPDATE_CHATLEFT);
}
/**
* Handle refusing a chat invite.
*/
static void matrixprpl_reject_chat(PurpleConnection *gc, GHashTable *components)
{
const char *room_id = g_hash_table_lookup(components,
PRPL_CHAT_INFO_ROOM_ID);
matrix_connection_reject_invite(gc, room_id);
}
static void matrixprpl_chat_invite(PurpleConnection *gc, int id,
const char *message, const char *who)
{
PurpleConversation *conv = purple_find_chat(gc, id);
MatrixConnectionData *conn;
conn = (MatrixConnectionData *)(conv->account->gc->proto_data);
matrix_api_invite_user(conn, conv->name, who, NULL, NULL, NULL, NULL);
}
/**
* handle leaving a chat: notify the server that we are leaving, and
* (ultimately) free the memory structures associated with it
*/
static void matrixprpl_chat_leave(PurpleConnection *gc, int id) {
PurpleConversation *conv = purple_find_chat(gc, id);
purple_debug_info("matrixprpl", "%s is leaving chat room %s\n",
gc->account->username, conv->name);
matrix_room_leave_chat(conv);
}
/**
* handle sending messages in a chat
*/
static int matrixprpl_chat_send(PurpleConnection *gc, int id,
const char *message, PurpleMessageFlags flags) {
PurpleConversation *conv = purple_find_chat(gc, id);
if(!conv) {
purple_debug_info("matrixprpl",
"tried to send message to chat room #%d but couldn't find "
"chat room", id);
return -1;
}
matrix_room_send_message(conv, message);
return 0;
}
/**
* Get the user_id of a user, given their displayname in a room
*
* @returns a string, which will be freed by the caller
*/
static char *matrixprpl_get_cb_real_name(PurpleConnection *gc, int id,
const char *who)
{
PurpleConversation *conv = purple_find_chat(gc, id);
gchar *res;
if(conv == NULL)
return NULL;
res = matrix_room_displayname_to_userid(conv, who);
purple_debug_info("matrixprpl", "%s's real id in %s is %s\n", who,
conv->name, res);
return res;
}
/******************************************************************************
*
* prpl stuff. see prpl.h for more information.
*/
static PurplePluginProtocolInfo prpl_info =
{
OPT_PROTO_UNIQUE_CHATNAME | OPT_PROTO_CHAT_TOPIC |
OPT_PROTO_PASSWORD_OPTIONAL |
OPT_PROTO_IM_IMAGE, /* options */
NULL, /* user_splits, initialized in matrixprpl_init() */
NULL, /* protocol_options, initialized in matrixprpl_init() */
{ /* icon_spec, a PurpleBuddyIconSpec */
"png,jpg,gif", /* format */
0, /* min_width */
0, /* min_height */
128, /* max_width */
128, /* max_height */
10000, /* max_filesize */
PURPLE_ICON_SCALE_DISPLAY, /* scale_rules */
},
matrixprpl_list_icon, /* list_icon */
NULL, /* list_emblem */
NULL, /* status_text */
NULL, /* tooltip_text */
matrixprpl_status_types, /* status_types */
NULL, /* blist_node_menu */
matrixprpl_chat_info, /* chat_info */
matrixprpl_chat_info_defaults, /* chat_info_defaults */
matrixprpl_login, /* login */
matrixprpl_close, /* close */
NULL, /* send_im */
NULL, /* set_info */
NULL, /* send_typing */
NULL, /* get_info */
NULL, /* set_status */
NULL, /* set_idle */
NULL, /* change_passwd */
NULL, /* add_buddy */
NULL, /* add_buddies */
NULL, /* remove_buddy */
NULL, /* remove_buddies */
NULL, /* add_permit */
NULL, /* add_deny */
NULL, /* rem_permit */
NULL, /* rem_deny */
NULL, /* set_permit_deny */
matrixprpl_join_chat, /* join_chat */
matrixprpl_reject_chat, /* reject_chat */
matrixprpl_get_chat_name, /* get_chat_name */
matrixprpl_chat_invite, /* chat_invite */
matrixprpl_chat_leave, /* chat_leave */
NULL, /* chat_whisper */
matrixprpl_chat_send, /* chat_send */
NULL, /* keepalive */
NULL, /* register_user */
NULL, /* get_cb_info */
NULL, /* get_cb_away */
NULL, /* alias_buddy */
NULL, /* group_buddy */
NULL, /* rename_group */
NULL, /* buddy_free */
NULL, /* convo_closed */
NULL, /* normalize */
NULL, /* set_buddy_icon */
NULL, /* remove_group */
matrixprpl_get_cb_real_name, /* get_cb_real_name */
NULL, /* set_chat_topic */
NULL, /* find_blist_chat */
NULL, /* roomlist_get_list */
NULL, /* roomlist_cancel */
NULL, /* roomlist_expand_category */
NULL, /* can_receive_file */
NULL, /* send_file */
NULL, /* new_xfer */
NULL, /* offline_message */
NULL, /* whiteboard_prpl_ops */
NULL, /* send_raw */
NULL, /* roomlist_room_serialize */
NULL, /* unregister_user */
NULL, /* send_attention */
NULL, /* get_attention_types */
sizeof(PurplePluginProtocolInfo), /* struct_size */
NULL, /* get_account_text_table */
NULL, /* initiate_media */
NULL, /* get_media_caps */
NULL, /* get_moods */
NULL, /* set_public_alias */
NULL, /* get_public_alias */
NULL, /* add_buddy_with_invite */
NULL /* add_buddies_with_invite */
};
static void matrixprpl_init(PurplePlugin *plugin)
{
GList *protocol_options = NULL;
purple_debug_info("matrixprpl", "starting up\n");
protocol_options = g_list_append(protocol_options,
purple_account_option_string_new(
_("Home server URL"), PRPL_ACCOUNT_OPT_HOME_SERVER,
DEFAULT_HOME_SERVER));
protocol_options = g_list_append(protocol_options,
purple_account_option_bool_new(
_("On reconnect, skip messages which were received in a "
"previous session"),
PRPL_ACCOUNT_OPT_SKIP_OLD_MESSAGES, FALSE));
protocol_options = g_list_append(protocol_options,
purple_account_option_bool_new(
_("Prefer Markdown over HTML"),
PRPL_ACCOUNT_OPT_PREFER_MARKDOWN, FALSE));
prpl_info.protocol_options = protocol_options;
}
static void matrixprpl_destroy(PurplePlugin *plugin) {
purple_debug_info("matrixprpl", "shutting down\n");
}
static GList *matrixprpl_actions(PurplePlugin *plugin, gpointer context)
{
GList *list = NULL;
list = matrix_e2e_actions(list);
return list;
}
static PurplePluginInfo info =
{
PURPLE_PLUGIN_MAGIC, /* magic */
PURPLE_MAJOR_VERSION, /* major_version */
PURPLE_MINOR_VERSION, /* minor_version */
PURPLE_PLUGIN_PROTOCOL, /* type */
NULL, /* ui_requirement */
0, /* flags */
NULL, /* dependencies */
PURPLE_PRIORITY_DEFAULT, /* priority */
PRPL_ID, /* id */
"Matrix", /* name */
DISPLAY_VERSION, /* version */
N_("Matrix Protocol Plugin"), /* summary */
N_("Matrix Protocol Plugin"), /* description */
"Richard van der Hoff <richard@matrix.org>", /* author */
MATRIX_WEBSITE, /* homepage */
NULL, /* load */
NULL, /* unload */
matrixprpl_destroy, /* destroy */
NULL, /* ui_info */
&prpl_info, /* extra_info */
NULL, /* prefs_info */
matrixprpl_actions, /* actions */
NULL, /* padding... */
NULL,
NULL,
NULL,
};
PURPLE_INIT_PLUGIN(matrix, matrixprpl_init, info);
