main.h

softphone client for test

 * Fixed to work with new Linux implementation
 *
 * Revision 1.6  1999/04/26 06:14:46  craigs
 * Initial implementation for RTP decoding and lots of stuff
 * As a whole, these changes are called "First Noise"
 *
 * Revision 1.5  1999/02/23 11:04:28  robertj
 * Added capability to make outgoing call.
 *
 * Revision 1.4  1999/01/16 08:05:00  robertj
 * Moved h323 code to a library
 *
 * Revision 1.3  1999/01/16 01:31:36  robertj
 * Major implementation.
 *
 * Revision 1.2  1998/12/14 10:15:30  robertj
 * Fixed leak of sockets
 *
 * Revision 1.1  1998/12/14 09:13:23  robertj
 * Initial revision
 *
 */

#ifndef _OhPhone_MAIN_H
#define _OhPhone_MAIN_H

#include <h323.h>

#ifdef _WIN32
#include <vblasterlid.h>
#endif

#ifdef HAS_IXJ
#include <ixjlid.h>
#endif

#if defined(HAS_IXJ) || defined(HAS_VBLASTER)
#define HAS_LIDDEVICE
#endif

#if P_SDL
class PSDLDisplayThread;
#endif

#ifdef __BEOS__

#ifndef _APPLICATION_H
#include <Application.h>
#endif


class OhPhoneApplication : public BApplication 
{
  public:
    OhPhoneApplication()
      : BApplication("application/x-vnd.BeOhPhone") { }
};

OhPhoneApplication OhPhoneApp;

#endif


class OhPhone : public PProcess
{
    PCLASSINFO(OhPhone, PProcess)
  public:
    OhPhone();
    ~OhPhone();

    void Main();
};

class CallOptions : public PObject
{
  PCLASSINFO(CallOptions, PObject);

  public:
    BOOL Initialise(PArgList & args);
    void PrintOn(ostream & str) const;

    BOOL     noFastStart;
    BOOL     noH245Tunnelling;
    BOOL     noH245InSetup;
    BOOL     noSilenceSuppression;
    unsigned minJitter;
    unsigned maxJitter;
    PINDEX   connectRing;
    WORD     connectPort;
};


class MyH323EndPoint : public H323EndPoint
{
    PCLASSINFO(MyH323EndPoint, H323EndPoint);
  public:
    // overrides from H323EndPoint
    virtual H323Connection * CreateConnection(unsigned callReference);
    virtual BOOL OnIncomingCall(H323Connection &, const H323SignalPDU &, H323SignalPDU &);
    virtual BOOL OnConnectionForwarded(H323Connection &, const PString &, const H323SignalPDU &);
    virtual void OnConnectionEstablished(H323Connection &, const PString &);
    virtual void OnConnectionCleared(H323Connection &, const PString &);
    virtual BOOL OpenAudioChannel(H323Connection &, BOOL, unsigned, H323AudioCodec &);
    virtual BOOL OpenVideoChannel(H323Connection &, BOOL, H323VideoCodec &);
    virtual H323Connection * SetupTransfer(const PString &, const PString &, const PString &, PString &, void * userData = NULL);
    virtual void TranslateTCPAddress(PIPSocket::Address &localAddr, const PIPSocket::Address &remoteAddr);


    // new functions
    BOOL Initialise(PConfigArgs & args, int verbose, BOOL hasMenu);
    void MakeOutgoingCall(const PString &, const PString &);
    void MakeOutgoingCall(const PString &, const PString &, CallOptions callOptions);
    void AwaitTermination();
    void TriggerDisconnect();

    void HandleUserInterface();
    void StartRinging();
    void StopRinging();
    void HandleRinging();

    void TestVideoGrabber(PConfigArgs &args);
    void TestHandleUserInterface();


#ifdef HAS_LIDDEVICE
    void HandleStateChange(BOOL onHook);
    void HandleHandsetOffHook();
    void HandleHandsetOnHook();
    void HandleHandsetDTMF(PString & digits);
    void HandleHandsetTimeouts(const PTime & offHookTime);
#endif

    void SendDTMF(const char * tone);

    void StartCall(const PString & str);
    void NewSpeedDial(const PString & str);
    void ListSpeedDials();

    PDECLARE_NOTIFIER(PTimer, MyH323EndPoint, OnAutoDisconnect);

    PString GetCurrentCallToken() const
      { return currentCallToken; }

    BOOL       terminateOnHangup;

    void WaitForSdlTermination();
    BOOL InitialiseSdl(PConfigArgs & args);

    int GetChannelsOpenLimit() const
      { return channelsOpenLimit; }

  protected:
    // only used internally
    BOOL SetSoundDevice(PConfigArgs &, const char *, PSoundChannel::Directions);
    void AnswerCall(H323Connection::AnswerCallResponse response);

    void ReportSessionStatistics(H323Connection *connection, unsigned sessionID);

    CallOptions defaultCallOptions;
    CallOptions currentCallOptions;


    int  verbose;
    BOOL autoAnswer;

    PString  alwaysForwardParty;
    PString  busyForwardParty;
    PString  noAnswerForwardParty;
    unsigned noAnswerTime;
    PTimer   noAnswerTimer;
    PDECLARE_NOTIFIER(PTimer, MyH323EndPoint, OnNoAnswerTimeout);

    PString videoReceiveDevice;
    int  videoQuality;
    int  videoTxQuality;
    int  videoTxMinQuality;

    int  videoSize;       //0=small, 1=large.
    int  videoInput;
    int  videoQ;           
    int  videoFill;
    int  videoFramesPS;
    int  videoBitRate;
    int  frameTimeMs;

    BOOL    videoIsPal;
    BOOL    videoFake;    
    BOOL    videoLocal;
    BOOL    videoPIP;
    PString videoDevice;
    PString pfdColourFormat;
    int     videoCu30Stats;
    PString configDirectory;

// used for testing the video (no connection made).
    PVideoChannel *localVideoChannel; 

    PString autoDial;
    BOOL    dialAfterHangup;
    BOOL    callerIdEnable;
    BOOL    callerIdCallWaitingEnable;
    PString setupParameter;

    PFilePath ringFile;
    int ringDelay;
    PSyncPoint ringFlag;
    PThread * ringThread;

    int autoDisconnect;
    PTimer autoDisconnectTimer;

    int recordVolume;
    int playVolume;

#ifdef HAS_OSS
    BOOL InitialiseMixer(PConfigArgs & args, int _verbose);
    int  mixerDev;
    int  mixerRecChan;
    int  savedMixerRecChan;
    int  ossRecVol;
    int  ossPlayVol;
#endif

    PString currentCallToken;
    PString callTransferCallToken;

    enum {
      uiDialtone,
      uiAnsweringCall,
      uiConnectingCall,
      uiWaitingForAnswer,
      uiCallInProgress,
      uiCallHungup,
      uiStateIllegal,
    } uiState;

    PMutex uiStateMutex;

    PSyncPoint exitFlag;
    BOOL       speakerphoneSwitch;
    BOOL       hasMenu;
#ifdef HAS_LIDDEVICE
    BOOL autoHook;

    OpalLineInterfaceDevice * lidDevice;
    BOOL isXJack;
#endif

#if P_SDL
    PSDLDisplayThread *sdlThread;
    PMutex           sdlThreadLock;
#endif
    int channelsOpenLimit;

    BOOL behind_masq;
    PIPSocket::Address *masqAddressPtr;

  friend class MyH323Connection;
};


class MyH323Connection : public H323Connection
{
    PCLASSINFO(MyH323Connection, H323Connection);

  public:
    MyH323Connection(
      MyH323EndPoint & ep,
      unsigned callRef,
      unsigned options,
      unsigned minJitter,
      unsigned maxJitter,
      int verbose
    );

    // overrides from H323Connection
    BOOL OnSendSignalSetup(H323SignalPDU & setupPDU);
    AnswerCallResponse OnAnswerCall(const PString &, const H323SignalPDU &, H323SignalPDU &);
    BOOL OnStartLogicalChannel(H323Channel &);
    void OnClosedLogicalChannel(H323Channel &);
    BOOL OnAlerting(const H323SignalPDU &, const PString &);
    void OnUserInputString(const PString &);
    PString GetCallerIdString() const;

  protected:
    MyH323EndPoint & myEndpoint;
    int verbose;
    int channelsOpen;
};

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

class UserInterfaceThread : public PThread
{
    PCLASSINFO(UserInterfaceThread, PThread);
  public:
    UserInterfaceThread(MyH323EndPoint & end)
      : PThread(1000, NoAutoDeleteThread), endpoint(end) { Resume(); }
    void Main()
      { endpoint.HandleUserInterface(); }
  protected:
    MyH323EndPoint & endpoint;
};

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

class TestUserInterfaceThread : public PThread
{
    PCLASSINFO(TestUserInterfaceThread, PThread);
  public:
    TestUserInterfaceThread(MyH323EndPoint & end)
      : PThread(1000, NoAutoDeleteThread), endpoint(end) { Resume(); }
    void Main()
      { endpoint.TestHandleUserInterface(); }
  protected:
    MyH323EndPoint & endpoint;
};

#endif  // _OhPhone_MAIN_H


// End of File ///////////////////////////////////////////////////////////////