devpcdmsyncobjhand.cpp

是一本关于

//
//	File:
//	=====
//	DevPCDMSyncObjHand.cpp: Implementation file
//
//	Description:
//	============
//	Implements the IReplObjHandler interface. Serializes/de-serializes
//	items from and to the desktop.
//

#include "DevPCDMSync.h"
#include "DevPCDMSyncFldr.h"

#include "DevPCDMSyncObjHand.h"

//<BOOK_ADDON Chapter 9.3.2.2> ***************************************************
#include "..\syncbuffer.h"
//</BOOK_ADDON Chapter 9.3.2.2> ***************************************************
//
// ========================== MEMBERS ================================
//
CPCDMSyncObjHandler::CPCDMSyncObjHandler(CPCDMSyncFolder *pFolder): m_cRef(1)
{
	m_pFolder	  = pFolder;
	m_pWriteSetup = NULL;
	m_pReadSetup  = NULL;
	m_pReadPacket = NULL;
}

CPCDMSyncObjHandler::~CPCDMSyncObjHandler()
{
}

//
// ======================== IUnkown Implementation =======================
//
STDMETHODIMP_(ULONG) CPCDMSyncObjHandler::AddRef()
{
    return ::InterlockedIncrement(&m_cRef);
}

STDMETHODIMP_(ULONG) CPCDMSyncObjHandler::Release()
{
	ULONG urc;
    if ((urc = ::InterlockedDecrement(&m_cRef)) == 0) 
        delete this;

    return urc;
}

STDMETHODIMP CPCDMSyncObjHandler::QueryInterface(const IID& iid, void  **ppv)
{
	if(ppv == NULL)
		return E_INVALIDARG;

    *ppv = static_cast<IUnknown*>(this);
    reinterpret_cast<IUnknown *>(*ppv)->AddRef();

    return S_OK;
}

//
// ======================== IReplObjHandler Implementation =======================
//

STDMETHODIMP CPCDMSyncObjHandler::Setup(PREPLSETUP pSetup)
{
	if(pSetup == NULL)
		return E_INVALIDARG;

	//
	//	TODO: Called before GetPacket() or SetPacket() is called.
	//	We could be reading & writing at the same time, so we
	//	need to store the setup ptr away. Add any initialization
	//	code here, before starting serializing/de-serializing.
	//
 printf("Setup: OID=<%d>, Mode=<%d>\n\r",pSetup->oid,pSetup->fRead);
	if(pSetup->fRead)
	{
        m_pReadSetup = pSetup;
		m_pReadPacket = new BYTE[MAXDATASIZE];		// we can handle upto MAXDATASIZE bytes of data
		if(m_pReadPacket == NULL)
			return E_OUTOFMEMORY;
	}
    else
	{
        m_pWriteSetup = pSetup;
	}

    return S_OK;
}

STDMETHODIMP CPCDMSyncObjHandler::Reset(PREPLSETUP pSetup)
{
	if(pSetup == NULL)
		return E_INVALIDARG;

	//
	//	TODO: Called right after GetPacket() or GetPacket() calls are
	//	completed. Add any clean-up code here.
	//
printf("Reset: OID=<%d>\n\r",pSetup->oid);
	if(m_pReadPacket)
	{
		delete [] m_pReadPacket;
		m_pReadPacket = NULL;
	}
    else
    {
		//
        //	on writing, update the object ID and
		//	time stamp stored in data file
		//
		m_pFolder->SetFileOID(m_pWriteSetup->oidNew);
	    m_pFolder->UpdateFileTime();
    }
	return S_OK;
}

STDMETHODIMP CPCDMSyncObjHandler::DeleteObj(PREPLSETUP pSetup)
{
	if(pSetup == NULL)
		return E_INVALIDARG;

	//
	//	TODO: Called when an object has been deleted on the desktop, the
	//	pSetup->oid member is the id of the object to be deleted. Add
	//	code to delete the object here.
	//
	//	The file has been deleted on the desktop
	//	we need to delete it on the device.
	//
    CEOIDINFO oidInfo;
	::memset(&oidInfo, NULL, sizeof(oidInfo));
printf("DeleteObj: OID=<%d>\n\r",pSetup->oid);

	return S_OK;
}

STDMETHODIMP CPCDMSyncObjHandler::GetPacket(LPBYTE *lppbPacket, DWORD *pcbPacket, DWORD cbRecommend)
{
	if((lppbPacket == NULL)||(pcbPacket == NULL))
		return E_INVALIDARG;

	//
	//	TODO: Active Sync manager calls this function to get the object
	//	(m_pReadSetup->hItem), streamed into the memory location *lppbPacket.
	//	You will need to break up the object into packets of size <= cbRecommend.
	//	It is your responsibility to obtain & free the required memory for each packet.
	//	When done with all the packets return RWRN_LAST_PACKET, else, return
	//	S_OK.
	//
	*lppbPacket = NULL;
	*pcbPacket  = NULL;

	//
	//	We open our sample text file, and stream its data into the buffer
	//	m_pPacketRead.
	//
    CEOIDINFO oidInfo;
	::memset(&oidInfo, NULL, sizeof(oidInfo));

printf("GetPacket: OID=<%d>\n\r",m_pReadSetup->oid);

	TCHAR tStr[1024];
	VARIANT value,tvalue;
	int cntRec=0,i;
	long CRC=0,FieldCnt=0,lCnt=0;
	long DBHandle=0;
	PSYNCBUFFERUP pSync=(PSYNCBUFFERUP)m_pReadPacket;

		::memset(m_pReadPacket,0,MAXDATASIZE);
		::memset(tStr,0,1024*sizeof(TCHAR));
		VariantInit(&value); VariantInit(&tvalue);
		pSync->ID=m_pReadSetup->oid;

		wsprintf(tStr,L"DELETE FROM Titles WHERE TitleID=%d;",m_pReadSetup->oid);
		wcscat(pSync->str,tStr);
		wsprintf(tStr,L"INSERT INTO Titles (TitleID, Artist, Title, Label, ReleaseDate, Copyright) VALUES (%d,",m_pReadSetup->oid);
		wcscat(pSync->str,tStr);
		HRESULT hr=m_pFolder->comDB->OpenTable(TEXT("\\My Documents\\PCDM.cdb"),TEXT("PCDMCDs"),_variant_t((LONG)PCDM_PID_ID),&DBHandle);
		if (hr!=S_OK) 
			return RERR_BAD_OBJECT;
		hr=m_pFolder->comDB->MoveFirst(DBHandle);
		hr=m_pFolder->comDB->FindRecord(DBHandle,_variant_t((LONG)PCDM_PID_ID),_variant_t((long)(m_pReadSetup->oid)));
		if (hr!=S_OK) 
		{
			m_pFolder->comDB->CloseTable(DBHandle);	
			*lppbPacket = (LPBYTE)pSync;
			*pcbPacket  = 0;			
			return RERR_USER_SKIP; //RERR_BAD_OBJECT;
		}
		hr=m_pFolder->comDB->ReadRecord(DBHandle,&FieldCnt);
		if (hr==S_OK)
		{
			for (i=PCDM_PID_AUTHOR;i<PCDM_PID_CRC;i++)
			{
				VariantClear(&value);
				hr=m_pFolder->comDB->GetValue(_variant_t((LONG)(i)),&value);
				if (hr==S_OK)
				{
					if (i!=PCDM_PID_COPYRIGHT)
						wsprintf(tStr,L"'%s',",value.bstrVal);
					else
						wsprintf(tStr,L"'%s');",value.bstrVal);
					wcscat(pSync->str+lCnt,tStr);
				}
			}
		}
		hr=m_pFolder->comDB->SetValue(_variant_t((LONG)(PCDM_PID_CRC)),_variant_t(TEXT("1")));
		hr=m_pFolder->comDB->WriteRecord(DBHandle);
		m_pFolder->comDB->CloseTable(DBHandle);

		wsprintf(tStr,L"DELETE FROM Tracks WHERE TitleID=%d; ",m_pReadSetup->oid);
		wcscat(pSync->str,tStr);
wprintf(TEXT("GP1: Value=<%s>; \n\r"),pSync->str);
		

		hr=m_pFolder->comDB->OpenTable(TEXT("\\My Documents\\PCDM.cdb"),TEXT("PCDMTracks"),_variant_t((LONG)PCDM_PID_TRACKS_ID),&DBHandle);
		while (hr==S_OK)
		{
			hr=m_pFolder->comDB->ReadRecord(DBHandle,&FieldCnt);
			if (hr==S_OK)
			{
				for (i=0;i<FieldCnt;i++)	
				{
					VariantClear(&value); VariantClear(&tvalue);
					hr=m_pFolder->comDB->GetValue(_variant_t((LONG)(i)),&value);
					if (i==PCDM_PID_TRACKS_ID && VariantChangeType(&tvalue,&value,0,VT_I4)==S_OK)
					{
						if (tvalue.lVal!=(long)m_pReadSetup->oid)
							break;
						wcscat(pSync->str,L"INSERT INTO PCDMTracks (TitleID, TrackName,TrackID) VALUES (");
					}
					VariantChangeType(&value,&value,0,VT_BSTR);
					if (i!=PCDM_PID_TRACKS_TRACKNO)
						wsprintf(tStr,L"'%s',",value.bstrVal);
					else
						wsprintf(tStr,L"'%s');",value.bstrVal);
					wcscat(pSync->str+lCnt,tStr);
				}
			}
			hr=m_pFolder->comDB->MoveNext(DBHandle);
		}
		m_pFolder->comDB->CloseTable(DBHandle);
		hr=RWRN_LAST_PACKET;
wprintf(TEXT("GP2: Value=<%s>; \n\r"),pSync->str);
		*lppbPacket = (LPBYTE)pSync;
		*pcbPacket  = ((lstrlen(pSync->str)+1)*sizeof(WCHAR))+sizeof(DWORD);

    return RWRN_LAST_PACKET;
}

STDMETHODIMP CPCDMSyncObjHandler::SetPacket(LPBYTE lpbPacket, DWORD cbPacket)
{
	if(lpbPacket == NULL)
		return E_INVALIDARG;
	//
	//	TODO: Called to de-serialize an object from the desktop. The m_pReadSetup->oid
	//	is the object in question. When Reset() is called, you know that you have
	//	received all the packets.
	//
	//	We create our sample file if it is not already created,
	//	and write the data received to the file.
	//
IPCDMUtilsPtr	  comUtils;

wprintf(L"SetPacket:<%d>:<%s>\n\r",cbPacket,(WCHAR *)lpbPacket);
	HRESULT hr=comUtils.CreateInstance(__uuidof( PCDMUtils ) );
	if (FAILED(hr)) 
		return hr;
	hr=comUtils->AnalyzeURL((WCHAR *)lpbPacket);
wprintf(L"SetPacketOut\n\r");
    return S_OK;
}