main.cxx

使用VOIP技术.能够无连接接通远程用户

  PWaitAndSignal m(access);
  return enabledCapabilities; 
}

void ConnectOptions::SetAvailableCapabilities(PStringList newCapabilities)
{ 
  PWaitAndSignal m(access);

  availableCapabilities = newCapabilities; 
  UpdateDisabledCapabilities();
}

void ConnectOptions::SetEnabledCapabilities(PStringList newCapabilities)
{ 
  PWaitAndSignal m(access);

  enabledCapabilities = newCapabilities; 
  UpdateDisabledCapabilities();
}

void ConnectOptions::UpdateDisabledCapabilities()
{
  PWaitAndSignal m(access);

  disabledCapabilities.RemoveAll();

  for (PINDEX i = 0; i < availableCapabilities.GetSize(); i++) {
    PINDEX loc = enabledCapabilities.GetStringsIndex(availableCapabilities[i]);
    if (loc == P_MAX_INDEX)
      disabledCapabilities.AppendString(availableCapabilities[i]);
  }
}


void ConnectOptions::PrintOn(ostream & strm) const
{
  strm <<  "-------------------------------------------------------"    << endl
       <<  "search for Gatekeeper is  "    <<  searchForGatekeeper      << endl 
       <<  "gatekeeper Name is     "       <<  gatekeeperName           << endl
                                                                        << endl 
       <<  "autoAnswer is          "       <<  autoAnswer               << endl
       <<  "noFastStart is         "       <<  noFastStart              << endl
       <<  "noH245Tunnelling is    "       <<  noH245Tunnelling         << endl
                                                                        << endl 
       <<  "useDefaultAudioBandwidth is  " <<  useDefaultAudioBandwidth << endl
       <<  "useDefaultVideoBandwidth is  " <<  useDefaultVideoBandwidth << endl
       <<  "audio Bandwidth is           " <<  audioBandwidth           << endl
       <<  "video Bandwidth is           " <<  videoBandwidth           << endl
       <<  "packet utilization is        " <<  packetUtilization        << endl
                                                                        << endl
       << "video reception enabled is    " << videoReceptionEnabled     << endl
       << "video trasnsmission enabled is "<< videoTransmissionEnabled  << endl
                                                                        << endl
       <<  "user Name is                  "<<  userName                 << endl
                                                                        << endl
       <<  "Enabled codecs are            "                             << endl
       <<   enabledCapabilities                                         << endl
       <<  "Disabled codecs are           "                             << endl
       <<   disabledCapabilities                                        << endl
       <<  "-------------------------------------------------------"    << endl;
}


///////////////////////////////////////////////////////////////

CpConnection::CpConnection(unsigned callReference,
			   unsigned options)
  : H323Connection(CPhone::GetUi(), callReference, options)
{
}


BOOL CpConnection::OnSendSignalSetup(H323SignalPDU & setupPDU)
{
  if (!CPhone::GetUi().setupInformation) {
    setupPDU.m_h323_uu_pdu.IncludeOptionalField(H225_H323_UU_PDU::e_nonStandardData);
    setupPDU.m_h323_uu_pdu.m_nonStandardData.m_nonStandardIdentifier.SetTag(H225_NonStandardIdentifier::e_h221NonStandard);
    endpoint.SetH221NonStandardInfo(setupPDU.m_h323_uu_pdu.m_nonStandardData.m_nonStandardIdentifier);
    setupPDU.m_h323_uu_pdu.m_nonStandardData.m_data = CPhone::GetUi().setupInformation;
  }
  return TRUE;
}


H323Connection::AnswerCallResponse
     CpConnection::OnAnswerCall(const PString & caller,
				const H323SignalPDU &,
				H323SignalPDU &)
{
  return CPhone::GetUi().AnswerCallConditional(caller, GetCallToken());
}


BOOL CpConnection::OnStartLogicalChannel(H323Channel & channel)
{
  if (!H323Connection::OnStartLogicalChannel(channel))
    return FALSE;

  int videoQuality = CPhone::GetUi().videoOpts.GetReceiveQuality();

  if ( (channel.GetDirection() == H323Channel::IsReceiver) &&
       (channel.GetCodec()->IsDescendant(H323VideoCodec::Class())) && 
       (videoQuality >= 0) ) {

    PThread::Current()->Sleep(3000);
    
    H323ControlPDU pdu;
    H245_CommandMessage & command = pdu.Build(H245_CommandMessage::e_miscellaneousCommand);
    
    H245_MiscellaneousCommand & miscCommand = command;
    miscCommand.m_logicalChannelNumber = (unsigned)channel.GetNumber();
    miscCommand.m_type.SetTag(H245_MiscellaneousCommand_type::e_videoTemporalSpatialTradeOff);
    PASN_Integer & value = miscCommand.m_type;
    value = videoQuality;
    WriteControlPDU(pdu);
  }

  return TRUE;
}


BOOL CpConnection::OnAlerting(const H323SignalPDU & /*alertingPDU*/,
                                  const PString & username)
{
  PAssert((CPhone::GetUi().epState == MainUi::epConnectingCall) ||
          (CPhone::GetUi().epState == MainUi::epWaitingForAnswer) ,
     psprintf("Have received an alerting. However, am in in state %i ", 
	      CPhone::GetUi().epState));

  CPhone::GetUi().DisplayMessage("Requesting \"" + username + "\"");

  CPhone::GetUi().epState = MainUi::epWaitingForAnswer;

  return TRUE;
}


void CpConnection::OnUserInputString(const PString & value)
{
  cerr << "UNknown ::  User input received: \"" << value << '"' << endl;
}

//////////////////////////////////////////////////////////////////////
#ifdef HAS_IXJ

LidHandlerThread::LidHandlerThread()
  : PThread(1000, NoAutoDeleteThread)
{
  playingTone = FALSE;

  Resume();
}

LidHandlerThread::~LidHandlerThread()
{
}

void LidHandlerThread::TerminateThread()
{
  exitFlag.Signal();
}

BOOL LidHandlerThread::SetEchoCancellation(PINDEX i)
{
    return lid.SetAEC(OpalIxJDevice::POTSLine, (OpalLineInterfaceDevice::AECLevels)i);
}

BOOL LidHandlerThread::SetRecordVolume(PINDEX i)
{
  return lid.SetRecordVolume(OpalIxJDevice::POTSLine, i);
}

BOOL LidHandlerThread::SetPlayVolume(PINDEX i)
{
  return lid.SetPlayVolume(OpalIxJDevice::POTSLine, i);
}

BOOL LidHandlerThread::SetPhoneDevice(PString name)
{
  lid.Close();

  if (!lid.Open(name)) {
    CPhone::GetUi().DisplayMessage("Failed to Open " + name);
    return FALSE;
  }  

  lidNameMutex.Wait();
  lidName = name;
  lidNameMutex.Signal();
  CPhone::GetUi().DisplayMessage("Open " + name + " fine....");

  lid.SetLineToLineDirect(0, 1, FALSE);
  lid.EnableAudio(OpalIxJDevice::POTSLine, TRUE);

  oldIsOffHook = lid.IsLineOffHook(OpalIxJDevice::POTSLine);

  return TRUE;
}

void LidHandlerThread::PlayTone(OpalLineInterfaceDevice::CallProgressTones newTone)
{
  playingTone = TRUE;
  lid.PlayTone(OpalIxJDevice::POTSLine, newTone);
}

void LidHandlerThread::StopTone()
{
  if (!playingTone)
    return;

  playingTone = FALSE;
  lid.StopTone(OpalIxJDevice::POTSLine);
}

void LidHandlerThread::AddIxjCapabilities(H323Capabilities &caps)
{
  if (lid.IsOpen()) 
    H323_LIDCapability::AddAllCapabilities(lid, caps, 0, 0); 
}

PString LidHandlerThread::GetDeviceName()
{ 
  PWaitAndSignal m(lidNameMutex); 
  return lidName; 
}

void LidHandlerThread::RingPhone(BOOL isOn)
{
  if (!lid.IsOpen())
    return;

  lid.RingLine(OpalIxJDevice::POTSLine, isOn ? 0x1010 : 0);
} 

void LidHandlerThread::Main()
{
  BOOL newIsOffHook = FALSE;
  BOOL oldIsOffHook = FALSE;

  MainUi::States oldState, newState;

  PString destAddress;
  char digit;

  oldState = CPhone::GetUi().GetEpState();

  while (!exitFlag.Wait(100)) {
    if (!lid.IsOpen())
      continue;

    newState = CPhone::GetUi().GetEpState();
    newIsOffHook = lid.IsLineOffHook(OpalIxJDevice::POTSLine);

    if (newIsOffHook != oldIsOffHook) 
      CPhone::GetUi().HandleHandsetDown(!newIsOffHook);

    oldIsOffHook = newIsOffHook;
    
    if (newState != oldState) {
      StopTone();

      switch(newState) {
      case MainUi::epDialTone:
	PlayTone(OpalLineInterfaceDevice::DialTone);      

      case MainUi::epNoTone:
	remoteFullAddress = PString();
	break;

      case MainUi::epAnsweringCall:
      case MainUi::epConnectingCall:
      case MainUi::epWaitingForAnswer:

	if (!remoteFullAddress.IsEmpty()) {
	  if (remoteFullAddress.FindRegEx("[^0-9]") != P_MAX_INDEX)
	    PlayTone(OpalLineInterfaceDevice::RingTone);  /*Not calling a phone number */
	}
	break;

      case MainUi::epCallInProgress:
	break;
      case MainUi::epCallHungup:
	PlayTone(OpalLineInterfaceDevice::BusyTone);
	break;

      default:
	break;
      }
    }
    oldState = newState;
    
    if (newState == MainUi::epDialTone) {
      digit = lid.ReadDTMF(OpalIxJDevice::POTSLine);
      if (digit) {
	StopTone();
	if (digit == '#') {
	  PString name;
	  AddressBook::GetNameAddressForSpeedDial(name, remoteFullAddress, destAddress);
	  CPhone::GetUi().DisplayMessage("Start call to  " + name);
	  CPhone::GetUi().StartCall(remoteFullAddress);
	  destAddress = PString();
	} else {
	  destAddress += digit;
	  CPhone::GetUi().DisplayMessage("Speed dial " + destAddress);
	}
      }	
    }
  }
}

#endif
// End of File ///////////////////////////////////////////////////////////////