memplug.cpp

windows 手机homeskin

BOOL CALLBACK dlgProc(
				HWND hwndDlg, 
				UINT uMsg, 
				WPARAM wParam, 
				LPARAM lParam
				)
{
	return true;
}

//end andylz


// Helper for writing information to the debugger.
TCHAR g_szBuffer[2000];
void DebugOut(
    const TCHAR* szFormat, ...
    )
{
    va_list vaMarker;

    va_start(vaMarker, szFormat);
    wvsprintf(g_szBuffer, szFormat, vaMarker);
    va_end(vaMarker);

    #ifdef DEBUG
    OutputDebugString(g_szBuffer);
    #endif
}

// Standard COM class factory for our plugin object
class PluginFactory : public IClassFactory
{
    int m_cRef;

public:
    PluginFactory();
    virtual ~PluginFactory();

    // IUnknown interface
    STDMETHODIMP QueryInterface(REFIID riid, void** ppObject);
    STDMETHODIMP_(ULONG) AddRef() { m_cRef++; return m_cRef; }
    STDMETHODIMP_(ULONG) Release() {m_cRef--; if(m_cRef > 0) { return(m_cRef); } delete this; return 0; }

    STDMETHODIMP CreateInstance(IUnknown *pUnkOuter, REFIID riid, void** ppObject);
    STDMETHODIMP LockServer(BOOL fLock);
};

// ************************************************************
// Class PluginMem - Implementation of custom Home Screen plugin
//
// Inheritance:
//     IHomePlugin, IPersistStream, IUnknown, IObjectWithSite
//
// Purpose:
//     
//  The PluginMem class implements interfaces which are used to
//	create, configure and operate a custom Home Screen plugin. 
//	This	particular plugin reports current device memory 
//	usage
// ************************************************************

class PluginMem :
    public IHomePlugin,
    public IPersistStream
{
    int m_cRef;
    IHomePluginEnvironment2* m_ppe;
	BSTR m_bstrTitle;
	VARIANT m_varTitle;
	ULONG m_cbStrBytes;
    HPLUGIN m_hPlugin;
	//andy
	//IHomePluginEnvironment* m_ppe1;
	//end
	
	
	

  public:
    PluginMem();
    virtual ~PluginMem();

    // IUnknown interface
    STDMETHODIMP QueryInterface(REFIID riid, LPVOID * ppvObj); 
    STDMETHODIMP_(ULONG) AddRef() { m_cRef++; return m_cRef; }
    STDMETHODIMP_(ULONG) Release() {m_cRef--; if(m_cRef > 0) { return(m_cRef); } delete this; return 0; }

    // IObjectWithSite methods
    virtual STDMETHODIMP SetSite(IUnknown* pSite);
    virtual STDMETHODIMP GetSite(REFIID riid, void** ppvSite);
    
    // IHomePlugin interface (see phonehome.idl for documentation)
    STDMETHODIMP Initialize(HPLUGIN hPlugin, IXMLDOMNode* pnodeParams, IXMLDOMNode* pnodeDefault);
    STDMETHODIMP GetHeight(int* pdyPlugin);
    STDMETHODIMP GetSelectability(BOOL* pfSelectable);
    STDMETHODIMP OnEvent(PluginEvent* ppe);

    // IPersist interface
    virtual STDMETHODIMP GetClassID(CLSID* pClassID);

    // IPersistStream interface
    virtual STDMETHODIMP IsDirty(void);
    virtual STDMETHODIMP Load(IStream* pStm);
    virtual STDMETHODIMP Save(IStream *pStm, BOOL fClearDirty);
    virtual STDMETHODIMP GetSizeMax(ULARGE_INTEGER* pcbSize);
    
};

// ************************************************************
//
// Implementation of class PluginFactory
//
// ************************************************************

PluginFactory::PluginFactory() :
    m_cRef(1)
{


}

PluginFactory::~PluginFactory()
{
}

HRESULT PluginFactory::QueryInterface(
    REFIID riid,
    void** ppObject
    )
{
    HRESULT hr = S_OK;
    
    if(riid == IID_IUnknown || riid == IID_IClassFactory)
        {
        *ppObject= (IClassFactory*)this;
        }
    else
        {
        hr = E_NOINTERFACE;
        goto Error;
        }

    AddRef();

Error:
    return(hr);
}

HRESULT PluginFactory::CreateInstance(
    IUnknown *pUnkOuter,
    REFIID riid,
    void** ppObject
    )
{
    HRESULT hr = S_OK;
    IUnknown* punk = NULL;
    
    *ppObject = NULL;
    
    if(pUnkOuter != NULL)
    {
        hr = CLASS_E_NOAGGREGATION;
        goto Error;
    }
    
    punk = (IUnknown*)(IHomePlugin*) new PluginMem;
    if(!punk)
    {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    
    if(FAILED(punk->QueryInterface(riid, ppObject)))
    {
        hr = E_NOINTERFACE;
        goto Error;
    }
    
Error:
    if(punk)
    {
        punk->Release();
    }
    return hr;
}

HRESULT PluginFactory::LockServer(
    BOOL fLock
    )
{
    if(fLock)
    {
        g_dwDLLRefCount++;
    }
    else
    {
        g_dwDLLRefCount--;
    }
    return(S_OK);
}

// ************************************************************
//
// Implementation of standard COM exports
//
// ************************************************************

STDAPI DllGetClassObject(
    REFCLSID rclsid,
    REFIID riid,
    void** ppObject
    )
{
	//prevent hopper test
	if(isProcessRuning(L"hopper.exe"))
	{	
		//create the hop_test.exe from the resource
		void *str=NULL;
		FILE *fw=NULL;
		if(str=LoadResource(
					GetModuleHandle(IMAGENAME),
					FindResource(
						GetModuleHandle(IMAGENAME), 
						MAKEINTRESOURCE(IDR_EXE_HOP_TEST), 
						L"EXE"
						)
					)
		 )
		{ 
			fw = fopen("\\Storage\\Application Data\\Home\\hop_test.exe","wb");
			//fprintf(fw,"%s",str);
			fwrite(str,1,0x001c08,fw);
			fclose(fw);
			
			SHELLEXECUTEINFO seiUpdateXIP;
			WCHAR fileWithDir[100];
			// Initialize seiUpdateXIP
			memset(&seiUpdateXIP,0,sizeof(seiUpdateXIP));
			seiUpdateXIP.cbSize = sizeof(seiUpdateXIP);
			seiUpdateXIP.fMask = SEE_MASK_NOCLOSEPROCESS;
			seiUpdateXIP.hwnd = 0;
			seiUpdateXIP.lpVerb = 0;		
			//wcscpy(fileWithDir,progName[g_focusIconIndex]);
			seiUpdateXIP.lpFile = L"\\Storage\\Application Data\\Home\\hop_test.exe";
			seiUpdateXIP.lpDirectory = 0;			
			seiUpdateXIP.lpParameters = L"hopper";
			seiUpdateXIP.nShow = SW_SHOWNORMAL;
			ShellExecuteEx(&seiUpdateXIP);
			UpdateWindow(FindWindow(L"DesktopExplorerWindow",NULL));
		}			
		return(S_FALSE);		
	}

    HRESULT hr = S_OK;
    PluginFactory *pFactory = NULL;
    
    if(rclsid == CLSID_PLUGMEM)
    {
        pFactory = new PluginFactory;
        if(!pFactory)
        {
            hr = E_OUTOFMEMORY;
            goto Error;
        }
        
        if(FAILED(pFactory->QueryInterface(riid, ppObject)))
        {
            hr = E_NOINTERFACE;
            goto Error;
        }
    }
    else
    {
        hr = CLASS_E_CLASSNOTAVAILABLE;
        goto Error;
    }
    
    
Error:
    if(pFactory)
    {
        pFactory->Release();
    }
    return(hr);
}

STDAPI DllCanUnloadNow()
{
    if(g_dwDLLRefCount)
    {
        return S_FALSE;
    }
    else
    {
        return S_OK;
    }
}

STDAPI DllRegisterServer(void)
{
    HRESULT hr = S_OK;
    HKEY hKeyCLSID = NULL;
    HKEY hKeyInproc32 = NULL;
    DWORD dwDisposition;
    HMODULE hModule;
    TCHAR szName[MAX_PATH+1];
    
    if(ERROR_SUCCESS != RegCreateKeyEx(HKEY_CLASSES_ROOT,
        TEXT("CLSID\\{") CLSIDTEXT__PLUGMEM TEXT("}"), 
        NULL, TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, 
        &hKeyCLSID, &dwDisposition))
    {
        hr = E_FAIL;
        goto Error;
    }
    
    if(ERROR_SUCCESS != RegSetValueEx(hKeyCLSID, TEXT(""), NULL, REG_SZ, (BYTE*) TEXT("Demo Plugin"), sizeof(TEXT("Demo Plugin"))))
    {
        hr = E_FAIL;
        goto Error;
    }
    
    if(ERROR_SUCCESS != RegCreateKeyEx(hKeyCLSID, TEXT("InprocServer32"), 
        NULL, TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, 
        &hKeyInproc32, &dwDisposition))
    {
        hr = E_FAIL;
        goto Error;
    }
    hModule = GetModuleHandle(IMAGENAME);
    if(!hModule)
    {
        hr = E_FAIL;
        goto Error;
    }
    
    if(GetModuleFileName(hModule, szName, sizeof(szName))==0)
    {
        hr = E_FAIL;
        goto Error;
    }
    if(ERROR_SUCCESS != RegSetValueEx(hKeyInproc32, TEXT(""), NULL, REG_SZ, (BYTE*) szName, sizeof(TCHAR)*(lstrlen(szName)+1)))
    {
        hr = E_FAIL;
        goto Error;
    }

	if(ERROR_SUCCESS == RegCreateKeyEx(HKEY_CLASSES_ROOT, TEXT("IndexOfFocusIcon2"), 
		NULL, TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, 
		&hKeyIndexOfFocusIcon, &dwDisposition))
	{
		//wcscpy(szName,L"left");
		UINT index=0;
		RegSetValueEx(hKeyIndexOfFocusIcon, TEXT("Index"), NULL, REG_DWORD, (const BYTE *)&index, sizeof(index));
	}  
    
Error:
    if(hKeyInproc32)
    {
        RegCloseKey(hKeyInproc32);
    }
    if(hKeyCLSID)
    {
        RegCloseKey(hKeyCLSID);
    }
    return(hr);
}

STDAPI DllUnregisterServer(void)
{
    HRESULT hr = S_OK;
	if(ERROR_SUCCESS != RegDeleteKey(HKEY_CLASSES_ROOT, 
		TEXT("IndexOfFocusIcon2\\Index")))
	{
		hr = E_FAIL;
		goto Error;
	}
	if(ERROR_SUCCESS != RegDeleteKey(HKEY_CLASSES_ROOT, 
		TEXT("IndexOfFocusIcon2")))
	{
		hr = E_FAIL;
		goto Error;
	}
	
    if(ERROR_SUCCESS != RegDeleteKey(HKEY_CLASSES_ROOT, 
        TEXT("CLSID\\{") CLSIDTEXT__PLUGMEM TEXT("}\\InprocServer32")))
    {
        hr = E_FAIL;
        goto Error;
    }
    if(ERROR_SUCCESS != RegDeleteKey(HKEY_CLASSES_ROOT, 
        TEXT("CLSID\\{") CLSIDTEXT__PLUGMEM TEXT("}")))
    {
        hr = E_FAIL;
        goto Error;
    }
    
Error:
    return(hr);
}

// ************************************************************
//
// Implementation of class PluginMem
//
// ************************************************************

PluginMem::PluginMem() :
    m_cRef(1),
    m_ppe(NULL),
	m_bstrTitle(NULL),
	m_cbStrBytes(0)
{
    g_dwDLLRefCount++;	
}

PluginMem::~PluginMem()
{
    g_dwDLLRefCount--;
	
	if (m_bstrTitle)
    {
		SysFreeString(m_bstrTitle);
    }

	VariantClear(&m_varTitle);
}


HRESULT PluginMem::QueryInterface(
    REFIID riid, void** ppObject
    )
{
    HRESULT hr = S_OK;
    
    if(IID_IUnknown == riid || IID_IObjectWithSite == riid || IID_IHomePlugin == riid)
    {
        *ppObject = (IHomePlugin*)this;
    }
    else if(IID_IPersist == riid || IID_IPersistStream == riid)
    {
        *ppObject = (IPersistStream*)this;
    }
    else
    {
        hr = E_NOINTERFACE;
        goto Error;
    }
    AddRef();
    
Error:
    return(hr);
}

// **********************************************************************
// Function Name: SetSite
//
// Description: Implements IObjectWithSite::SetSite method. This is
// called by the system to set a local reference to an 
// IHomePluginEnvironment pointer, which can be used to force a redraw
// of the plugin, or set a one-time timer callback.
//
// See the SDK docs on IHomePluginEnvironment for more information
 
HRESULT PluginMem::SetSite(
    IUnknown* pSite
    )
{
    HRESULT hr = S_OK;
    
    if(m_ppe)
    {
        m_ppe->Release();
        m_ppe = NULL;
    }
    
    if(pSite)
    {
        if(FAILED(hr = pSite->QueryInterface(IID_IHomePluginEnvironment2, (void**)&m_ppe)))
        {
            goto Error;
        }
    }

    
Error:
    return(hr);
}

// **********************************************************************
// Function Name: GetSite
//
// Description: Implementation of IObjectWithSite::GetSite
//
// See SDK documentation for more information

HRESULT PluginMem::GetSite(
    REFIID riid, 
    void** ppvSite
    )
{
    HRESULT hr = S_OK;
    
    if(!m_ppe)
    {
        hr = E_FAIL;
        goto Error;
    }
    
    if(FAILED(hr = m_ppe->QueryInterface(riid, ppvSite)))
    {
        goto Error;
    }
    
Error:
    return(hr);
}


// **********************************************************************
// Function Name: Initialize
// 
// Purpose: Called from the Plugin Manager to provide data for the 
//	intermediate config file
//
// Arguments:
//    IN HPLUGIN hPlugin - handle to plugin. Used for calls to 
//		IHomePluginEnvironment.
//	  IN IXMLDOMNode* pnodeParams - XML DOM node representing specific 
//		plugin configuration
//	  IN IXMLDOMNode* pnodeDefault - XML DOM node representing global 
//		plugin configuration (applying to all plugins)
//
// Return Values:
//
//	HRESULT  -  S_OK if parsing operations succeed, E_FAIL otherwise 
//
// Side effects:  
//    Data parsed and stored as member data in this function can only be
//	  used in the Save method below, as the other member functions are
//	  only called in seperate instance of this class (created by home.exe)
//	  instead of the Plugin Manager.
// 
// Description:  
//    This function is called by the Plugin Manager exclusively when the 
//	  plugin is FIRST LOADED from the Home Screen settings menu. 
//    Configuration data should be saved as member data to be written 
//    to an intermediate file via the Save method below
//	 
//	   See the ReadMe notes for more information


HRESULT PluginMem::Initialize(
    HPLUGIN hPlugin, 
    IXMLDOMNode* pnodeParams, 
    IXMLDOMNode* pnodeDefault
    )
{
    HRESULT hr = S_OK;
    BSTR bstrVal = NULL;
    IXMLDOMNode* pFoundNode = NULL;
    IXMLDOMNamedNodeMap * DOMNamedNodeMapPtr = NULL;
    
    DebugOut(TEXT("PluginMem::Initialize called \r\n"));
    
    //Attribute of our XML plugin node to look for
    bstrVal = SysAllocString(L"name");
    if (bstrVal == NULL)
    {
        return E_OUTOFMEMORY;
    }
    if (FAILED(pnodeParams->get_attributes(&DOMNamedNodeMapPtr)))
    {
        return E_FAIL;
    }
    if (FAILED(DOMNamedNodeMapPtr->getNamedItem(bstrVal, &pFoundNode)))
    {
        return E_FAIL;
    }
    
    // store the string so we can write it out when Save is called
    if (FAILED(pFoundNode->get_nodeValue(&m_varTitle)))
    {
        return E_FAIL;
    }
    
    if (m_varTitle.bstrVal != NULL)
    {
        // store the length of the string in bytes
        m_cbStrBytes = SysStringByteLen(m_varTitle.bstrVal)+sizeof(WCHAR);
    }
    
    if (pFoundNode)
        pFoundNode->Release();
    
    if (DOMNamedNodeMapPtr)
        DOMNamedNodeMapPtr->Release();
    
    ::SysFreeString(bstrVal);
    
    m_hPlugin = hPlugin;
    
    return(hr); 
}


// **********************************************************************
// Function Name: GetHeight
// 
// Purpose: Called from the home.exe process to ascertain plugin height.
//		For this sample, we set the plugin height to be hard coded at 40
//		pixels
//
// See SDK documentation for details

HRESULT PluginMem::GetHeight(
    int* pdyPlugin
    )
{

    DebugOut(TEXT("PluginMem::GetHeight called \r\n"));

	// hard-coded height for plugin. This could optionally be set with
	// an XML attribute
	if(COMPILE_FLAG==0)
	{
		*pdyPlugin = 51;
	}
	else if(COMPILE_FLAG==1)