Chris Danford
297 lines
7.7 KiB
C++
297 lines
7.7 KiB
C++
#include "global.h"
|
|
/*
|
|
-----------------------------------------------------------------------------
|
|
Class: MemoryCardManager
|
|
|
|
Desc: See Header.
|
|
|
|
Copyright (c) 2001-2003 by the person(s) listed below. All rights reserved.
|
|
Chris Danford
|
|
Chris Gomez
|
|
-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "MemoryCardManager.h"
|
|
#include "arch/MemoryCard/MemoryCardDriver.h" // for UsbStorageDevice
|
|
#include "arch/arch.h"
|
|
#include "ScreenManager.h"
|
|
#include "ThemeManager.h"
|
|
#include "PrefsManager.h"
|
|
#include "RageLog.h"
|
|
#include "ScreenManager.h"
|
|
#include "ProfileManager.h"
|
|
|
|
MemoryCardManager* MEMCARDMAN = NULL; // global and accessable from anywhere in our program
|
|
|
|
|
|
MemoryCardManager::MemoryCardManager()
|
|
{
|
|
m_pDriver = MakeMemoryCardDriver();
|
|
m_bCardsLocked = false;
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
m_bTooLate[p] = false;
|
|
m_bWriteError[p] = false;
|
|
}
|
|
m_pDriver->GetStorageDevices( m_vStorageDevices );
|
|
|
|
m_bDontPlaySoundsOnce = false;
|
|
|
|
m_soundReady.Load( THEME->GetPathToS("MemoryCardManager ready") );
|
|
m_soundError.Load( THEME->GetPathToS("MemoryCardManager error") );
|
|
m_soundTooLate.Load( THEME->GetPathToS("MemoryCardManager too late") );
|
|
m_soundDisconnect.Load( THEME->GetPathToS("MemoryCardManager disconnect") );
|
|
|
|
AssignUnassignedCards();
|
|
}
|
|
|
|
MemoryCardManager::~MemoryCardManager()
|
|
{
|
|
delete m_pDriver;
|
|
}
|
|
|
|
void MemoryCardManager::Update( float fDelta )
|
|
{
|
|
if( m_pDriver->StorageDevicesChanged() )
|
|
{
|
|
vector<UsbStorageDevice> vOld = m_vStorageDevices; // copy
|
|
m_pDriver->GetStorageDevices( m_vStorageDevices );
|
|
vector<UsbStorageDevice> &vNew = m_vStorageDevices;
|
|
vector<UsbStorageDevice> vConnects; // fill these in below
|
|
vector<UsbStorageDevice> vDisconnects; // fill these in below
|
|
|
|
|
|
// check for disconnects
|
|
{
|
|
for( unsigned i=0; i<vOld.size(); i++ )
|
|
{
|
|
const UsbStorageDevice &old = vOld[i];
|
|
if( find(vNew.begin(),vNew.end(),old) == vNew.end() ) // didn't find
|
|
{
|
|
LOG->Trace( ssprintf("Disconnected bus %d port %d device %d path %s", old.iBus, old.iPort, old.iLevel, old.sOsMountDir.c_str()) );
|
|
vDisconnects.push_back( old );
|
|
}
|
|
}
|
|
}
|
|
|
|
// check for connects
|
|
{
|
|
for( unsigned i=0; i<vNew.size(); i++ )
|
|
{
|
|
const UsbStorageDevice &newd = vNew[i];
|
|
if( find(vOld.begin(),vOld.end(),newd) == vOld.end() ) // didn't find
|
|
{
|
|
LOG->Trace( ssprintf("Connected bus %d port %d device %d path %s", newd.iBus, newd.iPort, newd.iLevel, newd.sOsMountDir.c_str()) );
|
|
vConnects.push_back( newd );
|
|
}
|
|
}
|
|
}
|
|
|
|
// unassign cards that were disconnected
|
|
{
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
if( m_Device[p].IsBlank() ) // not assigned a card
|
|
continue;
|
|
|
|
if( find(vDisconnects.begin(),vDisconnects.end(),m_Device[p]) != vDisconnects.end() ) // assigned card was disconnected
|
|
{
|
|
m_pDriver->Unmount(&m_Device[p], MEM_CARD_MOUNT_POINT[p]);
|
|
|
|
m_Device[p].MakeBlank();
|
|
m_soundDisconnect.Play();
|
|
|
|
if( PROFILEMAN->ProfileWasLoadedFromMemoryCard((PlayerNumber)p) )
|
|
PROFILEMAN->UnloadProfile( (PlayerNumber)p );
|
|
}
|
|
}
|
|
}
|
|
|
|
AssignUnassignedCards();
|
|
|
|
// Load profiles from cards that were just connected.
|
|
if( !m_bCardsLocked )
|
|
{
|
|
FOREACH_PlayerNumber( pn )
|
|
{
|
|
bool bPlayersCardWasJustConnected = find(vConnects.begin(),vConnects.end(),m_Device[pn]) != vConnects.end();
|
|
if( bPlayersCardWasJustConnected )
|
|
PROFILEMAN->LoadFirstAvailableProfile( pn, true ); // fast load
|
|
}
|
|
}
|
|
SCREENMAN->RefreshCreditsMessages();
|
|
}
|
|
}
|
|
|
|
MemoryCardState MemoryCardManager::GetCardState( PlayerNumber pn )
|
|
{
|
|
if( m_Device[pn].IsBlank() )
|
|
return MEMORY_CARD_STATE_NO_CARD;
|
|
else if( m_bTooLate[pn] )
|
|
return MEMORY_CARD_STATE_TOO_LATE;
|
|
else if( m_bWriteError[pn] )
|
|
return MEMORY_CARD_STATE_WRITE_ERROR;
|
|
else
|
|
return MEMORY_CARD_STATE_READY;
|
|
}
|
|
|
|
/*
|
|
CString MemoryCardManager::GetOsMountDir( PlayerNumber pn )
|
|
{
|
|
if( m_Device[pn].IsBlank() )
|
|
return "";
|
|
else
|
|
{
|
|
CString sDir = m_Device[pn].sOsMountDir;
|
|
FixSlashesInPlace( sDir );
|
|
if( !sDir.empty() && sDir.Right(1)!="/" )
|
|
sDir += '/';
|
|
return sDir;
|
|
}
|
|
}
|
|
*/
|
|
|
|
void MemoryCardManager::LockCards( bool bLock )
|
|
{
|
|
m_bCardsLocked = bLock;
|
|
|
|
if( !bLock )
|
|
{
|
|
// clear too late flag
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
m_bTooLate[p] = false;
|
|
}
|
|
}
|
|
|
|
void MemoryCardManager::AssignUnassignedCards()
|
|
{
|
|
LOG->Trace( "AssignUnassignedCards" );
|
|
|
|
// make a list of unassigned
|
|
vector<UsbStorageDevice> vUnassignedDevices = m_vStorageDevices; // copy
|
|
|
|
// remove cards that are already assigned
|
|
{
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
if( m_Device[p].IsBlank() ) // no card assigned to this player
|
|
continue;
|
|
|
|
vector<UsbStorageDevice>::iterator it = find(vUnassignedDevices.begin(),vUnassignedDevices.end(),m_Device[p]);
|
|
if( it != vUnassignedDevices.end() )
|
|
vUnassignedDevices.erase( it );
|
|
}
|
|
}
|
|
|
|
// try to assign each device to a player
|
|
{
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
LOG->Trace( "Looking for a card for Player %d", p+1 );
|
|
|
|
if( !m_Device[p].IsBlank() ) // they already have an assigned card
|
|
{
|
|
LOG->Trace( "Player %d already has a card: '%s'", p+1, m_Device[p].sOsMountDir.c_str() );
|
|
continue; // skip
|
|
}
|
|
|
|
unsigned i;
|
|
|
|
// search for card dir match
|
|
if( !PREFSMAN->m_sMemoryCardOsMountPoint[p].empty() )
|
|
{
|
|
for( i=0; i<vUnassignedDevices.size(); i++ )
|
|
{
|
|
UsbStorageDevice &usbd = vUnassignedDevices[i];
|
|
if( usbd.sOsMountDir.CompareNoCase(PREFSMAN->m_sMemoryCardOsMountPoint[p]) == 0 ) // match
|
|
{
|
|
LOG->Trace( "dir match: iScsiIndex: %d, iBus: %d, iLevel: %d, iPort: %d",
|
|
usbd.iScsiIndex, usbd.iBus, usbd.iLevel, usbd.iPort );
|
|
goto match;
|
|
}
|
|
}
|
|
}
|
|
|
|
// search for USB bus match
|
|
for( i=0; i<vUnassignedDevices.size(); i++ )
|
|
{
|
|
UsbStorageDevice &usbd = vUnassignedDevices[i];
|
|
|
|
if( PREFSMAN->m_iMemoryCardUsbBus[p] != -1 &&
|
|
PREFSMAN->m_iMemoryCardUsbBus[p] != usbd.iBus )
|
|
continue; // not a match
|
|
|
|
if( PREFSMAN->m_iMemoryCardUsbPort[p] != -1 &&
|
|
PREFSMAN->m_iMemoryCardUsbPort[p] != usbd.iPort )
|
|
continue; // not a match
|
|
|
|
if( PREFSMAN->m_iMemoryCardUsbLevel[p] != -1 &&
|
|
PREFSMAN->m_iMemoryCardUsbLevel[p] != usbd.iLevel )
|
|
continue; // not a match
|
|
|
|
LOG->Trace( "bus/port match: iScsiIndex: %d, iBus: %d, iLevel: %d, iPort: %d",
|
|
usbd.iScsiIndex, usbd.iBus, usbd.iLevel, usbd.iPort );
|
|
goto match;
|
|
}
|
|
|
|
LOG->Trace( "Player %d memory card: none", p+1 );
|
|
continue; // no matches
|
|
match:
|
|
m_Device[p] = vUnassignedDevices[i]; // save a copy
|
|
LOG->Trace( "Player %d memory card: '%s'", p+1, m_Device[p].sOsMountDir.c_str() );
|
|
vUnassignedDevices.erase( vUnassignedDevices.begin()+i ); // remove the device so we don't match it for another player
|
|
m_bTooLate[p] = m_bCardsLocked;
|
|
m_bWriteError[p] = false;
|
|
if( !m_bCardsLocked )
|
|
{
|
|
if( !m_pDriver->MountAndTestWrite(&m_Device[p], MEM_CARD_MOUNT_POINT[p]) )
|
|
{
|
|
m_bWriteError[p] = true;
|
|
}
|
|
}
|
|
|
|
if( !m_bDontPlaySoundsOnce )
|
|
{
|
|
// play sound
|
|
if( m_bWriteError[p] )
|
|
m_soundError.Play();
|
|
else if( m_bTooLate[p] )
|
|
m_soundTooLate.Play();
|
|
else
|
|
m_soundReady.Play();
|
|
}
|
|
}
|
|
}
|
|
|
|
m_bDontPlaySoundsOnce = false;
|
|
}
|
|
|
|
void MemoryCardManager::FlushAndReset()
|
|
{
|
|
FOREACH_PlayerNumber( p )
|
|
{
|
|
if( m_Device[p].IsBlank() ) // no card assigned
|
|
continue; // skip
|
|
if( m_bWriteError[p] || m_bTooLate[p] )
|
|
continue; // skip
|
|
m_pDriver->Flush(&m_Device[p]);
|
|
}
|
|
|
|
m_pDriver->ResetUsbStorage(); // forces cards to be re-detected
|
|
|
|
m_bDontPlaySoundsOnce = true;
|
|
}
|
|
|
|
bool MemoryCardManager::PathIsMemCard( CString sDir ) const
|
|
{
|
|
FOREACH_PlayerNumber( p )
|
|
if( !sDir.Left(MEM_CARD_MOUNT_POINT[p].size()).CompareNoCase( MEM_CARD_MOUNT_POINT[p] ) )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
CString MemoryCardManager::GetName( PlayerNumber pn ) const
|
|
{
|
|
return m_Device[pn].sName;
|
|
}
|