my_iax_wrapper.cpp

我自己根据kiax改写的iax协议软终端

#include "My_IAX_Wrapper.h"
#include "math.h"
My_IAX_Wrapper *callbackCaller;

/*
	Global method used as callback function in libiaxclient
	Forwards incoming events to void My_IAX_Wrapper::handleIaxCEvent(void* callbackCaller, iaxc_event e) via customEvent(QCustomEvent)
*/

int iaxc_callback(iaxc_event e)
{
  // wrap iaxc_event into a QEvent
My_IAX_Event * wrapperEvent = new My_IAX_Event(e);
  // and create a CustomEvent to be posted
 // QCustomEvent * wev = new QCustomEvent(QEvent::User, wrapperEvent);
  //QEvent * wev = new QObject::customEvent(  wrapperEvent);
  /*
     we are not allowed to access GUI thread directly from external threads
     so, post event to be processed by the GUI thread
  */
  QApplication::postEvent(callbackCaller,  wrapperEvent);
  return 1;
}

/*
	Initialization and destruction of the wrapper
*/

My_IAX_Wrapper::My_IAX_Wrapper(QObject *parent )
    : QObject(parent)
{
  showStats = false;
  registered=false; // we are not ready to call
  callbackCaller = this; // to use it in the class callback function

  //load the settings prior to do anything else
  //settings = new KiaxPrefs(this,0);
  //settings->loadSettings();
  
  /* allocate memory for the statistics vars*/
  rtt = (int*) malloc(sizeof(int));
  localNetstat = (struct iaxc_netstat*) malloc(sizeof(struct iaxc_netstat));
  remoteNetstat = (struct iaxc_netstat*) malloc(sizeof(struct iaxc_netstat));
  
  ringInTone = NULL;
  ringTimer = new QTimer(); // repeats ringing every 4 seconds

  callDurationTimer = new QTimer(); // shows duration of the time every second

  connect(ringTimer, SIGNAL(timeout()), this, SLOT(ring()));
  connect(callDurationTimer, SIGNAL(timeout()), this, SLOT(callDuration()));
  
  char* version = (char*)malloc(256);
  iaxc_ver = iaxc_version(version);
  
 // debug("Using IAXClient ver. %s\n", iaxc_ver);  需要改写debug来输出到终端

}

My_IAX_Wrapper::~My_IAX_Wrapper()
{
  shutdown_iax_client();
}

int My_IAX_Wrapper::registerAccount(QString ServerAccName,QString ServerPasswd ,QString ServerHst) {
    start_iax_client();
   const char* func = "My_IAX_Wrapper::registerMultipleAccounts()";
   //debug ("%s registering accounts..\n", func);
    const char* accName = ServerAccName.toLocal8Bit().data();
    const char* passwd = ServerPasswd.toLocal8Bit().data();
    const char* hst = ServerHst.toLocal8Bit().data();
    
    if ((ServerAccName!="")&&(ServerHst!=""))
    {
      // tell to an Asterisk server where we are
      iaxRegistrationId = iaxc_register((char*)accName,(char*) passwd, (char*) hst);
//int iaxRegistrationId=0;
      //debug ("%s register %s [%s:xxx@%s], given ID = %d\n",  func, accName, uname, hst, account->iaxRegistrationId);
      emit signalRegistrationRequested(iaxRegistrationId);  //返回注册后的帐号
    }
    else
    {
     // debug ("%s skipped registration %s [%s:xxx@%s]\n", func, accName,uname, hst);
      iaxRegistrationId = -1; //skipped
    }
    return iaxRegistrationId;
}

int My_IAX_Wrapper::unregisterAccount(int iaxRegistrationId) {
	if (iaxRegistrationId!=-1) {
		int result = iaxc_unregister(iaxRegistrationId);  
stop_iax_client();        //返回没有注册的结果，
		//emit signalUnregistrationRequested(account);
		//account->setState(ACCOUNT_INACTIVE);
	} else return -1; // skipped
}







void My_IAX_Wrapper::dial(QString accountId,QString ServerPassword,QString ServerHst, QString contactName)
{


  QString uname = accountId;
  QString passwd = ServerPassword;
  QString hst = ServerHst;

 // if (registered) // if user is allowed to dial
  {
    QString full_url = uname+":"+passwd+"@"+hst+"/"+contactName;
    const char *dest = "";
   // configureCall(accountNumber);  处理设置电话号码，先搁置不管
    
      dest = full_url.toLocal8Bit().data();
    
    // first, emit signal to notify the GUI //
    // then call our friend
   /* debug( "My_IAX_Wrapper::dial(int, QString) dialing %s:%s@%s/%s ..\n", (const  char*)uname, "xxx", (const char*) hst, (const char*)callRecord->getCallerIdNumber());*/
    iaxc_call(  dest);
  //  callSession[getSelectedCall()] = *callRecord;
    emit signalCalling(getSelectedCall(), tr("Calling.."));
  }
}

/*
	Methods interfacing directly with libiaxclient
*/

bool My_IAX_Wrapper::init_iax_client()
{
  int result = iaxc_initialize(1);

 // debug( "My_IAX_Wrapper::iaxc_initialize() result = %d\n", result);
  /*if (result==-1)
  {
    // hopefully not many people will have to read this..
    fatal_error("cannot initialize iaxclient!\n");
    return false;
  }*/
  iaxc_set_formats(IAXC_FORMAT_GSM,IAXC_FORMAT_GSM|IAXC_FORMAT_SPEEX|IAXC_FORMAT_ULAW|IAXC_FORMAT_ILBC);
  return true;
}

void My_IAX_Wrapper::shutdown_iax_client()
{
  // shutdown
 // debug( "My_IAX_Wrapper::shutdown_iax_client() shutting down..\n");
  iaxc_shutdown();
  //debug( "My_IAX_Wrapper::shutdown_iax_client() done.\n");
}

void My_IAX_Wrapper::start_iax_client()
{
  // we want iaxevents to be passed to iaxc_callback
  iaxc_set_event_callback(iaxc_callback);
  // fire
  //debug( "My_IAX_Wrapper::start_iax_client() starting processing thread..\n");
 int result = iaxc_start_processing_thread();
  //int result =0;
  //debug( "My_IAX_Wrapper::iaxc_start_processing_thread() result = %d\n", result);
  if (result==-1)
    fatal_error("cannot start processing thread!\n");
}

void My_IAX_Wrapper::stop_iax_client()
{
  // close any active calls
  iaxc_dump_all_calls();
  // wait a bit
  iaxc_millisleep(1000);
  // stop the thread
  iaxc_stop_processing_thread();
  // reset type of call
}

void My_IAX_Wrapper::send_dtmf(char digit)
{
  // allow sending dtmf only if we are in a state of a call (ACTIVE)
  // TODO:  this is a cheap version - has to be changed
  if (registered)
  {
    printf ("My_IAX_Wrapper::send_dtmf(char digit) sending DTMF%c\n", digit);
    // I like playing with these voice menus
    iaxc_send_dtmf(digit);
  }
}

void My_IAX_Wrapper::answer_call(int callNumber)
{
  QString func = "My_IAX_Wrapper::answer_call()";
  // answer the call
  iaxc_answer_call(callNumber);
 // debug (func+" answered call  %d\n", getSelectedCall());
  // notify GUI
  emit signalAnsweredCall(callNumber);
}

void My_IAX_Wrapper::transfer_call(int callNo, QString number)
{
  QString func = "My_IAX_Wrapper::transfer_call("+number+")";
  // answer the call
  const char* exten =  number.toLocal8Bit().data();
  iaxc_blind_transfer_call(callNo, (char*) exten);
//  debug (func+" transferred call  %d\n", callNo);
}

void My_IAX_Wrapper::select_call(int callNumber)
{
  QString func = "My_IAX_Wrapper::select_call("+QString::number(callNumber)+")";
//  debug(func,"\n");
  iaxc_select_call(callNumber);
 // debug (func+" selected call  %d\n", getSelectedCall());
}

void My_IAX_Wrapper::hold_call(int callNumber)
{
  QString func = "My_IAX_Wrapper::hold_call()";
  // answer the call
  iaxc_quelch(callNumber,0);
 // debug (func+" hold call  %d\n", callNumber);
  // notify GUI
 
  emit signalHoldCall(callNumber);
}

void My_IAX_Wrapper::resume_call(int callNumber)
{
  QString func = "My_IAX_Wrapper::resume_call()";
  // answer the call
  iaxc_unquelch(callNumber);
  
  // notify GUI
  emit signalResumedCall(callNumber);
}

void My_IAX_Wrapper::reject_call(int callNo)
{
  QString func = "My_IAX_Wrapper::reject_call()";
 // debug(func+"  rejecting call %d..\n", callNo);
  iaxc_reject_call_number(callNo);
 // debug(func+"  rejected call %d\n", callNo);
}

void My_IAX_Wrapper::interrupt_call()
{
  printf("My_IAX_Wrapper::interrupt_call() hanging up and exiting..\n");
  // hang up the call
  iaxc_dump_call();
  // wait a bit
  iaxc_millisleep(1000);
}

int My_IAX_Wrapper::getSelectedCall()
{
  return iaxc_selected_call();
}



/*
     Procedures handling iaxclient events (forwarded from iaxc_callback(iaxc_event e)
*/

void My_IAX_Wrapper::handleIaxCEvent(iaxc_event e)
{
  switch(e.type)
  {
  case IAXC_EVENT_LEVELS:
    // monitor input and output signal levels (audio)
    event_level(e.ev.levels.input, e.ev.levels.output);
    break;
  case IAXC_EVENT_REGISTRATION:
    // monitor registration status
    event_registration(e.ev.reg.id, e.ev.reg.reply, e.ev.reg.msgcount);
    break;
  case IAXC_EVENT_TEXT:
    event_text(e.ev.text.type, e.ev.text.message);
    break;
  case IAXC_EVENT_STATE:
    event_state(e.ev.call.callNo, e.ev.call.state, e.ev.call.remote,
                e.ev.call.remote_name, e.ev.call.local,
                e.ev.call.local_context, e.ev.reg.id);
    break;
  default:
    event_unknown(e.type);
    break;
  }
}

void My_IAX_Wrapper::event_level(float in, float out)
{
  emit signalLevels((int)-in, (int) -out, (int) 0);
}

void My_IAX_Wrapper::event_registration(int id, int reply, int msgcount)
{  iaxRegistrationId =id;
  //debug("Registration id = %d, reply = %d, msgcount = %d\n", id, reply, msgcount);
  //KiaxAccount * account = getAccountByRegistrationId(id);
 /* if (account!=NULL) { */
  switch (reply) {