pidgin/pidgin

Stop automatically adding/remove conversations from the conversation manager

7 weeks ago, Gary Kramlich
8019945e1c21
Stop automatically adding/remove conversations from the conversation manager

This was done to mimic the old conversations API and shouldn't be needed going
forward. However, since we can't create conversations right now, we're probably
missing some edge cases here.

Also make sure to keep a reference around on the conversation while removing to avoid use after frees.

Testing Done:
Trained with the turtles.

Reviewed at https://reviews.imfreedom.org/r/3049/
/*
* 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/>.
*/
#if !defined(PURPLE_GLOBAL_HEADER_INSIDE) && !defined(PURPLE_COMPILATION)
# error "only <purple.h> may be included directly"
#endif
#ifndef PURPLE_MEDIA_MANAGER_H
#define PURPLE_MEDIA_MANAGER_H
#include <glib.h>
#include <glib-object.h>
typedef struct _PurpleMediaManager PurpleMediaManager;
#include "media.h"
#include "purpleaccount.h"
#include "purpleversion.h"
#define PURPLE_TYPE_MEDIA_MANAGER purple_media_manager_get_type()
/**
* PurpleMediaManagerClass:
*
* The media manager class.
*
* Since: 2.6
*/
/**
* PurpleMediaAppDataCallbacks:
* @readable: Called when the stream has received data and is readable.
* @writable: Called when the stream has become writable or has stopped being
* writable.
*
* A set of callbacks that can be installed on an Application data session with
* purple_media_manager_set_application_data_callbacks()
*
* Once installed the @readable callback will get called as long as data is
* available to read, so the data must be read completely.
* The @writable callback will only be called when the writable state of the
* stream changes. The @writable argument defines whether the stream has
* become writable or stopped being writable.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_TYPE_IN_2_6
typedef struct {
void (*readable) (PurpleMediaManager *manager, PurpleMedia *media,
const gchar *session_id, const gchar *participant, gpointer user_data);
void (*writable) (PurpleMediaManager *manager, PurpleMedia *media,
const gchar *session_id, const gchar *participant, gboolean writable,
gpointer user_data);
} PurpleMediaAppDataCallbacks;
G_BEGIN_DECLS
/**************************************************************************/
/* Media Manager API */
/**************************************************************************/
PURPLE_AVAILABLE_IN_2_6
G_DECLARE_FINAL_TYPE(PurpleMediaManager, purple_media_manager, PURPLE,
MEDIA_MANAGER, GObject)
/**
* purple_media_manager_get:
*
* Gets the "global" media manager object. It's created if it doesn't already exist.
*
* Returns: (transfer none): The "global" instance of the media manager object.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
PurpleMediaManager *purple_media_manager_get(void);
/**
* purple_media_manager_create_media:
* @manager: The media manager to create the session under.
* @account: The account to create the session on.
* @conference_type: The conference type to feed into Farstream.
* @remote_user: The remote user to initiate the session with.
* @initiator: TRUE if the local user is the initiator of this media call, FALSE otherwise.
*
* Creates a media session.
*
* Returns: (transfer full): A newly created media session.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
PurpleMedia *purple_media_manager_create_media(PurpleMediaManager *manager,
PurpleAccount *account,
const char *conference_type,
const char *remote_user,
gboolean initiator);
/**
* purple_media_manager_get_media:
* @manager: The media manager to get all of the sessions from.
*
* Gets all of the media sessions.
*
* Returns: (transfer none) (element-type PurpleMedia): A list of all the media sessions.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
GList *purple_media_manager_get_media(PurpleMediaManager *manager);
/**
* purple_media_manager_get_media_by_account:
* @manager: The media manager to get the sessions from.
* @account: The account the sessions are on.
*
* Gets all of the media sessions for a given account.
*
* Returns: (transfer container) (element-type PurpleMedia): A list of the media sessions on the given account.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
GList *purple_media_manager_get_media_by_account(
PurpleMediaManager *manager, PurpleAccount *account);
/**
* purple_media_manager_remove_media:
* @manager: The media manager to remove the media session from.
* @media: The media session to remove.
*
* Removes a media session from the media manager.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
void
purple_media_manager_remove_media(PurpleMediaManager *manager,
PurpleMedia *media);
/**
* purple_media_manager_create_private_media:
* @manager: The media manager to create the session under.
* @account: The account to create the session on.
* @conference_type: The conference type to feed into Farstream.
* @remote_user: The remote user to initiate the session with.
* @initiator: TRUE if the local user is the initiator of this media call, FALSE otherwise.
*
* Creates a private media session.
* A private media session is a media session which is private to the caller. It is
* meant to be used by plugins to create a media session that the front-end does not
* get notified about. It is useful especially for sessions with a type of
* PURPLE_MEDIA_APPLICATION which the front-end wouldn't know how to handle.
*
* Returns: (transfer full): A newly created media session.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
PurpleMedia *purple_media_manager_create_private_media(
PurpleMediaManager *manager,
PurpleAccount *account,
const char *conference_type,
const char *remote_user,
gboolean initiator);
/**
* purple_media_manager_get_private_media:
* @manager: The media manager to get all of the sessions from.
*
* Gets all of the private media sessions.
*
* Returns: (transfer none) (element-type PurpleMedia): A list of all the private media sessions.
*
* Since: 2.11
*/
PURPLE_AVAILABLE_IN_2_11
GList *purple_media_manager_get_private_media(PurpleMediaManager *manager);
/**
* purple_media_manager_get_private_media_by_account:
* @manager: The media manager to get the sessions from.
* @account: The account the sessions are on.
*
* Gets all of the private media sessions for a given account.
*
* Returns: (transfer container) (element-type PurpleMedia): A list of the private media sessions on the given account.
*
* Since: 2.11
*/
PURPLE_AVAILABLE_IN_2_11
GList *purple_media_manager_get_private_media_by_account(
PurpleMediaManager *manager, PurpleAccount *account);
/**
* purple_media_manager_create_output_window:
* @manager: Manager the output windows are registered with.
* @media: Media session the output windows are registered for.
* @session_id: The session the output windows are registered with.
* @participant: The participant the output windows are registered with.
*
* Signals that output windows should be created for the chosen stream.
*
* This shouldn't be called outside of mediamanager.c and media.c
*
* Returns: TRUE if it succeeded, FALSE if it failed.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
gboolean purple_media_manager_create_output_window(
PurpleMediaManager *manager, PurpleMedia *media,
const gchar *session_id, const gchar *participant);
/**
* purple_media_manager_set_output_window:
* @manager: The manager to register the output window with.
* @media: The media instance to find the stream in.
* @session_id: The session the stream is associated with.
* @participant: The participant the stream is associated with.
*
* Registers a video output window to be created for a given stream.
*
* Returns: A unique ID to the registered output window, 0 if it failed.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
gulong purple_media_manager_set_output_window(PurpleMediaManager *manager,
PurpleMedia *media, const gchar *session_id,
const gchar *participant);
/**
* purple_media_manager_remove_output_window:
* @manager: The manager the output window was registered with.
* @output_window_id: The ID of the output window.
*
* Remove a previously registered output window.
*
* Returns: TRUE if it found the output window and was successful, else FALSE.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
gboolean purple_media_manager_remove_output_window(
PurpleMediaManager *manager, gulong output_window_id);
/**
* purple_media_manager_remove_output_windows:
* @manager: The manager the output windows were registered with.
* @media: The media instance the output windows were registered for.
* @session_id: The session the output windows were registered for.
* @participant: The participant the output windows were registered for.
*
* Remove all output windows for a given conference/session/participant/stream.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
void purple_media_manager_remove_output_windows(
PurpleMediaManager *manager, PurpleMedia *media,
const gchar *session_id, const gchar *participant);
/**
* purple_media_manager_set_ui_caps:
* @manager: The manager to set the caps on.
* @caps: The caps to set.
*
* Sets which media caps the UI supports.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
void purple_media_manager_set_ui_caps(PurpleMediaManager *manager,
PurpleMediaCaps caps);
/**
* purple_media_manager_get_ui_caps:
* @manager: The manager to get caps from.
*
* Gets which media caps the UI supports.
*
* Returns: caps The caps retrieved.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
PurpleMediaCaps purple_media_manager_get_ui_caps(PurpleMediaManager *manager);
/**
* purple_media_manager_set_backend_type:
* @manager: The manager to set the caps on.
* @backend_type: The media backend type to use.
*
* Sets which media backend type media objects will use.
*
* Since: 2.7
*/
PURPLE_AVAILABLE_IN_2_7
void purple_media_manager_set_backend_type(PurpleMediaManager *manager,
GType backend_type);
/**
* purple_media_manager_get_backend_type:
* @manager: The manager to get the media backend type from.
*
* Gets which media backend type media objects will use.
*
* Returns: The type of media backend type media objects will use.
*
* Since: 2.7
*/
PURPLE_AVAILABLE_IN_2_7
GType purple_media_manager_get_backend_type(PurpleMediaManager *manager);
/**
* purple_media_manager_set_application_data_callbacks:
* @manager: The manager to register the callbacks with.
* @media: The media instance to register the callbacks with.
* @session_id: The session to register the callbacks with.
* @participant: The participant to register the callbacks with.
* @callbacks: The callbacks to be set on the session.
* @user_data: a user_data argument for the callbacks.
* @notify: a destroy notify function.
*
* Set callbacks on a session to be called when the stream becomes writable
* or readable for media sessions of type #PURPLE_MEDIA_APPLICATION
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
void purple_media_manager_set_application_data_callbacks(
PurpleMediaManager *manager, PurpleMedia *media, const gchar *session_id,
const gchar *participant, PurpleMediaAppDataCallbacks *callbacks,
gpointer user_data, GDestroyNotify notify);
/**
* purple_media_manager_send_application_data:
* @manager: The manager to send data with.
* @media: The media instance to which the session belongs.
* @session_id: The session to send data to.
* @participant: The participant to send data to.
* @buffer: The buffer of data to send.
* @size: The size of @buffer
* @blocking: Whether to block until the data was send or not.
*
* Sends a buffer of data to a #PURPLE_MEDIA_APPLICATION session.
* If @blocking is set, unless an error occurred, the function will not return
* until the data has been flushed into the network.
* If the stream is not writable, the data will be queued. It is the
* responsibility of the user to stop sending data when the stream isn't
* writable anymore. It is also the responsibility of the user to only start
* sending data after the stream has been configured correctly (encryption
* parameters for example).
*
* Returns: Number of bytes sent or -1 in case of error.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
gint purple_media_manager_send_application_data (
PurpleMediaManager *manager, PurpleMedia *media, const gchar *session_id,
const gchar *participant, gpointer buffer, guint size, gboolean blocking);
/**
* purple_media_manager_receive_application_data:
* @manager: The manager to receive data with.
* @media: The media instance to which the session belongs.
* @session_id: The session to receive data from.
* @participant: The participant to receive data from.
* @buffer: The buffer to receive data into.
* @max_size: The max_size of @buffer
* @blocking: Whether to block until the buffer is entirely filled or return
* with currently available data.
*
* Receive a buffer of data from a #PURPLE_MEDIA_APPLICATION session.
* If @blocking is set, unless an error occurred, the function will not return
* until @max_size bytes are read.
*
* Returns: Number of bytes received or -1 in case of error.
*
* Since: 2.6
*/
PURPLE_AVAILABLE_IN_2_6
gint purple_media_manager_receive_application_data (
PurpleMediaManager *manager, PurpleMedia *media, const gchar *session_id,
const gchar *participant, gpointer buffer, guint max_size,
gboolean blocking);
/*}@*/
G_END_DECLS
#endif /* PURPLE_MEDIA_MANAGER_H */