/*
* Copyright (c) 2008-2008 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:  Manages MCP plugins, and content publishing.
*
*/


#include <liwservicehandler.h>
#include <mpxcollectionmessagedefs.h>
#include <mpxmessagecontainerdefs.h>
#include <mpxmediacollectiondetaildefs.h>
#include <mpxmessagegeneraldefs.h>
#include <mpxcollectionutility.h>
#include <mpxcollectionpath.h>
#include <mpxcollectionhelperfactory.h>
#include <mpxcollectionuihelper.h>
#include <mpxcollectionmessage.h>

#include "cpglobals.h" //This will be moved to domain API (HSFW)
#include "mpxcollectionpublisher.h"



_LIT8( KMCPDataKey,"musicmenu_collectioninfo_numb1data" );
_LIT( KMCPublisher, "MpxCollectionPublisher" );
_LIT( KMCPType,"integer" );
_LIT( KMCPContent,"musicmenu_collectioninfo_numb1" );

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CMpxCollectionPublisher::CMpxCollectionPublisher(
        MLiwInterface* aCPSInterface ) : iRefreshOperation( EFalse )
	{
	iCPSInterface = aCPSInterface;

	}

// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CMpxCollectionPublisher::ConstructL()
    {
    iDefaultAttrs.Append( KMPXMediaColDetailNumberOfItems );
    iCollectionUiHelper = 
            CMPXCollectionHelperFactory:: NewCollectionUiHelperL();      
	iCollectionUtility = 
	        MMPXCollectionUtility::NewL( this, KMcModeIsolated );
    
	TUid collection = KLocalCollection;
	collection = iCollectionUtility->
                    Collection().CollectionIDL( collection );
    iCollectionUtility->Collection().CommandL( EMcCmdCollectionInit, 
                                               collection.iUid );
	//music
    iAllSongsPath = iCollectionUiHelper->MusicAllSongsPathL();
    iCollectionUtility->Collection().CancelRequest();
    iCollectionUtility->Collection().MediaL( *iAllSongsPath , 
    	        iDefaultAttrs.Array());
    }

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CMpxCollectionPublisher* CMpxCollectionPublisher::NewL(  
        MLiwInterface* aCPSInterface )
    {
    CMpxCollectionPublisher* self = 
            new ( ELeave ) CMpxCollectionPublisher( aCPSInterface );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CMpxCollectionPublisher::~CMpxCollectionPublisher()
    {
    if ( iCollectionUiHelper )
		{
		iCollectionUiHelper->Close();
		}

	if ( iCollectionUtility )
		{
		iCollectionUtility->Close();
		}
	iDefaultAttrs.Close();
	delete iAllSongsPath;
    }

  
void CMpxCollectionPublisher::UpdateL() 
    {

    }

// ---------------------------------------------------------------------------
// From MMPXCollectionObserver
// empty
// ---------------------------------------------------------------------------
// 	    
void CMpxCollectionPublisher::HandleOpenL( const CMPXMedia& /* aMedia */,
            TInt /* aIndex */,
    		TBool /* aComplete */,TInt /* aError */  )
    {
    }

// ---------------------------------------------------------------------------
// From MMPXCollectionObserver
// empty
// ---------------------------------------------------------------------------
//     					
void CMpxCollectionPublisher::HandleOpenL( 
            const CMPXCollectionPlaylist& /* aPlaylist */, 
            TInt /* aError */)
    {
    }

// ---------------------------------------------------------------------------
// From MMPXCollectionObserver
// Handles MediaL
// ---------------------------------------------------------------------------
// 
void CMpxCollectionPublisher::HandleCollectionMediaL( const CMPXMedia& aMedia,
		TInt aError )
	{
	if (KErrNone == aError && 
	        aMedia.IsSupported( KMPXMediaColDetailNumberOfItems ) )
		{
		TInt numberOfSongs = 
		       aMedia.ValueTObjectL<TBool>( KMPXMediaColDetailNumberOfItems );
        PublishNumberL( numberOfSongs );
		}
	}

// ---------------------------------------------------------------------------
// Handle collection messages.
// ---------------------------------------------------------------------------
//
void CMpxCollectionPublisher::HandleCollectionMessageL( CMPXMessage* aMsg )
    {       
    TMPXMessageId messageId = 
            aMsg->ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId );
    if ( messageId == KMPXMessageGeneral )        
        {          
        DoHandleGeneralMessageL( *aMsg );   
        } 
    else if( messageId == KMPXMessageIdItemChanged )
        {
        // Loop through messages for arrays.
        //
        if ( aMsg->IsSupported( KMPXMessageArrayContents ) )
            {
			CMPXMessageArray* messageArray =
                    aMsg->Value<CMPXMessageArray>( KMPXMessageArrayContents );
							
            User::LeaveIfNull( messageArray ); 
            for( TInt i=0; i<messageArray->Count(); ++i )
                {
                HandleCollectionMessage( (*messageArray)[i], KErrNone);  
                } 
            }            
        else // Single item
            {                
            DoHandleItemChangedMessageL( *aMsg ) ;                
            }                
        }                     
    }     

// ---------------------------------------------------------------------------
// From MMPXCollectionObserver
// Handle collection messages.
// ---------------------------------------------------------------------------
//
void CMpxCollectionPublisher::HandleCollectionMessage( CMPXMessage* aMsg, 
                                                  TInt aError )
    {
	if ( aError == KErrNone && aMsg )
		{
        TRAP_IGNORE( HandleCollectionMessageL( aMsg ) );
        }
    }  

// ---------------------------------------------------------------------------
// Handle item change message.
// ---------------------------------------------------------------------------
//
void CMpxCollectionPublisher::DoHandleItemChangedMessageL( 
                                                    const  CMPXMessage& aMsg )
    {
    TMPXChangeEventType eventType( 
            aMsg.ValueTObjectL<TMPXChangeEventType>( 
                        KMPXMessageChangeEventType ) );
    TMPXItemId itemId( 
            aMsg.ValueTObjectL<TMPXItemId>(KMPXMessageMediaGeneralId ) );
  
    if ( !iRefreshOperation && 
          ( eventType == EMPXItemDeleted || eventType == EMPXItemInserted ) ) 
        { 
        //everytime an item is changed we need to refresh data
        iCollectionUtility->Collection().CancelRequest();
        iCollectionUtility->Collection().MediaL( *iAllSongsPath , 
        	        iDefaultAttrs.Array() );
        }                           
        
    } 

// ---------------------------------------------------------------------------
// Handle collection general message.
// ---------------------------------------------------------------------------
//
void CMpxCollectionPublisher::DoHandleGeneralMessageL(  
        const CMPXMessage& aMsg )
    {
    TInt event = aMsg.ValueTObjectL<TInt>( KMPXMessageGeneralEvent );
    TInt type = aMsg.ValueTObjectL<TInt>( KMPXMessageGeneralType ); 
    
      
    if ( event == TMPXCollectionMessage::EBroadcastEvent && 
         ( type == EMcMsgRefreshStart || type == EMcMsgFormatStart ||             
          type == EMcMsgUSBMassStorageStart || type == EMcMsgUSBMTPStart )         
         )
        {
        //if refresh operation starts we block until refresh ends
        iRefreshOperation = ETrue;
        iCollectionUtility->Collection().CancelRequest(); 
        }
    else if ( event == TMPXCollectionMessage::EBroadcastEvent && 
              ( type == EMcMsgRefreshEnd || type == EMcMsgFormatEnd ||
               type == EMcMsgDiskRemoved || type == EMcMsgDiskInserted ||
               type == EMcMsgUSBMassStorageEnd || type == EMcMsgUSBMTPEnd )
            )
        {
        iRefreshOperation = EFalse;
        iCollectionUtility->Collection().CancelRequest();
        iCollectionUtility->Collection().MediaL( *iAllSongsPath , 
        	        iDefaultAttrs.Array() );
        }                       
    }       

// ---------------------------------------------------------------------------
// Publishes a number to the required destination
// ---------------------------------------------------------------------------
//

void CMpxCollectionPublisher::PublishNumberL( const TInt aNumb )
	{
	if ( iCPSInterface )
		{
		CLiwGenericParamList * inParam = CLiwGenericParamList::NewLC();
		CLiwGenericParamList * outParam = CLiwGenericParamList::NewLC();

		TLiwGenericParam cptype( KType, TLiwVariant( KCpData ) );
		inParam->AppendL( cptype );
		CLiwDefaultMap * cpdatamap = CLiwDefaultMap::NewLC();
		CLiwDefaultMap * map = CLiwDefaultMap::NewLC();

		map->InsertL( KMCPDataKey, TLiwVariant( TInt32( aNumb ) ) );

		cpdatamap->InsertL( KPublisherId, TLiwVariant( KMCPublisher ) );
		cpdatamap->InsertL( KContentType, TLiwVariant( KMCPType ) );
		cpdatamap->InsertL( KContentId, TLiwVariant( KMCPContent ) );
		cpdatamap->InsertL( KDataMap, TLiwVariant( map ) );

		TLiwGenericParam item( KItem, TLiwVariant( cpdatamap ) );
		inParam->AppendL( item );

		iCPSInterface->ExecuteCmdL( KAdd, *inParam, *outParam );

		CleanupStack::PopAndDestroy( map );
		CleanupStack::PopAndDestroy( cpdatamap );
		CleanupStack::PopAndDestroy( outParam );
		CleanupStack::PopAndDestroy( inParam );
		}
	}


//  End of File