callbacks.c

SIP（Session Initiation Protocol）是由IETF定义

#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <ctype.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gtk/gtk.h>

#include "vocalconfig.h"
#include "VideoEnable.h"

#include "configuration.h"
#include "callbacks.h"
#include "interface.h"
#include "support.h"
#include "registered.xpm"
#include "unregistered.xpm"

#include "VideoEnable.h"

#define NamedDir "/tmp/sipset."

extern GtkWidget *main_window;
extern GtkWidget *log_dialog;
extern GtkWidget *basic_config_dialog;
extern GtkWidget *advanced_config_dialog;
extern int videoEnabled;

extern int display_name_set_by_user;

GtkWidget *incoming_call_dialog = NULL;

int state = INACTIVE;

int mediaStartFlg = 0;

GIOChannel *channel_out, *channel_in;
guint handle_to_gtk_input_add_full;

FILE *dial_history;
char dial_history_path[50];
GtkWidget *dial_combo, *tooltips, *register_eventbox, *username_eventbox;
GtkWidget *registered_pixmap, *unregistered_pixmap;
GList *dial_items = NULL;

/* number of the current call in progress */
char *current_call;

void
on_main_window_destroy                 (GtkObject       *object,
                                        gpointer         user_data)
{
  VideoDevice_shutdown();
  send_message(GUI_SHUTDOWN_STR);
  exit(1);
}

void
on_basic_configuration1_activate       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  GtkWidget *ok_button;
  basic_config_dialog = create_basic_config_dialog();
  ok_button = lookup_widget (basic_config_dialog, "basic_config_ok");

  /* cannot get this working right now */
  gtk_window_set_default(GTK_WINDOW(basic_config_dialog), ok_button), 
  read_basic_config();
  set_basic_config_tooltips(basic_config_dialog);
  gtk_widget_show(basic_config_dialog);
}


void
on_advanced1_activate                  (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  advanced_config_dialog = create_advanced_config_dialog();
  read_advanced_config();
  set_advanced_config_tooltips(advanced_config_dialog);
  gtk_widget_show(advanced_config_dialog);
}


void
on_messages1_activate                  (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  gtk_widget_show(log_dialog);
}


void
on_basic_config_ok_clicked             (GtkButton       *button,
                                        gpointer         user_data)
{
  if (write_basic_config())
  {
    set_name();
    set_registered(FALSE);
    gtk_widget_destroy(gtk_widget_get_toplevel(GTK_WIDGET(button)));
    send_message(GUI_PREF_STR);
  }
}


void
on_basic_config_cancel_clicked         (GtkButton       *button,
                                        gpointer         user_data)
{
  gtk_widget_destroy(gtk_widget_get_toplevel(GTK_WIDGET(button)));
}


void
on_advanced_config_ok_clicked          (GtkButton       *button,
                                        gpointer         user_data)
{
  write_advanced_config();
  set_name();
  set_registered(FALSE);
  gtk_widget_destroy(gtk_widget_get_toplevel(GTK_WIDGET(button)));
  send_message(GUI_PREF_STR);
}


void
on_advanced_config_cancel_clicked      (GtkButton       *button,
                                        gpointer         user_data)
{
  gtk_widget_destroy(gtk_widget_get_toplevel(GTK_WIDGET(button)));
}

void
hangup_the_phone(void);
void
take_phone_off_hook(void);
void
start_media(void);

void
on_talk_button_clicked                 (GtkButton       *button,
                                        gpointer         user_data)
{
  static char msgbuf[50];
  gchar *dial_number = NULL;

  switch (state)
  {
    case CALL_IN_PROGRESS:
    {
      GtkWidget *message_entry;
      hangup_the_phone();
      send_message(GUI_STOP_STR);
      message_entry = lookup_widget (main_window, "message_entry");
      gtk_entry_set_text(GTK_ENTRY(message_entry), "STOPPING CALL");
      break;
    }
    case INACTIVE:
    {
      gpointer list_number;
      int i, dial_number_len;
      GtkWidget *dial_entry = lookup_widget(main_window, "dial_entry");

      dial_number = gtk_editable_get_chars(GTK_EDITABLE(dial_entry),
                             0, -1);
      dial_number_len = strlen(dial_number);
      /* strip blanks from beginning of number*/
      i = 0;
      while(isspace(*dial_number))
      {
        if (++i >= dial_number_len)
        {
          GtkWidget *missing_number_popup = create_missing_number_dialog ();
          gtk_widget_show (missing_number_popup);
          gtk_entry_set_text(GTK_ENTRY(dial_entry), "");
          gtk_widget_grab_focus(dial_entry);
          return;
        }
        dial_number++;
      }

      /* strip blanks from end of number */
      for (i=0; i<strlen(dial_number); i++)
      {
        if (isspace(*(dial_number+i)))
        {
          printf ("inserting end-of-string at %d\n", i);
          *(dial_number+i) = '\0';
          break;
        }
      }
      if (strlen(dial_number) <= 0)
      {
        GtkWidget *missing_number_popup = create_missing_number_dialog ();
        gtk_widget_show (missing_number_popup);
        return;
      }
      
      /* disable the Talk button */
      gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);

      take_phone_off_hook();

      sprintf(msgbuf, "%s %s", GUI_INVITE_STR, dial_number);
      send_message(msgbuf);

      /* Add the number to dial history, if not already there */
      list_number = g_list_find_custom(dial_items, dial_number, (GCompareFunc)strcmp);

      if (list_number == NULL)
      {
        char *new_number = strdup(dial_number);

        dial_items = g_list_insert_sorted(dial_items, new_number,
           (GCompareFunc)strcmp);
        gtk_combo_set_popdown_strings(GTK_COMBO(dial_combo), dial_items);
        gtk_entry_set_text(GTK_ENTRY(dial_entry), new_number);
        write_phone_history(dial_items, dial_history_path);
      }
      g_free(dial_number);
      break;
    }
    default:
    break;
      /* do nothing */
  }

}


gboolean
on_log_dialog_delete_event             (GtkWidget       *widget,
                                        GdkEvent        *event,
                                        gpointer         user_data)
{
  gtk_widget_hide(log_dialog);
  return TRUE;
}

void
on_log_ok_clicked                      (GtkButton       *button,
                                        gpointer         user_data)
{
  gtk_widget_hide(log_dialog);
}


void
on_log_clear_clicked                   (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkWidget *logger = lookup_widget (log_dialog, "log_text");
  guint len = gtk_text_get_length(GTK_TEXT(logger));
  gtk_text_set_point(GTK_TEXT(logger), 0);
  gtk_text_forward_delete(GTK_TEXT(logger), len);
}


void
on_clear_history1_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  GList *emptyList = NULL;
  emptyList = g_list_append(emptyList, "");
  gtk_combo_set_popdown_strings(GTK_COMBO(dial_combo), emptyList);

  unlink(dial_history_path);
  creat(dial_history_path, 0666);

  g_list_free(dial_items);
  dial_items = NULL;

}


void
on_missing_number_ok_clicked           (GtkButton       *button,
                                        gpointer         user_data)
{
  gtk_widget_destroy(gtk_widget_get_toplevel(GTK_WIDGET(button)));
}


void
on_incoming_call_accept_clicked        (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkWidget *message_entry = lookup_widget (main_window, "message_entry");
  char display_string[50];

  send_message(GUI_ACCEPT_STR);
  take_phone_off_hook();

  /* set status message */
  sprintf(display_string, "ACCEPTED CALL FROM %s", current_call);
  gtk_entry_set_text(GTK_ENTRY(message_entry), display_string);

  gtk_widget_destroy(incoming_call_dialog);
  incoming_call_dialog = NULL;
}

void set_state(int new_state);

void
on_incoming_call_reject_clicked        (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkWidget *message_entry = lookup_widget (main_window, "message_entry");
  char display_string[50];

  send_message(GUI_REJECT_STR);

  /* set status message */
  sprintf(display_string, "REJECTED CALL FROM %s", current_call);
  gtk_entry_set_text(GTK_ENTRY(message_entry), display_string);

  gtk_widget_destroy(incoming_call_dialog);
  incoming_call_dialog = NULL;
  set_state(INACTIVE);
}


void
on_error_ok_clicked                    (GtkButton       *button,
                                        gpointer         user_data)
{
  gtk_widget_destroy(gtk_widget_get_toplevel(GTK_WIDGET(button)));
}

void
on_fatal_error_ok_clicked              (GtkButton       *button,
                                        gpointer         user_data)
{
  exit(1);
}


void
on_dial_entry_activate                 (GtkEditable     *editable,
                                        gpointer         user_data)
{
  GtkWidget *talk_button = lookup_widget (main_window, "talk_button");
  GtkArg arg;
  arg.name = "sensitive";

  gtk_object_getv(GTK_OBJECT(talk_button), 1, &arg);
  if (GTK_VALUE_BOOL(arg) == TRUE)
  {
    gtk_button_clicked(GTK_BUTTON(talk_button));
  }
}


gboolean
on_Display_Name_key_press_event        (GtkWidget       *widget,
                                        GdkEventKey     *event,
                                        gpointer         user_data)
{
  display_name_set_by_user = TRUE;
  return FALSE;
}


void
on_exit_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  VideoDevice_shutdown();
  send_message(GUI_SHUTDOWN_STR);
  gtk_main_quit();

}

/***************** code added *******************/

void print_error(GIOError error)
{
  switch(error)
  {
    case G_IO_ERROR_NONE:
    break;

    case G_IO_ERROR_AGAIN:
    g_message("again error\n");
    break;

    case G_IO_ERROR_INVAL:
    g_message("inval error\n");
    break;

    case G_IO_ERROR_UNKNOWN:
    default:
    g_message("unknown error: %d\n", error);
  }
}

void send_message(char* message)
{
  GIOError error;
  int len = 0;
  gsize bytes_written;

  /* If fatal error occurred, then writing to pipe will cause "Broken pipe" message */
  if (state == FATAL_ERROR)
  {
    return;
  }
  else
  {
    /*
    printf ("in send_message, state is %d\n", state);
    */
  }

  len = strlen(message);

  error = g_io_channel_write(channel_out, message, len+1, &bytes_written);
  /*g_message("wrote %d bytes: %s\n", bytes_written, message);*/

  if (error != G_IO_ERROR_NONE)
  {
    g_message("error occurred during write to UA: ");
    print_error(error);
  }
  else
  {
    /*
    printf("no error on send message\n");
    */
  }
}

void set_state(int new_state)
{
  /* uncomment for debugging
  switch(new_state)
  {
    case INACTIVE:
    printf("setting state to INACTIVE\n");
    break;

    case INCOMING_REQUEST:
    printf("setting state to INCOMING_REQUEST\n");
    break;

    case CALL_IN_PROGRESS:
    printf("setting state to CALL_IN_PROGRESS\n");
    break;

    case FATAL_ERROR:
    printf("setting state to FATAL_ERROR\n");
    break;

  } */

  state = new_state;
}

void take_phone_off_hook()
{
  GtkWidget *talk_button = lookup_widget(main_window, "talk_button");
  GtkWidget *dial_entry = lookup_widget(main_window, "dial_entry");
  gtk_object_set(GTK_OBJECT(talk_button), "GtkButton::label", (gchar*)HANGUP, NULL);
  gtk_tooltips_set_tip(GTK_TOOLTIPS(tooltips), talk_button, "Stop the call", NULL);
  gtk_tooltips_set_tip (GTK_TOOLTIPS(tooltips), dial_entry, _("Press Enter to stop call"), NULL);
  set_state (CALL_IN_PROGRESS);
  start_media();

}

void start_media()
{
#ifdef USE_MPEGLIB
  if(videoEnabled)
  {
      printf("Starting media\n" );
      if(!mediaStartFlg)
      {
          Video_start();
          Player_start();
          mediaStartFlg = 1;
      }
  }
#endif
}

void hangup_the_phone()
{
  GtkWidget *talk_button = lookup_widget(main_window, "talk_button");
  GtkWidget *dial_entry = lookup_widget(main_window, "dial_entry");

  /* if there is an incoming call dialog, destroy it */
  if (incoming_call_dialog != NULL)
  {
    gtk_widget_destroy(incoming_call_dialog);
    incoming_call_dialog = NULL;
  }

  /* disable the Talk button */