/*

* 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 <mpxlog.h>                     // MPX_DEBUG

#include <LiwServiceHandler.h>

#include <LiwVariant.h>

#include <LiwGenericParam.h>

#include <mcpplugin.h>

#include <mcppluginuids.hrh>

#include <fbs.h>

#include <coemain.h>

#include <AknsUtils.h>

#include <gdi.h>

#include <musichomescreen.rsg>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

#include <s32mem.h>

#include <e32hashtab.h>

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

#include "musiccontentpublisher.h"

#include "pluginmanager.h"

#include "mcpharvesterpublisherobserver.h"

_LIT( KExecute,       "execute" );

_LIT( KPubData,        "publisher" );

_LIT8( KMyActive, "active" );

_LIT8( KMyDeActive, "deactive");

_LIT8( KMySuspend, "suspend");

_LIT8( KMyResume, "resume");

_LIT8( KMySelected, "selected");

_LIT8( KMyActionMap, "action_map" );

_LIT8( KMyItem, "item" );

_LIT8( KMyAdd, "Add" );

_LIT8( KMyItemId, "item_id" );

_LIT8( KMyResultName,"mydata" );

_LIT( KMyActionName, "data" );

_LIT( KEmpty, "" );

_LIT( KLoc, "LOC:");

_LIT( KNowPlaying, "LOC:NOW PLAYING" );

_LIT( KLastPlayed, "LOC:LAST PLAYED" );

_LIT( KMask, "_mask");

_LIT( KMWPublisher, "MWPublisher");

//for application launcher AHPlugin

const TInt KMmUid3AsTInt( 0x101f4cd2 );

const TInt KMSGUidAsTInt( 0x10003A39 );

_LIT8( KAdditionalData, "additional_data" );

_LIT( KLaunchApp, "launch_application" );

_LIT( KMessageWithTail, "message_with_tail" );

_LIT8( KMessageForMMOpenMusicSuiteWithHide, "mm://root/musicsuite?exit=hide");

_LIT( KResourceFile, "z:musichomescreen.rsc");

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

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

//

CMusicContentPublisher::CMusicContentPublisher( MLiwInterface* aCPSInterface )

    {

    iCPSInterface = aCPSInterface;

    iActivePlugin=NULL;

    iIsPublisherActive = EFalse;

    }

// ---------------------------------------------------------------------------

// Symbian 2nd phase constructor can leave.

// ---------------------------------------------------------------------------

//

void CMusicContentPublisher::ConstructL()

    {

    MPX_DEBUG1("CMusicContentPublisher::ConstructL <---");

    //Load the destination translation table.

    TInt dstl (sizeof(KMCPDestinationInfo)/sizeof(TMCPDestinationItem));

    for (TInt i = 0; i < dstl; i++)

        {

        iDestinationMap.InsertL(KMCPDestinationInfo[i].id, 

                KMCPDestinationInfo[i]);

        }

    dstl = (sizeof(KMCPImageDestinationInfo)/sizeof(

            TMCPImageDestinationInfoItem));

    for (TInt i = 0; i < dstl; i++)

        {

        iImageDestinationSizeMap.Insert(KMCPImageDestinationInfo[i].id,

                TSize(KMCPImageDestinationInfo[i].sizex,

                        KMCPImageDestinationInfo[i].sizey));

        }

    MPX_DEBUG1("CMusicContentPublisher::ConstructL loading resources");

    //Load Loc strings

    RFs fs;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);  

    TFileName fileName;

    TParse* parseObj = new(ELeave) TParse();

    TInt errInt = parseObj->Set( KResourceFile(),&KDC_APP_RESOURCE_DIR,NULL );

    if(KErrNone != errInt)

      {

      delete parseObj;

      User::Leave(errInt);

      }

    fileName = parseObj->FullName();

    delete parseObj;

    BaflUtils::NearestLanguageFile(fs,fileName);

    if(!BaflUtils::FileExists(fs,fileName))

        {

        User::Leave(KErrNotFound);

        }

    RResourceFile resourceFile;

    resourceFile.OpenL(fs,fileName);

    CleanupClosePushL(resourceFile);

    resourceFile.ConfirmSignatureL();

    GetLocalizedStringL(resourceFile, iLastPlayedBuffer, R_MUSICHOMESCREEN_LAST_PLAYED);

    GetLocalizedStringL(resourceFile, iNowPlayingBuffer, R_MUSICHOMESCREEN_NOW_PLAYING);

    GetLocalizedStringL(resourceFile, iGoToMusicBuffer, R_MUSICHOMESCREEN_GO_TO_MUSIC);

    CleanupStack::PopAndDestroy(&resourceFile);

    CleanupStack::PopAndDestroy(&fs);

    MPX_DEBUG1("CMusicContentPublisher::ConstructL resources loaded");

    // connect to the skin server, to receive skin changed event.

    iAknsSrvSession.Connect(this);

    // enable skin.

    AknsUtils::InitSkinSupportL();

    MPX_DEBUG1("CMusicContentPublisher::ConstructL subscribing to observer");

 TPtrC8 dataKey;

 TPtrC type;

 TPtrC content;

 MapEnumToDestinationInfoL(EMusicWidgetImage1, type, dataKey, content); 

    TUint id = RegisterPublisherL( 

            KMWPublisher,

            content, 

            type, 

            dataKey );

    if( id != 0 )

        {

    CLiwDefaultMap* filter = CLiwDefaultMap::NewLC();

    filter->InsertL( KPublisherId, TLiwVariant( KMWPublisher ) );

    filter->InsertL( KContentId, TLiwVariant( content ) );

    filter->InsertL( KContentType, TLiwVariant( type ) );

    filter->InsertL( KOperation, TLiwVariant( KExecute ));

    iHPObserver = CMCPHarvesterPublisherObserver::NewL(this);

    iHPObserver->RegisterL(filter);

    CleanupStack::PopAndDestroy(filter);

        }

    MPX_DEBUG1("CMusicContentPublisher::ConstructL subscription to observer done");

    ResetL();

    MPX_DEBUG1("CMusicContentPublisher::ConstructL --->");

    }

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CMusicContentPublisher* CMusicContentPublisher::NewL(  

        MLiwInterface* aCPSInterface )

    {

    CMusicContentPublisher* self = new ( ELeave ) CMusicContentPublisher( 

            aCPSInterface );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CMusicContentPublisher::~CMusicContentPublisher()

    {

    MPX_DEBUG1("CMusicContentPublisher::~CMusicContentPublisher <---");

    if(iHPObserver)

        {

        MPX_DEBUG1("CMusicContentPublisher::~CMusicContentPublisher deleting observer");

        delete iHPObserver; 

        }

    delete iNowPlayingBuffer;

    delete iLastPlayedBuffer;

    delete iGoToMusicBuffer;

    MPX_DEBUG1("CMusicContentPublisher::~CMusicContentPublisher closing destination maps");

    iImageDestinationSizeMap.Close();

    iDestinationMap.Close();

    MPX_DEBUG1("CMusicContentPublisher::~CMusicContentPublisher resetting bitmap cache");

    ResetBitmapCache();

    MPX_DEBUG1("CMusicContentPublisher::~CMusicContentPublisher closing skin server session");

    iAknsSrvSession.Close();

    MPX_DEBUG1("CMusicContentPublisher::~CMusicContentPublisher deleting plugin manager");

    delete iPluginManager;

    MPX_DEBUG1("CMusicContentPublisher::~CMusicContentPublisher resetting publishing buffers");

    ResetPublishingBuffers();

    MPX_DEBUG1("CMusicContentPublisher::~CMusicContentPublisher --->");

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

void CMusicContentPublisher::InstallGoToMusicL(

        TMCPTriggerDestination aDestination )

    {

    MPX_DEBUG1("CMusicContentPublisher::InstallGoToMusicL <---");

    CLiwDefaultMap* mapTrigger = CLiwDefaultMap::NewLC();

    CLiwDefaultMap* mapData = CLiwDefaultMap::NewLC();

    mapTrigger->InsertL( KPluginUid, TLiwVariant( TUid::Uid( 0x10282E5F ) ) );

    mapData->InsertL( KType, TLiwVariant( KLaunchApp ) );

    mapData->InsertL( KLaunchMethod, TLiwVariant( KMessageWithTail ) );

    mapData->InsertL(KApplicationUid,

            TLiwVariant(TInt32(KMmUid3AsTInt) ) );

        mapData->InsertL( KAdditionalData, 

            TLiwVariant( KMessageForMMOpenMusicSuiteWithHide ) );

    mapData->InsertL(KMessageUid,

            TLiwVariant(TInt32(KMSGUidAsTInt) ) );

    mapTrigger->InsertL( KData, TLiwVariant( mapData ) );

    PublishActionL( NULL, aDestination, mapTrigger );

    CleanupStack::PopAndDestroy( mapData );

    CleanupStack::PopAndDestroy( mapTrigger );

    MPX_DEBUG1("CMusicContentPublisher::InstallGoToMusicL --->");

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

void CMusicContentPublisher::InstallEmptyActionL(

        TMCPTriggerDestination aDestination )

    {

    MPX_DEBUG1("CMusicContentPublisher::InstallEmptyActionL <---");

    CLiwDefaultMap* mapTrigger = CLiwDefaultMap::NewLC();

    PublishActionL( NULL, aDestination, mapTrigger );

    CleanupStack::PopAndDestroy( mapTrigger );

    MPX_DEBUG1("CMusicContentPublisher::InstallEmptyActionL --->");

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

void CMusicContentPublisher::MapEnumToDestinationInfoL(TInt aEnum,

        TPtrC& aType, TPtrC8& aDataKey, TPtrC& aContent)

    {

    MPX_DEBUG1("CMusicContentPublisher::MapEnumToDestinationInfoL <---");

    TMCPDestinationItem* tmpdstitemp;

    tmpdstitemp = iDestinationMap.Find(aEnum);

    if (tmpdstitemp)

        {

        TPtrC type ( reinterpret_cast<const TUint16*>(

                tmpdstitemp->type) );

        TPtrC8 dataKey ( reinterpret_cast<const TUint8*>(

                tmpdstitemp->dataKey ) );

        TPtrC content ( reinterpret_cast<const TUint16*>(

                tmpdstitemp->content) );

        aType.Set(type);

        aDataKey.Set(dataKey);

        aContent.Set(content);

        }

    else

        {

        //API user provided an invalid destination or the destination is not

        //defined properly.

        __ASSERT_DEBUG(EFalse,User::Invariant());

        }

    MPX_DEBUG1("CMusicContentPublisher::MapEnumToDestinationInfoL --->");

    }

// ----------------------------------------------------------------------------

// Get a heap descriptor from the resource file

// ----------------------------------------------------------------------------

//

void CMusicContentPublisher::GetLocalizedStringL(RResourceFile& aResourceFile,

        HBufC*& aRetBuf, TInt aResourceId )

   {

   MPX_DEBUG1("CMusicContentPublisher::GetLocalizedStringL <---");

   HBufC8* dataBuffer = aResourceFile.AllocReadLC(aResourceId);

   TResourceReader theReader;

   theReader.SetBuffer(dataBuffer);

   aRetBuf = theReader.ReadHBufCL();

   CleanupStack::PopAndDestroy(dataBuffer);

   MPX_DEBUG1("CMusicContentPublisher::GetLocalizedStringL --->");

   }

// ----------------------------------------------------------------------------

// Publishes buffered data and actions.

// ----------------------------------------------------------------------------

//

void CMusicContentPublisher::DoPublishL()

    {

    MPX_DEBUG1("CMusicContentPublisher::DoPublishL <---");

    THashMapIter<TInt, TMyBufferItem> dataIter( iPublishingDataBuffers );

    MPX_DEBUG1("CMusicContentPublisher::DoPublish publishing data");

    TMyBufferItem const* itemptr;

    itemptr = dataIter.NextValue();

    while (itemptr)

        {

        RMemReadStream rs(itemptr->buf, itemptr->size);

        CLiwGenericParamList * inParam =

        CLiwGenericParamList::NewLC(rs);

        CLiwGenericParamList * outParam = CLiwGenericParamList::NewLC();

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

        CleanupStack::PopAndDestroy(outParam);

        CleanupStack::PopAndDestroy(inParam);

        itemptr = dataIter.NextValue();

        }

    //The order in wich we publish is important, actions should be published after the data contents.

    THashMapIter<TInt, TMyBufferItem> actionIter( iPublishingActionBuffers );

    MPX_DEBUG1("CMusicContentPublisher::DoPublish publishing actions");

    itemptr = NULL;

    itemptr = actionIter.NextValue();

    while (itemptr)

        {

        RMemReadStream rs(itemptr->buf, itemptr->size);

        CLiwGenericParamList * inParam = CLiwGenericParamList::NewLC(rs);

        CLiwGenericParamList * outParam = CLiwGenericParamList::NewLC();

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

        CleanupStack::PopAndDestroy(outParam);

        CleanupStack::PopAndDestroy(inParam);

        itemptr = actionIter.NextValue();

        }

    MPX_DEBUG1("CMusicContentPublisher::CMusicContentPublisher::DoPublishL --->");

    }

// ---------------------------------------------------------------------------

// Resets all the graphical elements.

// ---------------------------------------------------------------------------

//

void CMusicContentPublisher::ResetL()

    {

    MPX_DEBUG1("CMusicContentPublisher::ResetL <---");

    //Plugin deletion is handled by the pluginmanager.

    iActivePlugin = NULL;

    //Reset The Widget

    PublishImageL(NULL,EMusicWidgetImage1,KEmpty);

    InstallGoToMusicL( EMusicWidgetTrigger1 );

    PublishTextL( NULL,EMusicWidgetText1, KEmpty );

    PublishImageL(NULL,EMusicWidgetToolbarB1,KEmpty);

    PublishImageL(NULL,EMusicWidgetToolbarB2,KEmpty);

    PublishImageL(NULL,EMusicWidgetToolbarB3,KEmpty);

    InstallEmptyActionL(EMusicWidgetTB1Trigger);

    InstallEmptyActionL(EMusicWidgetTB2Trigger);

    InstallEmptyActionL(EMusicWidgetTB3Trigger);

    PublishTextL( NULL,EMusicWidgetDefaultText, iGoToMusicBuffer->Des() );  

    InstallGoToMusicL( EMusicWidgetTrigger2 );

    //Reset the music menu info

    InstallEmptyActionL(EMusicMenuMusicInfoTrigger);

    PublishTextL( NULL, EMusicMenuMusicInfoLine1, iLastPlayedBuffer->Des() );

    PublishTextL( NULL, EMusicMenuMusicInfoLine2, KEmpty );

    PublishImageL( NULL, EMusicMenuMusicInfoImage1, KEmpty );

    MPX_DEBUG1("CMusicContentPublisher::ResetL --->");

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

TSize CMusicContentPublisher::GetImageDestinationSize(

        TMCPImageDestination aDst)

    {

    MPX_DEBUG1("CMusicContentPublisher::GetImageDestinationSize <---");

    TSize * ret;

    ret = iImageDestinationSizeMap.Find(aDst);

    if (ret)

        {

        MPX_DEBUG1("CMusicContentPublisher::GetImageDestinationSize --->");

        return *ret;    

        }

    else

        {

        MPX_DEBUG1("CMusicContentPublisher::GetImageDestinationSize --->");

        return TSize(0,0);

        }

    }

// ---------------------------------------------------------------------------

// Destroys the bitmaps saved on the cache.

// ---------------------------------------------------------------------------

//

void CMusicContentPublisher::ResetBitmapCache()

    {

    MPX_DEBUG1("CMusicContentPublisher::ResetBitmapCache <---");

    THashMapIter<TInt, TBmpMsk> iter(iBitmapCache);

    TBmpMsk const* ptr = iter.NextValue();

    CFbsBitmap* bmp( NULL );

    CFbsBitmap* msk( NULL );

    while ( ptr )

        {

        bmp = ptr->bitmap;

        msk = ptr->mask;

        delete bmp;

        bmp = NULL;

        delete msk;

        msk = NULL;

        ptr = iter.NextValue();

        }

    iBitmapCache.Close();

    MPX_DEBUG1("CMusicContentPublisher::ResetBitmapCache --->");

    }

// ---------------------------------------------------------------------------

// Destroys the publishing buffers.

// ---------------------------------------------------------------------------

//

void CMusicContentPublisher::ResetPublishingBuffers()

    {

    THashMapIter<TInt, TMyBufferItem> dataIter( iPublishingDataBuffers );

    THashMapIter<TInt, TMyBufferItem> actionIter( iPublishingActionBuffers );

    TMyBufferItem const* itemptr;

    itemptr = dataIter.NextValue();

    while (itemptr)

        {

        User::Free(itemptr->buf);

        dataIter.RemoveCurrent();

        itemptr = dataIter.NextValue();

        }

    iPublishingDataBuffers.Close();

    itemptr = NULL;

    itemptr = actionIter.NextValue();

    while (itemptr)

        {

        User::Free(itemptr->buf);

        actionIter.RemoveCurrent();

        itemptr = actionIter.NextValue();

        }

    iPublishingActionBuffers.Close();

    }

TUint CMusicContentPublisher::RegisterPublisherL( 

    const TDesC& aPublisherId, 

    const TDesC& aContentId,

    const TDesC& aContentType, 

    const TDesC8& aResultType )

    {

    MPX_DEBUG1("CMusicContentPublisher::RegisterPublisherL <---");

    TUint id( 0 );

    if( iCPSInterface )

        {   

        CLiwGenericParamList* inparam( CLiwGenericParamList::NewLC() );

        CLiwGenericParamList* outparam( CLiwGenericParamList::NewLC() );

        TLiwGenericParam type( KType, TLiwVariant( KPubData ));

        inparam->AppendL( type );

        CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

        CLiwDefaultMap* datamap = CLiwDefaultMap::NewLC();

        CLiwDefaultMap* actionmap( NULL );

        // Create the data map for publisher registry

        cpdatamap->InsertL( KContentType, TLiwVariant( aContentType ));

        cpdatamap->InsertL( KContentId, TLiwVariant( aContentId ));

        cpdatamap->InsertL( KPublisherId, TLiwVariant( aPublisherId ));

        datamap->InsertL( KMyResultName, TLiwVariant( aResultType ));

        cpdatamap->InsertL( KDataMap, TLiwVariant(datamap) );

        // Create the action map for publisher registry

        actionmap = CLiwDefaultMap::NewLC();

        actionmap->InsertL(KMyActive, TLiwVariant( KMyActionName ));

        actionmap->InsertL(KMyDeActive, TLiwVariant( KMyActionName ));

        actionmap->InsertL(KMySuspend, TLiwVariant( KMyActionName ));

        actionmap->InsertL(KMyResume, TLiwVariant( KMyActionName ));

        actionmap->InsertL(KMySelected, TLiwVariant( KMyActionName ));

        cpdatamap->InsertL( KMyActionMap, TLiwVariant(actionmap));

        CleanupStack::PopAndDestroy( actionmap );

        TLiwGenericParam item( KMyItem, TLiwVariant( cpdatamap ));        

        inparam->AppendL( item );

        iCPSInterface->ExecuteCmdL( KMyAdd , *inparam, *outparam);

        id = ExtractItemId(*outparam);

        CleanupStack::PopAndDestroy( datamap );

        CleanupStack::PopAndDestroy( cpdatamap );

        item.Reset();

        type.Reset();   

        CleanupStack::PopAndDestroy(outparam);

        CleanupStack::PopAndDestroy(inparam);

        }

    MPX_DEBUG1("CMusicContentPublisher::RegisterPublisherL --->");

    return id;

    }

TUint CMusicContentPublisher::ExtractItemId( const CLiwGenericParamList& aInParamList )

    {

    MPX_DEBUG1("CMusicContentPublisher::ExtractItemId <---");

    TUint result ( 0 );

    TInt pos( 0 );

    aInParamList.FindFirst( pos, KMyItemId );

    if( pos != KErrNotFound )

        {

        // item id present - extract and return

        aInParamList[pos].Value().Get( result );

        }

    MPX_DEBUG1("CMusicContentPublisher::ExtractItemId --->");