source: verona/phcpp/phapipp.cpp @ 324:0c57fb464168

/*
  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 <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "phapipp.h"

#if defined(_WIN32)
#include <windows.h>
# ifdef _WIN32_WCE
#  include "connmgr_status.h"
# endif
#define strdup _strdup
#endif

namespace verona {

static phapi *uniqueobj;

phapi::phapi()
{
        assert(uniqueobj == 0);
        uniqueobj = this;
}


phapi::~phapi()
{
        assert(uniqueobj == this);
        uniqueobj = 0;
}



int phapi::init(bool asyncMode)
{
        return phInit(&callbacks, 0, asyncMode);
}


void phapi::terminate()
{
        phTerminate();
}



int phapi::addAuthInfo(const char* username, const char* userid,  const char* passwd,
                const char *realm, const char* ha1)
{
        return phAddAuthInfo(username, userid, passwd, ha1, realm);
}


int phapi::addVline(const char* displayname, const char* username, const char* host,
                const char*  proxy, int regTimeout, int mobility)
{
        return phAddVline3(displayname, username, host, proxy, regTimeout, mobility);
}

int phapi::delVline(int vlid)
{
        return phDelVline(vlid);
}

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

int phapi::sendOptions(int vlid, const char *to)
{
        return phLineSendOptions(vlid, to);
}

int phapi::placeCall(int vlid, const char*  uri, void* userdata, int rcid, int streams,
                const char* adev, const char* audio_addr, const char* video_addr)
{
        return phLinePlaceCall4(vlid, uri, userdata, rcid, streams, adev, audio_addr, video_addr);
}


int phapi::acceptCall(int cid, void* userData, int streams,
                const char* audio_addr, const char* video_addr)
{
        return phAcceptCall4(cid, userData, streams, audio_addr, video_addr);
}


int phapi::rejectCall(int cid, int reason, const char *uri)
{
        return uri ? phRejectCall(cid, reason) : phRejectCall2(cid, uri, reason);
}


int phapi::ringingCall(int cid)
{
        return phRingingCall(cid);
}

int phapi::closeCall(int cid)
{
        return phCloseCall(cid);

}

int phapi::holdCall(int cid)
{
        return phHoldCall(cid);
}

int phapi::resumeCall(int cid)
{
        return phResumeCall(cid);
}

int phapi::blindTransferCall(int cid, const char *uri)
{
        return phBlindTransferCall(cid, uri);
}

int phapi::sendDtmf(int cid, int dtmfChar, int mode)
{
        return phSendDtmf(cid, dtmfChar, mode);
}

int phapi::messageInCall(int cid, const char *mime,  const char *buff)
{
        return phCallSendMessage(cid, (char*) mime, (char*) buff);
}


int phapi::getSipCallID(int cid, char *idbuf,  int bufsize)
{
        return phCallGetSipCallID(cid, idbuf, bufsize);
}

int phapi::setFollowMe(int vlid, const char *uri)
{
        return phLineSetFollowMe(vlid, uri);
}

int phapi::setBusy(int vlid, bool busy)
{
        return phLineSetBusy(vlid, busy);
}

int phapi::sendMessage(int vlid, const char* to,  const char* buff, const char* mime,
                const char* target, const char* sipcid)
{
        return phLineSendMessage2(vlid, target, to, buff, mime, sipcid);
}



int phapi::subscribe(int vlid, const char* to, int winfo, char* data, int use_proxy, int expire)
{
        return phLineSubscribe2(vlid, to, winfo, data, use_proxy, expire);
}


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


int phapi::publish(int vlid, const char* to, const char* evt, const char* ctt, const char* content,
                int expires)
{
        if (expires == -1)
                expires = 600;

        return phLinePublish2(vlid, to, evt, ctt, content, expires);
}



int phapi::poll()
{
        return phPoll();
}

void phapi::refresh()
{
        phRefresh();
}


void phapi::setLogFile(const char* logFile)
{
        phSetLogFileName(logFile);
}


int phapi::mobility(int vlid)
{
        return phLineGetMobility(vlid);

}

int phapi::setUsername2(int vlid, const char* username)
{
        return phLineSetUsername2(vlid, username);
}



int phapi::getLineSipAddress(int vlid, char *buf, int size)
{
        return phLineGetSipAddress(vlid, buf, size);
}

void phapi::setUaString(const char *uastr)
{
        phSetUaString(uastr);
}

void phapi::changeAudioCodecList(const char *audio_codecs)
{
        ph_config_s *phcfg = ph_get_config();
        const size_t S = sizeof(phcfg->audio_codecs);

        strncpy(phcfg->audio_codecs, audio_codecs, S);
        phcfg->audio_codecs[S-1] = 0;
}

void phapi::changeVideoCodecList(const char *video_codecs)
{
        ph_config_s *phcfg = ph_get_config();
        const size_t S = sizeof(phcfg->video_codecs);
        
        strncpy(phcfg->video_codecs, video_codecs, S);
        phcfg->video_codecs[S-1] = 0;
}
        
#if defined(_WIN32_WCE)
char * phapi::getLocalIpFromDescription(const char *description)
{
        DWORD pcbBufferSize = 0;
        ConnMgrQueryDetailedStatus(0,&pcbBufferSize);
        CONNMGR_CONNECTION_DETAILED_STATUS *  pStatusBuffer = (CONNMGR_CONNECTION_DETAILED_STATUS *)calloc(pcbBufferSize, 1);

        if(!ConnMgrQueryDetailedStatus(pStatusBuffer,&pcbBufferSize))
        {
                for (CONNMGR_CONNECTION_DETAILED_STATUS * curItem = pStatusBuffer; curItem != 0; curItem = curItem->pNext)
                {
                        WCHAR NameBuffer[512];
                        mbstowcs(NameBuffer,description,512);

                        if (curItem->pIPAddr != NULL && (curItem->szAdapterName && !wcscmp(NameBuffer,curItem->szAdapterName) || curItem->szDescription && !wcscmp(NameBuffer,curItem->szDescription)))
                        {
                                WCHAR addressAsString[128];
                                DWORD addressSize = sizeof(addressAsString);

                                WSAAddressToString((LPSOCKADDR)curItem->pIPAddr->IPAddr,128,0,addressAsString,&addressSize);

                                char *local_ip = new char[128];
                                WideCharToMultiByte(CP_ACP, 0, addressAsString, -1,local_ip, 128, NULL, NULL);
                                return local_ip;
                        }
                }
        }
        return "";
}
#endif

void phapi::changeLocalIP(const char *local_ip)
{
        ph_config_s *phcfg = ph_get_config();
        const size_t S = sizeof(phcfg->local_ip_addr);
        strncpy(phcfg->local_ip_addr, local_ip, S);
        phcfg->local_ip_addr[S-1] = 0;
}

std::map<char*, char*> phapi::getAudioCaptureDevices()
{
        ph_audio_card_desc_t* device_tab = NULL;
        int pos = 0;
        int i = 0;
        std::map<char*, char*> device_map;

        pos = phAudioCaptureCardList(&device_tab);

        for (i = 0; i < pos; i++)
        {
                device_map.insert(std::pair<char*, char*>(device_tab[i].id, device_tab[i].name));
                printf("MSSndCard id:%s name:%s !!!!\n", device_tab[i].id, device_tab[i].name);
        }
        
        if(device_tab)
                delete device_tab;
        
        return device_map;
}

std::map<char*, char*> phapi::getVideoWebcamDevices()
{
        ph_video_web_cam_desc_t* device_tab = NULL;
        int pos =0;
        int i = 0;
        std::map<char *, char*> device_map;
                
        pos = phVideoWebcamList(&device_tab);
                
        for (i = 0; i < pos; i++)
        {
                device_map.insert(std::pair<char*, char*>(device_tab[i].id, device_tab[i].name));
                printf("webcam id:%s name:%s !!!!\n", device_tab[i].id, device_tab[i].name);
        }
        
        if(device_tab)
                delete device_tab;
        
        return device_map;
}
        
std::map<char*, char*> phapi::getAudioPlaybackDevices()
{
        ph_audio_card_desc_t* device_tab = NULL;
        int pos = 0;
        int i = 0;
        std::map<char*, char*> device_map;

        pos = phAudioPlaybackCardList(&device_tab);

        for (i = 0; i < pos; i++)
        {
                device_map.insert(std::pair<char*, char*>(device_tab[i].id, device_tab[i].name));
        }
        
        if(device_tab)
                delete device_tab;
        
        return device_map;
}

void phapi::changeAudioDeviceIn(const char *devstr)
{
        phChangeAudioDeviceIn(devstr);
}

void phapi::changeAudioDeviceOut(const char *devstr)
{
        phChangeAudioDeviceOut(devstr);
}
        
void phapi::changeVideoDevices(const char *devstr)
{
        phChangeVideoDevices(devstr);
}
        
int phapi::setSoftRecvVolumeGain(int cid, float gain)
{
        return phAudioSoftRecvVolumeGain(cid, gain);
}

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

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

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

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

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

int phapi::setSoundFileGain(phStream* phstream,float gain)
{
        return phSetSoundFileGain(phstream,gain);
}
        
phStream * phapi::playSoundFile(const char * filename, int interval, const char* deviceid)
{
        return phPlaySoundFile(filename,interval,deviceid);
}
        
int phapi::stopSoundFile(phStream * phstream)
{
        return phStopSoundFile(phstream);
}

phStream * phapi::videoStartPreview(const char* deviceid)
{
        phStream * stream = phVideoStartPreview(deviceid);
        return stream;
}
        
int phapi::videoStopPreview(phStream * phstream)
{
        return phVideoStopPreview(phstream);
}

int phapi::videoSetDefaultImage(const char* path)
{
        return phVideoSetDefaultImage(path);
}

void phapi::onCallProgress(int cid, const phCallStateInfo_t *info)
{
        if(info->event == phDTMF)
                onDtmfProgress(cid,info->dtmfDigit);
        else if(info->event == phCALLCLOSED || info->event == phCALLERROR) {
#if defined(_WIN32_WCE)
                onCallProgress2(cid,info->event,(wchar_t*)"",info->errorCode);
#else
                onCallProgress2(cid,info->event,(char*)"",info->errorCode);
#endif
        }else {
#if defined(_WIN32_WCE)
                int utfsize = MultiByteToWideChar(CP_ACP, 0, info->remoteUri, -1, NULL, 0);
                wchar_t *tmp = (wchar_t *)alloca((utfsize + 1) * sizeof(*tmp));
                        
                MultiByteToWideChar(CP_ACP, 0, info->remoteUri, -1,tmp, utfsize);
                onCallProgress2(cid,info->event, tmp,info->errorCode);
#else
                onCallProgress2(cid,info->event,(char*)info->remoteUri,info->errorCode);
#endif
        }
}

#if defined(_WIN32_WCE)
void phapi::onCallProgress2(int cid, phCallStateEvent status, wchar_t * uri, int error)
#else
void phapi::onCallProgress2(int cid, phCallStateEvent status, char * uri, int error)
#endif
{

}

void phapi::onDtmfProgress(int cid, int)
{

}

void phapi::onTransferProgress(int cid, const phTransferStateInfo_t *info)  { }
void phapi::onConfProgress(int cfid, const phConfStateInfo_t *info)  { }
void phapi::onRegProgress(int regid, int status)  { }
void phapi::onMsgProgress(int mid,  const phMsgStateInfo_t *info)  
{
        onMsgProgress2(mid,     (char *)info->rawctt, (char *)info->content);
}
void phapi::onMsgProgress2(int mid, char * type, char * content) { }
void phapi::onConnectionLost(const char* host, int port) { }
#if defined(_WIN32_WCE)
void phapi::onNotifyProgress (const char* event, const char* from, const char *ctt, wchar_t* content)  { }
#else
void phapi::onNotifyProgress (const char* event, const char* from, const char *ctt, const char* content)  { }
#endif
void phapi::onSubscriptionProgress(int sid,  const phSubscriptionStateInfo_t *info)  { }
void phapi::onFrameReady(int cid, phVideoFrameReceivedEvent_t *ev) { }
void phapi::onPhLogCsl(const char *msg){ }

void phapi::onSoundFileStopped(void *userdata , unsigned int _id, void *arg){}
        
void phapi::callProgress(int cid, const phCallStateInfo_t *info)
{
        if (uniqueobj)
                uniqueobj->onCallProgress(cid, info);
}

void phapi::transferProgress(int cid, const phTransferStateInfo_t *info)
{
        if (uniqueobj)
                uniqueobj->onTransferProgress(cid, info);

}


void phapi::confProgress(int cfid, const phConfStateInfo_t *info)
{
        if (uniqueobj)
                uniqueobj->onConfProgress(cfid, info);

}

void phapi::regProgress(int regid, int status)
{
        if (uniqueobj)
                uniqueobj->onRegProgress(regid, status);

}

void phapi::msgProgress(int mid,  const phMsgStateInfo_t *info)
{
        if (uniqueobj)
                uniqueobj->onMsgProgress(mid, info);

}

void phapi::connectionLost(const char *host, int port)
{
        if (uniqueobj)
                uniqueobj->onConnectionLost(host, port);
}

void phapi::notifyProgress (const char* event, const char* from, const char *ctt, const char* content)
{
#if defined(_WIN32_WCE)
        int utfsize = MultiByteToWideChar(CP_ACP, 0, content, -1, NULL, 0);
        wchar_t *tmp = (wchar_t *)alloca((utfsize + 1) * sizeof(*tmp));
                        
        MultiByteToWideChar(CP_ACP, 0, content, -1,tmp, utfsize);

        if (uniqueobj)
                uniqueobj->onNotifyProgress(event, from, ctt, tmp);
#else
        if (uniqueobj)
                uniqueobj->onNotifyProgress(event, from, ctt, content);
#endif

}

void phapi::subscriptionProgress(int sid,  const phSubscriptionStateInfo_t *info)
{
        if (uniqueobj)
                uniqueobj->onSubscriptionProgress(sid, info);

}


void phapi::frameReady(int cid, phVideoFrameReceivedEvent_t *ev)
{
        if (uniqueobj)
                uniqueobj->onFrameReady(cid, ev);

}

void phapi::phLogCsl(const char *msg)
{
        if (uniqueobj)
                uniqueobj->onPhLogCsl(msg);
}

void phapi::soundFileStopped(void *userdata , unsigned int _id, void *arg)
{
        if (uniqueobj)
                uniqueobj->onSoundFileStopped(userdata,_id,arg);
}
        
phCallbacks_t phapi::callbacks = {
                phapi::callProgress,
                phapi::transferProgress,
                phapi::confProgress,
                phapi::regProgress,
                phapi::msgProgress,
                phapi::connectionLost,
                phapi::notifyProgress,
                phapi::subscriptionProgress,
                phapi::frameReady,
                0,
#ifdef HAVE_CSL
                phapi::phLogCsl,
#endif /*!HAVE_CSL*/
                phapi::soundFileStopped
};


}
/*


#ifdef TEST

using namespace verona;

stdphapi* myphapi = new stdphapi; 


void testAuth(const std::string& name, const std::string& id, const std::string& pw, const std::string& realm)
{
  myphapi->addAuthInfo(name, id, pw, realm);
}


int main(int argc, char *argv[])
{

}

#endif
 */