source: verona/phcpp/phapipp.h @ 468:20cc76e23da7

#ifndef __PHAPIPP_H__
#define __PHAPIPP_H__ 1

/*
  The phapipp module implements thin C++ wrapper around phapi
  Copyright (C) 2007  Vadim Lebedev  <vadim@mbdsys.com>

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <phapi.h>
#include <string>
#include <map>
#include <vector>

/*

  This module declares:
   1/  phapi class which can be derived from or 
   used directly by the application.

   2/  phapitp template class which can be used to simplify interface 
   with the code using C++ strings.


   example using std::string is provided as a typedef stdphapi

   to use with QString one should do something like:

   struct qtenv {
      typedef QString string;
      static const char *cstr(const QString& str) { return str.toLatin(); }
      };

   typedef verona::phapitp<qtenv> QtPhapi;

 */

struct phMsgStateInfo2 {
  enum phMsgEvent event;
  int   status;
  const char *from;
  const char *to;
  const char *ctype;
  const char *subtype;
  const char *content;
  const char *rawctt;
  int   tid;     /*!<  Trasnaction id of corresponding MESSAGE request */
  int   cid;     /*!<  when non-zero this is message inside a dialog corresponding to call 'cid' */
  std::vector<std::pair<const char*, const char*> > hlist;
};


namespace verona {


class phapi
{

public:

        phapi();
        virtual ~phapi();

        virtual int init(bool asyncMode = true);
        virtual void terminate();

        virtual int addAuthInfo(const char* username, const char* userid,  const char* passwd,
                        const char *realm, const char* ha1 = 0);

        virtual int listenAddr(int local_sip_port);

        virtual int addVline(const char* displayname, const char* username, const char* host,
                        const char*  proxy, int regTimeout, int mobility = PH_LINE_MOBILITY_DEFAULT);

        virtual int delVline(int vlid);

        virtual int vlRegister(int vlid);

        virtual int sendOptions(int vlid, const char *to);

        virtual int placeCall(int vlid, const char*  uri, void* userdata =0 , int rcid = 0, int streams = PH_STREAM_AUDIO,
                        const char* adev = 0, const char* audio_addr = 0, const char* video_addr = 0);

        virtual int acceptCall(int cid, void* userData = 0, int streams = PH_STREAM_AUDIO,
                        const char* audio_addr = 0, const char* video_addr = 0);

        virtual int rejectCall(int cid, int reason, const char *uri = 0);
        virtual int ringingCall(int cid);
        virtual int closeCall(int cid);
        virtual int holdCall(int cid);
        virtual int resumeCall(int cid);
        virtual int blindTransferCall(int cid, const char *uri);

        virtual int messageInCall(int cid, const char *buff, const char *mime);
        virtual int getSipCallID(int cid, char *idbuf,  int bufsize);
        virtual int sendDtmf(int cid, int dtmfChar, int mode);


        virtual int setFollowMe(int vlid, const char *uri);
        virtual int setBusy(int vlid, bool busy);
        virtual int sendMessage(int vlid, const char* to,  const char* buff, const char* mime,
                        const char* target = 0, const char* sipcid = 0);
        virtual int sendMessage3(int vlid, const char* to,  const char* buff, const char* mime,
                        const std::vector<std::pair<const char*, const char* > >& hdrs, const char* target = 0);

        virtual int subscribe(int vlid, const char* to, int winfo, int use_proxy = 1, int expire = 600,
                        const std::vector<std::pair<const char*, const char* > >* hdrs = 0);
        virtual int unsubscribe(int sid, int winfo);
        virtual int publish(int vlid, const char* to, const char* evt, const char* ctt, const char* content,
                        int expires = -1);
        int unpublish(int vlid, const char* to, const char* evt)
        {
                return publish(vlid, to, evt, 0, 0, 0);
        }

        virtual int getLineSipAddress(int vlid, char *buf, int size);
        virtual int mobility(int vlid);
        virtual int setUsername2(int vlid, const char* username);

        int getVersion() { return phGetVersion(); }
        const char * getRevision() { return phGetRevision(); }
        struct ph_config_s*  getConfig() { return ph_get_config(); }

        void changeAudioCodecList(const char *audio_codecs);
        void changeVideoCodecList(const char *video_codecs);
        void changeLocalIP(const char *local_ip);

        int addCustomHeader(const char *reqnames, const char *hdrname,  const char *hdrval)
        {
                return phAddCustomization(reqnames, hdrname, hdrval);
        }

        int enableCustomization(int ruleId, int enable)
        {
                return phEnableCustomization(ruleId, enable);
        }

        int monitorHeader(const char *reqnames, const char *hdrname)
        {
                return phMonitorHeader(reqnames, hdrname);
        }


        int enableMonitor(int ruleID, int enable) { return phEnableMonitor(ruleID, enable); }

        void resetMonitoring() { phResetMonitoring(); }


#if defined(_WIN32_WCE)
#ifdef SWIG
%newobject getLocalIpFromDescription;
#endif
        char * getLocalIpFromDescription(const char *description);
#endif
        virtual void setUaString(const char *uastr);

#ifdef SWIG
%newobject getAudioCaptureDevices;
%newobject getAudioPlaybackDevices;
%newobject getVideoWebcamDevices;
#endif

        virtual std::map<char*, char*> getAudioCaptureDevices();
        virtual std::map<char*, char*> getAudioPlaybackDevices();
        virtual std::map<char*, char*> getVideoWebcamDevices();
        
        virtual void changeAudioDeviceIn(const char *devstr);
        virtual void changeAudioDeviceOut(const char *devstr);
        virtual void changeVideoDevices(const char *devstr);

        virtual int setSoftRecvVolumeGain(int cid, float gain);
        virtual int setSoftSendVolumeGain(int cid, float gain);
        virtual int setRecvVolumeLevel(int cid, int level);
        virtual int setSendVolumeLevel(int cid, int level);
        virtual int mutePlayback(int cid, int val);
        virtual int muteCapture(int cid, int val);
        
        virtual int setSoundFileGain(phStream* phstream,float gain);
        virtual phStream * playSoundFile(const char * filename, int interval, const char* deviceid);
        virtual int stopSoundFile(phStream * phstream);
        virtual phStream * videoStartPreview(const char* deviceid);
        virtual int videoStopPreview(phStream * phstream);
        virtual int videoSetDefaultImage(const char* path);

        virtual int poll();
        virtual void refresh();

        int getDebugLevel() { return phGetDebugLevel(); }
        void setDebugLevel(int lvl) { phSetDebugLevel(lvl); }

        virtual void setLogFile(const char* logFile);


protected:

        //  user overridable callbacks
        virtual void onCallProgress(int cid, const phCallStateInfo_t *info);
        virtual void onTransferProgress(int cid, const phTransferStateInfo_t *info);
        virtual void onConfProgress(int cfid, const phConfStateInfo_t *info);
        virtual void onRegProgress(int regid, int status);
        virtual void onMsgProgress(int mid,  const phMsgStateInfo *info);
        virtual void onMsgProgress2(int mid,  char * type, char * content);
        virtual void onConnectionLost(const char* host, int port);
#if defined(_WIN32_WCE)
        virtual void onNotifyProgress (const char* ev, const char* from, const char *ctt, wchar_t* content);
#else
        virtual void onNotifyProgress (const char* ev, const char* from, const char *ctt, const char* content);
#endif
        virtual void onSubscriptionProgress(int sid,  const phSubscriptionStateInfo_t *info);
        virtual void onFrameReady(int cid, phVideoFrameReceivedEvent_t *ev);

#if defined(_WIN32_WCE)
        virtual void onCallProgress2(int cid, phCallStateEvent status, wchar_t * uri, int error);
#else
        virtual void onCallProgress2(int cid, phCallStateEvent status, char * uri, int error);
#endif
        virtual void onDtmfProgress(int cid, int dtmf);
        virtual void onPhLogCsl(const char *msg);
        virtual void onSoundFileStopped(void *userdata , unsigned int _id, void *arg);
        virtual void onQosEvent(int cid, const phQosInfo_t * info);


private:

#ifndef SWIG
        static phCallbacks_t callbacks;

        static void  callProgress(int cid, const phCallStateInfo_t *info);
        static void  transferProgress(int cid, const phTransferStateInfo_t *info);
        static void  confProgress(int cfid, const phConfStateInfo_t *info);
        static void  regProgress(int regid, int status);
        static void  msgProgress(int mid,  const phMsgStateInfo_t *info);
        static void  connectionLost(const char* host, int port);
        static void  notifyProgress(const char* ev, const char* from, const char *ctt, const char* content);
        static void  subscriptionProgress(int sid,  const phSubscriptionStateInfo_t *info);
        static void  frameReady(int cid, phVideoFrameReceivedEvent_t *ev);
        static void  phLogCsl(const char *msg);
        static void  soundFileStopped(void *userdata , unsigned int _id, void *arg);
        static void  qosEvent(int cid, const phQosInfo_t * info);
#endif

};

#ifndef SWIG
//#define phthis ((phapi *) this)
template<class Env>
class phapitp: public phapi
{
public:

        typedef typename Env::string string;

        static inline const char *cstr(const string& s) { return Env::cstr(s); }

        virtual ~phapitp(){};

        int addAuthInfo(const string &username, const string& userid, const string& passwd, const char* realm)
        {
                return phapi::addAuthInfo(cstr(username), cstr(userid), cstr(passwd), realm);
        }

        int addAuthInfo(const string &username, const string& userid, const string&passwd, const char* realm,
                        const string& ha1)
        {
                return phapi::addAuthInfo(cstr(username), cstr(userid), cstr(passwd), realm, cstr(ha1));
        }
        int listenAddr(int local_sip_port)
        {
                return phapi::listenAddr(local_sip_port);
        }

        int addVline(const string& displayname, const string& username, const string& host,
                        const string&  proxy, int regTimeout, int mobility = PH_LINE_MOBILITY_DEFAULT)
        {
                return phapi::addVline(cstr(displayname), cstr(username), cstr(host), cstr(proxy), regTimeout, mobility);
        }

        int vlRegister(int vlid)
        {
                return phvlRegister(vlid);
        }

        int  sendOptions(int vlid, const string& to)
        {
                return phapi::sendOptions(vlid, cstr(to));
        }


        int placeCall(int vlid, const string& uri, void* userdata = 0, int rcid =0 , int streams = PH_STREAM_AUDIO,
                        const char* adev = 0, const char* audio_addr = 0, const char* video_addr = 0)
        {
                return phapi::placeCall(vlid, cstr(uri), userdata, rcid, streams, adev, audio_addr, video_addr);
        }



        int rejectCall(int cid, int reason, const string& uri)
        {
                return phapi::rejectCall(cid, reason, cstr(uri));
        }



        int messageInCall(int cid, const string& mime, const string& buf)
        {
                return phapi::messageInCall(cid, cstr(mime), cstr(buf));
        }




        int setFollowMe(int vlid, const string& uri)
        {
                return phapi::setFollowMe(vlid, cstr(uri));
        }



        string getSipCallID(int cid)
        {
                char buf[256];

                phapi::getSipCallID(cid, buf, sizeof(buf));

                return buf;
        }


        string getSipAddress(int vlid)
        {
                char buf[256];

                phapi::getLineSipAddress(vlid, buf, sizeof(buf));

                return buf;
        }



        int sendMessage(int vlid, const string& to, const string& buff,
                        const string& mime,
                        const string& target, const string& sipcid)
        {
                return  phapi::sendMessage(vlid, cstr(to), cstr(buff), cstr(mime), cstr(target), cstr(sipcid));
        }


        int sendMessage(int vlid, const string& to, const string& buff,
                        const string& mime, const string& target)
        {
                return phapi::sendMessage(vlid, cstr(to), cstr(buff), cstr(mime), cstr(target), 0);
        }



        int sendMessage(int vlid, const string& to, const string& buff, const string& mime)
        {
                return phapi::sendMessage(vlid, cstr(to), cstr(buff), cstr(mime), 0, 0);
        }



        int subscribe(int vlid, const string& to, int winfo, int use_proxy = 1, int expire = 600,
                        vector<pair<const char*, const char*> >* hdrs=0)
        {
                return phapi::subscribe(vlid, cstr(to), winfo, use_proxy, expire, hdrs);
        }

        int unsubscribe(int sid, int winfo)
        {
                return phapi::unsubscribe(sid, winfo);
        }

        int publish(int vlid, const string& to, const string& evt, const string& ctt,
                        const string& content, int expires = -1)
        {
                return phapi::publish(vlid, cstr(to), cstr(evt), cstr(ctt), cstr(content), expires);
        }

        int unpublish(int vlid, const string& to, const string& evt)
        {
                return phapi::unpublish(vlid, cstr(to), cstr(evt));
        }

        std::map<char*, char*> getAudioCaptureDevices()
    {
                return phapi::getAudioCaptureDevices();
    }

        std::map<char*, char*> getAudioPlaybackDevices()
    {
                return phapi::getAudioPlaybackDevices();
    }

        int setSoftRecvVolumeGain(int cid, float gain)
        {
                return phapi::setSoftRecvVolumeGain(cid, gain);
        }

        int setSoftSendVolumeGain(int cid, float gain)
        {
                return phapi::setSoftSendVolumeGain(cid, gain);
        }

        int setRecvVolumeLevel(int cid, int level)
        {
                return phapi::setRecvVolumeLevel(cid, level);
        }

        int setSendVolumeLevel(int cid, int level)
        {
                return phapi::setSendVolumeLevel(cid, level);
        }

        int mutePlayback(int cid, int val)
        {
                return phapi::mutePlayback(cid, val);
        }

        int muteCapture(int cid, int val)
        {
                return phapi::muteCapture(cid, val);
        }

        int addCustomHeader(const string& reqnames, const string& hdrname,  const string& hdrval)
        {
                return phapi::addCustomHeader(cstr(reqnames), cstr(hdrname), cstr(hdrval));
        }

        int monitorHeader(const string& reqnames, const string& hdrname)
        {
                return phapi::monitorHeader(cstr(reqnames), cstr(hdrname));
        }



        void setUaString(const string& ua) {  phapi::setUaString(cstr(ua)); }
        void changeAudioDeviceIn(const string& devstr) {  phapi::changeAudioDeviceIn(cstr(devstr)); }
        void changeAudioDeviceOut(const string& devstr) {  phapi::changeAudioDeviceOut(cstr(devstr)); }
        void changeAudioCodecList(const string& audio_codecs)
        {
                phapi::changeAudioCodecList(cstr(audio_codecs));
        }
        void changeLocalIP(const string& local_ip)
        {
                phapi::changeLocalIP(cstr(local_ip));
        }

        void setLogFile(const string& logfile) {  phapi::setLogFile(cstr(logfile)); }


protected:

};

//#undef phthis

class stdenv
{
public:
        typedef std::string string;
        static const char *cstr(const string& s) {  if (&s != NULL) return s.c_str(); else return NULL; }


};


// decalare a wrapper using std::string
typedef phapitp<stdenv> stdphapi;
#endif

}

#endif /* __PHAPIPP_H__ */