/*

* 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 "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:  Implements the ECom plugin for HTI audio playback control

*                service.

*

*/

// INCLUDE FILES

#include <apgcli.h>

#include <AudioPreference.h>

#include <bautils.h>

#include <e32std.h>

#include <HtiDispatcherInterface.h>

#include <HtiLogging.h>

#include <pathinfo.h>

#include "HtiAudioServicePlugin.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const static TInt KPlayToneCmdLength        = 13;

const static TInt KPlayTone2CmdLength       = 16;

const static TInt KStopCmdLength            = 1;

const static TInt KSetVolCmdLength          = 2;

const static TInt KSetVol2CmdLength         = 5;

const static TInt KListCmdMinLength         = 4;

const static TInt KPlayDtmfCmdMinLength     = 17;

const static TInt KPlayDtmf2CmdMinLength    = 20;

const static TInt KPlayFileCmdMinLength     = 21;

const static TInt KPlayFile2CmdMinLength    = 24;

const static TInt KDurationCmdMinLength     = 6;

const static TInt KMaxVolCmdMinLength       = 6;

const static TInt KTUintSize = sizeof( TUint );

// MACROS

// LOCAL CONSTANTS AND MACROS

const static TUid KAudioServiceUid = { 0x10210CCB };

_LIT( KBackslash, "\\" );

_LIT( KRngMimeType, "application/vnd.nokia.ringing-tone" );

_LIT( KAudioMimeType, "audio/*" );

// NOTE: Max length for error description is defined

// in HtiDispatcherInterface.h (currently 118).

_LIT8( KErrorNoCmd, "ERROR: No command given" );

_LIT8( KErrorUnknownCmd, "ERROR: Unknown Audio Service command" );

_LIT8( KErrorInvalidParameters,

    "ERROR: Invalid parameter data for this command" );

_LIT8( KErrorInvalidPath, "ERROR: Invalid path" );

_LIT8( KErrorToneInitFailed, "ERROR: Tone initialization failed" );

_LIT8( KErrorTonePlayFailed, "ERROR: Tone playing failed" );

_LIT8( KErrorFileInitFailed, "ERROR: File playing initialization failed" );

_LIT8( KErrorFilePlayFailed, "ERROR: File playing failed" );

_LIT8( KErrorBusyPlaying, "ERROR: Currently busy playing" );

_LIT8( KErrorNothingPlaying, "ERROR: Nothing playing" );

_LIT8( KErrorDurationFailed, "ERROR: Duration query failed" );

_LIT8( KErrorMaxVolFailed, "ERROR: Max volume query failed" );

_LIT8( KErrorPosition, "ERROR: Invalid start or end position value" );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CHtiAudioServicePlugin::CHtiAudioServicePlugin

// C++ default constructor can NOT contain any code, that might leave.

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

//

CHtiAudioServicePlugin::CHtiAudioServicePlugin():iIsBusy( EFalse ),

                                                 iIsPlaying( EFalse ),

                                                 iCommandId( 0 ),

                                                 iPlayCommandId( 0 ),

                                                 iMessage( NULL ),

                                                 iErrorCode( 0 ),

                                                 iVolume( 0 ),

                                                 iRepeats( 0 ),

                                                 iTrailingSilence( 0 ),

                                                 iDtmfLength( 0 ),

                                                 iDtmfGapLength( 0 ),

                                                 iStartPos( 0 ),

                                                 iEndPos( 0 )

    {

    }

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

// CHtiAudioServicePlugin::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHtiAudioServicePlugin::ConstructL()

    {

    }

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

// CHtiAudioServicePlugin::NewL

// Two-phased constructor.

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

//

CHtiAudioServicePlugin* CHtiAudioServicePlugin::NewL()

    {

    CHtiAudioServicePlugin* self = new (ELeave) CHtiAudioServicePlugin;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CHtiAudioServicePlugin::~CHtiAudioServicePlugin()

    {

    delete iMessage;

    iMessage = NULL;

    delete iAudioPlayer;

    iAudioPlayer = NULL;

    delete iTonePlayer;

    iTonePlayer = NULL;

    }

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

// CHtiAudioServicePlugin::ProcessMessageL

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

//

void CHtiAudioServicePlugin::ProcessMessageL( const TDesC8& aMessage,

                                        THtiMessagePriority /*aPriority*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiAudioServicePlugin::ProcessMessageL" );

    HTI_LOG_FORMAT( "Message length = %d", aMessage.Length() );

    if ( iIsBusy )

        {

        HTI_LOG_TEXT( "Plugin is busy - leaving" );

        User::Leave( KErrInUse );

        }

    // Will be set to EFalse in the SendResponseMsg or SendErrorResponseMsg

    // methods when the response has been successfully sent and the plugin is

    // ready for next message.

    iIsBusy = ETrue;

    if ( aMessage.Length() < 1 )

        {

        User::LeaveIfError(

            SendErrorResponseMsg( KErrArgument, KErrorNoCmd ) );

        return;

        }

    iCommandId = aMessage[0];

    HTI_LOG_FORMAT( "Command = %d", iCommandId );

    TInt err = KErrNone;

    if ( iCommandId == ECmdListAudioFiles )

        {

        TRAP( err, HandleListAudioFilesCmdL( aMessage ) );

        }

    else if ( iCommandId == ECmdPlayFile || iCommandId == ECmdPlayFile2)

        {

        TRAP( err, HandlePlayFileCmdL( aMessage ) );

        }

    else if ( iCommandId == ECmdPlayTone || iCommandId == ECmdPlayTone2)

        {

        TRAP( err, HandlePlayToneCmdL( aMessage ) );

        }

    else if ( iCommandId == ECmdPlayDtmf || iCommandId == ECmdPlayDtmf2)

        {

        TRAP( err, HandlePlayDtmfCmdL( aMessage ) );

        }

    else if ( iCommandId == ECmdStop )

        {

        TRAP( err, HandleStopCmdL( aMessage ) );

        }

    else if ( iCommandId == ECmdGetDuration )

        {

        TRAP( err, HandleGetDurationCmdL( aMessage ) );

        }

    else if ( iCommandId == ECmdGetMaxVol || iCommandId == ECmdGetMaxVol2)

        {

        TRAP( err, HandleGetMaxVolCmdL( aMessage ) );

        }

    else if ( iCommandId == ECmdSetVol || iCommandId == ECmdSetVol2)

        {

        TRAP( err, HandleSetVolCmdL( aMessage ) );

        }

    else

        {

        User::LeaveIfError(

            SendErrorResponseMsg( KErrArgument, KErrorUnknownCmd ) );

        }

    if ( err != KErrNone )

        {

        User::LeaveIfError(

                SendErrorResponseMsg( err, KNullDesC8, iCommandId ) );

        }

    HTI_LOG_FUNC_OUT( "CHtiAudioServicePlugin::ProcessMessageL" );

    }

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

// CHtiAudioServicePlugin::HandleListAudioFilesCmdL()

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

//

void CHtiAudioServicePlugin::HandleListAudioFilesCmdL( const TDesC8& aMessage )

    {

    HTI_LOG_FUNC_IN( "CHtiAudioServicePlugin::HandleListAudioFilesCmdL" );

    RFs fsSession;

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

    CleanupClosePushL( fsSession );

    // Build a list of directories to scan

    CDesCArraySeg* directories = new (ELeave) CDesCArraySeg( 5 );

    CleanupStack::PushL( directories );

    if ( aMessage.Length() == 1 )  // Add default sound directories

        {

        TFileName directory;

        // ROM

        directory.Append( PathInfo::RomRootPath() );

        directory.Append( PathInfo::SoundsPath() );

        if ( BaflUtils::PathExists( fsSession, directory ) )

            {

            directories->AppendL( directory );

            AddSubdirsRecursivelyL( directories->MdcaPoint(

                directories->Count() - 1 ), *directories, fsSession );

            }

        // Phone memory

        directory.Zero();

        directory.Append( PathInfo::PhoneMemoryRootPath() );

        directory.Append( PathInfo::SoundsPath() );

        if ( BaflUtils::PathExists( fsSession, directory ) )

            {

            directories->AppendL( directory );

            AddSubdirsRecursivelyL( directories->MdcaPoint(

                directories->Count() - 1 ), *directories, fsSession );

            }

        // Memory card

        directory.Zero();

        directory.Append( PathInfo::MemoryCardRootPath() );

        directory.Append( PathInfo::SoundsPath() );

        if ( BaflUtils::PathExists( fsSession, directory ) )

            {

            directories->AppendL( directory );

            AddSubdirsRecursivelyL( directories->MdcaPoint(

                directories->Count() - 1 ), *directories, fsSession );

            }

        }

    else  // Add given directory

        {

        if ( aMessage.Length() < KListCmdMinLength )

            {

            User::LeaveIfError( SendErrorResponseMsg(

                                    KErrArgument, KErrorInvalidParameters ) );

            CleanupStack::PopAndDestroy( 2 ); // directories, fsSession

            return;

            }

        TInt pathLength = aMessage[1];

        if ( ( aMessage.Length() - pathLength ) != KListCmdMinLength - 2 )

            {

            User::LeaveIfError( SendErrorResponseMsg(

                                    KErrArgument, KErrorInvalidParameters ) );

            CleanupStack::PopAndDestroy( 2 ); // directories, fsSession

            return;

            }

        TFileName directory;

        TInt nextOffset = ParseString( aMessage, 1, directory );

        TInt dirLength = directory.Length();

        if ( dirLength < 2 || nextOffset < 0 )

            {

            User::LeaveIfError( SendErrorResponseMsg(

                                    KErrArgument, KErrorInvalidParameters ) );

            CleanupStack::PopAndDestroy( 2 ); // directories, fsSession

            return;

            }

        HTI_LOG_DES( directory );

        if ( directory[dirLength - 1] != '\\' )

            {

            HTI_LOG_TEXT( "Adding backslash to the end" );

            directory.Append( KBackslash );

            HTI_LOG_DES( directory );

            }

        if ( BaflUtils::PathExists( fsSession, directory ) )

            {

            HTI_LOG_TEXT( "Given path exists" );

            directories->AppendL( directory );

            AddSubdirsRecursivelyL( directories->MdcaPoint(

                directories->Count() - 1 ), *directories, fsSession );

            }

        }

    // Buffer for the file list that is returned

    CBufFlat* fileListBuf = CBufFlat::NewL( 256 );

    CleanupStack::PushL( fileListBuf );

    TInt bufPos = 0;

    TInt audioFileCount = 0;

    TInt dirCount( directories->Count() );

    HTI_LOG_FORMAT( "Total directory count = %d", dirCount );

    if ( dirCount == 0 )

        {

        HTI_LOG_TEXT( "The given directory did not exist" );

        User::LeaveIfError( SendErrorResponseMsg(

                                KErrArgument, KErrorInvalidPath ) );

        CleanupStack::PopAndDestroy( 3 ); // fileListBuf, directories, fsSession

        return;

        }

    // Loop all the directories

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

        {

        HTI_LOG_TEXT( "Reading dir:" );

        HTI_LOG_DES( directories->MdcaPoint( i ) );

        CDir* dir;

        TInt err = fsSession.GetDir( directories->MdcaPoint( i ),

            KEntryAttNormal, ESortNone, dir );

        if ( err )

            {

            delete dir;

            dir = NULL;

            continue; // This dir is skipped

            }

        CleanupStack::PushL( dir );

        // Loop all the entries in this directory

        TInt fileCount( dir->Count() );

        for ( TInt j = 0; j < fileCount; j++ )

            {

            TFileName filePath;

            filePath.Copy( directories->MdcaPoint( i ) );

            filePath.Append( ( *dir )[j].iName );

            // Check MIME type match

            if ( MatchMimeTypeL( filePath, KAudioMimeType ) ||

                 MatchMimeTypeL( filePath, KRngMimeType ) )

                {

                HBufC8* filePathBuf8 = HBufC8::NewLC( KMaxFileName );

                filePathBuf8->Des().Copy( filePath );

                TInt pathLength = filePathBuf8->Length();

                HTI_LOG_DES( *filePathBuf8 );

                fileListBuf->ExpandL( bufPos, pathLength + 1 );

                TBuf8<1> lengthBuf;

                lengthBuf.Append( pathLength );

                fileListBuf->Write( bufPos, lengthBuf, 1 );

                bufPos++;

                fileListBuf->Write( bufPos, filePathBuf8->Ptr(), pathLength );

                bufPos += pathLength;

                CleanupStack::PopAndDestroy(); // filePathBuf8

                audioFileCount++;

                }

            } // files loop

        CleanupStack::PopAndDestroy(); // dir

        } // directories loop

    HTI_LOG_FORMAT( "Total audio file count = %d", audioFileCount );

    // All files added - write number of files to the beginning of buffer...

    TBuf8<2> countBuf;

    countBuf.Append( (TUint8*)(&audioFileCount), 2 );

    fileListBuf->InsertL( 0, countBuf, 2 );

    // ...and send it away

    TPtr8 ptr = fileListBuf->Ptr( 0 );

    User::LeaveIfError( SendResponseMsg( ptr ) );

    CleanupStack::PopAndDestroy( 3 ); // fileListBuf, directories, fsSession

    HTI_LOG_FUNC_OUT( "CHtiAudioServicePlugin::HandleListAudioFilesCmdL" );

    }

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

// CHtiAudioServicePlugin::HandlePlayFileCmdL()

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

//

void CHtiAudioServicePlugin::HandlePlayFileCmdL( const TDesC8&aMessage )

    {

    HTI_LOG_FUNC_IN( "CHtiAudioServicePlugin::HandlePlayFileCmdL" );

    if ( iIsPlaying )

        {

        User::LeaveIfError( SendErrorResponseMsg(

                                KErrInUse, KErrorBusyPlaying ) );

        return;

        }

    iPlayCommandId = (TUint8) aMessage[0];

    /*

    Message bytes:

             0      = command code

             1      = path length

         2 - n      = full path to file

        next 1 or 4 = volume

        next 4      = start position

        next 4      = end position

        next 1      = repeats

        next 4      = silence between repeats

        next 1      = audio setting

    */

    if ( aMessage.Length() < KPlayFileCmdMinLength )

        {

        User::LeaveIfError( SendErrorResponseMsg(

                                KErrArgument, KErrorInvalidParameters ) );

        return;

        }

    // Parse parameter values from the message

    const TUint8* ptr = aMessage.Ptr();

    TInt pathLength = aMessage[1];

    if ( (iPlayCommandId == ECmdPlayFile &&

            ( aMessage.Length() - pathLength ) !=  ( KPlayFileCmdMinLength - 4 ))

            || (iPlayCommandId == ECmdPlayFile2 && 

            ( aMessage.Length() - pathLength ) !=  ( KPlayFile2CmdMinLength - 4 )))

        {

        User::LeaveIfError( SendErrorResponseMsg(

                                KErrArgument, KErrorInvalidParameters ) );

        return;

        }

    TFileName filePath;

    TInt nextOffset = ParseString( aMessage, 1, filePath );

    if ( filePath.Length() < 2 || nextOffset < 0 )

        {

        User::LeaveIfError( SendErrorResponseMsg(

                                KErrArgument, KErrorInvalidParameters ) );

        return;

        }

    HTI_LOG_TEXT( "Full file path:" );

    HTI_LOG_DES( filePath );

    if(iPlayCommandId == ECmdPlayFile)

        {

        iVolume = aMessage[nextOffset];

        nextOffset++;

        }

    else

        {

        iVolume = ParseUint32( ptr + nextOffset );

        nextOffset += 4;

        }

    HTI_LOG_FORMAT( "Volume = %d", iVolume );

    iStartPos = ParseUint32( ptr + nextOffset );

    HTI_LOG_FORMAT( "Start position = %d", iStartPos );

    nextOffset += 4;

    iEndPos = ParseUint32( ptr + nextOffset );

    HTI_LOG_FORMAT( "End position = %d", iEndPos );

    nextOffset += 4;

    iRepeats = aMessage[nextOffset];

    nextOffset++;

    HTI_LOG_FORMAT( "Repeats = %d", iRepeats );

    iTrailingSilence = ParseUint32( ptr + nextOffset );

    HTI_LOG_FORMAT( "Trailing silence = %d", iTrailingSilence );

    nextOffset += 4;

    TInt audioSetting = aMessage[nextOffset];

    HTI_LOG_FORMAT( "Audio setting = %d", audioSetting );

    // Set audio settings

    if ( audioSetting > ERingTonePreview ) audioSetting = EDefault;

    SetAudioSettings( ( TAudioSetting ) audioSetting );

    // Check if file is rng ringtone, it has to be played using tone player -

    // other formats are played with audio player.

    TInt err = KErrNone;

    TBool isRng = EFalse;

    TRAP( err, isRng = MatchMimeTypeL( filePath, KRngMimeType ) );

    if ( err )

        {

        User::LeaveIfError( SendErrorResponseMsg( err, KErrorFileInitFailed ) );

        return;

        }

    if ( isRng )

        {

        HTI_LOG_TEXT( "File is RNG - creating tone player" );

        TRAP( err, iTonePlayer = CMdaAudioToneUtility::NewL(

                *this, NULL, iAudioPriority, iAudioPriorityPreference ) );

        }

    else