/**
* ppg_session_connection_connected:
* @connection: (in): A #PkConnection.
* @result: (in): A #GAsyncResult.
* @user_data: (closure): User data for callback.
*
* Callback upon the connection connecting to the agent.
*
* Returns: None.
* Side effects: None.
*/
static void
ppg_session_channel_stopped (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
PpgSession *session = user_data;
PpgSessionPrivate *priv;
GError *error = NULL;
g_return_if_fail(PPG_IS_SESSION(session));
priv = session->priv;
if (!pk_connection_channel_stop_finish(priv->conn, result, &error)) {
ppg_session_report_error(session, G_STRFUNC, error);
g_error_free(error);
return;
/*
* FIXME: We need to make sure we handle this gracefully and stop
* updating the UI. This goes for the rest of the states.
*/
}
priv->state = PPG_SESSION_STOPPED;
g_timer_stop(priv->timer);
ppg_session_stop_position_notifier(session);
g_signal_emit(session, signals[STOPPED], 0);
}
/**
* ppg_memory_instrument_unload:
* @instrument: (in): A #PpgMemoryInstrument.
* @session: (in): A #PpgSession.
* @error: (out): A location for a #GError or %NULL.
*
* Unloads the instrument and destroys remote resources.
*
* Returns: TRUE if successful; otherwise FALSE.
* Side effects: Agent resources are destroyed.
*/
static gboolean
ppg_memory_instrument_unload (PpgInstrument *instrument,
PpgSession *session,
GError **error)
{
PpgMemoryInstrumentPrivate *priv;
PkConnection *conn;
gboolean ret = FALSE;
gboolean removed;
g_return_val_if_fail(PPG_IS_MEMORY_INSTRUMENT(instrument), FALSE);
g_return_val_if_fail(PPG_IS_SESSION(session), FALSE);
priv = PPG_MEMORY_INSTRUMENT(instrument)->priv;
g_object_get(session,
"connection", &conn,
NULL);
RPC_OR_FAILURE(manager_remove_subscription,
(conn, priv->sub, &removed, error));
RPC_OR_FAILURE(manager_remove_source,
(conn, priv->source, error));
failure:
priv->sub = 0;
priv->source = 0;
g_object_unref(conn);
return ret;
}
/**
* ppg_session_channel_unmuted:
* @connection: (in): A #PkConnection.
* @result: (in): A #GAsyncResult.
* @user_data: (closure): User data for callback.
*
* Callback upon the channel unmuting.
*
* Returns: None.
* Side effects: None.
*/
static void
ppg_session_channel_unmuted (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
PpgSession *session = user_data;
PpgSessionPrivate *priv;
GError *error = NULL;
g_return_if_fail(PPG_IS_SESSION(session));
priv = session->priv;
if (!pk_connection_channel_unmute_finish(priv->conn, result, &error)) {
ppg_session_report_error(session, G_STRFUNC, error);
g_error_free(error);
return;
}
/*
* XXX: What do we do here for timer? Add adjust variable?
*/
priv->state = PPG_SESSION_STARTED;
g_timer_start(priv->timer);
ppg_session_start_position_notifier(session);
g_signal_emit(session, signals[UNPAUSED], 0);
}
static void
ppg_instrument_set_session (PpgInstrument *instrument,
PpgSession *session)
{
PpgInstrumentClass *klass;
PpgInstrumentPrivate *priv;
GError *error = NULL;
g_return_if_fail(PPG_IS_INSTRUMENT(instrument));
g_return_if_fail(PPG_IS_SESSION(session));
priv = instrument->priv;
klass = PPG_INSTRUMENT_GET_CLASS(instrument);
priv->session = session;
g_object_add_weak_pointer(G_OBJECT(priv->session), (gpointer *)&priv->session);
if (klass->load) {
if (!klass->load(instrument, session, &error)) {
priv->failed = TRUE;
g_critical("Failed to load instrument %s: %s",
g_type_name(G_TYPE_FROM_INSTANCE(instrument)),
error->message);
/*
* XXX: Should we store the error?
*/
g_error_free(error);
return;
}
}
}
/**
* ppg_session_channel_started:
* @connection: (in): A #PkConnection.
* @result: (in): A #GAsyncResult.
* @user_data: (closure): User data for callback.
*
* Callback upon the channel starting.
*
* Returns: None.
* Side effects: None.
*/
static void
ppg_session_channel_started (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
PpgSession *session = user_data;
PpgSessionPrivate *priv;
GError *error = NULL;
g_return_if_fail(PPG_IS_SESSION(session));
priv = session->priv;
if (!pk_connection_channel_start_finish(priv->conn, result, &error)) {
ppg_session_report_error(session, G_STRFUNC, error);
g_error_free(error);
return;
}
priv->state = PPG_SESSION_STARTED;
priv->timer = g_timer_new();
ppg_session_start_position_notifier(session);
g_message("Channel %d started.", priv->channel);
g_signal_emit(session, signals[STARTED], 0);
}
/**
* ppg_session_channel_muted:
* @connection: (in): A #PkConnection.
* @result: (in): A #GAsyncResult.
* @user_data: (closure): User data for callback.
*
* Callback upon the channel muting.
*
* Returns: None.
* Side effects: None.
*/
static void
ppg_session_channel_muted (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
PpgSession *session = user_data;
PpgSessionPrivate *priv;
GError *error = NULL;
g_return_if_fail(PPG_IS_SESSION(session));
priv = session->priv;
if (!pk_connection_channel_mute_finish(priv->conn, result, &error)) {
ppg_session_report_error(session, G_STRFUNC, error);
g_error_free(error);
return;
}
/*
* XXX: How do we deal with timer skew?
*/
priv->state = PPG_SESSION_PAUSED;
g_timer_stop(priv->timer);
ppg_session_stop_position_notifier(session);
g_signal_emit(session, signals[PAUSED], 0);
}
static void
ppg_configure_instrument_dialog_set_session (PpgConfigureInstrumentDialog *dialog,
PpgSession *session)
{
PpgConfigureInstrumentDialogPrivate *priv;
g_return_if_fail(PPG_IS_CONFIGURE_INSTRUMENT_DIALOG(dialog));
g_return_if_fail(PPG_IS_SESSION(session));
priv = dialog->priv;
priv->session = session;
}
static void
ppg_session_set_env (PpgSession *session,
gchar **env)
{
PpgSessionPrivate *priv;
g_return_if_fail(PPG_IS_SESSION(session));
priv = session->priv;
g_strfreev(priv->env);
priv->env = g_strdupv(env);
g_object_notify(G_OBJECT(session), "env");
}
static void
ppg_session_set_target (PpgSession *session,
const gchar *target)
{
PpgSessionPrivate *priv;
g_return_if_fail(PPG_IS_SESSION(session));
priv = session->priv;
g_free(priv->target);
priv->target = g_strdup(target);
g_object_notify(G_OBJECT(session), "target");
}
static void
ppg_session_set_args (PpgSession *session,
gchar **args)
{
PpgSessionPrivate *priv;
g_return_if_fail(PPG_IS_SESSION(session));
priv = session->priv;
g_strfreev(priv->args);
priv->args = g_strdupv(args);
g_object_notify(G_OBJECT(session), "args");
}
/**
* ppg_session_unpause:
* @session: (in): A #PpgSession.
*
* Unpauses the session.
*
* Returns: None.
* Side effects: None.
*/
void
ppg_session_unpause (PpgSession *session)
{
PpgSessionPrivate *priv;
g_return_if_fail(PPG_IS_SESSION(session));
g_return_if_fail(session->priv->conn != NULL);
g_return_if_fail(session->priv->channel >= 0);
priv = session->priv;
pk_connection_channel_unmute_async(priv->conn, priv->channel, NULL,
ppg_session_channel_unmuted,
session);
}
gdouble
ppg_session_get_position (PpgSession *session)
{
PpgSessionPrivate *priv;
g_return_val_if_fail(PPG_IS_SESSION(session), 0.0);
priv = session->priv;
if (priv->timer) {
return ppg_session_get_position_fast(session);
}
return 0.0;
}
/**
* ppg_session_started:
* @session: (in): A #PpgSession.
*
* Starts the session by starting the channel on the agent.
*
* Returns: None.
* Side effects: None.
*/
void
ppg_session_start (PpgSession *session)
{
PpgSessionPrivate *priv;
g_return_if_fail(PPG_IS_SESSION(session));
g_return_if_fail(session->priv->conn != NULL);
g_return_if_fail(session->priv->channel >= 0);
priv = session->priv;
g_message("Starting channel %d", priv->channel);
pk_connection_channel_start_async(priv->conn, priv->channel, NULL,
ppg_session_channel_started,
session);
}
/**
* ppg_session_set_uri:
* @session: (in): A #PpgSession.
*
* Sets the URI for the session. The session will attempt to connect
* to the target immediately.
*
* Returns: None.
* Side effects: The connection is set and an attempt to connect is made.
*/
static void
ppg_session_set_uri (PpgSession *session,
const gchar *uri)
{
PpgSessionPrivate *priv;
g_return_if_fail(PPG_IS_SESSION(session));
g_return_if_fail(session->priv->conn == NULL);
g_return_if_fail(uri != NULL);
priv = session->priv;
if (!(priv->conn = pk_connection_new_from_uri(uri))) {
g_critical("Invalid URI specified: %s", uri);
return;
}
pk_connection_connect_async(priv->conn, NULL,
ppg_session_connection_connected,
session);
}
/**
* ppg_session_channel_added:
* @connection: (in): A #PkConnection.
* @result: (in): A #GAsyncResult.
* @user_data: (closure): User data for callback.
*
* Callback upon the channel being created.
*
* Returns: None.
* Side effects: None.
*/
static void
ppg_session_channel_added (GObject *connection,
GAsyncResult *result,
gpointer user_data)
{
PpgSession *session = user_data;
PpgSessionPrivate *priv;
GError *error = NULL;
g_return_if_fail(PPG_IS_SESSION(session));
priv = session->priv;
if (!pk_connection_manager_add_channel_finish(priv->conn, result,
&priv->channel, &error)) {
ppg_session_report_error(session, G_STRFUNC, error);
g_error_free(error);
return;
}
g_signal_emit(session, signals[READY], 0);
}
PpgSessionState
ppg_session_get_state (PpgSession *session)
{
g_return_val_if_fail(PPG_IS_SESSION(session), 0);
return session->priv->state;
}
static const gchar *
ppg_session_get_target (PpgSession *session)
{
g_return_val_if_fail(PPG_IS_SESSION(session), NULL);
return session->priv->target;
}
