/*
* Copyright (c) 2010 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: 
*
*/

#include "cpixstateobserver.h"
#include <mpxcollectionutility.h>
#include <mpxmessagegeneraldefs.h>
#include <mpxcollectionmessage.h>
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "cpixstateobserverTraces.h"
#endif


// -----------------------------------------------------------------------------
// CPiXStateObserver::NewL()
// -----------------------------------------------------------------------------
//
CPiXStateObserver* CPiXStateObserver::NewL( MCPiXStateObserver* aObserver, RFs* aFsSession )
    {        
    CPiXStateObserver* self = new ( ELeave ) CPiXStateObserver(aObserver);
    CleanupStack::PushL( self );
    self->ConstructL( aFsSession );
    CleanupStack::Pop(self);
    return self;
    }


CPiXStateObserver::CPiXStateObserver(MCPiXStateObserver* aObserver)
            : iObserver(aObserver)                                
                    
    {
    iPreviousState = KErrNotFound;
    iMMCHarvesting = KErrNotFound;
    iMPXHarvesting = KErrNotFound;    
    }
// -----------------------------------------------------------------------------
// CPiXStateObserver::~CPiXStateObserver()
// -----------------------------------------------------------------------------
//
CPiXStateObserver::~CPiXStateObserver()
   {
   iHarvesterClient.RemoveHarvesterEventObserver(*this);
   iHarvesterClient.Close();
   }

// -----------------------------------------------------------------------------
// CPiXStateObserver::ConstructL()
// -----------------------------------------------------------------------------
//
void CPiXStateObserver::ConstructL( RFs* aFsSession )
    {    
    iFsSession = aFsSession;
    }

void CPiXStateObserver::StartMonitoringL()
    {
    TInt err(KErrNone);
    err = iHarvesterClient.Connect();    
    
    if(err == KErrNone)
        {
        err = iHarvesterClient.AddHarvesterEventObserver( *this, EHEObserverTypeMMC, 1000 );        
        }
    iCollectionUtility = MMPXCollectionUtility::NewL( this );

    }
// -----------------------------------------------------------------------------
// CPiXStateObserver::HarvestingUpdated()
// -----------------------------------------------------------------------------
//
void CPiXStateObserver::HarvestingUpdated( HarvesterEventObserverType aHEObserverType, 
             HarvesterEventState aHarvesterEventState, TInt aItemsLeft  )
    {    
    if(aHEObserverType == EHEObserverTypeMMC)
        {
        switch(aHarvesterEventState)
            {
            case EHEStateStarted:
            case EHEStateHarvesting:            
                {
                iMMCHarvesting = ETrue;                
                break;
                }
            case EHEStateFinished:
            case EHEStateUninitialized:
                {
                iMMCHarvesting = EFalse;                
                break;
                }
            default:
                break;
            }
        OstTrace0( TRACE_FLOW, CPIXSTATEOBSERVER_HARVESTINGUPDATED, "CPiXStateObserver::HarvestingUpdated MMC Event" );        
        NotifyObserverL();
        }    
    }

void CPiXStateObserver::HandleCollectionMessage( CMPXMessage* aMessage, TInt aError )
    {
    if ( aError != KErrNone )
        {
        return;
        }
    
    TMPXMessageId generalId( *aMessage->Value<TMPXMessageId>( KMPXMessageGeneralId ) );
    
    //we are interestead of only general system events
    if ( generalId == KMPXMessageGeneral )
        {
        TInt event( *aMessage->Value<TInt>( KMPXMessageGeneralEvent ) );
        TInt op( *aMessage->Value<TInt>( KMPXMessageGeneralType ) );
        
        if ( event == TMPXCollectionMessage::EBroadcastEvent )
            {
            switch( op )
                {
                //when MTP sync or music collection is started then pause processing
                case EMcMsgRefreshStart:
                case EMcMsgUSBMTPStart:
                    {
                    iMPXHarvesting = ETrue;
                    break;
                    }
                //when MTP sync or music collection refresh is complete then resume processing
                case EMcMsgRefreshEnd:
                case EMcMsgUSBMTPEnd:
                case EMcMsgUSBMTPNotActive:
                    {
                    iMPXHarvesting = EFalse;
                    break;
                    }
                default:
                    break;
                }
            OstTrace0( TRACE_FLOW, CPIXSTATEOBSERVER_HANDLECOLLECTIONMESSAGE, "CPiXStateObserver::HandleCollectionMessage MPX Event" );            
            NotifyObserverL();
            }        
        }
    }

void CPiXStateObserver::HandleOpenL( const CMPXMedia& /*aEntries*/, TInt /*aIndex*/,
                                               TBool /*aComplete*/, TInt /*aError*/ )
     {
     // not needed here
     }

void CPiXStateObserver::HandleOpenL( const CMPXCollectionPlaylist& /*aPlaylist*/, TInt /*aError*/ )
   {
   // not needed here
   }

void CPiXStateObserver::HandleCollectionMediaL( const CMPXMedia& /*aMedia*/,
                                                       TInt /*aError*/ )
    {
    // not needed here
    }

TBool CPiXStateObserver::GetStatus()
    {
    TBool ret = EFalse;
    if( iMMCHarvesting || iMPXHarvesting )
        ret = ETrue;
    return ret;        
    }

void CPiXStateObserver::NotifyObserverL()
    {
    TBool status = GetStatus();
    if( iPreviousState != status )
            {
            iPreviousState = status; 
            if (iObserver)
                {
                iObserver->HandleStateObserverChangeL(status);
                OstTrace1( TRACE_FLOW, CPIXSTATEOBSERVER_NOTIFYOBSERVERL, "CPiXStateObserver::NotifyObserverL status=%d", status );
                
                }
            }    
    }