mobiletool.cpp

Mobile平台下GPRS上网连接方式

DWORD   dwIndex  = 0; 
DWORD   dwResult = 0; 
DWORD   dwStatus = 0; 
BOOL   tResult   = FALSE; 
CONNMGR_CONNECTIONINFO sCI = { 0 }; 
HRESULT hResult = S_OK; 

sCI.cbSize           = sizeof(sCI); 
sCI.dwParams         = CONNMGR_PARAM_GUIDDESTNET; 
sCI.dwFlags          = CONNMGR_FLAG_PROXY_HTTP | CONNMGR_FLAG_PROXY_WAP | CONNMGR_FLAG_PROXY_SOCKS4 | CONNMGR_FLAG_PROXY_SOCKS5;
sCI.dwPriority       = CONNMGR_PRIORITY_USERINTERACTIVE; 
sCI.guidDestNet      = IID_DestNetSecureWAP; 

HRESULT hrEstablish = ConnMgrEstablishConnectionSync(&sCI, &hConnection, 30000, &dwStatus);
if (FAILED(hrEstablish)) 
{ 
if( CONNMGR_STATUS_WAITINGCONNECTION == dwStatus )
{
//if(g_pLoggerNet) g_pLoggerNet->Save( L"\n WAP2 TimeOut, try again hrEstablish:%08x dwStatus:%02x", hrEstablish, dwStatus );
hrEstablish = ConnMgrEstablishConnectionSync(&sCI, &hConnection, 20000, &dwStatus);
//if(g_pLoggerNet) g_pLoggerNet->Save( L"\n Try2 again End hrEstablish:%08x dwStatus:%02x", hrEstablish, dwStatus );
}
}
else
{
bRet = TRUE;
}

if( pnResultStatus )
{
*pnResultStatus = dwStatus;
}
unsigned int nEndMode = ZMGStatus::GetInst()->GetFenduIni()->usbConnMode;
//if(g_pLoggerNet) g_pLoggerNet->Save( L"\n GPRSCmwapConnect2 End mode:%d bRet:%d hrEstablish:%08x dwStatus:%02x", nEndMode, bRet, hrEstablish, dwStatus );
return bRet;
}
*/
/**********************************************************************************
*Function:GPRSCmwapConnect( pnResultStatus )
*Description:Create CMWAP GPRS connection
*Input:N/A
*Output:N/A
*Return:BOOL,TRUE-Success FALSE-FAILURE
*Others:None
***********************************************************************************/

BOOL GPRSCmwapConnect(uint32* pnResultStatus )
{
	BOOL bRet = FALSE;
	
	if(g_pLoggerNet) g_pLoggerNet->Save( L"\n GPRSCmwapConnect start..." );
	
	HANDLE hConnection = NULL; 

	DWORD   dwIndex  = 0; 
	DWORD   dwResult = 0; 
	DWORD   dwStatus = 0; 
	BOOL   tResult   = FALSE; 
	CONNMGR_CONNECTIONINFO sCI = { 0 }; 
	HRESULT hResult = S_OK; 

	sCI.cbSize           = sizeof(sCI); 
	sCI.bExclusive		 = TRUE; 
	sCI.dwParams         = CONNMGR_PARAM_GUIDDESTNET; 
	sCI.dwFlags          = CONNMGR_FLAG_PROXY_HTTP | CONNMGR_FLAG_PROXY_WAP | CONNMGR_FLAG_PROXY_SOCKS4 | CONNMGR_FLAG_PROXY_SOCKS5;
	sCI.dwPriority       = CONNMGR_PRIORITY_USERINTERACTIVE; 
	sCI.guidDestNet      = IID_DestNetWAP; 

	HRESULT hrConnect = ConnMgrEstablishConnection( &sCI, &hConnection );
	
	//::MessageBoxW(g_hwnd,L"GPRSCmwapConnect",L"",0);
	//if(g_pLoggerNet) g_pLoggerNet->Save( L"\n ConnMgrEstablishConnection hrConnect:%08x hConnection:%08x", hrConnect, hConnection );
	if( hConnection && S_OK == hrConnect )
	{
		unsigned int nOld = GetTickCount();
		unsigned int nNow = GetTickCount();
		while( (nNow - nOld) < 30000 )
		{
			HRESULT hrStatus = ConnMgrConnectionStatus( hConnection, &dwStatus );
			//if(g_pLoggerNet) g_pLoggerNet->Save( L"\n ConnMgrConnectionStatus hConnection:%08x hrStatus:%08x dwStatus:%08x", hConnection, hrStatus, dwStatus );

			if( S_OK == hrStatus )
			{
				if( CONNMGR_STATUS_CONNECTED & dwStatus )
				{
					bRet = TRUE;
					break;
				}
				else if( (CONNMGR_STATUS_WAITINGCONNECTION & dwStatus) || (CONNMGR_STATUS_UNKNOWN == dwStatus) )
				{
					::Sleep(200);
				}
				else if( ( CONNMGR_STATUS_DISCONNECTED & dwStatus ) || ( CONNMGR_STATUS_WAITINGDISCONNECTION & dwStatus ) )
				{
					break;
				}
				else
				{
					::Sleep(200);
				}
			}
			else
			{
				break;
			}
			nNow = GetTickCount();
		}
	}

	//HRESULT hrEstablish = ConnMgrEstablishConnectionSync(&sCI, &hConnection, 30000, &dwStatus);
	//if (FAILED(hrEstablish)) 
	//{ 
	//	if( CONNMGR_STATUS_WAITINGCONNECTION == dwStatus )
	//	{
	//		//if(g_pLoggerNet) g_pLoggerNet->Save( L"\n WAP TimeOut, try again hrEstablish:%08x dwStatus:%02x", hrEstablish, dwStatus );
	//		hrEstablish = ConnMgrEstablishConnectionSync(&sCI, &hConnection, 20000, &dwStatus);
	//		//if(g_pLoggerNet) g_pLoggerNet->Save( L"\n Try again End hrEstablish:%08x dwStatus:%02x", hrEstablish, dwStatus );
	//	}
	//}
	//else
	//{
	//	bRet = TRUE;
	//}

	//if( pnResultStatus )
	//{
	//	*pnResultStatus = dwStatus;
	//}
	if(g_pLoggerNet) g_pLoggerNet->Save( L"\n GPRSCmwapConnect end dwStatus:%02x", dwStatus );
	//if(bRet)
	//::MessageBoxW(g_hwnd,L"GPRSCmwapConnect OK",L"",0);
	return bRet;
}

/**********************************************************************************
*Function:ClosRasGPRSConnections()
*Description:If there is active CMNET connection,don't close it,because we need 
*CMNET connection in our program.If there is active CMWAP connection,we disconnect it.
*Input:N/A
*Output:N/A
*Return:DWORD,0-no active connection(CMWAP),1-cmnet is active,-1-error happened
*Others:None
***********************************************************************************/

DWORD CloseRasGPRSConnections()
{
	DWORD nRet = 0xFFFFFFFF;

	int index = 99; // An integer index
	DWORD dwError = 0;

	DWORD dwRasConnSize;
	DWORD dwNumConnections;
	RASCONN RasConn[20]; // Buffer for connection state data,Assume the maximum number of entries is 20.

	TCHAR CMNET[64]=_T("GPRS连接互联网");
	TCHAR CMWAP[64]=_T("移动梦网(GPRS)");

	// Assume no more than 20 connections.
	RasConn[0].dwSize = sizeof (RASCONN);
	dwRasConnSize = 20 * sizeof (RASCONN);

	// Find all connections.
	if (dwError = RasEnumConnections (RasConn, &dwRasConnSize,&dwNumConnections))
	{
		goto JUMP_OUT;
		//return -1;
	}

	// If there are no connections, return zero.
	if (!dwNumConnections)
	{
		nRet = 0;
		goto JUMP_OUT;
		//return 0;
	}

	// Terminate all of the remote access connections.
	for (index = 0; index < (int)dwNumConnections; ++index)
	{
		if (dwError = RasHangUp (RasConn[index].hrasconn))
		{
			goto JUMP_OUT;
		}
		else
		{
			++nRet;
		}
		//if(!wcscmp(RasConn[index].szEntryName,CMWAP))
		//{
		//	if (dwError = RasHangUp (RasConn[index].hrasconn))
		//	{
		//		goto JUMP_OUT;
		//		//return -1;
		//	}
		//	else
		//	{
		//		nRet = 0;
		//		goto JUMP_OUT;
		//		//return 0;  //successfully disconnect cmwap;
		//	}
		//}
		//if(wcscmp(RasConn[index].szEntryName,CMNET)==0)
		//{
		//	nRet = 1;
		//	goto JUMP_OUT;
		//	//return 1;
		//}
	}
	nRet = 0;
	//return 0;

JUMP_OUT:
	return nRet;
}

// ***************************************************************************
// Function Name: GetTSPLineDeviceID
//
// Purpose: To get a TSP Line Device ID
//
// Arguments:
//  hLineApp = the HLINEAPP returned by lineInitializeEx
//  dwNumberDevices = also returned by lineInitializeEx
//  dwAPIVersionLow/High = min version of TAPI that we need
//  psTSPLineName = "Cellular Line"
//
// Return Values: Current Device ID
//
// Description:
//  This function returns the device ID of a named TAPI TSP.  The Device ID is 
//  used in the call to lineOpen

DWORD GetTSPLineDeviceID(const HLINEAPP hLineApp, 
						 const DWORD dwNumberDevices, 
						 const DWORD dwAPIVersionLow, 
						 const DWORD dwAPIVersionHigh, 
						 const TCHAR* const psTSPLineName)
{
	DWORD dwReturn = 0xffffffff;

	for(DWORD dwCurrentDevID = 0 ; dwCurrentDevID < dwNumberDevices ; dwCurrentDevID++)
	{
		DWORD dwAPIVersion;
		LINEEXTENSIONID LineExtensionID;
		if(0 == lineNegotiateAPIVersion(hLineApp, dwCurrentDevID, 
			dwAPIVersionLow, dwAPIVersionHigh, 
			&dwAPIVersion, &LineExtensionID)) 
		{
			LINEDEVCAPS LineDevCaps;
			LineDevCaps.dwTotalSize = sizeof(LineDevCaps);
			if(0 == lineGetDevCaps(hLineApp, dwCurrentDevID, 
				dwAPIVersion, 0, &LineDevCaps)) 
			{
				BYTE* pLineDevCapsBytes = new BYTE[LineDevCaps.dwNeededSize];
				if(0 != pLineDevCapsBytes) 
				{
					LINEDEVCAPS* pLineDevCaps = (LINEDEVCAPS*)pLineDevCapsBytes;
					pLineDevCaps->dwTotalSize = LineDevCaps.dwNeededSize;
					if(0 == lineGetDevCaps(hLineApp, dwCurrentDevID, 
						dwAPIVersion, 0, pLineDevCaps)) 
					{
						if(0 == _tcscmp((TCHAR*)((BYTE*)pLineDevCaps+pLineDevCaps->dwLineNameOffset), 
							psTSPLineName)) 
						{
							dwReturn = dwCurrentDevID;
						}
					}
					delete []pLineDevCapsBytes;
				}
			}
		}
	}
	return dwReturn;
}

#define ARRAY_LENGTH(x)         (sizeof(x)/sizeof((x)[0]))
#define TAPI_API_LOW_VERSION    0x00020000
#define TAPI_API_HIGH_VERSION   0x00020000
#define EXT_API_LOW_VERSION     0x00010000
#define EXT_API_HIGH_VERSION    0x00010000

BOOL GetInfo(wchar * imei)
{
	//if(g_pLoggerNet) g_pLoggerNet->Save( L"\n GetInfo Begin" );

	DWORD dwNumDevs = 0;
	DWORD dwAPIVersion = TAPI_API_HIGH_VERSION;
	LINEINITIALIZEEXPARAMS liep ={0};
	HLINEAPP hLineApp = 0;
	HLINE hLine = 0;
	DWORD dwExtVersion = 0;
	BOOL bRetVal = FALSE;
	LPBYTE pLineGeneralInfoBytes = NULL;
	DWORD dwTAPILineDeviceID=0;
	const DWORD dwMediaMode = LINEMEDIAMODE_DATAMODEM | LINEMEDIAMODE_INTERACTIVEVOICE;
	LINEGENERALINFO lviGeneralInfo={0};
	LPLINEGENERALINFO plviGeneralInfo=NULL;
	LPTSTR tsSerialNumber=NULL;

	// set the line init params
	liep.dwTotalSize = sizeof(liep);
	liep.dwOptions = LINEINITIALIZEEXOPTION_USEEVENT;

	if (lineInitializeEx(&hLineApp, 0, 0, TEXT("ZhangMei"), 
		&dwNumDevs, &dwAPIVersion, &liep)) 
	{
		goto cleanup;
	}

	// get the device ID
	dwTAPILineDeviceID = GetTSPLineDeviceID(hLineApp, dwNumDevs, 
		TAPI_API_LOW_VERSION, 
		TAPI_API_HIGH_VERSION, 
		CELLTSP_LINENAME_STRING);

	// error getting the line device ID?
	if (0xffffffff == dwTAPILineDeviceID) 
	{
		goto cleanup;
	}

	// now try and open the line
	if(lineOpen(hLineApp, dwTAPILineDeviceID, 
		&hLine, dwAPIVersion, 0, 0, 
		LINECALLPRIVILEGE_OWNER, dwMediaMode, 0)) 
	{
		goto cleanup;
	}

	// set up ExTAPI
	if (lineNegotiateExtVersion(hLineApp, dwTAPILineDeviceID, 
		dwAPIVersion, EXT_API_LOW_VERSION, 
		EXT_API_HIGH_VERSION, &dwExtVersion)) 
	{
		goto cleanup;
	}

	// try to get the general info
	lviGeneralInfo.dwTotalSize = sizeof(lviGeneralInfo);

	// step 1: find out how much space we need
	if (lineGetGeneralInfo(hLine, &lviGeneralInfo)) 
	{
		goto cleanup;
	}

	// step 2: malloc space for all the info we need
	pLineGeneralInfoBytes = new BYTE[lviGeneralInfo.dwNeededSize];
	plviGeneralInfo = (LPLINEGENERALINFO)pLineGeneralInfoBytes;

	// step 3: call lGGI again with the appropriately sized buffer
	if(NULL != pLineGeneralInfoBytes) 
	{
		plviGeneralInfo->dwTotalSize = lviGeneralInfo.dwNeededSize;
		if (lineGetGeneralInfo(hLine, plviGeneralInfo)) 
		{
			goto cleanup;
		}
	} else 
	{
		goto cleanup;
	}

	// step 4: cast all the arguments to strings
	if(0 < plviGeneralInfo->dwSerialNumberSize)
	{
		tsSerialNumber = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwSerialNumberOffset);
	}

	DWORD imeiLen = lstrlen(tsSerialNumber);
	//	imei = (wchar_t*)malloc(sizeof(wchar_t)*(imeiLen+1));
	memcpy(imei,tsSerialNumber,sizeof(wchar)*imeiLen);
	imei[imeiLen] = L'\0';

	bRetVal = TRUE;

cleanup:
	if (pLineGeneralInfoBytes) delete [] pLineGeneralInfoBytes;
	if (hLine) lineClose(hLine);
	if (hLineApp) lineShutdown(hLineApp);

	////if(g_pLoggerNet) g_pLoggerNet->Save( L"\n GetInfo End bRetVal:%d", bRetVal );

	return bRetVal;
}

BOOL GetImei(int8* imei)
{
	if(strlen(imei)>=10)
		return TRUE;
	memset(imei,0,32);
	wchar wIMEI[32] = {0};
	if(GetInfo(wIMEI))
	{
		//::MessageBoxW(g_hwnd,L"GetInfo(wIMEI)",L"",0);
		Wchar2Byte(wIMEI,imei,32);
		memset(imei+17,0,5);
	}
	if(strlen(imei)<10)
	{
		GUID guid;
		CoCreateGuid(&guid);
		sprintf(imei,"95588%u%u%u",guid.Data1,guid.Data2,guid.Data3);
		memset(imei+15,0,5);
	}
	return TRUE;
}

// lpstrFile：文件名（最好是包含路径在内） 
// hWnd 
// nScrWidth：输出图片的宽度 
// nScrHeight：输出图片的高度 
// nScrWidth、nScrHeight是输出图片的实际大小，换而言之是指缩放后的尺寸 
/*
HRESULT ShowPic(wchar *lpstrFile,HWND hWnd,int nScrWidth,int nScrHeight) 
{ 
HDC hDC_Temp=GetDC(hWnd); 

IPicture *pPic; 
IStream *pStm; 

BOOL bResult; 

HANDLE hFile=NULL; 
DWORD dwFileSize,dwByteRead; 

//打开硬盘中的图形文件 
hFile=CreateFile(lpstrFile,GENERIC_READ, 
FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL); 

if (hFile!=INVALID_HANDLE_VALUE) 
{ 
dwFileSize=GetFileSize(hFile,NULL);//获取文件字节数 

if (dwFileSize==0xFFFFFFFF) 
return FALSE; 
} 
else 
{ 
return FALSE; 
} 


//分配全局存储空间 
HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, dwFileSize); 
LPVOID pvData = NULL; 

if (hGlobal == NULL) 
return E_FAIL; 

if ((pvData = GlobalLock(hGlobal)) == NULL)//锁定分配内存块 
return E_FAIL; 

ReadFile(hFile,pvData,dwFileSize,&dwByteRead,NULL);//把文件读入内存缓冲区 

GlobalUnlock(hGlobal); 

CreateStreamOnHGlobal(hGlobal, TRUE, &pStm); 

//装入图形文件 
bResult=OleLoadPicture(pStm,dwFileSize,TRUE,IID_IPicture,(LPVOID*)&pPic); 

if(FAILED(bResult)) 
return E_FAIL; 

OLE_XSIZE_HIMETRIC hmWidth;//图片的真实宽度 
OLE_YSIZE_HIMETRIC hmHeight;//图片的真实高度 
pPic->get_Width(&hmWidth); 
pPic->get_Height(&hmHeight);