pcdmsyncstore.cpp

《Windows CE 权威指南》（作者：(美)CHRIS MUENCH

			//
			//	Create a new CReplItem object
			//
			CReplItem *pReplItem = new CReplItem((LPTSTR)lpb);
			if(pReplItem == NULL)
				return NULL;

//<BOOK_ADDON Chapter 9.3.2.1> ***************************************************
			lpb += MAXDATASIZE * sizeof(TCHAR);
//</BOOK_ADDON Chapter 9.3.2.1> ***************************************************

			pReplItem->SetModified(*(FILETIME *)lpb);
			lpb += sizeof(FILETIME);
			
			return reinterpret_cast<HREPLOBJ>(pReplItem);
		}
	default:
		break;
    }
	return NULL;
}

STDMETHODIMP_(void) CPCDMSyncStore::FreeObject(HREPLOBJ hObject)
{
	if(hObject == NULL)
		return;
	
	//
	//	ActiveSync manager calls this function to give us a chance to free
	//	any of the CReplFolder/CReplItems that we had previously returned
	//	thru other calls. We simple call the objects virtual destructor.
	//
	delete(reinterpret_cast<CReplObject*>(hObject));
    return;
}

STDMETHODIMP_(BOOL) CPCDMSyncStore::CopyObject(HREPLOBJ hObjSrc, HREPLOBJ hObjDst)
{
	if((hObjSrc == NULL)||(hObjDst == NULL))
		return FALSE;

	//
	//	ActiveSync manager will call this function to make a copy of a CReplObject instance.
	//	This implementation simply calls the overloaded operator=() function. If you modify
	//	the members, you will also need to modify the operator=() function for the object.
	//
    if(reinterpret_cast<CReplObject*>(hObjSrc)->GetType() != reinterpret_cast<CReplObject*>(hObjDst)->GetType())
        return FALSE;

    switch(reinterpret_cast<CReplObject*>(hObjSrc)->GetType())
    {
    case CReplObject::PCDMSYNC_OBJ_FOLDER:
		{
			CReplFolder* pSrcFolder = reinterpret_cast<CReplFolder*>(hObjSrc);
			CReplFolder* pDstFolder = reinterpret_cast<CReplFolder*>(hObjDst);
			*pDstFolder = *pSrcFolder;
			break;
		}
    case CReplObject::PCDMSYNC_OBJ_ITEM:
		{
			CReplItem* pSrcItem = reinterpret_cast<CReplItem*>(hObjSrc);
			CReplItem* pDstItem = reinterpret_cast<CReplItem*>(hObjDst);
			*pDstItem = *pSrcItem;
			break;
		}
	default:
		break;
    }

    return TRUE;
}

STDMETHODIMP CPCDMSyncStore::IsValidObject(HREPLFLD hFolder, HREPLITEM hItem, UINT uFlags)
{
	//
	//	TODO: Modify the code below to validate the handles that are passed in.
	//	Either hFolder alone will be non-null or hFolder & hItem will be non-null.
	//	The default implementation simply verifies the object type &
	//	delegates to the folder object if necessary.
	//
	CReplFolder *pReplFolder = reinterpret_cast<CReplFolder *>(hFolder);
	CReplItem   *pReplItem	 = reinterpret_cast<CReplItem *>(hItem);

	if(pReplFolder)
	{
		if(pReplFolder->GetType() != CReplObject::PCDMSYNC_OBJ_FOLDER)
			return HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE);
	}
	if(pReplItem)
	{
		if(pReplItem->GetType() != CReplObject::PCDMSYNC_OBJ_ITEM)
			return HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE);
		
		CBaseFolder *pFolder = pReplFolder->GetFolder();
		if(pFolder)
			return pFolder->IsValidObject(hItem, uFlags);
		else
			return E_INVALIDARG;
	}
	return S_OK;
}

//
// ============= folder related routines  ================
//
STDMETHODIMP CPCDMSyncStore::GetFolderInfo(LPSTR lpszName, HREPLFLD *phFolder, IUnknown **ppObjHandler)
{
	if((lpszName == NULL)||(phFolder == NULL)||(ppObjHandler == NULL))
		return E_INVALIDARG;

	HRESULT hr = S_OK;

	CBaseFolder *pFolder = GetFolderByName(lpszName);
	if(pFolder == NULL)
		return E_INVALIDARG;

	hr = pFolder->Initialize(ppObjHandler);	// initialize folder object and
	if(FAILED(hr))							// obtain the IReplObjHandler interface.
		return hr;

	//
    //	We need to create our CReplFolder object here if *phFolder is NULL
	//	This object will be streamed & stored away in the repl.dat file.
	//
	if(*phFolder == NULL)
	{
		*phFolder = reinterpret_cast<HREPLFLD>(new CReplFolder(lpszName, pFolder));
		if(*phFolder == NULL)
			return E_OUTOFMEMORY;
	}

    return S_OK;
}

STDMETHODIMP CPCDMSyncStore::IsFolderChanged(HREPLFLD hFolder, BOOL *pfChanged)
{
	if((hFolder == NULL)||(pfChanged == NULL))
		return E_INVALIDARG;
	
	//
	//	Delegate to the folder object
	//
	CBaseFolder *pFolder = reinterpret_cast<CReplFolder *>(hFolder)->GetFolder();
	if(pFolder)
	{
		return pFolder->IsFolderChanged(pfChanged);
	}
	else
	{
		*pfChanged = FALSE;
		return E_INVALIDARG;
	}
}

//
// ============= Enumeration of folder objects ================
//
STDMETHODIMP CPCDMSyncStore::FindFirstItem(HREPLFLD hFolder, HREPLITEM *phItem, BOOL *pfExist)
{
	if((hFolder == NULL)||(phItem == NULL)||(pfExist == NULL))
		return E_INVALIDARG;

	//
	//	Delegate to the folder object
	//
	CBaseFolder *pFolder = reinterpret_cast<CReplFolder *>(hFolder)->GetFolder();
	if(pFolder)
	{
		return pFolder->FindFirstItem(phItem, pfExist);
	}
	else
	{
		*phItem  = NULL;
		*pfExist = FALSE;
		return E_INVALIDARG;
	}
}

STDMETHODIMP CPCDMSyncStore::FindNextItem(HREPLFLD hFolder, HREPLITEM *phItem, BOOL *pfExist)
{
	if((hFolder == NULL)||(phItem == NULL)||(pfExist == NULL))
		return E_INVALIDARG;

	//
	//	Delegate to the folder object
	//
	CBaseFolder *pFolder = reinterpret_cast<CReplFolder *>(hFolder)->GetFolder();
	if(pFolder)
	{
		return pFolder->FindNextItem(phItem, pfExist);
	}
	else
	{
		*phItem  = NULL;
		*pfExist = FALSE;
		return E_INVALIDARG;
	}
}

STDMETHODIMP CPCDMSyncStore::FindItemClose(HREPLFLD hFolder)
{
	if(hFolder == NULL)
		return E_INVALIDARG;

	//
	//	Delegate to the folder object
	//
	CBaseFolder *pFolder = reinterpret_cast<CReplFolder *>(hFolder)->GetFolder();
	if(pFolder)
		return pFolder->FindItemClose();
	else
		return E_INVALIDARG;
}

//
// ================== object related routines ================
//
STDMETHODIMP_(int) CPCDMSyncStore::CompareItem(HREPLITEM hItem1, HREPLITEM hItem2)
{
	if((hItem1 == NULL)||(hItem2 == NULL))
		return E_INVALIDARG;

	//
	//	Delegate to compare function of CReplItem class
	//
	return reinterpret_cast<CReplItem*>(hItem1)->Compare(reinterpret_cast<CReplItem*>(hItem2));
}

STDMETHODIMP_(BOOL) CPCDMSyncStore::IsItemChanged(HREPLFLD hFolder, HREPLITEM hItem, HREPLITEM hItemComp)
{
	if((hFolder == NULL)||(hItem == NULL))
		return FALSE;
	
	//
	//	The ActiveSync manager calls this function to check if
	//	any item has changed since the last time we synced.
	//	This implementation checks the modified time of the
	//	two handles(if they are both passed in), or delegates
	//	to the folder object.
	//
    CReplItem *pReplItem	 = reinterpret_cast<CReplItem *>(hItem);
    CReplItem *pReplItemComp = reinterpret_cast<CReplItem *>(hItemComp);

    if(pReplItemComp)
	{
        return ::CompareFileTime(&(pReplItem->GetModified()), &(pReplItemComp->GetModified()));
	}
    else
	{
		CBaseFolder *pFolder = reinterpret_cast<CReplFolder *>(hFolder)->GetFolder();
		if(pFolder)
			return pFolder->IsItemChanged(hItem); 		//	Delegate to folder object
		else
			return FALSE;
	}
}

STDMETHODIMP_(BOOL) CPCDMSyncStore::IsItemReplicated(HREPLFLD hFolder, HREPLITEM hItem)
{
	if(hFolder == NULL)
		return FALSE;

	if(hItem == NULL)	// If this is the case, we are checking to see
		return TRUE;	// if this folder can be replicated

	//
	//	Delegate to the folder object
	//
	CBaseFolder *pFolder = reinterpret_cast<CReplFolder *>(hFolder)->GetFolder();
	if(pFolder)
		return pFolder->IsItemReplicated(hItem);
	else
		return FALSE;
}

STDMETHODIMP_(void) CPCDMSyncStore::UpdateItem(HREPLFLD hFolder, HREPLITEM hItemDst, HREPLITEM hItemSrc)
{
	if((hFolder == NULL)||(hItemDst == NULL))
		return;

	//
	//	The ActiveSync manager calls this function to update
	//	an item in a folder. If both item handles are passed
	//	in, we simply update the modified times here. Else, 
	//	we delegate to the appropriate folder object.
	//
    CReplItem *pReplItemDst = reinterpret_cast<CReplItem *>(hItemDst);
    CReplItem *pReplItemSrc = reinterpret_cast<CReplItem *>(hItemSrc);

    if(pReplItemSrc)
	{
        pReplItemDst->SetModified(pReplItemSrc->GetModified());
	}
    else
	{
		CBaseFolder *pFolder = reinterpret_cast<CReplFolder *>(hFolder)->GetFolder();
		if(pFolder)
			pFolder->UpdateItem(hItemDst);	//	Delegate to the folder object
	}
	return;
}

STDMETHODIMP CPCDMSyncStore::RemoveDuplicates(LPSTR lpszObjType, UINT uFlags)
{
	//
	//	Called to remove duplicate items caused by a
	//	combine of the store objects.
	//
	if(lpszObjType == NULL)	// all folders
	{
		HRESULT hr = S_OK;

		for(int i=0; i < PCDMSYNC_NUM_FOLDERS; i++)
			hr = m_pFolders[i]->RemoveDuplicates();
		
		return hr;
	}
	else	// delegate to specific folder
	{
		CBaseFolder *pFolder = GetFolderByName(lpszObjType);
		if(pFolder)
			return pFolder->RemoveDuplicates();
		else
			return E_INVALIDARG;
	}
}

//
//  ==================== UI related routines =====================
//
STDMETHODIMP CPCDMSyncStore::GetConflictInfo(PCONFINFO pConfInfo)
{
	if(pConfInfo == NULL)
		return E_INVALIDARG;

	//
	//	Delegate to the folder object
	//
	CBaseFolder *pFolder = reinterpret_cast<CReplFolder *>(pConfInfo->hFolder)->GetFolder();
	if(pFolder)
		return pFolder->GetConflictInfo(pConfInfo);
	else
		return E_INVALIDARG;
}

STDMETHODIMP CPCDMSyncStore::ActivateDialog(UINT uDlg, HWND hWnd, HREPLFLD hFolder, IEnumReplItem *pEnum)
{
	if((hWnd == NULL)||(hFolder == NULL)||(pEnum == NULL))
		return E_INVALIDARG;

	//
	//	Delegate to the folder object
	//
	CBaseFolder *pFolder = reinterpret_cast<CReplFolder *>(hFolder)->GetFolder();
	if(pFolder)
		return pFolder->ActivateDialog(uDlg, hWnd, pEnum);
	else
		return E_INVALIDARG;
}

STDMETHODIMP CPCDMSyncStore::GetObjTypeUIData(HREPLFLD hFolder, POBJUIDATA pData)
{
	if((hFolder == NULL)||(pData == NULL))
		return E_INVALIDARG;

	//
	//	Delegate to the folder object
	//
	CBaseFolder *pFolder = reinterpret_cast<CReplFolder *>(hFolder)->GetFolder();
	if(pFolder)
		return pFolder->GetObjTypeUIData(pData);
	else
		return E_INVALIDARG;
}