public bool ResetSlot(int slotIndex, out IPlayerSlotController slotController)
{
slotController = null;
if (slotIndex == PlayerManagerConsts.SECONDARY_SLOT && !_slots[PlayerManagerConsts.PRIMARY_SLOT].IsActive)
{
// This is the only invalid constellation because it is not allowed to have the secondary slot active while the primary slot is inactive
return(false);
}
// We don't set a lock because the IsActive property must be set outside the lock. It is no very good solution
// to avoid the lock completely but I'll risk it here. Concurrent accesses to the player manager should be avoided
// by organizational means.
PlayerSlotController psc = _slots[slotIndex];
if (psc.IsActive)
{
psc.IsActive = false; // Must be done outside the lock
}
psc.IsActive = true;
psc.IsMuted = _isMuted;
psc.Volume = _volume;
psc.IsAudioSlot = false;
if (AudioSlotIndex == -1)
{
AudioSlotIndex = slotIndex;
}
slotController = psc;
return(true);
}
public void CloseSlot(IPlayerSlotController playerSlotController)
{
PlayerSlotController psc = playerSlotController as PlayerSlotController;
if (psc == null)
{
return;
}
bool isAudio = psc.IsAudioSlot && !psc.IsClosed;
PlayerSlotController nextPsc;
lock (_syncObj)
{
int nextIndex = _slots.IndexOf(psc);
_slots.Remove(psc);
int numSlots = _slots.Count;
nextIndex = numSlots == 0 ? 0 : (nextIndex + 1) % numSlots;
nextPsc = numSlots > nextIndex ? _slots[nextIndex] : null;
}
psc.Close_NoLock(); // Must be done outside the lock
if (isAudio && nextPsc != null)
{
nextPsc.IsAudioSlot = true;
}
}
public IPlayer this[int slotIndex]
{
get
{
lock (_syncObj)
{
PlayerSlotController psc = GetPlayerSlotControllerInternal(slotIndex);
if (psc == null)
{
return(null);
}
return(psc.IsActive ? psc.CurrentPlayer : null);
}
}
}
public void CloseSlot(IPlayerSlotController playerSlotController)
{
PlayerSlotController psc = playerSlotController as PlayerSlotController;
if (psc == null)
{
return;
}
bool isAudio = psc.IsActive && psc.IsAudioSlot;
psc.IsActive = false; // Must be done outside the lock
CleanupSlotOrder();
if (isAudio)
{
AudioSlotIndex = PlayerManagerConsts.PRIMARY_SLOT;
}
}
public IPlayerSlotController OpenSlot()
{
// We don't set a lock because the IsActive property must be set outside the lock. It is no very good solution
// to avoid the lock completely but I'll risk it here. Concurrent accesses to the player manager should be avoided
// by organizational means.
PlayerSlotController result = new PlayerSlotController(this)
{
IsMuted = _isMuted,
IsAudioSlot = false
};
if (AudioSlotController == null)
{
result.IsAudioSlot = true;
}
lock (SyncObj)
_slots.Add(result);
return(result);
}
public void SwitchSlots()
{
lock (_syncObj)
{
if (!_slots[PlayerManagerConsts.SECONDARY_SLOT].IsActive)
{
// Don't move an inactive player slot to the primary slot index
return;
}
PlayerSlotController tmp = _slots[PlayerManagerConsts.PRIMARY_SLOT];
_slots[PlayerManagerConsts.PRIMARY_SLOT] = _slots[PlayerManagerConsts.SECONDARY_SLOT];
_slots[PlayerManagerConsts.SECONDARY_SLOT] = tmp;
for (int i = 0; i < 2; i++)
{
_slots[i].SlotIndex = i;
}
// Audio slot index changes automatically as it is stored in the slot instance itself
PlayerManagerMessaging.SendPlayerManagerPlayerMessage(PlayerManagerMessaging.MessageType.PlayerSlotsChanged);
}
}
public IPlayerSlotController OpenSlot()
{
// We don't set a lock because the IsActive property must be set outside the lock. It is no very good solution
// to avoid the lock completely but I'll risk it here. Concurrent accesses to the player manager should be avoided
// by organizational means.
PlayerSlotController result = new PlayerSlotController(this)
{
IsMuted = _isMuted,
IsAudioSlot = false
};
if (AudioSlotController == null)
result.IsAudioSlot = true;
lock (SyncObj)
_slots.Add(result);
return result;
}
