/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  mpx playback utility stub for STIF testing
*
*/

// Version : %version: ou1cpsw#9 %


#include <mpxcommandgeneraldefs.h>
#include <mpxplaybackcommanddefs.h>
#include <mpxmediageneralextdefs.h>

#include "mpxplaybackutilityimp_stub.h"
#include "mpxvideoplayerconstants.h"
#include "stifutilities.h"
#include <mpxvideoplaybackdefs.h>
#include "mpxvideo_debug.h"


MMPXPlaybackUtility* MMPXPlaybackUtility::UtilityL( const TMPXCategory aCategory, const TUid& aModeId )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::UtilityL()"));

    StifUtilities* utility = reinterpret_cast<StifUtilities*>( Dll::Tls() );

    if ( ! utility )
    {
        utility = new (ELeave) StifUtilities;

        Dll::SetTls( utility );
    }

    if ( ! utility->iPlaybackUtility )
    {
        utility->iPlaybackUtility = new (ELeave) CMPXPlaybackUtility();
    }

    utility->iPlaybackUtility->AddRefCount();

    //
    //  Send notification to observer
    //
    utility->iPlaybackUtility->StartPdlPlaybackUtility();

    return utility->iPlaybackUtility;
}

CMPXPlaybackUtility::~CMPXPlaybackUtility()
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::~CMPXPlaybackUtility()"));

    iObservers.Close();
}

CMPXPlaybackUtility::CMPXPlaybackUtility()
{
}

void CMPXPlaybackUtility::AddRefCount()
{
    iRefCount++;
}

void CMPXPlaybackUtility::StartPdlPlaybackUtility()
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::StartPdlPlaybackUtility()"));

    if ( iStifObserver )
    {
        TCallbackEvent* event = new TCallbackEvent;
        event->iEvent    = EPlaybackUtilityPdlInstance;
        iStifObserver->HandleUtilityEvent( event );
    }
}

void CMPXPlaybackUtility::AddStifObserverL( MAppUiEngineStifTestObserver* aObserver )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::AddStifObserverL()"));

    iStifObserver= aObserver;
}

void CMPXPlaybackUtility::RemoveStifObserverL()
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::RemoveStifObserverL()"));

    iStifObserver = NULL;
}

// -------------------------------------------------------------------------------------------------
//   MMPXPlaybackUtility Implementation
// -------------------------------------------------------------------------------------------------

void CMPXPlaybackUtility::AddObserverL( MMPXPlaybackObserver& aObs )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::AddObserverL()"));
    iObservers.AppendL(&aObs);
}

void CMPXPlaybackUtility::RemoveObserverL( MMPXPlaybackObserver& aObs )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::RemoveObserverL()"));

    TInt i = iObservers.FindL(&aObs);
    iObservers.Remove(i);
}


void CMPXPlaybackUtility::GetClientsL( RArray<TProcessId>& /*aClients*/ )
{
}

void CMPXPlaybackUtility::UpdatePlaylistL( const CMPXCollectionPlaylist& /*aPlaylist*/ )
{
}

void CMPXPlaybackUtility::InitL( const CMPXCollectionPlaylist& /*aPlaylist*/, TBool /*aPlay*/ )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::InitL(CMPXCollectionPlaylist)"));

    if ( iStifObserver )
    {
        TCallbackEvent* event = new TCallbackEvent;
        event->iEvent = EPlaybackUtilityInitPlaylist;
        iStifObserver->HandleUtilityEvent( event );
    }
}

void CMPXPlaybackUtility::InitL( const TDesC& aUri, const TDesC8* /*aType*/ )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::InitL()"),
                   _L("aUri = %S"), &aUri );

    if ( iStifObserver )
    {
        TCallbackEvent* event = new TCallbackEvent;
        event->iEvent    = EPlaybackUtilityInitFileName;
        event->iFileName = aUri;
        iStifObserver->HandleUtilityEvent( event );
    }
}

void CMPXPlaybackUtility::InitL( RFile& aShareableFile )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::InitL( RFile )"));

    if ( iStifObserver )
    {
        TCallbackEvent* event = new TCallbackEvent;
        event->iEvent = EPlaybackUtilityInitFileHandle;
        aShareableFile.FullName( event->iFileName );
        iStifObserver->HandleUtilityEvent( event );
    }
}

void CMPXPlaybackUtility::Close()
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::Close()"),
                   _L("iRefCount = %d"), iRefCount );

    //
    //  When the ref count is 2, it should be the app ui engine closing the utility
    //
    if ( iRefCount == 2 )
    {
        if ( iStifObserver )
        {
            TCallbackEvent* event = new TCallbackEvent;
            event->iEvent = EPlaybackUtilityClose;
            iStifObserver->HandleUtilityEvent( event );
        }
    }

    if ( --iRefCount == 0 )
    {
        StifUtilities* utility = reinterpret_cast<StifUtilities*>( Dll::Tls() );

        utility->DeletePlaybackUtility();
    }
}

void CMPXPlaybackUtility::CancelRequest()
{
}

void CMPXPlaybackUtility::CommandL( TMPXPlaybackCommand aCmd, TInt /*aData*/ )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::CommandL()"),
                   _L("aCmd = %d"), aCmd );

    switch ( aCmd )
    {
        case EPbCmdPlay:
        {
            if ( iStifObserver )
            {
                TCallbackEvent* event = new TCallbackEvent;
                event->iEvent = EPlaybackUtilityPlayCmd;
                iStifObserver->HandleUtilityEvent( event );
            }

            break;
        }
        case EPbCmdClose:
        {
            if ( iStifObserver )
            {
                TCallbackEvent* event = new TCallbackEvent;
                event->iEvent = EPlaybackUtilityClose;
                iStifObserver->HandleUtilityEvent( event );
            }

            break;
        }
    }
}

void CMPXPlaybackUtility::CommandL( CMPXCommand& aCmd, MMPXPlaybackCallback* /*aCallback*/ )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::CommandL( CMPXCommand )"));

    if ( aCmd.IsSupported( KMPXCommandGeneralId ) )
    {
        TInt cmdId = *aCmd.Value<TInt>(KMPXCommandGeneralId);

        MPX_DEBUG(_L("CMPXPlaybackUtility::CommandL() id = 0x%08x"), cmdId );

        switch ( cmdId )
        {
            case KMPXCommandIdPlaybackGeneral:
            {
                break;
            }
            case KMPXCommandIdPlaybackPD:
            {
                TMPXPlaybackPdCommand pdCmd =
                    static_cast<TMPXPlaybackPdCommand>(
                        *aCmd.Value<TInt>(KMPXCommandPlaybackGeneralType) );

                switch ( pdCmd )
                {
                    case EPbCmdStartPd:
                    {
                        TInt downloadId = *aCmd.Value<TInt>( KMPXCommandPlaybackPDTransactionID );
                        TPtrC fileName( aCmd.ValueText( KMPXMediaVideoPlaybackFileName ) );
                        TInt movePdlFile = *aCmd.Value<TInt>( KMPXMediaVideoMovePdlFile );

                        if ( iStifObserver )
                        {
                            TCallbackEvent* event = new TCallbackEvent;
                            event->iEvent      = EPlaybackUtilityStartPdl;
                            event->iDownloadId = downloadId;
                            event->iFileName   = fileName;
                            event->iExtra      = movePdlFile;
                            iStifObserver->HandleUtilityEvent( event );
                        }

                        break;
                    }
                }
                break;
            }
            case KMPXMediaIdVideoPlayback:
            {
                TMPXVideoPlaybackCommand videoCmd =
                        static_cast<TMPXVideoPlaybackCommand>(
                            *aCmd.Value<TInt>(KMPXMediaVideoPlaybackCommand) );

                switch ( videoCmd )
                {
                    case EPbCmdUpdateSeekable:
                    {
                        TBool seekable = *aCmd.Value<TBool>( KMPXMediaGeneralExtVideoSeekable );

                        if ( iStifObserver )
                        {
                            TCallbackEvent* event = new TCallbackEvent;
                            event->iEvent      = EAsxAttributeSeekUpdate;
                            event->iExtra      = seekable;
                            iStifObserver->HandleUtilityEvent( event );
                        }
                        break;
                    }
                }

                break;
            }

        }
    }
}

TMPXPlaybackState CMPXPlaybackUtility::StateL() const
{
    return EPbStateNotInitialised;
}

MMPXSource* CMPXPlaybackUtility::Source()
{
    return this;
}

MMPXPlayerManager& CMPXPlaybackUtility::PlayerManager()
{
    return *this;
}

void CMPXPlaybackUtility::SetL( TMPXPlaybackProperty /*aProperty*/, TInt /*aValue*/ )
{
}

void CMPXPlaybackUtility::ValueL( MMPXPlaybackCallback& /*aCallback*/,
                                  TMPXPlaybackProperty /*aProperty*/ )
{
}

void CMPXPlaybackUtility::PropertyL( MMPXPlaybackCallback& /*aCallback*/,
                                   TMPXPlaybackProperty /*aProperty*/ )
{
}

CDesCArray* CMPXPlaybackUtility::SupportedMimeTypes()
{
    return NULL;
}

CDesCArray* CMPXPlaybackUtility::SupportedExtensions()
{
    return NULL;
}

CDesCArray* CMPXPlaybackUtility::SupportedSchemas()
{
    return NULL;
}

void CMPXPlaybackUtility::SetPriority( TInt /*aPriority*/ )
{
}

void CMPXPlaybackUtility::AddSubscriptionL( const CMPXSubscription& /*aSubscription*/ )
{
}

void CMPXPlaybackUtility::RemoveSubscriptionL( const CMPXSubscription& /*aSubscription*/ )
{
}

void CMPXPlaybackUtility::ClearSubscriptionsL()
{
}

void CMPXPlaybackUtility::InitStreamingL( const TDesC& aUri,
                                          const TDesC8* /*aType*/,
                                          const TInt aAccessPoint )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::InitStreamingL()"),
                   _L("aUri = %S, aAccessPoint = %d"), &aUri, aAccessPoint );

    if ( iStifObserver )
    {
        TCallbackEvent* event = new TCallbackEvent;
        event->iEvent    = EPlaybackUtilityInitStreamingUrl;
        event->iFileName = aUri;
        event->iApId     = aAccessPoint;
        iStifObserver->HandleUtilityEvent( event );
    }
}

void CMPXPlaybackUtility::InitStreamingL( RFile& aShareableFile, const TInt aAccessPoint )
{
    MPX_ENTER_EXIT(_L("CMPXPlaybackUtility::InitStreamingL( RFile )"),
                   _L("aAccessPoint = %d"), aAccessPoint );

    if ( iStifObserver )
    {
        TCallbackEvent* event = new TCallbackEvent;
        event->iEvent    = EPlaybackUtilityInitStreamingFileHandle;
        aShareableFile.FullName( event->iFileName );
        event->iApId     = aAccessPoint;
        iStifObserver->HandleUtilityEvent( event );
    }
}


// -------------------------------------------------------------------------------------------------
//   MMPXPlayerManager Implementation
// -------------------------------------------------------------------------------------------------

void CMPXPlaybackUtility::GetPlayerTypesL( RArray<TMPXPlaybackPlayerType>& /*aTypes*/ )
{
}

HBufC* CMPXPlaybackUtility::PlayerTypeDisplayNameL( TMPXPlaybackPlayerType /*aType*/ )
{
    return NULL;
}

void CMPXPlaybackUtility::GetPlayerListL( RArray<TUid>& /*aPlayers*/ )
{
}

void CMPXPlaybackUtility::GetPlayerListL( RArray<TUid>& /*aPlayers*/,
                                          TMPXPlaybackPlayerType /*aType*/ )
{
}

void CMPXPlaybackUtility::SubPlayerNamesL( MMPXPlaybackCallback& /*aCallback*/, TUid /*aPlayer*/ )
{
}

void CMPXPlaybackUtility::SelectPlayersL( TMPXPlaybackPlayerType /*aType*/ )
{
}

void CMPXPlaybackUtility::SelectSubPlayerL( TUid /*aPlayer*/, TInt /*aSubPlayerIndex*/ )
{
}

void CMPXPlaybackUtility::SelectPlayerL( TUid /*aPlayer*/ )
{
}

void CMPXPlaybackUtility::ClearSelectPlayersL()
{
}

void CMPXPlaybackUtility::GetSelectionL( TMPXPlaybackPlayerType& /*aType*/,
                                         TUid& /*aPlayer*/,
                                         TInt& /*aSubPlayerIndex*/,
                                         HBufC*& /*aSubPlayerName*/ )
{
}

MMPXPlayer* CMPXPlaybackUtility::CurrentPlayer()
{
    return this;
}


// -------------------------------------------------------------------------------------------------
//   MMPXPlayer Implementation
// -------------------------------------------------------------------------------------------------

TMPXPlaybackPlayerType CMPXPlaybackUtility::TypeL()
{
    return EPbUnknown;
}

HBufC* CMPXPlaybackUtility::TypeNameL()
{
    return NULL;
}

void CMPXPlaybackUtility::SubPlayerNamesL( MMPXPlaybackCallback& /*aCallback*/ )
{
}

TInt CMPXPlaybackUtility::SubPlayerL() const
{
    return 0;
}

TUid CMPXPlaybackUtility::UidL() const
{
    return KNullUid;
}


// -------------------------------------------------------------------------------------------------
//   MPXSource Implementation
// -------------------------------------------------------------------------------------------------

CMPXCollectionPlaylist* CMPXPlaybackUtility::PlaylistL()
{
    return NULL;
}

RFile* CMPXPlaybackUtility::FileL()
{
    return NULL;
}

HBufC* CMPXPlaybackUtility::UriL()
{
    return NULL;
}

void CMPXPlaybackUtility::MediaL( const TArray<TMPXAttribute>& /*aAttrs*/,
                                  MMPXPlaybackCallback& /*aCallback*/ )
{
}

void CMPXPlaybackUtility::MediaL( const TArray<TMPXAttribute>& /*aAttrs*/,
                                  MMPXPlaybackCallback& /*aCallback*/,
                                  CMPXAttributeSpecs* /*aSpecs*/ )
{
}

// End of file