/*

* Copyright (c) 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:  Implementation for music store integration.

*

*/

#include <apgcli.h>

#include <apgtask.h>

#include <centralrepository.h>

#include <e32base.h>

#include <e32property.h>

#include <eikenv.h>

#include <eikmenup.h>

#include <eikmenub.h>

#include <fmradio.rsg>

#include <mpxfindinmusicshop.h>

#include <mpxfindinmusicshopcommon.h>   //for p&s keys

#include "fmradio.hrh"

#include "fmradiomusicstorehandler.h"

#include "debug.h"

// Some debug flags

// If defined, forces Operator specific music shop to be enabled,

// regardless if it is supported or not. For debugging purposes

#undef FORCE_OPERATOR_MUSIC_SHOP

// Following constants are from mpxmusicplayer_101FFCDC.crml

const TUid KCRUidMPXMPSettings = {0x101FFCDC}; // UID for Music Store Settings CenRep

const TUint32 KMPXMusicStoreUID = 0x3;

const TUint32 KOperatorMusicStore = 0x4;

const TUint32 KOperatorMusicStoreType = 0x5;

const TUint32 KOperatorMusicStoreDisplayName = 0x6;

const TUint32 KOperatorMusicStoreNativeUid = 0x7;

const TUint32 KOperatorMusicStoreWebPage = 0x9;

const TUint32 KOperatorMusicStoreURI = 0xA;

const TInt TUInt32HexLength = 8;

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

// CFMRadioMusicStoreHandler::CMusicStoreHandler

// C++ class constructor.

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

//

CFMRadioMusicStoreHandler::CFMRadioMusicStoreHandler( TInt aResourceId )

: iResourceId( aResourceId )

    {

    // Nothing to do

    }

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

// CFMRadioMusicStoreHandler::~CMusicStoreHandler

// Default destructor.

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

//

CFMRadioMusicStoreHandler::~CFMRadioMusicStoreHandler()

    {

    iOperatorMusicStoreName.Close();

    iOperatorStoreWebsite.Close();

    }

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

// CFMRadioMusicStoreHandler::NewL

// Two-phased class constructor.

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

//

CFMRadioMusicStoreHandler* CFMRadioMusicStoreHandler::NewL( TInt aResourceId )

    {

    CFMRadioMusicStoreHandler* self = new (ELeave) CFMRadioMusicStoreHandler( aResourceId );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CFMRadioMusicStoreHandler::NewL

// Second phase class constructor.

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

//

void CFMRadioMusicStoreHandler::ConstructL()

    {

    iCoeEnv = CEikonEnv::Static();

    CRepository* repository = CRepository::NewL( KCRUidMPXMPSettings );

    CleanupStack::PushL( repository );

    RBuf8 uidDes;

    uidDes.CleanupClosePushL();

    uidDes.CreateL( TUInt32HexLength );

    TInt error = KErrNone;

    error = repository->Get( KMPXMusicStoreUID, uidDes );

    // Check for availability of Nokia Music store

    if ( !error )

        {

        iMusicStoreUID = Uint32Presentation( uidDes );

        iMusicStoreAppInstalled = IsAppInstalledL( TUid::Uid( iMusicStoreUID ) );

        }

    if ( NokiaMusicStoreAvailable() )

        {

        InitializeMusicStore( TUid::Uid( iMusicStoreUID ) );

        }

    // Check if operator provided a music store

    TFMRadioOperatorAppType appType = CheckOperatorMusicStoreTypeL( *repository );

    if ( appType != EFMRadioAppNotAvailable )

        {

        // Get the name of the music store

        const TInt initialNameLength = 11;

        iOperatorMusicStoreName.CreateL( initialNameLength );

        TInt realLength = KErrNotFound;

        error = repository->Get( KOperatorMusicStoreDisplayName, iOperatorMusicStoreName, realLength );

        if ( error == KErrOverflow )

            {

            iOperatorMusicStoreName.ReAllocL( realLength );

            error = repository->Get( KOperatorMusicStoreDisplayName, iOperatorMusicStoreName );

            }

        User::LeaveIfError( error );

#ifdef FORCE_OPERATOR_MUSIC_SHOP

        if ( !iOperatorMusicStoreName.Length() )

            {

            _LIT( KHardCodedName, "O'MusicShop" ); // length <= initialNameLength

            iOperatorMusicStoreName.Copy( KHardCodedName );

            }

#endif

        // Get application type specific parameters

        InitializeParametersL( *repository, appType );

        }

    CleanupStack::PopAndDestroy( 2 ); // uidDes, repository

    }

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

// CFMRadioMusicStoreHandler::CheckOperatorMusicStoreTypeL

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

//

CFMRadioMusicStoreHandler::TFMRadioOperatorAppType CFMRadioMusicStoreHandler::CheckOperatorMusicStoreTypeL(

        CRepository& aRepository )

    {

    TFMRadioOperatorAppType appType = EFMRadioAppNotAvailable;

    // Check if operator provided a music store

    TBool operatorStorePresent = EFalse;

    TInt error = aRepository.Get( KOperatorMusicStore, operatorStorePresent );

    if ( error != KErrNotFound )

        {

        User::LeaveIfError( error );

        }

    if ( operatorStorePresent )

        {

        TInt appTypeCR;

        error = aRepository.Get( KOperatorMusicStoreType, appTypeCR );

        User::LeaveIfError( error );

        if ( appTypeCR == 0 ) // 0 = Native app

            {

            appType = EFMRadioNativeApp;

            }

        else    // 1 = Java app

            {

            appType = EFMRadioJavaApp;

            }

         }

    // The code assumes that if both application and website is available then

    // website is preferred type

    TInt website;

    error = aRepository.Get( KOperatorMusicStoreWebPage, website );

    User::LeaveIfError( error );

#ifdef FORCE_OPERATOR_MUSIC_SHOP

    website = ETrue;

#endif

    if ( website )

        {

        appType = EFMRadioWebsite;

        }

    return appType;

    }

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

// CFMRadioMusicStoreHandler::InitializeParametersL

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

//

void CFMRadioMusicStoreHandler::InitializeParametersL(

        CRepository& aRepository,

        TFMRadioOperatorAppType aAppType )

    {

    TInt error = KErrNone;

    switch ( aAppType )

        {

        case EFMRadioNativeApp:

            {

            RBuf8 operatorUidDes;

            operatorUidDes.CleanupClosePushL();

            operatorUidDes.CreateL( TUInt32HexLength );

            TInt error = KErrNone;

            error = aRepository.Get( KOperatorMusicStoreNativeUid, operatorUidDes );

            if ( !error )

                {

                iOperatorStoreNativeUID = Uint32Presentation( operatorUidDes );

                // It is assumed that both Nokia Music Shop and operator specific music store use

                // same kind of interface to communicate

                InitializeMusicStore( TUid::Uid( iOperatorStoreNativeUID ) );

                }

            CleanupStack::PopAndDestroy( &operatorUidDes );

            break;

            }

        case EFMRadioJavaApp:

            // Java application not supported currently

            break;

        case EFMRadioWebsite:

            {

            const TInt initialSize = 5;

            TInt realLength = KErrNotFound;

            iOperatorStoreWebsite.Create( initialSize );

            error = aRepository.Get( KOperatorMusicStoreURI, iOperatorStoreWebsite, realLength );

            if ( error == KErrOverflow )

                {

                iOperatorStoreWebsite.ReAllocL( realLength );

                error = aRepository.Get( KOperatorMusicStoreURI, iOperatorStoreWebsite );

                }

            User::LeaveIfError( error );

#ifdef FORCE_OPERATOR_MUSIC_SHOP

            if ( !iOperatorStoreWebsite.Length() )

                {

                _LIT( KHardCodedName, "http://www.google.com/" );

                iOperatorStoreWebsite.ReAllocL( KHardCodedName().Length() );

                iOperatorStoreWebsite.Copy( KHardCodedName );

                }

#endif

            break;

            }

        default:

            break;

        }

    }

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

// CFMRadioMusicStoreHandler::InitializeMusicShop

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

//

void CFMRadioMusicStoreHandler::InitializeMusicStore( TUid aMusicstoreUid )

    {

    //MusicShop CenRep initialization values

    _LIT_SECURITY_POLICY_C1(KMPlayerRemoteReadPolicy, ECapabilityReadUserData);

    _LIT_SECURITY_POLICY_C1(KMPlayerRemoteWritePolicy, ECapabilityWriteUserData);

    TInt retval(KErrNone);

    // P/S key for music shop

    retval = RProperty::Define( aMusicstoreUid,

            KMShopCategoryId,

            RProperty::EInt,

            KMPlayerRemoteReadPolicy,

            KMPlayerRemoteWritePolicy );

    if( retval != KErrAlreadyExists)

        {

        RProperty::Set( aMusicstoreUid,

                KMShopCategoryId,

                KFindInMShopKeyInValid );  // initialize Find In Musicshop was not called

        RProperty::Define( aMusicstoreUid,

                KMShopCategoryName,

                RProperty::ELargeText,

                KMPlayerRemoteReadPolicy,

                KMPlayerRemoteWritePolicy );

        }

    }

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

// CFMRadioMusicStoreHandler::GetUint32Presentation

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

//

TUint32 CFMRadioMusicStoreHandler::Uint32Presentation( const TDesC8& aBuf )

    {

    TUint32 result = 0;

    const TInt KProEngByteLength( 8 );

    const TInt length( aBuf.Length() );

    const TInt maxBitShift( KProEngByteLength * ( length - 1 ) );

    for ( TInt i( 0 ); i < length; ++i )

        {

        result |= ( aBuf[i] <<

                   ( maxBitShift - ( KProEngByteLength * i ) ) );

        }

    return result;

    }

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

// CFMRadioMusicStoreHandler::IsMusicStoreCommandId

// Goes through known command ids and compares to them

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

//

TBool CFMRadioMusicStoreHandler::IsMusicStoreCommandId( TInt aCommandId )

    {

    TBool isHandled = EFalse;

    switch( aCommandId )

        {

        case EFMRadioMusicStore:

        case EFMRadioMusicStoreGoogle:

        case EFMRadioMusicStoreWikipedia:

        case EFMRadioMusicStoreAmg:

        case EFMRadioMusicStoreNokiaMusicShop:

        case EFMRadioMusicStoreMusicPortl:

        case EFMRadioMusicStoreOperator:

            isHandled = ETrue;

            break;

        default:

            break;

        }

    return isHandled;

    }

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

// CFMRadioMusicStoreHandler::MusicStoreCount

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

//

TInt CFMRadioMusicStoreHandler::MusicStoreCount()

    {

    TInt count = 0;

    if ( NokiaMusicStoreAvailable() )

        {

        count++;

        }

    if ( OperatorMusicStoreAvailable() )

        {

        count++;

        }

    return count;

    }

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

// CFMRadioMusicStoreHandler::OperatorMusicStoreAvailable

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

//

TBool CFMRadioMusicStoreHandler::OperatorMusicStoreAvailable()

    {

    return ( iOperatorMusicStoreName.Length() != 0 );

    }

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

// CFMRadioMusicStoreHandler::NokiaMusicStoreAvailable

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

//

TBool CFMRadioMusicStoreHandler::NokiaMusicStoreAvailable()

    {

    TBool response = EFalse;

    if ( iMusicStoreUID != 0 && iMusicStoreAppInstalled )

        {

        response = ETrue;

        }

    return response;

    }

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

// CFMRadioMusicStoreHandler::InitializeMenuL

// Takes care of dynamically initializing menu items related to Music shop.

// Takes care of adding either menu item or cascaded menuitem

// based on how many Music shops there is available. Fills the

// cascaded menuitem automatically.

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

//

TBool CFMRadioMusicStoreHandler::InitializeMenuL( TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    TBool resourceHandled = EFalse;

    if ( aResourceId == R_FMRADIO_OPTIONS_MUSIC_STORE_SUB_MENU )

        {

        if ( NokiaMusicStoreAvailable() )

            {

            aMenuPane->SetItemDimmed( EFMRadioMusicStoreNokiaMusicShop, EFalse );

            }

        else

            {

            aMenuPane->SetItemDimmed( EFMRadioMusicStoreNokiaMusicShop, ETrue );

            }

        if ( OperatorMusicStoreAvailable() )

            {

            aMenuPane->SetItemTextL( EFMRadioMusicStoreOperator, iOperatorMusicStoreName );

            aMenuPane->SetItemDimmed( EFMRadioMusicStoreOperator, EFalse );

            }

        else

            {

            aMenuPane->SetItemDimmed( EFMRadioMusicStoreOperator, ETrue );

            }

        resourceHandled = ETrue;

        }

    else if ( iResourceId == aResourceId )

        {

        const TInt firstIndex = 0;

        TInt firstCommand = aMenuPane->MenuItemCommandId( firstIndex );

        if ( MusicStoreCount() > 1 || OperatorMusicStoreAvailable() )

            {

            aMenuPane->AddMenuItemsL( R_FMRADIO_OPTIONS_MUSIC_STORE_WITH_SUB_MENU, firstCommand );

            }

        else

            {

            aMenuPane->AddMenuItemsL( R_FMRADIO_OPTIONS_MUSIC_STORE, firstCommand );

            }

        // Show or hide menu item based on Music store state

        if ( iState == EFMRadioMusicStoreDisabled || iState == EFMRadioMusicStoreUninitialized )

            {

            aMenuPane->SetItemDimmed( EFMRadioMusicStore, ETrue );

            }

        else if ( iState == EFMRadioMusicStoreEnabled && !MusicStoreCount() )

            {

            aMenuPane->SetItemDimmed( EFMRadioMusicStore, ETrue );

            }

        else

            {

            aMenuPane->SetItemDimmed( EFMRadioMusicStore, EFalse );

            }

        }

    else

        {

        //NOP

        }

    return resourceHandled;

    }

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

// CFMRadioMusicStoreHandler::EnableMusicStore

// Shows or hides Music store related functionality

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

//

void CFMRadioMusicStoreHandler::EnableMusicStore( TBool aEnable, TBool aForce )

    {

    if ( aForce && aEnable )

        {

        iState = EFMRadioMusicStoreForceEnabled;

        }

    else if ( aEnable )

        {

        iState = EFMRadioMusicStoreEnabled;

        }

    else

        {

        iState = EFMRadioMusicStoreDisabled;

        }

    }

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

// CFMRadioMusicStoreHandler::LaunchMusicStoreL

// Launches appropriate Music Store functionality based on parameters.

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

//

void CFMRadioMusicStoreHandler::LaunchMusicStoreL(

        TInt aCommandId,

        const TDesC& aTitle,

        const TDesC& aArtist,

        const TDesC& aAlbum )

    {

    if ( aCommandId == EFMRadioMusicStore )

        {

        aCommandId = EFMRadioMusicStoreNokiaMusicShop;

        }

    RBuf searchString;

    searchString.CleanupClosePushL();

    TBool isHandled = ETrue;

    switch( aCommandId )

        {

        case EFMRadioMusicStoreGoogle:

        case EFMRadioMusicStoreWikipedia:

        case EFMRadioMusicStoreAmg:

        case EFMRadioMusicStoreMusicPortl:

            isHandled = EFalse;

            break;

        case EFMRadioMusicStoreNokiaMusicShop:

            searchString.Assign( NokiaMusicShopSearchL( aTitle, aArtist, aAlbum ) );

            break;

        case EFMRadioMusicStoreOperator:

            if ( iOperatorStoreWebsite.Length() != 0 )

                {

                searchString.CreateL( iOperatorStoreWebsite );

                }

            else if ( iOperatorStoreNativeUID )

                {

                // It is assumed that both Nokia Music Shop and operator specific music store use

                // same kind of interface to communicate

                searchString.Assign( NokiaMusicShopSearchL( aTitle, aArtist, aAlbum ) );

                }

            else

                {

                isHandled = EFalse;

                }

            break;

        default:

            FTRACE( FPrint( _L("CFMRadioMusicStoreHandler::LaunchMusicStoreL - Unknown id = %d"), aCommandId ) );

            isHandled = EFalse;

            break;

        }

    if ( isHandled )

        {

        switch( aCommandId )

            {

            case EFMRadioMusicStoreNokiaMusicShop:

                {

                TUid musicshopUid( TUid::Uid( iMusicStoreUID ) );

                LaunchMusicShopL( musicshopUid, searchString );

                break;

                }

            case EFMRadioMusicStoreOperator:

                LaunchOperatorMusicStoreL( searchString );

                break;

            default:

                LaunchWebPageL( searchString );

                break;

            }