/*
* 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 the License "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:   Streaming handler*
*/


// Version : %version: 8 %

#include <eikon.hrh>
#include <avkon.hrh>
#include <mpxmessage.h>
#include <mpxmessage2.h>
#include <mpxcommand.h>
#include <mpxcommandgeneraldefs.h>
#include <mpxmessagegeneraldefs.h>
#include <mpxplaybackmessage.h>
#include <mpxplaybackutility.h>
#include <mpxcollectionmessage.h>
#include <mpxmediageneraldefs.h>
#include <mpxcollectionmessagedefs.h>
#include <vcxmyvideosdefs.h>

#include "IptvDebug.h"
#include "vcxnsstreaminghandler.h"
#include "vcxnscontent.h"
#include "vcxnsuiengine.h"
#include "vcxnscontentprovider.h"

// Get spec for this.
const TInt KMinIntervalFromBegin    = 1000; // 1 sec
const TInt KMinIntervalFromEnd      = 5000; // 5 sec

// -----------------------------------------------------------------------------
//   CVcxNsStreamingHandler::CVcxNsStreamingHandler
// -----------------------------------------------------------------------------
//
CVcxNsStreamingHandler::CVcxNsStreamingHandler( CVcxNsUiEngine& aUiEngine ) :
    iUiEngine ( aUiEngine )
    {
    }

// -----------------------------------------------------------------------------
//   CVcxNsStreamingHandler::NewL
// -----------------------------------------------------------------------------
//
CVcxNsStreamingHandler* CVcxNsStreamingHandler::NewL( CVcxNsUiEngine& aUiEngine )
    {
    CVcxNsStreamingHandler* self = new( ELeave) CVcxNsStreamingHandler( aUiEngine );
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
//   CVcxNsStreamingHandler::ConstructL
// -----------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::ConstructL()
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::ConstructL");
    
    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::ConstructL");
    }

// -----------------------------------------------------------------------------
//   CVcxNsStreamingHandler::~CVcxNsStreamingHandler
// -----------------------------------------------------------------------------
//
CVcxNsStreamingHandler::~CVcxNsStreamingHandler()
    {
    HandleCloseStream();
    
    if ( iPlaybackUtility )
        {
        TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );
        iPlaybackUtility->Close();
        }
    }

// ---------------------------------------------------------------------------
// From MMPXPlaybackObserver
// Handle playback message.
// ---------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::HandlePlaybackMessage( CMPXMessage* aMessage, TInt aError )
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::HandlePlaybackMessage");
    
    if ( aError == KErrNone && aMessage )
        {
        TRAP_IGNORE( DoHandlePlaybackMessageL( *aMessage ) );
        }
    
    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::HandlePlaybackMessage");
    }

// ---------------------------------------------------------------------------
// Handle playback message.
// ---------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::DoHandlePlaybackMessageL( const CMPXMessage& aMessage )
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::DoHandlePlaybackMessageL");

    TMPXMessageId id( *aMessage.Value< TMPXMessageId >( KMPXMessageGeneralId ) );

    IPTVLOGSTRING2_LOW_LEVEL("CVcxNsStreamingHandler::DoHandlePlaybackMessageL TMPXMessageId = 0x%08x", id );

    if ( KMPXMessageGeneral == id )
        {
        TInt event = *aMessage.Value<TInt>( KMPXMessageGeneralEvent );
        
        IPTVLOGSTRING2_LOW_LEVEL("CVcxNsStreamingHandler::DoHandlePlaybackMessageL: event = %d", event );
        
        switch ( event )
        {
            case TMPXPlaybackMessage::EPropertyChanged:
                {
                HandlePropertyChangedL( aMessage );
                }
                break;
            case TMPXPlaybackMessage::EStateChanged:
                {
                HandleStateChangedL( aMessage );
                }
                break;
            default:
                break;
            }
        }
    
    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::DoHandlePlaybackMessageL");
    }

// -------------------------------------------------------------------------------------------------
//   CVcxNsStreamingHandler::HandleStateChangedL
// -------------------------------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::HandleStateChangedL( const CMPXMessage& aMessage )
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::HandleStateChangedL");
    
    if ( iContent && 
         aMessage.IsSupported( KMPXMessageGeneralType ) )
        {
        iCurrentState = *aMessage.Value<TInt>( KMPXMessageGeneralType );
        
        IPTVLOGSTRING2_LOW_LEVEL("CVcxNsStreamingHandler::HandleStateChangedL: state = %d", iCurrentState );
       
        switch ( iCurrentState )
            {
            case EPbStateInitialised:
                {
                if ( iLastPosPending )
                    {
                    SeekToLastPosL();
                    }
                }
                break;
            case EPbStateStopped:
            case EPbStateShuttingDown:
                {
                HandleCloseStream();
                }
                break;
            case EPbStatePlaying:
                {
                GetDurationL();
                }
                break;
            default:
                break;
            }
        }
    
    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::HandleStateChangedL");
    }
    
// -------------------------------------------------------------------------------------------------
//   CVcxNsStreamingHandler::HandlePropertyChangedL
// -------------------------------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::HandlePropertyChangedL( const CMPXMessage& aMessage )
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::HandlePropertyChangedL");
    
    if( iContent &&
        aMessage.IsSupported( KMPXMessageGeneralType ) &&
        aMessage.IsSupported( KMPXMessageGeneralData ) )
        {
        TInt property = *aMessage.Value<TInt>( KMPXMessageGeneralType );
        TInt data = *aMessage.Value<TInt>( KMPXMessageGeneralData );
        
        if( property == EPbPropertyPosition )
            {
            IPTVLOGSTRING2_LOW_LEVEL("CVcxNsStreamingHandler::HandlePropertyChangedL(): pos = %d", data );

            iContent->SetLastPlaybackPosition( TReal32 ( data ),
                                               CVcxNsContent::EVcxContentTypeStream );
            }
        }
    
    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::HandlePropertyChangedL");
    }

// -------------------------------------------------------------------------------------------------
//   CVcxNsStreamingHandler::HandleOpenStreamL
// -------------------------------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::HandleOpenStreamL( CVcxNsContent* aContent )
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::HandleOpenStreamL");
    
    HandleCloseStream();
    
    if ( !iPlaybackUtility )
        {
        iPlaybackUtility = MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeDefault );
        iPlaybackUtility->AddObserverL( *this );    
        }
    
    iContent = CVcxNsContent::NewL( *aContent );
    
    TInt prevPos = iContent->GetLastPlaybackPosition( CVcxNsContent::EVcxContentTypeStream );
    
    if ( prevPos > KMinIntervalFromBegin )
        {
        iLastPosPending = ETrue;
        iResumePos = prevPos;
        }
    else
        {
        iLastPosPending = EFalse;
        iResumePos = 0;
        }

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::HandleOpenStreamL");
    }

// -------------------------------------------------------------------------------------------------
//   CVcxNsStreamingHandler::HandleCloseStream
// -------------------------------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::HandleCloseStream()
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::HandleCloseStream");
    
    TRAP_IGNORE( StoreLastPosL() );

    delete iContent;
    iContent = NULL;
    
    iLastPosPending = EFalse;
    iResumePos      = 0;
    iDuration       = 0;
    iCurrentState   = EPbStateNotInitialised;
    
    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::HandleCloseStream");
    }

// -------------------------------------------------------------------------------------------------
//   CVcxNsStreamingHandler::SeekToLastPosL
// -------------------------------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::SeekToLastPosL()
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::SeekToLastPosL");
    
    iLastPosPending = EFalse;
    
    if ( iResumePos != 0 )
        {
        iPlaybackUtility->SetL( EPbPropertyPosition, iResumePos );
        iResumePos = 0;
        }

    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::SeekToLastPosL");
    }

// -------------------------------------------------------------------------------------------------
//   CVcxNsStreamingHandler::StoreLastPosL
// -------------------------------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::StoreLastPosL()
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::StoreLastPosL");
    
    if( iContent && iUiEngine.ContentProvider() )
        {
        TInt pos = iContent->GetLastPlaybackPosition( CVcxNsContent::EVcxContentTypeStream );
        
        if ( pos <= iDuration - KMinIntervalFromEnd && pos >= KMinIntervalFromBegin )
            {
            iUiEngine.ContentProvider()->StoreLastPlayPosL( iContent, 
                                                            CVcxNsContent::EVcxContentTypeStream,
                                                            TReal32( pos ) );
            }
        else
            {
            iUiEngine.ContentProvider()->StoreLastPlayPosL( iContent, 
                                                            CVcxNsContent::EVcxContentTypeStream,
                                                            TReal32 ( 0 ) );
            }
        }
    
    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::StoreLastPosL");
    }


// -------------------------------------------------------------------------------------------------
//   CVcxNsStreamingHandler::GetDurationL
// -------------------------------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::GetDurationL()
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::GetDurationL");
    
    iPlaybackUtility->PropertyL( *this, EPbPropertyDuration );
    
    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::GetDurationL");
    }

// -------------------------------------------------------------------------------------------------
//   CVcxNsStreamingHandler::HandlePropertyL
// -------------------------------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::HandlePropertyL( TMPXPlaybackProperty aProperty,
                                              TInt aValue, 
                                              TInt aError )
    {
    IPTVLOGSTRING_LOW_LEVEL(">>>CVcxNsStreamingHandler::HandlePropertyL");
    
    if ( aError == KErrNone &&
         aProperty == EPbPropertyDuration )
        {
        iDuration = aValue;
        }
    
    IPTVLOGSTRING_LOW_LEVEL("<<<CVcxNsStreamingHandler::HandlePropertyL");
    }

// -------------------------------------------------------------------------------------------------
//   CVcxNsStreamingHandler::HandleSubPlayerNamesL
// -------------------------------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::HandleSubPlayerNamesL( TUid /*aPlayer*/,
                                                    const MDesCArray* /*aSubPlayers*/,
                                                    TBool /*aComplete*/,
                                                    TInt /*aError*/ )
    {
    IPTVLOGSTRING_LOW_LEVEL("CVcxNsStreamingHandler::HandleSubPlayerNamesL");
    }

// -------------------------------------------------------------------------------------------------
//   CVcxNsStreamingHandler::HandleMediaL
// -------------------------------------------------------------------------------------------------
//
void CVcxNsStreamingHandler::HandleMediaL( const CMPXMedia& /*aProperties*/,
                                           TInt /*aError*/ )
    {
    IPTVLOGSTRING_LOW_LEVEL("CVcxNsStreamingHandler::HandleMediaL");
    }