rhodes 1.4.2 → 1.5.0

data/platform/wm/rhodes/Vibrate.h

@@ -0,0 +1,35 @@
+#ifndef __VIBRATE__H__
+#define __VIBRATE__H__
+
+#include <logging/RhoLog.h>
+#include <common/RhoThread.h>
+
+using namespace rho;
+using namespace rho::common;
+
+class CVibrate :  public CRhoThread
+{
+    DEFINE_LOGCLASS;
+    
+  public:
+    static CVibrate& getCVibrate();
+    
+    void toggle ();
+    void toggle (int seconds);
+    void untoggle ();
+    
+  private:
+    CVibrate (IRhoClassFactory* factory);
+    ~CVibrate ();
+    
+    virtual void run();
+    
+    int m_nDuration;
+    bool m_bToggled;
+    
+    static void createCVibrate();
+    static CVibrate *m_pInstance;    
+    static CMutex m_mxLocker;
+};
+
+#endif // __VIBRATE__H__

data/platform/wm/rhodes/phonebook/phonebook.cpp

@@ -36,7 +36,7 @@ void  closePhonebook(void* pb) {
 }
 
 void _addRecordValue(const char* key, const char* value, void* hash) {
-	addStrToHash(*((unsigned long*)hash), key, value, strlen(value));
+	addStrToHash(*((unsigned long*)hash), key, value);
 }
 
 #if defined (_WIN32_WCE)
@@ -46,7 +46,7 @@ static VALUE _getRecord(CABRecord* record) {
 		record->enumValues(_addRecordValue,&hash);
 		return hash;
 	}
-	return getnil();
+	return rho_ruby_get_NIL();
 }
 #endif
 
@@ -72,7 +72,7 @@ VALUE getallPhonebookRecords(void* pb) {
 		return hash;
 	}
 #endif
-	return getnil();	
+	return rho_ruby_get_NIL();	
 }
 
 VALUE getPhonebookRecord(void* pb, char* id) {
@@ -87,17 +87,17 @@ VALUE getPhonebookRecord(void* pb, char* id) {
 		}
 	}
 #endif
-	return getnil();	
+	return rho_ruby_get_NIL();	
 }
 
 //==================================================================================
 
 VALUE getfirstPhonebookRecord(void* pb) {
-	return getnil();
+	return rho_ruby_get_NIL();
 }
 
 VALUE getnextPhonebookRecord(void* pb) {
-	return getnil();}
+	return rho_ruby_get_NIL();}
 
 //==================================================================================
 

data/platform/wm/rhodes/rho/common/RhoClassFactory.h

@@ -26,6 +26,12 @@ public:
     {
         return new CSystemInfoImpl;
     }
+
+    net::ISSL* createSSLEngine()
+    {
+        return null;
+    }
+
 };
 
 }

data/platform/wm/rhodes/rho/common/SystemInfoImpl.h

@@ -4,6 +4,7 @@
 
 extern "C" int rho_sys_get_screen_width();
 extern "C" int rho_sys_get_screen_height();
+//extern VALUE rho_sys_get_property(char* property);
 
 namespace rho{
 namespace common{

data/platform/wm/rhodes/rho/net/NetRequest.cpp

@@ -22,18 +22,20 @@ INetResponse* CNetRequest::pushData(const String& strUrl, const String& strBody,
 
 INetResponse* CNetRequest::pullCookies(const String& strUrl, const String& strBody, IRhoSession* oSession)
 {
-    CNetRequestImpl oImpl(this, "POST",strUrl,oSession,null);
-    CNetResponseImpl* resp = oImpl.sendString(strBody);
-
-    if ( resp && resp->isOK() )
-    {
-        ((CNetResponseImpl*)resp)->getRawData() = oImpl.makeRhoCookie();
-        //((CNetResponseImpl*)resp)->getRawData() = "exists";
-    }
+	INetResponse* pResp = doRequest("POST", strUrl, strBody, oSession, null );
+	if ( pResp->isOK() )
+        ((CNetResponseImpl*)pResp)->getRawData() = pResp->getCookies();
+		
+	return pResp;
+}
 
-    return resp;
+INetResponse* CNetRequest::doRequest( const char* method, const String& strUrl, const String& strBody, IRhoSession* oSession, Hashtable<String,String>* pHeaders )
+{
+    CNetRequestImpl oImpl(this, method,strUrl,oSession,pHeaders);
+    return oImpl.sendString(strBody);
 }
 
+
 String CNetRequest::resolveUrl(const String& strUrl)
 {
     return RHODESAPP().canonicalizeRhoUrl(strUrl);
@@ -46,7 +48,7 @@ void CNetRequest::cancel()
         m_pCurNetRequestImpl->cancel();
 }
 
-INetResponse* CNetRequest::pushFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession)
+INetResponse* CNetRequest::pushFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
 {
     common::CRhoFile oFile;
     if ( !oFile.open(strFilePath.c_str(),common::CRhoFile::OpenReadOnly) ) 
@@ -63,7 +65,7 @@ INetResponse* CNetRequest::pushFile(const String& strUrl, const String& strFileP
         if ( pResp )
             delete pResp;
 
-        CNetRequestImpl oImpl(this, "POST",strUrl,oSession,null);
+        CNetRequestImpl oImpl(this, "POST",strUrl,oSession,pHeaders);
         pResp = oImpl.sendStream(oFile.getInputStream());
         nTry++;
 
@@ -72,7 +74,7 @@ INetResponse* CNetRequest::pushFile(const String& strUrl, const String& strFileP
     return pResp;
 }
 
-INetResponse* CNetRequest::pullFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession)
+INetResponse* CNetRequest::pullFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
 {
     common::CRhoFile oFile;
     if ( !oFile.open(strFilePath.c_str(),common::CRhoFile::OpenForWrite) ) 
@@ -89,7 +91,7 @@ INetResponse* CNetRequest::pullFile(const String& strUrl, const String& strFileP
         if ( pResp )
             delete pResp;
 
-        CNetRequestImpl oImpl(this, "GET",strUrl,oSession,null);
+        CNetRequestImpl oImpl(this, "GET",strUrl,oSession,pHeaders);
         pResp = oImpl.downloadFile(oFile);
         nTry++;
 
@@ -98,35 +100,5 @@ INetResponse* CNetRequest::pullFile(const String& strUrl, const String& strFileP
     return pResp;
 }
 
-INetResponse* CNetRequest::doRequest( const char* method, const String& strUrl, const String& strBody, IRhoSession* oSession, Hashtable<String,String>* pHeaders )
-{
-    int nTry = 0;
-    m_bCancel = false;
-    CNetResponseImpl* pResp = 0;
-    do
-    {
-        if ( pResp )
-            delete pResp;
-
-        CNetRequestImpl oImpl(this, method,strUrl,oSession,pHeaders);
-        pResp = oImpl.sendString(strBody);
-        nTry++;
-
-    }while( !m_bCancel && !pResp->isResponseRecieved() && nTry < MAX_NETREQUEST_RETRY );
-
-    return pResp;
-}
-
 }
 }
-
-extern "C" {
-
-int g_rho_net_has_network = 1;
-
-int rho_net_has_network()
-{
-	return g_rho_net_has_network > 0 ? 1 : 0;
-}
-
-}

data/platform/wm/rhodes/rho/net/NetRequest.h

@@ -18,8 +18,8 @@ public:
 
     virtual INetResponse* pullData(const String& strUrl, IRhoSession* oSession );
     virtual INetResponse* pushData(const String& strUrl, const String& strBody, IRhoSession* oSession);
-    virtual INetResponse* pushFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession);
-    virtual INetResponse* pullFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession);
+    virtual INetResponse* pushFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession, Hashtable<String,String>* pHeaders);
+    virtual INetResponse* pullFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession, Hashtable<String,String>* pHeaders);
     virtual INetResponse* pullCookies(const String& strUrl, const String& strBody, IRhoSession* oSession);
 
     virtual INetResponse* doRequest( const char* method, const String& strUrl, const String& strBody, IRhoSession* oSession, Hashtable<String,String>* pHeaders );

data/platform/wm/rhodes/rho/net/NetRequestImpl.cpp

@@ -18,18 +18,13 @@ namespace rho {
 namespace net {
 IMPLEMENT_LOGCLASS(CNetRequestImpl,"Net");
 
-static boolean isLocalHost(const char* szUrl)
-{
-    return strnicmp(szUrl, "http://localhost", strlen("http://localhost")) == 0 ||
-        strnicmp(szUrl, "http://127.0.0.0", strlen("http://127.0.0.0")) == 0;
-}
-
 CNetRequestImpl::CNetRequestImpl(CNetRequest* pParent, const char* method, const String& strUrl, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
 {
     m_pParent = pParent;
     m_pParent->m_pCurNetRequestImpl = this;
     m_pHeaders = pHeaders;
     m_bCancel = false;
+    m_pSession = oSession;
 
     pszErrFunction = NULL;
     hInet = NULL, hConnection = NULL, hRequest = NULL;
@@ -40,7 +35,7 @@ CNetRequestImpl::CNetRequestImpl(CNetRequest* pParent, const char* method, const
     LOG(INFO) + "Method: " + method + ";Url: " + strUrl;
     do 
     {
-        if ( !isLocalHost(strUrl.c_str()) && !SetupInternetConnection(strUrlW) )
+        if ( !URI::isLocalHost(strUrl.c_str()) && !SetupInternetConnection(strUrlW) )
         {
             pszErrFunction = L"SetupInternetConnection";
             break;
@@ -90,20 +85,6 @@ CNetRequestImpl::CNetRequestImpl(CNetRequest* pParent, const char* method, const
             break;
         }
 
-        if ( pHeaders && pHeaders->size() > 0 )
-        {
-            String strHeaders;
-
-            for ( Hashtable<String,String>::iterator it = pHeaders->begin();  it != pHeaders->end(); ++it )
-                strHeaders += it->first + ":" + it->second + "\r\n";
-
-            if ( !HttpAddRequestHeaders( hRequest, common::convertToStringW(strHeaders).c_str(), -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
-            {
-                pszErrFunction = L"HttpAddRequestHeaders";
-                break;
-            }
-        }
-
         if (oSession!=null)
         {
 			String strSession = oSession->getSession();
@@ -138,6 +119,7 @@ CNetResponseImpl* CNetRequestImpl::sendString(const String& strBody)
                 break;
             }
         }
+        writeHeaders(m_pHeaders);
 
         if ( !HttpSendRequest( hRequest, NULL, 0, const_cast<char*>(strBody.c_str()), strBody.length() ) )
         {
@@ -155,6 +137,23 @@ CNetResponseImpl* CNetRequestImpl::sendString(const String& strBody)
     return pNetResp;
 }
 
+void CNetRequestImpl::writeHeaders(Hashtable<String,String>* pHeaders)
+{
+    if ( pHeaders && pHeaders->size() > 0 )
+    {
+        String strHeaders;
+
+        for ( Hashtable<String,String>::iterator it = pHeaders->begin();  it != pHeaders->end(); ++it )
+            strHeaders += it->first + ":" + it->second + "\r\n";
+
+        if ( !HttpAddRequestHeaders( hRequest, common::convertToStringW(strHeaders).c_str(), -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
+        {
+            pszErrFunction = L"HttpAddRequestHeaders";
+            return;
+        }
+    }
+}
+
 boolean CNetRequestImpl::readHeaders(Hashtable<String,String>& oHeaders)
 {
     oHeaders.clear();
@@ -188,6 +187,7 @@ boolean CNetRequestImpl::readHeaders(Hashtable<String,String>& oHeaders)
 
         CAtlStringW strName = strHeader.Mid(0, nSep);
         strName.Trim();
+        strName.MakeLower();
         CAtlStringW strValue = strHeader.Mid(nSep+1);
         strValue.Trim();
 
@@ -197,10 +197,10 @@ boolean CNetRequestImpl::readHeaders(Hashtable<String,String>& oHeaders)
     return true;
 }
 
-String CNetRequestImpl::makeRhoCookie()
+String CNetRequestImpl::makeClientCookie()
 {
     DWORD nIndex = 0;
-    URI::CParsedCookie cookie;
+    String cookie;
     while(true)
     {
         CAtlStringW strCookie;
@@ -229,10 +229,10 @@ String CNetRequestImpl::makeRhoCookie()
     if (pszErrFunction)
         return "";
 
-    if ( cookie.strAuth.length() > 0 || cookie.strSession.length() >0 )
-        return cookie.strAuth + ";" + cookie.strSession + ";";
+//    if ( cookie.strAuth.length() > 0 || cookie.strSession.length() >0 )
+//        return cookie.strAuth + ";" + cookie.strSession + ";";
 
-    return "";
+    return cookie;
 }
 
 void CNetRequestImpl::readResponse(CNetResponseImpl* pNetResp)
@@ -261,18 +261,14 @@ void CNetRequestImpl::readResponse(CNetResponseImpl* pNetResp)
 
         // If we're unauthorized, delete any cookies that might have been
         // stored so we don't reuse them later
-        if ( nCode == 401 ) 
+        if ( nCode == 401 && m_pSession ) 
         {
-            CAtlStringA strUrlA;
-            int nQuest = strReqUrlW.Find('?'); 
-            if ( nQuest > 0 )
-                strUrlA = strReqUrlW.Mid(0,nQuest-1);
-            else
-                strUrlA = strReqUrlW;
-
-            ::InternetSetCookieA(strUrlA, NULL, "");
+            m_pSession->logout();
         }
 	}
+
+    if (pNetResp->isOK())
+        pNetResp->setCookies(makeClientCookie());
 }
 
 CNetResponseImpl* CNetRequestImpl::downloadFile(common::CRhoFile& oFile)
@@ -281,6 +277,8 @@ CNetResponseImpl* CNetRequestImpl::downloadFile(common::CRhoFile& oFile)
 
     do
     {
+        writeHeaders(m_pHeaders);
+
         if ( isError() )
             break;
 
@@ -317,6 +315,8 @@ CNetResponseImpl* CNetRequestImpl::sendStream(common::InputStream* bodyStream)
 
     do
     {
+        writeHeaders(m_pHeaders);
+
         if ( isError() )
             break;
 
@@ -614,6 +614,5 @@ bool CNetRequestImpl::SetupInternetConnection(LPCTSTR url)
 	return true;
 #endif //_WIN32_WCE
 }
-
 }
 }

data/platform/wm/rhodes/rho/net/NetRequestImpl.h

@@ -15,6 +15,7 @@ class CNetResponseImpl : public INetResponse
     bool   m_bValid;
     String m_data;
     int    m_nRespCode;
+    String m_cookies;
 public:
     CNetResponseImpl() : m_bValid(false),m_nRespCode(-1){}
 
@@ -48,6 +49,15 @@ public:
         return m_nRespCode == 401;
     }
 
+    void setCookies(String s)
+    {
+        m_cookies = s;
+    }
+    
+    String getCookies()
+    {
+        return m_cookies;
+    }
 };
 
 class CNetRequest;
@@ -63,7 +73,8 @@ class CNetRequestImpl
     CNetRequest* m_pParent;
     Hashtable<String,String>* m_pHeaders;
     boolean m_bCancel;
-    boolean readHeaders(Hashtable<String,String>& oHeaders);
+    IRhoSession* m_pSession;
+
 public :
     CNetRequestImpl(CNetRequest* pParent, const char* method, const String& strUrl, IRhoSession* oSession, Hashtable<String,String>* pHeaders);
     ~CNetRequestImpl();
@@ -75,6 +86,9 @@ public :
     CNetResponseImpl* sendStream(common::InputStream* body);
     CNetResponseImpl* downloadFile(common::CRhoFile& oFile);
 
+private:
+    String makeClientCookie();
+
     void ErrorMessage(LPCTSTR pszFunction);
     void readInetFile( void* hRequest, CNetResponseImpl* pNetData, common::CRhoFile* pFile = NULL );
     void alloc_url_components(URL_COMPONENTS *uri, const wchar_t *url);
@@ -82,7 +96,9 @@ public :
     void readResponse(CNetResponseImpl* pNetData);
     bool SetupInternetConnection(LPCTSTR url);
 
-    String makeRhoCookie();
+    boolean readHeaders(Hashtable<String,String>& oHeaders);
+    void    writeHeaders(Hashtable<String,String>* pHeaders);
+
 };
 
 }

data/platform/wm/rhodes/rho/rubyext/GeoLocationImpl.cpp

@@ -0,0 +1,441 @@
+#include "stdafx.h"
+
+#include "GeoLocationImpl.h"
+#include "rubyext/GeoLocation.h"
+
+#if defined(_WIN32_WCE)
+IMPLEMENT_LOGCLASS(CGPSDevice,"GPSDevice");
+IMPLEMENT_LOGCLASS(CGPSController,"GPSController");
+
+//To test GPS on emulator, use FakeGPS (coming from WM6 SDK refresh) 
+
+CGPSDevice * CGPSDevice::s_pInstance = NULL;
+
+#define MAX_WAIT    5000
+#define MAX_AGE     3000
+#define GPS_CONTROLLER_EVENT_COUNT 3
+
+CGPSDevice::CGPSDevice(void)
+{
+    m_pController = NULL;
+    m_hGPS_Device = NULL;
+    m_hNewLocationData = NULL;
+    m_hDeviceStateChange = NULL;
+    m_hExitThread = NULL;
+}
+
+CGPSDevice::~CGPSDevice(void)
+{
+}
+
+CGPSDevice * CGPSDevice::Instance()
+{
+    if( CGPSDevice::s_pInstance == NULL )
+    {
+        s_pInstance = new CGPSDevice();
+    }
+
+    return CGPSDevice::s_pInstance;
+}
+
+/*static*/ boolean CGPSDevice::isAvailable()
+{
+    return s_pInstance && s_pInstance->m_hGPS_Device;
+}
+
+DWORD WINAPI CGPSDevice::GPSThreadProc(__opt LPVOID lpParameter)
+{
+    DWORD dwRet = 0;
+    GPS_POSITION gps_Position = {0};
+    GPS_DEVICE gps_Device = {0};
+
+
+    CGPSDevice * pDevice = (CGPSDevice*) lpParameter;
+
+    HANDLE gpsHandles[GPS_CONTROLLER_EVENT_COUNT] = 
+    {   pDevice->m_hNewLocationData, 
+		pDevice->m_hDeviceStateChange,
+		pDevice->m_hExitThread
+    };
+
+    gps_Position.dwSize = sizeof(gps_Position);
+    gps_Position.dwVersion = GPS_VERSION_1;
+
+    gps_Device.dwVersion = GPS_VERSION_1;
+    gps_Device.dwSize = sizeof(gps_Device);
+
+    do
+    {
+        dwRet = WaitForMultipleObjects(
+            GPS_CONTROLLER_EVENT_COUNT, 
+            gpsHandles, FALSE, INFINITE);
+
+        if (dwRet == WAIT_OBJECT_0)
+        {
+            dwRet = GPSGetPosition(
+                pDevice->m_hGPS_Device, 
+                &gps_Position, MAX_AGE, 0);
+
+            if (ERROR_SUCCESS != dwRet)
+            {
+                rho_geo_callcallback_error();
+                continue;
+            }
+            else
+                pDevice->m_pController->SetGPSPosition(gps_Position);
+        }
+        else if (dwRet == WAIT_OBJECT_0 + 1)
+        {
+            dwRet = GPSGetDeviceState(&gps_Device);    
+
+            if (ERROR_SUCCESS != dwRet)
+                continue;
+            else
+                pDevice->m_pController->SetGPSDeviceInfo(gps_Device);
+        }
+        else if (dwRet == WAIT_OBJECT_0 + 2)
+            break;
+        else
+            RHO_ASSERT(0);
+
+    } while( TRUE );
+
+    return 0;
+}
+
+HRESULT CGPSDevice::StartThread()
+{
+    HRESULT hr = E_FAIL;
+    DWORD dwRet = 0;
+
+    m_hNewLocationData = CreateEvent(NULL, FALSE, FALSE, NULL);
+
+    if ( m_hNewLocationData )
+    {
+        m_hDeviceStateChange = CreateEvent(NULL, FALSE, FALSE, NULL);
+
+        if (m_hDeviceStateChange)
+        {
+
+            m_hExitThread = CreateEvent(NULL, FALSE, FALSE, NULL);
+            if (m_hExitThread)
+            {
+
+                m_hThread = ::CreateThread(NULL, NULL, 
+                    GPSThreadProc, this, NULL, &m_dwThreadID);
+
+                if ( m_hThread )
+                    hr = S_OK;
+            }
+        }
+    }
+
+    if( FAILED(hr) )
+    {
+        dwRet = GetLastError();
+        hr = HRESULT_FROM_WIN32(dwRet);
+    }
+
+    if (FAILED(hr))
+    {
+        if (m_hNewLocationData)
+        {
+            CloseHandle(m_hNewLocationData);
+            m_hNewLocationData = NULL;
+        }
+
+        if (m_hDeviceStateChange)
+        {
+            CloseHandle(m_hDeviceStateChange);
+            m_hDeviceStateChange = NULL;
+        }
+
+        if (m_hExitThread)
+        {
+            CloseHandle(m_hExitThread);
+            m_hExitThread = NULL;
+        }
+    }
+    return hr;    
+}
+
+HRESULT CGPSDevice::StopThread()
+{
+    HRESULT hr = E_FAIL;
+    DWORD dwRet = 0;
+
+    if( SetEvent(m_hExitThread) )
+    {
+        dwRet = WaitForSingleObject(m_hThread, MAX_WAIT);
+        if(WAIT_OBJECT_0 == dwRet)
+            hr = S_OK;
+    }
+
+    if( FAILED(hr) )
+    {
+        dwRet = GetLastError();
+        hr = HRESULT_FROM_WIN32(dwRet);
+    }
+
+	if (m_hNewLocationData)
+    {
+        CloseHandle(m_hNewLocationData);
+        m_hNewLocationData = NULL;
+    }
+
+    if (m_hDeviceStateChange)
+    {
+        CloseHandle(m_hDeviceStateChange);
+        m_hDeviceStateChange = NULL;
+    }
+
+    if (m_hExitThread)
+    {
+        CloseHandle(m_hExitThread);
+        m_hExitThread = NULL;
+    }
+
+    if (m_hThread)
+    {
+        CloseHandle(m_hThread);
+        m_hThread = NULL;
+        m_dwThreadID = 0;
+    }
+
+    return hr;
+}
+
+HRESULT CGPSDevice::TurnOn(IGPSController * pController)
+{
+    if( !pController )
+        return E_INVALIDARG;
+
+    CGPSDevice * pDevice = Instance();
+
+    //We already have a device opened
+    if( pDevice->m_hGPS_Device )
+        return E_UNEXPECTED;
+
+    if( pDevice->m_pController != NULL )
+        return E_UNEXPECTED;
+
+    pDevice->m_pController = pController;
+
+    HRESULT hr = pDevice->StartThread();
+
+    if( SUCCEEDED(hr) )
+    {
+        pDevice->m_hGPS_Device = GPSOpenDevice( 
+            pDevice->m_hNewLocationData, 
+            pDevice->m_hDeviceStateChange, 
+            NULL, NULL);
+
+        if( pDevice->m_hGPS_Device )
+            hr = S_OK;
+        else
+            hr = HRESULT_FROM_WIN32(GetLastError());
+    }
+
+    if( FAILED(hr) )
+        TurnOff();
+
+    return hr;
+}
+
+HRESULT CGPSDevice::TurnOff()
+{
+    CGPSDevice * pDevice = Instance();
+
+    if( !pDevice->m_hGPS_Device )
+        return E_UNEXPECTED;    
+
+    HRESULT hr = pDevice->StopThread();
+
+    pDevice->m_pController = NULL;
+
+    DWORD dwRet = GPSCloseDevice(pDevice->m_hGPS_Device);
+    pDevice->m_hGPS_Device = NULL;
+
+    if( SUCCEEDED(hr) )
+    {
+        if( ERROR_SUCCESS != dwRet )
+            hr = HRESULT_FROM_WIN32(GetLastError());
+    }
+
+    return hr;
+}
+
+// CGPSController
+#define GPS_TIMEOUT 30; //seconds
+
+CGPSController* CGPSController::s_pInstance = NULL;
+
+CGPSController* CGPSController::Instance() {
+    if( CGPSController::s_pInstance == NULL ) {
+        s_pInstance = new CGPSController();
+    }
+    return CGPSController::s_pInstance;
+}
+
+CGPSController* CGPSController::startInstance() {
+    if( CGPSController::s_pInstance == NULL ) {
+        s_pInstance = new CGPSController();
+    }
+	s_pInstance->TurnGpsOn();
+	s_pInstance->UpdateTimeout();
+
+    return CGPSController::s_pInstance;
+}
+
+void CGPSController::DeleteInstance() {
+    if( CGPSController::s_pInstance != NULL ) {
+		delete CGPSController::s_pInstance;
+	}	
+}
+
+CGPSController::CGPSController() {
+	InitializeCriticalSection(&m_critical_section);
+	m_knownPosition = false;
+	m_gpsIsOn = false;
+	m_latitude = 0;
+	m_longitude = 0;
+
+}
+
+void CGPSController::TurnGpsOn() {
+	Lock();
+	if((!m_gpsIsOn) && SUCCEEDED(CGPSDevice::TurnOn(this))) {
+		m_gpsIsOn = true;
+		m_timeout = time(NULL)+GPS_TIMEOUT;
+	}else if (!m_gpsIsOn)
+    {
+        rho_geo_callcallback_error();
+    }
+
+	Unlock();
+}
+
+void CGPSController::CheckTimeout() {
+	if( CGPSController::s_pInstance != NULL ) {
+		CGPSController* gps = CGPSController::s_pInstance;
+		gps->Lock();
+		bool gpsOff = gps->m_gpsIsOn && (time(NULL)>=gps->m_timeout);
+		gps->Unlock();
+		if (gpsOff) {
+			CGPSDevice::TurnOff();
+			gps->m_gpsIsOn = false;
+			gps->m_knownPosition = false;
+	    gps->m_latitude = 0;
+	    gps->m_longitude = 0;
+		}
+	}
+}
+
+CGPSController::~CGPSController() {
+	DeleteCriticalSection(&m_critical_section);
+	CGPSDevice::TurnOff();
+}
+
+HRESULT CGPSController::SetGPSPosition( GPS_POSITION gps_Position ) {
+	Lock();
+    boolean bNotify = m_knownPosition==false || m_latitude != gps_Position.dblLatitude || m_longitude != gps_Position.dblLongitude;
+
+	m_knownPosition = true;
+	m_latitude = gps_Position.dblLatitude;
+	m_longitude = gps_Position.dblLongitude;
+	Unlock();
+
+    if ( bNotify )
+        rho_geo_callcallback();
+
+	return S_OK;
+}
+
+HRESULT CGPSController::SetGPSDeviceInfo( GPS_DEVICE gps_Device ) {
+	//Lock();
+	//Unlock();
+	return S_OK;
+}
+
+bool CGPSController::IsKnownPosition() {
+	Lock();
+	bool ret = m_knownPosition;
+	Unlock();
+	return ret;
+}
+
+double CGPSController::GetLatitude() {
+	Lock();
+	double ret = m_latitude;
+	Unlock();
+	return ret;
+}
+
+double CGPSController::GetLongitude() {
+	Lock();
+	double ret = m_longitude;
+	Unlock();
+	return ret;
+}
+
+time_t CGPSController::UpdateTimeout(){
+	m_timeout = time(NULL)+GPS_TIMEOUT;
+	return m_timeout;
+}
+
+void CGPSController::Lock() {
+  EnterCriticalSection(&m_critical_section);
+  //ATLTRACE(_T("CGPSController locked\n"));
+}
+
+void CGPSController::Unlock() {
+  LeaveCriticalSection(&m_critical_section);
+  //ATLTRACE(_T("CGPSController unlocked\n"));
+}
+#endif //_WIN32_WCE
+
+extern "C"{
+double rho_geo_latitude() 
+{
+#if defined(_WIN32_WCE)
+	CGPSController* gps = CGPSController::startInstance();
+	return gps->GetLatitude();
+#else
+	return 0.0;
+#endif
+}
+
+double rho_geo_longitude() 
+{
+#if defined(_WIN32_WCE)
+  CGPSController* gps = CGPSController::startInstance();
+	return gps->GetLongitude();
+#else
+	return 0.0;
+#endif
+}
+
+int rho_geo_known_position() 
+{
+#if defined(_WIN32_WCE)
+	CGPSController* gps = CGPSController::startInstance();
+	return gps->IsKnownPosition();
+#else
+	return 0;
+#endif
+}
+
+void rho_geoimpl_settimeout(int nTimeoutSec)
+{
+}
+
+int rho_geo_is_available()
+{
+#if defined(_WIN32_WCE)
+    return CGPSDevice::isAvailable() ? 1 : 0;
+#else
+	return 0;
+#endif
+}
+
+}