source: verona/phcpp/phapipp.h @ 91:58f593f4c363

/*
  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>

/*

  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;

*/

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 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 sendOptions(int vlid, const char *to);

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

  virtual int acceptCall(int cid, void* userData, int streams, 
                         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 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 subscribe(int vlid, const char* to, int winfo);
  virtual int unsubscribe(int vlid, const char* to, 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);

  int getVersion() { return phGetVersion(); }
  struct ph_config_s*  getConfig() { return ph_get_config(); }

  virtual void setUaString(const char *uastr);
  virtual void changeAudioDevices(const char *devstr);
  virtual int   addCustomHeader(const char *reqnames, const char *hdrname,  const char *hdrval);



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


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

  virtual void setLogFile(const char* logFile);


 public:

  //  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_t *info);
  virtual void onNotifyProgress (const char* event, const char* from, const char *ctt, const char* content);
  virtual void onSubscriptionProgress(int sid,  const phSubscriptionStateInfo_t *info);
  virtual void onFrameReady(int cid, phVideoFrameReceivedEvent_t *ev);




private:

  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  notifyProgress(const char* event, 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);

};


#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); }
  


  int addAuthInfo(const string &username, const string& userid, const string& passwd, const char* realm)
    {
      return phthis->addAuthInfo(cstr(username), cstr(userid), cstr(passwd), realm);
    }

  int addAuthInfo(const string &username, const string& userid, const string& passwd, const string& realm,
                  const string& ha1)
    {
      return  phthis->addAuthInfo(cstr(username), cstr(userid), cstr(passwd), cstr(realm), cstr(ha1));
    }


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



  int  sendOptions(int vlid, const string& to)
    {
      return phthis->sendOptions(vlid, cstr(to));
    }


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


  
  int rejectCall(int cid, int reason, const string& uri)
    {
      return  phthis->rejectCall(cid, reason, cstr(uri));
    }



  int messageInCall(int cid, const string& mime, const string& buf)
    {
      return  phthis->messageInCall(cid, cstr(mime), cstr(buf));
    }




  int setFollowMe(int vlid, const string& uri) 
    {
      return  phthis->setFollowMe(vlid, cstr(uri));
    }



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

      phthis->getSipCallID(cid, buf, sizeof(buf));

      return buf;
    }


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

      phthis->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  phthis->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  phthis->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  phthis->sendMessage(vlid, cstr(to), cstr(buff), cstr(mime), 0, 0);
    }
  


  int subscribe(int vlid, const string& to, int winfo)
    {
      return  phthis->subscribe(vlid, cstr(to), winfo);
    }

  int unsubscribe(int vlid, const string& to, int winfo)
    {
      return  phthis->unsubscribe(vlid, cstr(to), winfo);
    }

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

  int unpublish(int vlid, const string& to, const string& evt)
    {
      return  phthis->unpublish(vlid, cstr(to), cstr(evt));
    }
        
  
  void setUaString(const string& ua) {  phthis->setUaString(cstr(ua)); }
  void changeAudioDevices(const string& devstr) {  phthis->changeAudioDevices(cstr(devstr)); }
  int addCustomHeader(const string& reqnames, const string& hdrname,  const string& hdrval)
    {
      return  phthis->addCustomHeader(cstr(reqnames), cstr(hdrname),  cstr(hdrval));
    }



  void setLogFile(const string& logfile) {  phthis->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;





}