rhodes 3.4.2 → 3.5.1.12

data/platform/shared/ruby/wp8/wp8.h

@@ -0,0 +1,274 @@
+
+#ifndef _EXT_WP8_
+#define _EXT_WP8_
+
+#include <tchar.h>
+#include <winsock2.h>
+//#include "tcmalloc/rhomem.h"
+#include <wchar.h>
+
+#ifndef _OFF_T_DEFINED
+
+typedef long _off_t;                    /* file offset value */
+
+#if     !__STDC__
+/* Non-ANSI name for compatibility */
+typedef long off_t;
+#endif
+
+#define _OFF_T_DEFINED
+#endif
+
+# define AreFileApisANSI() 1
+
+#define rb_w32_wopen _wopen
+
+/* unique difinition in wince platform. */
+
+//#ifndef _MIPS_
+//  #define CONTEXT_FLOATING_POINT  0x00000002L
+//#endif
+
+/* LockFile difinition. */
+#define LOCKFILE_FAIL_IMMEDIATELY   0x00000001
+#define LOCKFILE_EXCLUSIVE_LOCK     0x00000002
+
+/* Dual Mode difinition. */
+#define STARTF_USESHOWWINDOW    0x00000001
+#define STARTF_USESIZE          0x00000002
+#define STARTF_USEPOSITION      0x00000004
+#define STARTF_USECOUNTCHARS    0x00000008
+#define STARTF_USEFILLATTRIBUTE 0x00000010
+#define STARTF_RUNFULLSCREEN    0x00000020
+#define STARTF_FORCEONFEEDBACK  0x00000040
+#define STARTF_FORCEOFFFEEDBACK 0x00000080
+#define STARTF_USESTDHANDLES    0x00000100
+/* #define STARTF_USEHOTKEY        0x00000200 */
+
+#define STD_INPUT_HANDLE    (DWORD)-10
+#define STD_OUTPUT_HANDLE   (DWORD)-11
+#define STD_ERROR_HANDLE    (DWORD)-12
+
+#define NORMAL_PRIORITY_CLASS       0x00000020
+#define IDLE_PRIORITY_CLASS         0x00000040
+#define HIGH_PRIORITY_CLASS         0x00000080
+#define REALTIME_PRIORITY_CLASS     0x00000100
+
+
+/* WINSOCK.H? */
+#define SO_SYNCHRONOUS_NONALERT 0x20
+
+/* MoveFileEx definition. */
+#define MOVEFILE_REPLACE_EXISTING       0x00000001
+/*
+#define MOVEFILE_COPY_ALLOWED           0x00000002
+#define MOVEFILE_DELAY_UNTIL_REBOOT     0x00000004
+#define MOVEFILE_WRITE_THROUGH          0x00000008
+#define MOVEFILE_CREATE_HARDLINK        0x00000010
+#define MOVEFILE_FAIL_IF_NOT_TRACKABLE  0x00000020
+*/
+
+#define _fgetc fgetc
+#define _fputc fputc
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Win32 API redifinition. */
+
+//#undef GetCommandLine
+//#define GetCommandLine GetCommandLineA
+//
+//#undef SetFileAttributes
+//#define SetFileAttributes SetFileAttributesA
+//
+//#undef GetFileAttributes
+//#define GetFileAttributes GetFileAttributesA
+//
+//#undef FormatMessage
+//#define FormatMessage FormatMessageA
+//
+//#undef GetModuleFileName
+//#define GetModuleFileName GetModuleFileNameA
+//
+//#undef CreateFile
+//#define CreateFile CreateFileA
+//
+//#undef MoveFile
+//#define MoveFile MoveFileA
+//
+//#undef DeleteFile
+//#define DeleteFile DeleteFileA
+//
+//#undef CreateProcess
+//#define CreateProcess CreateProcessA
+//
+//#undef CharNext
+//#define CharNext CharNextA
+//
+//#undef CharPrev
+//#define CharPrev CharPrevA
+//
+//#undef WIN32_FIND_DATA
+//#define WIN32_FIND_DATA WIN32_FIND_DATAA
+//
+//#undef FindFirstFile
+//#define FindFirstFile FindFirstFileA
+//
+//#undef FindNextFile
+//#define FindNextFile FindNextFileA
+//
+/* stdio.c */
+FILE *freopen(const char *filename, const char *mode, FILE *file);
+FILE *fdopen( int handle, const char *mode );
+
+//#define fdopen _fdopen
+
+/* stdlib.c */
+char *getenv(const char *charstuff);
+char *_fullpath(char *absPath, const char *relPath, size_t maxLength);
+
+/* string.c */
+char *strdup(const char * str);
+/* char *strerror(int errno); */
+int strnicmp( const char *s1, const char *s2, size_t count );
+
+//#define strnicmp _strnicmp
+#define stricmp _stricmp
+
+/* for win32.c */
+FARPROC GetProcAddressX(HMODULE hModule, LPCSTR lpProcName);
+
+//WINBASEAPI BOOL WINAPI MoveFileEx(LPCSTR oldname, LPCSTR newname, DWORD dwFlags);
+//WINBASEAPI BOOL WINAPI DuplicateHandle(
+//	HANDLE source_process, HANDLE source,
+//	HANDLE dest_process, HANDLE *dest,
+//	DWORD access, BOOL inherit, DWORD options);
+BOOL LockFile(HANDLE hFile,
+	DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
+	DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh);
+//WINBASEAPI BOOL WINAPI LockFileEx(HANDLE hFile,
+//	DWORD dwFlags, DWORD dwReserved,
+//	DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
+//	LPOVERLAPPED lpOverlapped);
+//WINBASEAPI BOOL UnlockFile( HFILE hFile,
+//	DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
+//	DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh);
+//WINBASEAPI BOOL WINAPI UnlockFileEx(HANDLE hFile,
+//	DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow,
+//	DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped);
+//BOOL GetUserName(LPSTR lpBuffer, LPDWORD nSize);
+BOOL CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe,
+	LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize);
+HANDLE GetStdHandle(DWORD nStdHandle);
+BOOL SetStdHandle(DWORD nStdHandle, HANDLE h);
+DWORD GetLogicalDrives(VOID);
+//WINBASEAPI DWORD WINAPI WaitForMultipleObjectsEx(DWORD count,
+//	const HANDLE *handles, BOOL wait_all,
+//	DWORD timeout, BOOL alertable);
+DWORD GetEnvironmentVariable(LPCSTR name, LPSTR value, DWORD size);
+LPVOID GetEnvironmentStrings(VOID);
+BOOL FreeEnvironmentStrings(LPSTR lpszEnvironmentBlock);
+BOOL GenerateConsoleCtrlEvent(DWORD dwCtrlEvent,
+		DWORD dwProcessGroupID);
+BOOL GetProcessTimes(HANDLE hprocess,
+	LPFILETIME lpCreationTime, LPFILETIME lpExitTime,
+	LPFILETIME lpKernelTime, LPFILETIME lpUserTime);
+
+/* char -> wchar_t, wchar_t -> char */
+wchar_t* wce_mbtowc(const char* a);
+char*    wce_wctomb(const wchar_t* w);
+/* other helpers. */
+void wce_SetCommandLine(LPCWSTR wcmd);
+void wce_FreeCommandLine(void);
+TCHAR *wce_replaceRelativeDir(const char* str);
+void wce_SetCurrentDir();
+
+//#if _WIN32_WCE < 300
+//  /* for Handheld PC Pro. */
+//  char *strrchr( const char *p, int c );
+//  int stricmp( const char *p1, const char *p2 );
+//  VOID ZeroMemory(PVOID p, DWORD length);
+//
+//  #define isascii(c) ( (c>=0x00&&c<=0x7f)?1:0 )
+//  #define isspace(c) ( ((c>=0x09&&c<=0x0d)||c==0x20)?1:0 )
+//  #define isdigit(c) ( (c>=0x00&&c<=0x09)?1:0 )
+//  #define isupper(c) ( (c>='A'&&c<='Z')?1:0 )
+//  #define isalpha(c) ( ((c>='A'&&c<='Z')||(c>='a'&&c<='z'))?1:0 )
+//  #define isprint(c) ( (c>=0x20&&c<=0x7e)?1:0 )
+//  #define isalnum(c) ( (isalpha(c)||isdigit(c))?1:0 )
+//  #define iscntrl(c) ( ((c>=0x00&&c<=0x1f)||c==0x7f)?1:0 )
+//  #define islower(c) ( (c>='a'&&c<='z')?1:0 )
+//  #define ispunct(c) ( !(isalnum(c)||isspace(c))?1:0 )
+//  #define isxdigit(c) ( ((c>=0&&c<=9)||(c>='A'&&c<='F')||(c>='a'&&c<='f'))?1:0 )
+//#endif
+
+#ifdef __cplusplus
+};
+#endif
+
+#define SIZE_MAX UINT_MAX
+#define FILE_TYPE_UNKNOWN   0x0000
+#define FILE_TYPE_DISK      0x0001
+#define FILE_TYPE_CHAR      0x0002
+#define FILE_TYPE_PIPE      0x0003
+#define FILE_TYPE_REMOTE    0x8000
+#define WNOHANG -1
+
+#undef stati64
+#define stati64 stat
+
+BOOL GetHandleInformation(
+  HANDLE hObject,
+  LPDWORD lpdwFlags
+);
+
+DWORD GetFileType(
+  HANDLE hFile
+);
+
+WINBASEAPI void WINAPI GetSystemTimeAsFileTime(
+  LPFILETIME lpSystemTimeAsFileTime
+);
+
+DWORD GetCurrentDirectoryA(
+  DWORD nBufferLength,
+  LPSTR lpBuffer
+);
+
+int __cdecl _getdrive (void);
+#define _mbspbrk strpbrk
+
+//extern char **environ;
+
+#if _WIN32_WCE<=0x501
+#define BUFSIZ  512
+#define TLS_OUT_OF_INDEXES ((DWORD)0xFFFFFFFF)
+#endif //_WIN32_WCE<=0x501
+
+#define BUFSIZ  512
+
+//#if defined(OS_PLATFORM_CE)
+#ifdef __cplusplus
+extern "C"{
+#endif
+time_t time(time_t *);
+struct tm * __cdecl localtime(const time_t *);
+size_t strftime(char *, size_t, const char *,
+	const struct tm *);
+struct tm * gmtime(const time_t *);
+extern char * tzname[2];
+time_t mktime(struct tm *);
+
+extern int _daylight;
+#define daylight _daylight
+
+extern long _timezone;
+#ifdef __cplusplus
+};
+#endif
+
+//#endif
+
+#endif /* _EXT_CE_ */

data/platform/shared/ruby/wp8/wp8main.c

@@ -0,0 +1,18 @@
+#include <windows.h>
+#include <stdio.h>
+#include "wp8.h"
+
+extern int main(int, char**);
+
+
+int WINAPI
+WinMain(HINSTANCE current, HINSTANCE prev, LPWSTR wcmd, int showcmd)
+{
+    /* wchar_t -> char */
+    wce_SetCommandLine(wcmd);
+
+    wce_SetCurrentDir();
+
+    /* main. */
+    return main(0, NULL);
+}

data/platform/shared/rubyext/GeoLocation.cpp

@@ -289,4 +289,4 @@ double rho_geo_haversine_distance(double lat1, double lon1, double lat2, double
 	return dMi;
 }
 
-} //extern "C"
+} //extern "C"

data/platform/shared/rubyext/System.cpp

@@ -104,10 +104,7 @@ VALUE rho_sys_get_property(char* szPropName)
 
 	if (strcasecmp("device_id",szPropName) == 0) 
     {
-        rho::String strDeviceID = "";
-        if ( rho::sync::CClientRegister::getInstance() )
-            strDeviceID = rho::sync::CClientRegister::getInstance()->getDevicePin();
-
+        rho::String strDeviceID = rho::sync::CClientRegister::Get()->getDevicePin();
         return rho_ruby_create_string(strDeviceID.c_str());
     }
 
@@ -283,6 +280,23 @@ void rho_sys_set_window_size(int width, int height)
 {
     LOG(INFO) + "System.set_window_size is unsupported on current platform.";
 }
+
+void rho_sys_lock_window_size(int locked)
+{
+    LOG(INFO) + "System.lock_window_size is unsupported on current platform.";
+}
+#endif
+
+#if !defined(OS_WINCE) && !defined(OS_WINDOWS) && !defined(OS_WINDOWS_DESKTOP)
+void rho_sys_set_http_proxy_url(const char* url)
+{
+    LOG(INFO) + "System.set_http_proxy_url is unsupported on current platform.";
+}
+
+void rho_sys_unset_http_proxy()
+{
+    LOG(INFO) + "System.unset_http_proxy is unsupported on current platform.";
+}
 #endif
 
 } //extern "C"

data/platform/shared/rubyext/ZipFiles.cpp

@@ -6,8 +6,8 @@
 //  Copyright (c) 2012 __MyCompanyName__. All rights reserved.
 //
 
-#include "unzip/zip.h"
 #include "common/RhoStd.h"
+#include "unzip/zip.h"
 #include "common/RhoFile.h"
 #include "common/RhoFilePath.h"
 #include "logging/RhoLog.h"

data/platform/shared/sync/ClientRegister.cpp

@@ -25,7 +25,8 @@
 *------------------------------------------------------------------------*/
 
 #include "ClientRegister.h"
-#include "sync/SyncThread.h"
+#include "SyncThread.h"
+#include "ILoginListener.h"
 #include "common/RhoConf.h"
 #include "common/RhodesApp.h"
 
@@ -37,19 +38,48 @@ namespace sync{
 using namespace rho::common;
 using namespace rho::db;
 
-#define THREAD_WAIT_TIMEOUT 10
+static const int THREAD_WAIT_TIMEOUT = 10;
+static const char * const PUSH_PIN_NAME = "push_pin";
+
 
 IMPLEMENT_LOGCLASS(CClientRegister,"ClientRegister");
 
 CClientRegister* CClientRegister::m_pInstance = 0;
+bool CClientRegister::s_sslVerifyPeer = true;
+VectorPtr<ILoginListener*> CClientRegister::s_loginListeners;
 	
-/*static*/ CClientRegister* CClientRegister::Create(const char* device_pin, bool isAns) 
+/*static*/ CClientRegister* CClientRegister::Get()
 {
-	if ( m_pInstance ) 
-		return m_pInstance;
+    if (!m_pInstance)
+    {
+        m_pInstance = new CClientRegister();
+    }
+    return m_pInstance;
+}
 
-	m_pInstance = new CClientRegister(device_pin, isAns);
-	return m_pInstance;
+/*static*/ CClientRegister* CClientRegister::Create()
+{
+    String session = CSyncThread::getSyncEngine().loadSession();
+    if (session.length() > 0)
+    {
+        Get()->setRhoconnectCredentials("", "", session);
+    }
+    Get()->startUp();
+    return m_pInstance;
+}
+
+/*static*/ CClientRegister* CClientRegister::Create(const String& devicePin)
+{
+    Get()->setDevicehPin(devicePin);
+    return m_pInstance;
+}
+
+/*static*/ void CClientRegister::Stop()
+{
+    if(m_pInstance)
+    {
+        m_pInstance->doStop();
+    }
 }
 
 /*static*/ void CClientRegister::Destroy()
@@ -60,28 +90,70 @@ CClientRegister* CClientRegister::m_pInstance = 0;
     m_pInstance = 0;
 }
 
-CClientRegister::CClientRegister(const char* device_pin, const bool isAns) : CRhoThread() 
+/*static*/ void CClientRegister::SetSslVerifyPeer(boolean b)
 {
-	m_isAns = isAns;
-	m_strDevicePin = device_pin;
-    m_nPollInterval = POLL_INTERVAL_SECONDS;
+    s_sslVerifyPeer = b;
+    if (m_pInstance)
+        m_pInstance->m_NetRequest.setSslVerifyPeer(b);
+}
+
+
+/*static*/void CClientRegister::AddLoginListener(ILoginListener* listener)
+{
+    s_loginListeners.addElement(listener);
+}
+
+CClientRegister::CClientRegister() : m_nPollInterval(POLL_INTERVAL_SECONDS)
+{
+    m_NetRequest.setSslVerifyPeer(s_sslVerifyPeer);
 
-    startUp();
 }
 
 CClientRegister::~CClientRegister()
 {
-	m_NetRequest.cancel();
-	
-    stop(WAIT_BEFOREKILL_SECONDS);
+    doStop();
     m_pInstance = null;
 }
+void CClientRegister::setRhoconnectCredentials(const String& user, const String& pass, const String& session)
+{
+    LOG(INFO) + "New Sync credentials - user: " + user + ", sess: " + session;
 
-void CClientRegister::startUp() 
-{	
+    for(VectorPtr<ILoginListener*>::iterator I = s_loginListeners.begin(); I != s_loginListeners.end(); ++I)
+    {
+        (*I)->onLogin(user, pass, session);
+    }
+    startUp();
+}
+
+void CClientRegister::dropRhoconnectCredentials(const String& session)
+{
+    for(VectorPtr<ILoginListener*>::iterator I = s_loginListeners.begin(); I != s_loginListeners.end(); ++I)
+    {
+        (*I)->onLogout(session);
+    }
+}
+
+void CClientRegister::setDevicehPin(const String& pin)
+{
+    m_strDevicePin = pin;
+    RHOCONF().setString(PUSH_PIN_NAME, pin, true);
+
+    if (pin.length() > 0)
+    {
+        startUp();
+    } else
+    {
+        doStop();
+    }
+}
+
+void CClientRegister::startUp()
+{
     if ( RHOCONF().getString("syncserver").length() > 0 )
     {
-    	start(epLow);
+        LOG(INFO) + "Starting ClientRegister...";
+
+        start(epLow);
         stopWait();
     }
 }
@@ -89,10 +161,10 @@ void CClientRegister::startUp()
 void CClientRegister::run()
 {
     unsigned i = 0;
-    LOG(INFO)+"ClientRegister start";
+    LOG(INFO)+"ClientRegister is started";
 	while(!isStopping()) 
 	{
-	    i++;
+        i++;
         LOG(INFO)+"Try to register: " + i;
         if ( CSyncThread::getInstance() != null )
 		{
@@ -135,12 +207,22 @@ String CClientRegister::getRegisterBody(const String& strClientID)
 
 boolean CClientRegister::doRegister(CSyncEngine& oSync)
 {
-	String session = oSync.loadSession();
-	if ( session.length() == 0 )
+    String session = oSync.loadSession();
+    if ( session.length() == 0 )
     {
         m_nPollInterval = POLL_INTERVAL_INFINITE;
         LOG(INFO)+"Session is empty, do register later";
-		return false;
+        return false;
+    }
+    if ( m_strDevicePin.length() == 0 )
+    {
+        m_strDevicePin = RHOCONF().getString(PUSH_PIN_NAME);
+    }
+    if ( m_strDevicePin.length() == 0 )
+    {
+        m_nPollInterval = POLL_INTERVAL_INFINITE;
+        LOG(INFO)+"Device PUSH pin is empty, do register later";
+        return false;
     }
     m_nPollInterval = POLL_INTERVAL_SECONDS;
 
@@ -179,5 +261,13 @@ boolean CClientRegister::doRegister(CSyncEngine& oSync)
 	return false;
 }
 
+void CClientRegister::doStop()
+{
+    LOG(INFO) + "Stopping ClientRegister...";
+
+    m_NetRequest.cancel();
+    stop(WAIT_BEFOREKILL_SECONDS);
+}
+
 }
 }