path: root/src/conversation/gnunet-conversation-gtk_phone.c

/*
     This file is part of GNUnet.
     (C) 2010-2014 Christian Grothoff (and other contributing authors)

     GNUnet 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 3, or (at your
     option) any later version.

     GNUnet 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 GNUnet; see the file COPYING.  If not, write to the
     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
*/

/**
 * @file src/conversation/gnunet-conversation-gtk_phone.c
 * @brief main logic to manage phone calls
 * @author yids
 * @author hark
 * @author Christian Grothoff
 */
#include "gnunet-conversation-gtk.h"
#include "gnunet-conversation-gtk_egos.h"
#include "gnunet-conversation-gtk_history.h"
#include "gnunet-conversation-gtk_log.h"
#include "gnunet-conversation-gtk_phone.h"


/**
 * active calls treeview columns
 */
enum ActiveCallsTreeViewColumns
{
  AL_caller_id, //*gchar
  AL_caller,  //*
  AL_caller_num, //gint
  AL_type, //gint
  AL_caller_state, //gint
  AL_call, //*
  AL_call_state, //gint
  AL_call_num //gint
};


/**
 * callerstate (state of incoming call)
 */
enum CallerState
{
  CT_active,
  CT_suspended,
  CT_ringing,
  CT_dead,
  CT_hangup,
  CT_rejected,
  CT_other
};


/**
 * type of call
 */
enum TypeOfCall
{
  CALL_IN,
  CALL_OUT
};


/**
 * Possible states of the phone.
 */
enum PhoneState
{
  /**
   * We're waiting for our own idenitty.
   */
  PS_LOOKUP_EGO,

  /**
   * We're listening for calls
   */
  PS_LISTEN,

  /**
   * We accepted an incoming phone call.
   */
  PS_ACCEPTED,

  /**
   * Internal error
   */
  PS_ERROR
};


/**
 * States for current outgoing call.
 */
enum CallState
{
  /**
   * We are looking up some other participant.
   */
  CS_RESOLVING,

  /**
   * We are now ringing the other participant.
   */
  CS_RINGING,

  /**
   * The other party accepted our call and we are now connected.
   */
  CS_CONNECTED,

  /**
   * The call is currently suspended (by us).
   */
  CS_SUSPENDED
};



/**
 * List of incoming calls
 */
struct CallList
{

  /**
   * A DLL.
   */
  struct CallList *prev;

  /**
   * A DLL.
   */
  struct CallList *next;

  /**
   * Handle to hang up or activate.
   */
  struct GNUNET_CONVERSATION_Caller *caller;

  /**
   * Handle to call currently selected in list
   */
  struct GNUNET_CONVERSATION_Caller *caller_selected;

  /**
   * String identifying the caller.
   */
  char *caller_id;

  /**
   * Unique number of the caller.
   */
  unsigned int caller_num;

};


/**
 *
 */
static struct GNUNET_CONVERSATION_Caller *caller_selected;

/**
 *
 */
static struct GNUNET_CONVERSATION_Call *call_selected;


/**
 * List of active calls
 */
static GtkListStore *active_liststore;

/**
 * List of active calls
 */
static GtkTreeView *active_treeview;

/**
 * Unique number of call (outgoing)
 */
static unsigned int call_counter;

/**
 * Counts the number of incoming calls we have had so far.
 */
static unsigned int caller_num_gen;

/**
 * Phone handle
 */
static struct GNUNET_CONVERSATION_Phone *phone;

/**
 * Call handle (for active outgoing call).
 */
static struct GNUNET_CONVERSATION_Call *call;

/**
 * Caller handle (for active incoming call).
 */
static struct CallList *cl_active;

/**
 * Head of calls waiting to be accepted.
 */
static struct CallList *cl_head;

/**
 * Tail of calls waiting to be accepted.
 */
static struct CallList *cl_tail;

/**
 * Our speaker.
 */
static struct GNUNET_SPEAKER_Handle *speaker;

/**
 * Our microphone.
 */
static struct GNUNET_MICROPHONE_Handle *mic;

/**
 * Our phone's current state.
 */
static enum PhoneState phone_state;

/**
 * Our call's current state.
 */
static enum CallState call_state;

/**
 * Name of conversation partner (if any).
 */
static char *peer_name;

/**
 * GNS address for this phone.
 */
static char *address;

static GtkWidget *b_add_contact;

static GtkWidget *b_accept;

static GtkWidget *b_refuse;

static GtkWidget *b_suspend; // pause

static GtkWidget *b_resume;

static GtkWidget *b_call; // connect

static GtkWidget *b_hangup; // disconnect up



/**
 * Update status based on current phone state.
 *
 * @param args arguments given to the command
 */
static void
do_status ()
{
  switch (phone_state)
  {
  case PS_LOOKUP_EGO:
    GCG_update_status_bar ("%s",
                       _("Phone inactive: no ego selected for the caller ID."));
    GCG_set_status_icon ("gnunet-conversation-gtk-tray-pending");
    break;
  case PS_LISTEN:
    GCG_update_status_bar ("%s",
                       _("We are listening for incoming calls"));
    GCG_set_status_icon ("gnunet-conversation-gtk-tray-available");
    break;
  case PS_ACCEPTED:
    GCG_update_status_bar (_("You are having a conversation with `%s'.\n"),
                       peer_name);
    GCG_set_status_icon ("gnunet-conversation-call-active");
    break;
  case PS_ERROR:
    GCG_update_status_bar (_("We had an internal error setting up our phone line. You can still make calls."));
    GCG_set_status_icon ("gnunet-conversation-offline");
    break;
  }
  if (NULL != call)
  {
    switch (call_state)
    {
    case CS_RESOLVING:
      GCG_update_status_bar (_("We are trying to find the network address to call `%s'."),
                         peer_name);
      GCG_set_status_icon ("gnunet-conversation-gtk-tray-call-pending");
      break;
    case CS_RINGING:
      GCG_update_status_bar (_("We are calling `%s', his phone should be ringing."),
                         peer_name);
      GCG_set_status_icon ("gnunet-conversation-gtk-tray-call-ringing");
      break;
    case CS_CONNECTED:
      GCG_update_status_bar (_("You are having a conversation with `%s'."),
                         peer_name);
      GCG_set_status_icon ("gnunet-conversation-gtk-tray-call-active");
      break;
    case CS_SUSPENDED:
      GCG_update_status_bar (_("Conversation suspended, you can accept or initiate another call now."),
                         peer_name);
      GCG_set_status_icon ("gnunet-conversation-gtk-tray-call-suspended");
      break;
    }
  }
  if ( ( (NULL == call) ||
         (CS_SUSPENDED == call_state) ) &&
       (NULL != cl_head) &&
       ( (cl_head != cl_active) ||
         (cl_head != cl_tail) ) )
    GCG_set_status_icon ("gnunet-conversation-gtk-tray-call-incoming");
}



/**
 * @brief print info for currently selected call
 */
static void
print_call_info ()
{
  GtkTreeIter gtkiter;
  gboolean valid;
  gint row_count = 0;

  valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (active_liststore),
                                         &gtkiter);
  if (! valid)
    GNUNET_break(0);

  while (valid)
  {
    gchar *str_data;
    gint   int_data;
    gpointer cl_caller;
    gpointer cl_call;

    gtk_tree_model_get (GTK_TREE_MODEL (active_liststore),
                        &gtkiter,
                        AL_caller,     &cl_caller,
                        AL_caller_id,  &str_data,
                        AL_caller_num, &int_data,
                        AL_call,       &cl_call,
                        -1);
    if (call_selected == cl_call)
    {
      GCG_log (_("info for active outgoing call:%s number: %u row: %u"),
               str_data,
               int_data,
               row_count);
      break;
    }
    g_free (str_data);
    row_count++;
    valid = gtk_tree_model_iter_next (GTK_TREE_MODEL(active_liststore), &gtkiter);
  }
}


/**
 * @brief sets caller_selected, and enables or disables the active call list buttons
 */
static void
update_active_call_list_buttons ()
{
  gchar *caller_id;
  gpointer cl_caller;
  gpointer cl_call;
  gint     cl_caller_state;
  gint     cl_type;
  //gint     cl_caller_type;
  GtkTreeSelection *active_selection;
  GtkTreeIter gcl_selected;
  //   active_liststore_selection = GCG_get_main_window_object(ml,"GNUNET_CONVERSATION_GTK_active_calls_selection");

  // reset references to selected call/caller
  //caller_selected = NULL;
  //call_selected = NULL;
  GCG_log("reset caller selected");
  active_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (active_treeview));
  if (gtk_tree_selection_get_selected (active_selection,
                                       NULL,
                                       &gcl_selected))
  {
    // get selected call
    gtk_tree_model_get (GTK_TREE_MODEL(active_liststore), &gcl_selected,
                        AL_caller, &cl_caller, // reference to incoming call
                        AL_caller_id, &caller_id,
                        AL_caller_state, &cl_caller_state,
                        AL_type, &cl_type,
                        AL_call, &cl_call, // reference to outgoing call
                        -1);
    // check if selected call is a incoming or outgoing call
    switch (cl_type)
    {
    case CALL_IN:
      call_selected = NULL;
      caller_selected = cl_caller;
      GNUNET_break (NULL != caller_selected);
      break;
    case CALL_OUT:
      caller_selected = NULL;
      call_selected = cl_call;
      GCG_log("outgoing selected");
      GNUNET_break (NULL != call_selected);
      break;
    default:
      GNUNET_break(0);
      break;
    }
    gtk_widget_show(GTK_WIDGET(GCG_get_main_window_object("GNUNET_GTK_conversation_active_call_list_buttons")));
    GCG_log("caller state: %u phone_state: %u",
            cl_caller_state,
            phone_state);
    switch (cl_caller_state)
    {
      /* buttons:
       *  contact
       *  accept
       *  hangup
       *  suspend
       *  resume
       *
       *  TODO: check if there is incoming or outgoing call,
       *         disable resume and accept buttons.
       *         or suspend that other call
       */
    case CT_active:
      // hangup, pause
      //GCG_log("CT_active state: %u ",cl_caller_state);
      gtk_widget_set_sensitive (b_add_contact, TRUE);
      gtk_widget_set_sensitive (b_accept, FALSE);
      gtk_widget_set_sensitive (b_hangup, TRUE);
      gtk_widget_set_sensitive (b_suspend, TRUE);
      gtk_widget_set_sensitive (b_resume, FALSE);
      break;
    case CT_ringing:
      // pickup, phonebook
      //GCG_log("CT_ring show button");
      gtk_widget_set_sensitive (b_add_contact, TRUE);
      if (phone_state == PS_LISTEN)
      {
        gtk_widget_set_sensitive (b_accept, TRUE);
      }
      else
      {
        gtk_widget_set_sensitive (b_accept, FALSE);
      }
      gtk_widget_set_sensitive (b_hangup, FALSE);
      gtk_widget_set_sensitive (b_suspend, FALSE);
      gtk_widget_set_sensitive (b_resume, FALSE);
      break;
    case CT_rejected:
      //add to phonebook
      //GCG_log("CT_rejected ");
      gtk_widget_set_sensitive (b_add_contact, TRUE);
      gtk_widget_set_sensitive (b_accept, FALSE);
      gtk_widget_set_sensitive (b_hangup, FALSE);
      gtk_widget_set_sensitive (b_suspend, FALSE);
      gtk_widget_set_sensitive (b_resume, FALSE);
      break;
    case CT_suspended:
      // resume, hangup
      //GCG_log("CT_suspended ");
      gtk_widget_set_sensitive (b_add_contact, TRUE);
      gtk_widget_set_sensitive (b_accept, FALSE);
      gtk_widget_set_sensitive (b_hangup, TRUE);
      gtk_widget_set_sensitive (b_suspend, FALSE);
      if (phone_state == PS_LISTEN)
      {
        GCG_log("enable resume button");
        gtk_widget_set_sensitive (b_resume, TRUE);
      }
      else
      {
        GCG_log("do not disable resume button (for test)");
        gtk_widget_set_sensitive (b_resume, TRUE);
      }
      break;
    case CT_other:
      //add to phonebook
      //GCG_log("CT_rejected ");
      gtk_widget_set_sensitive (b_add_contact, TRUE);
      gtk_widget_set_sensitive (b_accept, TRUE);
      gtk_widget_set_sensitive (b_hangup, TRUE);
      gtk_widget_set_sensitive (b_suspend, TRUE);
      gtk_widget_set_sensitive (b_resume, TRUE);
      break;

    default:
      GNUNET_break(0);
      break;
    }
    print_call_info();
  }
  else
  {
    GCG_log("nothing selected");
    //gtk_widget_hide(GTK_WIDGET(GCG_get_main_window_object("GNUNET_GTK_conversation_active_call_list_buttons" )));
  }
}


/**
 * @brief executed when selecting a different item in active call list
 */
void
gnunet_conversation_gtk_active_calls_treeview_selection_changed_cb ()
{
  update_active_call_list_buttons();
}


static void
disable_list_buttons ()
{
  gtk_widget_set_sensitive (b_add_contact, FALSE);
  gtk_widget_set_sensitive (b_accept, FALSE);
  gtk_widget_set_sensitive (b_hangup, FALSE);
  gtk_widget_set_sensitive (b_suspend, FALSE);
  gtk_widget_set_sensitive (b_resume, FALSE);
}


/**
 * set state of outgoing call
 */
static void
set_outgoing_call_state (struct GNUNET_CONVERSATION_Call *call,
                         int state)
{
  GtkTreeIter gtkiter;
  gint valid = 0;
  gint cl_type;

  valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (active_liststore),
                                         &gtkiter);
  if (!valid)
    GNUNET_break(0);
  while (valid)
  {
    gchar *cl_caller_id;
    gint   cl_caller_num;
    gpointer cl_call;

    gtk_tree_model_get ( GTK_TREE_MODEL( active_liststore ), &gtkiter,
                         AL_call, &cl_call,
                         AL_caller_id,&cl_caller_id,
                         AL_caller_num,&cl_caller_num,
                         AL_type, &cl_type,
                         -1);
    if (cl_type == CALL_OUT)
    {
      if (call == NULL) // function called by phone event handler
      {
        GCG_log("event handler");
        gtk_list_store_set(active_liststore, &gtkiter,
                           AL_call_state, state,
                           -1);
        switch (state)
        {
          /**
           * We are the caller and are now ringing the other party (GNS lookup
           * succeeded).
           */
        case  GNUNET_CONVERSATION_EC_CALL_RINGING:
          break;
          /**
           * We are the caller and are now ready to talk as the callee picked up.
           */
        case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
          break;
          /**
           * We are the caller and failed to locate a phone record in GNS.
           * After this invocation, the respective call handle will be
           * automatically destroyed and the client must no longer call
           * #GNUNET_CONVERSATION_call_stop or any other function on the
           * call object.
           */
        case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
           gtk_list_store_remove(active_liststore,&gtkiter);
           disable_list_buttons();
           break;
          /**
           * We are the caller and the callee called
           * #GNUNET_CONVERSATION_caller_hang_up.  After this invocation, the
           * respective call handle will be automatically destroyed and the
           * client must no longer call #GNUNET_CONVERSATION_call_stop.
           */
        case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
          gtk_list_store_remove(active_liststore,&gtkiter);
          disable_list_buttons();
          break;
          /**
           * We are the caller and the callee suspended the call.  Note that
           * both sides can independently suspend and resume calls; a call is
           * only "working" of both sides are active.
           */
        case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
          break;
          /**
           * We are the caller and the callee suspended the call.  Note that
           * both sides can independently suspend and resume calls; a call is
           * only "working" of both sides are active.
           */
        case GNUNET_CONVERSATION_EC_CALL_RESUMED:
          break;
          /**
           * We had an error handing the call, and are now restarting it
           * (back to lookup).  This happens, for example, if the peer
           * is restarted during a call.
           */
        case GNUNET_CONVERSATION_EC_CALL_ERROR:
          break;
        default:
          break;
        }
      }
      else if (call == cl_call) // function called for specific call
      {
        //GCG_log (_("setting state for call:%u row: %u state: %u"),cl_caller_num,row_count,state);

        switch (state)
        {
        case CT_hangup:
          //GCG_log("remove line cause hangup");
          gtk_list_store_remove(active_liststore,&gtkiter);
          disable_list_buttons();
          break;
        case CT_rejected:
          //GCG_log("remove line cause rejected");
          gtk_list_store_remove(active_liststore,&gtkiter);
          disable_list_buttons();
          break;
        default:
          gtk_list_store_set(active_liststore, &gtkiter,
                             AL_caller_state, state,
                             -1);
          break;
        }
      }
    }
    g_free (cl_caller_id);
    valid = gtk_tree_model_iter_next (GTK_TREE_MODEL(active_liststore), &gtkiter);
  }
  GCG_update_status_bar ("");
}


/**
 * set call state of a incoming call
 */
static void
set_incoming_call_state (struct GNUNET_CONVERSATION_Caller *caller,
                         int state)
{
  GtkTreeIter gtkiter;
  gint valid = 0;

  valid = gtk_tree_model_get_iter_first( GTK_TREE_MODEL( active_liststore ), &gtkiter );
  if (!valid)
    GNUNET_break(0);
  while (valid)
  {
    gchar *cl_caller_id;
    gint   cl_caller_num;
    gpointer cl_caller;

    gtk_tree_model_get (GTK_TREE_MODEL (active_liststore ),
                        &gtkiter,
                        AL_caller, &cl_caller,
                        AL_caller_id, &cl_caller_id,
                        AL_caller_num, &cl_caller_num,
                        -1);
    if (caller == cl_caller)
    {
      switch (state)
      {
      case CT_hangup:
        //GCG_log("remove line cause hangup");
        gtk_list_store_remove (active_liststore,
                               &gtkiter);
        disable_list_buttons ();
        break;
      case CT_rejected:
        //GCG_log("remove line cause rejected");
        gtk_list_store_remove (active_liststore,
                               &gtkiter);
        disable_list_buttons ();
        break;
      default:
        gtk_list_store_set (active_liststore,
                            &gtkiter,
                            AL_caller_state, state,
                            -1);
        break;
      }
    }
    g_free (cl_caller_id);
    valid = gtk_tree_model_iter_next (GTK_TREE_MODEL(active_liststore),
                                      &gtkiter);
  }
  GCG_update_status_bar("");
}


/**
 * Function called with an event emitted by a phone.
 *
 * @param cls closure
 * @param code type of the event
 * @param caller handle for the caller
 * @param caller_id name of the caller in GNS
 */
static void
phone_event_handler (void *cls,
                     enum GNUNET_CONVERSATION_PhoneEventCode code,
                     struct GNUNET_CONVERSATION_Caller *caller,
                     const char *caller_id)
{
  GtkTreeIter gtkiter;
  GtkTreeIter gtkiter1;
  gboolean valid;
  struct CallList *cl;

  switch (code)
  {
  case GNUNET_CONVERSATION_EC_PHONE_RING:
    caller_num_gen++;
    GCG_log (_("A Incoming call from `%s' with number %u\n"),
             caller_id,
             caller_num_gen);
    cl = GNUNET_new (struct CallList);
    cl->caller = caller;
    cl->caller_id = GNUNET_strdup (caller_id);
    cl->caller_num = caller_num_gen;
    GNUNET_CONTAINER_DLL_insert (cl_head, cl_tail, cl);
    gtk_list_store_append (active_liststore,
                           &gtkiter);
    gtk_list_store_set (active_liststore,
                        &gtkiter,
                        AL_caller_id, caller_id,
                        AL_caller, caller,
                        AL_caller_num, caller_num_gen,
                        AL_caller_state, CT_ringing,
                        AL_type, CALL_IN,
                        -1);
    break;
  case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
    valid = gtk_tree_model_get_iter_first( GTK_TREE_MODEL( active_liststore ), &gtkiter1 );
    if (!valid)
      GNUNET_break(0);
    while (valid)
    {
      gchar *str_data;
      gint   int_data;
      gpointer cl_caller;

      gtk_tree_model_get (GTK_TREE_MODEL(active_liststore),
                          &gtkiter1,
                          AL_caller, &cl_caller,
                          AL_caller_id, &str_data,
                          AL_caller_num, &int_data,
                          -1);
      if (caller == cl_caller)
      {
        GCG_log (_("phone hung up:%s number: %u "),
                 str_data,
                 int_data);
        set_incoming_call_state (caller,
                                 CT_rejected);
        break;
      }
      g_free (str_data);
      valid = gtk_tree_model_iter_next (GTK_TREE_MODEL(active_liststore), &gtkiter1);
    }
    phone_state = PS_LISTEN;
    break;
  }
  do_status();
}


/**
 * Function called with an event emitted by a caller.
 *
 * @param cls closure with the `struct CallList` of the caller
 * @param code type of the event issued by the caller
 */
static void
caller_event_handler (void *cls,
                      enum GNUNET_CONVERSATION_CallerEventCode code)
{
  struct CallList *cl = cls;

  if (NULL == cl)
  {
    GNUNET_break (0);
    return;
  }
  switch (code)
  {
  case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
    //TODO: should this be cls? not cl->caller
    set_incoming_call_state(cl->caller,CT_suspended);
    GCG_log (_("Call from `%s' suspended by other user\n"), cl->caller_id);
    break;
  case GNUNET_CONVERSATION_EC_CALLER_RESUME:
    set_incoming_call_state(cl->caller,CT_active);
    GCG_log (_("Call from `%s' resumed by other user\n"), cl->caller_id);
    break;
  }
  do_status();
}


/**
 * Start our phone.
 */
static void
start_phone ()
{
  struct GNUNET_GNSRECORD_Data rd;
  struct GNUNET_IDENTITY_Ego *caller_id;

  caller_id = GCG_EGOS_get_selected_ego ();
  if (NULL == caller_id)
  {
    GCG_log ("%s\n",
             _("No ego selected, phone is now down."));
    phone_state = PS_LOOKUP_EGO;
    do_status();
    return;
  }
  phone =
    GNUNET_CONVERSATION_phone_create (GCG_get_configuration (),
                                      caller_id,
                                      &phone_event_handler,
                                      NULL);
  if (NULL == phone)
  {
    GCG_log ("%s",
             _("Failed to setup phone (internal error)\n"));
    phone_state = PS_ERROR;
    do_status();
    return;
  }
  GNUNET_CONVERSATION_phone_get_record (phone,
                                        &rd);
  /* FIXME: publish record to GNS! */
  GCG_log ("%s\n",
           _("Phone active"));
  phone_state = PS_LISTEN;
  do_status();
}


/**
 * Function called with an event emitted by a call.
 *
 * @param cls closure, NULL
 * @param code type of the event on the call
 */
static void
call_event_handler (void *cls,
                    enum GNUNET_CONVERSATION_CallEventCode code)
{
  //struct OutgoingCallClosure *cl = cls;

  set_outgoing_call_state (NULL, code);
  switch (code)
  {
  case GNUNET_CONVERSATION_EC_CALL_RINGING:
    GNUNET_break (CS_RESOLVING == call_state);
    GCG_log (_("Resolved address of `%s'. Now ringing other party."),
             peer_name);
    //   set_outgoing_call_state(cls, CT_ringing);
    call_state = CS_RINGING;
    break;
  case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
    GNUNET_break (CS_RINGING == call_state);
    GCG_log (_("Connection established to `%s'."),
             peer_name);
    call_state = CS_CONNECTED;
    break;
  case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
    GNUNET_break (CS_RESOLVING == call_state);
    GCG_log (_("Failed to resolve %s in current zone."),
             peer_name);
    call = NULL;
    break;
  case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
    GCG_log ("%s", _("Call terminated"));
    call = NULL;
    break;
  case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
    GNUNET_break (CS_CONNECTED == call_state);
    GCG_log (_("Connection to `%s' suspended (by other user)\n"),
             peer_name);
    break;
  case GNUNET_CONVERSATION_EC_CALL_RESUMED:
    GNUNET_break (CS_CONNECTED == call_state);
    GCG_log (_("Connection to `%s' resumed (by other user)\n"),
             peer_name);
    break;
  case GNUNET_CONVERSATION_EC_CALL_ERROR:
    GCG_log ("GNUNET_CONVERSATION_EC_CALL_ERROR %s",
             peer_name);
  }
}


/**
 * Initiating a new call
 *
 * @param arg arguments given to the command
 */
void
GSC_PHONE_make_call (const char *arg)
{
  GtkEntry *address_entry;
  struct GNUNET_IDENTITY_Ego *caller_id;
  GtkTreeIter gtkiter;

  address_entry = GTK_ENTRY (GCG_get_main_window_object ("GNUNET_GTK_conversation_address"));
  gtk_entry_set_text (address_entry,
                      address);
  caller_id = GCG_EGOS_get_selected_ego ();
  if (NULL == caller_id)
  {
    // should not be possible!
    GCG_log ("%s\n",
             _("Caller ID unavailable, cannot initiate call."));
    return;
  }
  if (NULL != call)
  {
    GCG_log (_("You are calling someone else already, hang up first!\n"));
    return;
  }
  switch (phone_state)
  {
  case PS_LOOKUP_EGO:
    GCG_log ("%s\n",
             _("Caller ID unavailable, cannot initiate call."));
    // should not be possible!
    return;
  case PS_LISTEN:
    /* ok to call! */
    break;
  case PS_ACCEPTED:
    GCG_log (_
         ("You are answering call from `%s', hang up or suspend that call first!\n"),
         peer_name);
    GNUNET_break(0);
    return;
  case PS_ERROR:
    /* ok to call */
    break;
  }
  //GNUNET_free_non_null (peer_name);
  peer_name = GNUNET_strdup (arg);
  GCG_log (_("now calling: %s"), peer_name);
  call_state = CS_RESOLVING;
  GNUNET_assert (NULL == call);

  call_counter++;
  call =
     GNUNET_CONVERSATION_call_start (GCG_get_configuration (),
                                     caller_id,
                                     arg,
                                     speaker, mic,
                                     &call_event_handler, NULL);
  //call = newcall;

  // add call to active call list

  gtk_list_store_append (active_liststore,
                         &gtkiter);
  gtk_list_store_set (active_liststore, &gtkiter,
                      AL_caller_id, peer_name,
                      AL_caller, NULL,
                      AL_caller_num, NULL,
                      AL_caller_state, CT_other,
                      AL_type, CALL_OUT,
                      AL_call, call,
                      AL_call_num, call_counter,
                      AL_call_state, CS_RESOLVING,
                      -1 );
  GCG_update_status_bar (_("We are calling `%s', his phone should be ringing."),
                         peer_name);
  GCG_HISTORY_add (GCG_HISTORY_TYPE_OUTGOING,
                   peer_name);
}


/**
 * Accepting an incoming call
 *
 * @param args arguments given to the command
 */
static void
do_accept (struct GNUNET_CONVERSATION_Caller *sel_caller)
{
  struct CallList *cl;

  if ( (NULL != call) &&
       (CS_SUSPENDED != call_state) )
  {
    GCG_log (_("You are calling someone else already, hang up first!\n"));
    GNUNET_break(0);
    return;
  }
  switch (phone_state)
  {
  case PS_LOOKUP_EGO:
    GNUNET_break (0);
    break;
  case PS_LISTEN:
    /* this is the expected state */
    break;
  case PS_ACCEPTED:
    GCG_log (_
         ("You are answering call from `%s', hang up or suspend that call first!\n"),
         peer_name);
    GNUNET_break(0);
    return;
  case PS_ERROR:
    GNUNET_break (0);
    break;
  }

  phone_state = PS_ACCEPTED;
  set_incoming_call_state(sel_caller,CT_active);

  for (cl = cl_head; cl; cl = cl->next)
  {
    /* FIXME: this may not be unique enough to identify the right item!
     * Why not store CallList items in treeview instead of just callers?
     */
    if (cl->caller == sel_caller)
      break;
  }
  GNUNET_CONVERSATION_caller_pick_up (sel_caller,
                                      &caller_event_handler, cl,
                                      speaker, mic);
  GCG_HISTORY_add (GCG_HISTORY_TYPE_ACCEPTED, peer_name);
}


/**
 * Suspending a call
 */
static void
do_suspend ()
{
  if ( (NULL != call_selected) &&
       (NULL != caller_selected) )
  {
    GNUNET_break(0);
    return;
  }
  if (NULL != call_selected)
  {
    /* outgoing */
    GNUNET_CONVERSATION_call_suspend (call_selected);
    set_outgoing_call_state(call_selected,CT_suspended);
    return;
  }
  if (NULL != caller_selected)
  {
    /* incoming */
    GNUNET_CONVERSATION_caller_suspend (caller_selected);
    set_incoming_call_state(caller_selected,CT_suspended);
    phone_state = PS_LISTEN;
    return;
  }
  GNUNET_break (0);
}


/**
 * Resuming a call
 *
 * @param args arguments given to the command
 */
static void
do_resume ()
{
  switch (phone_state)
  {
  case PS_LOOKUP_EGO:
  case PS_ERROR:
    GCG_log ("%s",
             _("There is no call that could be resumed right now.(PS_ERROR)"));
    return;
  case PS_LISTEN:
    break;
  case PS_ACCEPTED:
    GCG_log (_("Already talking with `%s', cannot resume a call right now."),
             peer_name);
    return;
  }
  if ( (NULL != call_selected) &&
       (NULL != caller_selected) )
  {
    GNUNET_break(0);
    return;
  }
  if (NULL != call_selected)
  {
    /* outgoing */
    GNUNET_CONVERSATION_call_resume (call_selected, speaker, mic);
    set_outgoing_call_state(call_selected,CT_active);
    return;
  }
  if (NULL != caller_selected)
  {
    /* incoming */
    GNUNET_CONVERSATION_caller_resume (caller_selected, speaker, mic);
    set_incoming_call_state(caller_selected,CT_active);
    phone_state = PS_ACCEPTED;
    return;
  }
  GNUNET_break(0);
}


/**
 / Rejecting a call
 *
 * @param args arguments given to the command
 */
static void
do_reject ()
{
  if ( (NULL == call_selected) &&
       (NULL == caller_selected) )
  {
    GNUNET_break(0);
    return;
  }
  if (NULL != call_selected)
  {
    /* if selected call is outgoing, stop it */
    set_outgoing_call_state (call_selected, CT_hangup);
    GNUNET_CONVERSATION_call_stop (call);
    call = NULL;
    call_selected = NULL;
    return;
  }
  if (NULL != caller_selected)
  {
    /* if selected call is incoming, hang it up */
    set_incoming_call_state (caller_selected,CT_hangup);
    GNUNET_CONVERSATION_caller_hang_up (caller_selected);
    phone_state = PS_LISTEN;
    caller_selected = NULL;
    return;
  }
  GNUNET_break (0);
}


/**
 *  hangup clicked
 */
void
GNUNET_CONVERSATION_GTK_on_hangup_clicked ()
{
  do_reject ();
  do_status ();
}


/**
 *  accept clicked
 */
void
GNUNET_CONVERSATION_GTK_on_accept_clicked ()
{
  if (NULL != caller_selected)
  {
    do_accept (caller_selected);
  }
  else
  {
    GNUNET_break(0);
  }
  do_status ();
}


/**
 *  reject clicked
 */
void
GNUNET_CONVERSATION_GTK_on_reject_clicked ()
{
  do_reject ();
  do_status ();
}


/**
 * User clicked the '> contact' button to move the selected
 * caller's information into our address book.
 */
void
GNUNET_CONVERSATION_GTK_use_current_button_clicked (GtkButton *button,
                                                    gpointer *user_data)
{
  // FIXME: implement, use "GSC_add_contact"
#if 0
  GtkEntry *addressEntry;

  addressEntry = GTK_ENTRY (GCG_get_main_window_object ("GNUNET_GTK_conversation_addressAdd"));
  gtk_entry_set_text (addressEntry,
                      "FIXME");
#endif
}


/**
 * pause clicked
 */
void
GNUNET_CONVERSATION_GTK_on_pause_clicked ()
{
  do_suspend ();
  do_status ();
}

/**
 *  resume clicked
 */
void
GNUNET_CONVERSATION_GTK_on_resume_clicked ()
{
  do_resume ();
  do_status ();
}


/**
 * call clicked
 */
void
GNUNET_CONVERSATION_GTK_on_call_clicked ()
{
  GtkEntry *address_entry;

  address_entry = GTK_ENTRY (GCG_get_main_window_object
                             ("GNUNET_GTK_conversation_address"));

  GSC_PHONE_make_call (gtk_entry_get_text (address_entry));
  do_status ();
}


/**
 * @brief outgoing ego selector changed, (re)start the phone.
 *
 * @param widget the combo box that changed
 * @param user_data builder (unused)
 */
void
gnunet_conversation_gtk_ego_combobox_changed_cb (GtkComboBox *widget,
                                                 gpointer user_data)
{
  if (NULL != phone)
  {
    GNUNET_CONVERSATION_phone_destroy (phone);
    phone = NULL;
  }
  start_phone();
}


/**
 * Initialize phone subsystem.
 */
void
GCG_PHONE_init ()
{
  const struct GNUNET_CONFIGURATION_Handle *cfg;

  cfg = GCG_get_configuration ();
  speaker = GNUNET_SPEAKER_create_from_hardware (cfg);
  mic = GNUNET_MICROPHONE_create_from_hardware (cfg);
  /* get gui objects */
  b_add_contact = GTK_WIDGET (GCG_get_main_window_object
                              ("gnunet_conversation_gtk_add_contact_button"));
  b_accept  = GTK_WIDGET (GCG_get_main_window_object
                          ("gnunet_conversation_gtk_accept_button"));
  b_refuse  = GTK_WIDGET (GCG_get_main_window_object
                          ("gnunet_conversation_gtk_hangup_button"));
  b_suspend = GTK_WIDGET (GCG_get_main_window_object
                          ("gnunet_conversation_gtk_suspend_button"));
  b_resume  = GTK_WIDGET (GCG_get_main_window_object
                          ("gnunet_conversation_gtk_resume_button"));
  b_call = GTK_WIDGET (GCG_get_main_window_object
                          ("gnunet_conversation_gtk_call_button"));
  b_hangup = GTK_WIDGET (GCG_get_main_window_object
                         ("gnunet_conversation_gtk_hangup_button"));

  active_liststore =
     GTK_LIST_STORE (GCG_get_main_window_object
                     ("gnunet_conversation_gtk_active_calls_liststore"));
  active_treeview =
      GTK_TREE_VIEW (GCG_get_main_window_object
                     ("gnunet_conversation_gtk_active_calls_treeview"));
}


/**
 * Shutdown phone subsystem.
 */
void
GCG_PHONE_shutdown ()
{
  struct CallList *cl;

  while (NULL != (cl = cl_head))
  {
    GNUNET_CONVERSATION_caller_hang_up (cl->caller);
    GNUNET_CONTAINER_DLL_remove (cl_head,
                                 cl_tail,
                                 cl);
    // FIXME: release other memory?
    GNUNET_free (cl);
  }
  if (NULL != call)
  {
    GNUNET_CONVERSATION_call_stop (call);
    call = NULL;
  }
  if (NULL != phone)
  {
    GNUNET_CONVERSATION_phone_destroy (phone);
    phone = NULL;
  }
  GNUNET_SPEAKER_destroy (speaker);
  speaker = NULL;
  GNUNET_MICROPHONE_destroy (mic);
  mic = NULL;
  GNUNET_free_non_null (peer_name);
  peer_name = NULL;
  phone_state = PS_ERROR;
}

/* end of gnunet-conversation-gtk_phone.c */