pmp300.cpp

这是一个mp3的源代码

                }
                else
                {
                    if(function)
                    {
                        PLMEvent event;

                        event.type = kPLMEvent_Error;
                        event.data.errorData.errorCode = rio.GetErrorID();
                        event.eventString = "Download failed, ";
                        event.eventString += rio.GetErrorStr();

                        function(&event, cookie);
                    }

                    if(rio.GetErrorID() == CRIO_ERROR_INTERRUPTED)
                        result = kError_UserCancel;
                }
                
                if(function)
                {
                    PLMEvent event;

                    event.type = kPLMEvent_Done;

                    function(&event, cookie);
                }

                delete [] path;
            }
        }   
    }

    return result;
}

bool FindRio ( CRio& rio, 
               DeviceInfo* device,
               PLMCallBackFunction function,
               void* cookie)
{
    bool rioPresent = false;

    if(function)
    {
        PLMEvent event;

        event.type = kPLMEvent_Status;
        event.eventString = "Searching for portable device...";

        function(&event, cookie);
    }

    if(device->GetPortAddress() && 
       rio.Set(device->GetPortAddress()) && 
       rio.CheckPresent())
    {
        rioPresent = true;
    }
    else // brute force it...
    {
        for(uint32 count = 0; count < sizeof(ports); count++)
        {
            if(rio.Set(ports[count]) && rio.CheckPresent())
            {
                device->SetPortAddress(ports[count]);
                rioPresent = true;
                break;
            }
        }
    }

    return rioPresent;
}

Error privateReadPlaylist(CRio& rio, 
                           bool useExternal,
                           uint32* totalMem,
                           uint32* usedMem,
                           vector<PlaylistItem*>* list,
                           PLMCallBackFunction function,
                           void* cookie)
{
    Error result = kError_UnknownErr;

    if(rio.RxDirectory())
	{
        result = kError_NoErr;

        CDirBlock& cDirBlock = rio.GetDirectoryBlock();
        CDirHeader& cDirHeader = cDirBlock.m_cDirHeader;

        *totalMem = ((long)cDirHeader.m_usCount32KBlockAvailable * CRIO_SIZE_32KBLOCK);
        *usedMem = ((long)cDirHeader.m_usCount32KBlockUsed * CRIO_SIZE_32KBLOCK);

        uint32 count = cDirHeader.m_usCountEntry;

	    if(count)
	    {
		    CDirEntry* pDirEntry = cDirBlock.m_acDirEntry;

		    if(count > CRIO_MAX_DIRENTRY)
			    count = CRIO_MAX_DIRENTRY;


            for(uint32 index = 0; index < count; ++index, ++pDirEntry)
            {
                string url;
                ostringstream ost;
                MetaData metadata;

                ost << "portable://rio_pmp300/" << 
                    (useExternal ?  "external/" : "internal/") << index <<
                    "/" << pDirEntry->m_szName;
                url = ost.str();

                metadata.SetSize(pDirEntry->m_lSize);
                metadata.SetTitle(pDirEntry->m_szName);

                PlaylistItem* item = new PlaylistItem(url.c_str(), &metadata);

                if(!item)
                {
                    result = kError_OutOfMemory;  
                    break;
                }

                list->push_back(item);

                if(function)
                {
                    PLMEvent event;

                    event.type = kPLMEvent_Progress;
                    event.data.progressData.position = index + 1;
                    event.data.progressData.total = count;
                    event.data.progressData.item = item;

                    function(&event, cookie);
                }
            }
	    }       
    }

    return result;
}

#ifdef WIN32

#include <windows.h>

static 
bool
InstallDriver(  SC_HANDLE  scManager,
                const char* driverName,
                const char* driverPath)

{
    bool result = false;
    SC_HANDLE  service;

    service = CreateService(scManager,              // SCManager database
                            driverName,             // name of service
                            driverName,             // name to display
                            SERVICE_ALL_ACCESS,     // desired access
                            SERVICE_KERNEL_DRIVER,  // service type
                            SERVICE_DEMAND_START,   // start type
                            SERVICE_ERROR_NORMAL,   // error control type
                            driverPath,             // service's binary
                            NULL,                   // no load ordering group
                            NULL,                   // no tag identifier
                            NULL,                   // no dependencies
                            NULL,                   // LocalSystem account
                            NULL);                  // no password


                                
    if(service || ERROR_SERVICE_EXISTS == GetLastError())
    {
        result = true;
    }
    /*else
    {
        LPVOID lpMessageBuffer;
        int32 error = GetLastError();

		FormatMessage(
		  FORMAT_MESSAGE_ALLOCATE_BUFFER |
		  FORMAT_MESSAGE_FROM_SYSTEM,
		  NULL,
		  error,
		  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		  (LPTSTR) &lpMessageBuffer,
		  0,
		  NULL );

		// now display this string
 		MessageBox(NULL, (char*)lpMessageBuffer, 0, MB_OK);

		// Free the buffer allocated by the system
		LocalFree( lpMessageBuffer );

    }*/
    
    CloseServiceHandle(service);

    return result;
}

static
bool
StartDriver(SC_HANDLE scManager,
            const char* driverName)
{
    bool result = false;
    SC_HANDLE  service;

    service = OpenService(  scManager,
                            driverName,
                            SERVICE_ALL_ACCESS);

    if(service)
    {
        BOOL error;

        error = StartService(service, // service identifier
                             0,       // number of arguments
                             NULL);   // pointer to arguments

        result = (error != 0);

        if(!result)
        {
            if(GetLastError() == ERROR_SERVICE_ALREADY_RUNNING)
                result = true;
        }

        CloseServiceHandle(service);    
    }
    
    return result;
}

static
bool
OpenDevice(const char* driverName)
{
    bool    result = false;
    char    path[MAX_PATH];
    HANDLE  handle;

    sprintf(path, "\\\\.\\%s", driverName);

    handle = CreateFile(path,
                        GENERIC_READ | GENERIC_WRITE,
                        0,
                        NULL,
                        OPEN_EXISTING,
                        FILE_ATTRIBUTE_NORMAL,
                        NULL);

    if(handle != INVALID_HANDLE_VALUE)
    {
        CloseHandle(handle);
        result = true;
    }
   
    return result;
}


bool 
LoadDriver(const char* driverName, 
           const char* driverPath)
{

    bool result = false;
    SC_HANDLE scManager;

    scManager = OpenSCManager(NULL,
                              NULL,
                              SC_MANAGER_ALL_ACCESS);

    if(scManager)
    {
        result = InstallDriver( scManager,
                                driverName,
                                driverPath);
        if(result)
        {
            result = StartDriver(scManager,
                                 driverName);

            if(result)
            {
                result = OpenDevice(driverName);
            }
        }

        CloseServiceHandle(scManager);
    }

    return result;
}

static
bool
StopDriver( SC_HANDLE scManager,
            const char* driverName)
{
    bool result = false;
    SC_HANDLE service;
    SERVICE_STATUS  serviceStatus;

    service = OpenService(  scManager,
                            driverName,
                            SERVICE_ALL_ACCESS);

    if(service)
    {
        BOOL error;

        error = ControlService( service,
                                SERVICE_CONTROL_STOP,
                                &serviceStatus);

        result = (error > 0);

        CloseServiceHandle(service);
    }

    return result;
}

static
bool
RemoveDriver(   SC_HANDLE scManager,
                const char* driverName)
{
    bool result = false;
    SC_HANDLE  service;

    service = OpenService(  scManager,
                            driverName,
                            SERVICE_ALL_ACCESS);
    if(service)
    {
        BOOL error;

        error = DeleteService(service);

        result = (error > 0);

        CloseServiceHandle(service);
    }

    return result;
}

bool 
UnloadDriver(const char* driverName)
{
    bool result = false;
    SC_HANDLE scManager;

    scManager = OpenSCManager(NULL,
                              NULL,
                              SC_MANAGER_ALL_ACCESS);

    if(scManager)
    {
        result = StopDriver(scManager,
                            driverName);

        if(result)
        {
            result = RemoveDriver(  scManager, 
                                    driverName);
        }

        CloseServiceHandle(scManager);
    }

    return result;
}

#endif