/*
* 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:
*
*/
#include "mcsdef.h"

#include "mcsmenu.h"
#include "menusrvdef.h"
#include "menumsg.h"
#include "menubuf.h"
#include "menuutil.h"
#include "menuclientoperation.h"
#include "menuhandlereng.h"
#include "mcsmenufilter.h"

#include <s32strm.h>
#include <e32debug.h>

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

/**
* Start the server executable.
* @return Error code.
*/
LOCAL_C TInt StartServer()
    {
    TInt err( KErrNone );
    RProcess server;
    err = server.Create( KMenuSrvExe, KNullDesC, EOwnerThread );
    if ( !err )
        {
        TRequestStatus status;
        server.Rendezvous( status );
        if ( status != KRequestPending )
            {
            server.Kill( 0 ); // Abort startup.
            }
        else
            {
            server.Resume(); // Logon OK - start the server.
            }
        User::WaitForRequest( status ); // Wait for start or death.
        // We can't use the 'exit reason' if the server panicked as this
        // is the panic 'reason' and may be '0' which cannot be distinguished
        // from KErrNone.
        err = (server.ExitType() == EExitPanic) ? KErrGeneral : status.Int();
        server.Close();
        }
    return err;
    }

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

NONSHARABLE_CLASS( RMenu::TData )
    {
public:
    // Transfer buffer. Size must be big enough to accomodate any object that
    // will go through it: attribute, TMenuItem
    TUint16 iBuf[KMenuMaxAttrValueLen];
    // Handler engine.
    CMenuHandlerEng* iHandler;
    };

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

// ---------------------------------------------------------
// RMenu::Close
// ---------------------------------------------------------
//
EXPORT_C void RMenu::Close()
    {
    RSessionBase::Close();
    if ( iData )
        {
        delete iData->iHandler; iData->iHandler = NULL;
        delete iData; iData = NULL;
        }
    }

// ---------------------------------------------------------
// RMenu::OpenL
// ---------------------------------------------------------
//
EXPORT_C void RMenu::OpenL( const TDesC& aName )
    {
    __ASSERT_DEBUG( !iData, User::Invariant() );
    User::LeaveIfError( ConnectSession() );
    CleanupClosePushL( *this ); // Atomcic connect + local data + construct.
    iData = new (ELeave) RMenu::TData();
    iData->iHandler = NULL;
    // We have a connected blank session, now construct it.
    // It would be good to have a CreateSession which leaves us at least one
    // IpcArg, so the name could be sent to session creation directly.
    // Since having a fully constructed session needs this extra IPC, the
    // server side session had to be cluttered with ASSERTS. (Almost all
    // messages need to check that the session is fully constructed.)
    //
    // The reason for this is a design issue (we use the session as an object,
    // and not just as a communication channel. But normally there is only one
    // object used, so why complicate things for the client?
    User::LeaveIfError
        ( SendReceive( EMenuConstructSession, TIpcArgs( &aName ) ) );
    CleanupStack::Pop( this );
    }

// ---------------------------------------------------------
// RMenu::RootFolderL
// ---------------------------------------------------------
//
EXPORT_C TInt RMenu::RootFolderL()
    {
    __ASSERT_DEBUG( iData, User::Invariant() );
    TPckgBuf<TInt> pckg;
    User::LeaveIfError( SendReceive( EMenuRootFolder, TIpcArgs( &pckg ) ) );
    return pckg();
    }

// ---------------------------------------------------------
// RMenu::GetItemsL
// ---------------------------------------------------------
//
EXPORT_C void RMenu::GetItemsL(
        RArray<TMenuItem>& aItemArray,
        TInt aFolder,
        const CMenuFilter* aFilter /*=NULL*/,
        TBool aRecursive /*=EFalse*/ )
    {
    __ASSERT_DEBUG( iData, User::Invariant() );
    if ( aFilter )
        {
        // Filtered query, 2+ more IPC.
        // The buffer is opened empty, used to send the filter
        // then the result is received into it.
        RMenuBuf buf;
        User::LeaveIfError( buf.Open( *this ) );
        CleanupClosePushL( buf );
        RWriteStream stream( &buf );
        aFilter->ExternalizeL( stream );
        stream.CommitL();
        TIpcArgs args( aFolder, aRecursive, buf.SubSessionHandle() );
        User::LeaveIfError( SendReceive( EMenuGetItemsFiltered, args ) );
        RReadStream rs( &buf );
        MenuUtil::InternalizeL( aItemArray, rs );
        CleanupStack::PopAndDestroy( &buf );
        }
    else
        {
        // Unfiltered query.
        // The buffer already contains the query result when Open() returns.
        RMenuBuf buf;
        TIpcArgs args( aFolder, aRecursive );
        User::LeaveIfError( buf.Open( *this, EMenuGetItems, args ) );
        CleanupClosePushL( buf );
        RReadStream stream( &buf );
        MenuUtil::InternalizeL( aItemArray, stream );
        CleanupStack::PopAndDestroy( &buf );
        }
    }

// ---------------------------------------------------------
// RMenu::GetRunningAppsL
// ---------------------------------------------------------
//
EXPORT_C  void RMenu::GetRunningAppsL( RArray<TUid>& aArray )
	{
    RMenuBuf buf;
    TIpcArgs args( 0 );
    User::LeaveIfError( buf.Open( *this, EMenuGetRunningApps, args ) );
    CleanupClosePushL( buf );
    RReadStream stream( &buf );
    MenuUtil::InternalizeL( aArray, stream );
    CleanupStack::PopAndDestroy( &buf );
	}
    

// ---------------------------------------------------------
// RMenu::RemoveL
// ---------------------------------------------------------
//
EXPORT_C CMenuOperation* RMenu::RemoveL( TInt aId, TRequestStatus& aStatus )
    {
    __ASSERT_DEBUG( iData, User::Invariant() );
    CMenuClientOperation* op = new (ELeave) CMenuClientOperation
        ( *this, CActive::EPriorityStandard, aStatus );
    CleanupStack::PushL( op );
    op->RemoveL( aId );
    CleanupStack::Pop( op );
    return op;
    }

// ---------------------------------------------------------
// RMenu::MoveToFolderL
// ---------------------------------------------------------
//
EXPORT_C CMenuOperation* RMenu::MoveToFolderL(
        const RArray<TInt>& aItems,
        TInt aFolder,
        TInt aMoveBefore,
        TRequestStatus& aStatus )
    {
    __ASSERT_DEBUG( iData, User::Invariant() );
    RMenuBuf buf;
    User::LeaveIfError( buf.Open( *this ) );
    CleanupClosePushL( buf );
    RWriteStream stream( &buf );
    MenuUtil::ExternalizeL( aItems, stream );
    stream.CommitL();
    CMenuClientOperation* op = new (ELeave) CMenuClientOperation
        ( *this, CActive::EPriorityStandard, aStatus );
    CleanupStack::PushL( op );
    op->MoveToFolderL( buf, aFolder, aMoveBefore );
    CleanupStack::Pop( op );
    CleanupStack::PopAndDestroy( &buf );
    return op;
    }

// ---------------------------------------------------------
// RMenu::ReorderL
// ---------------------------------------------------------
//
EXPORT_C CMenuOperation* RMenu::ReorderL
( TInt aId, TInt aMoveBefore, TRequestStatus& aStatus )
    {
    __ASSERT_DEBUG( iData, User::Invariant() );
    CMenuClientOperation* op = new (ELeave) CMenuClientOperation
        ( *this, CActive::EPriorityStandard, aStatus );
    CleanupStack::PushL( op );
    op->ReorderL( aId, aMoveBefore );
    CleanupStack::Pop( op );
    return op;
    }

// ---------------------------------------------------------
// RMenu::ResourceMark
// ---------------------------------------------------------
//
EXPORT_C void RMenu::ResourceMark()
    {
    SendReceive( EMenuResourceMarkStart );
    }

// ---------------------------------------------------------
// RMenu::ResourceCheck
// ---------------------------------------------------------
//
EXPORT_C void RMenu::ResourceCheck()
    {
    SendReceive( EMenuResourceMarkEnd );
    }

// ---------------------------------------------------------
// RMenu::ResourceCount
// ---------------------------------------------------------
//
EXPORT_C TInt RMenu::ResourceCount()
    {
    return SendReceive( EMenuResourceCount );
    }

#ifdef _DEBUG

// ---------------------------------------------------------
// RMenu::__DbgSetAllocFail
// ---------------------------------------------------------
//
EXPORT_C void RMenu::__DbgSetAllocFail
( RAllocator::TAllocFail aType, TInt aRate )
    {
    TInt type = STATIC_CAST( TInt, aType );
    SendReceive( EMenuSetHeapFailure, TIpcArgs( type, aRate ) );
    }

#else /* not _DEBUG */

// ---------------------------------------------------------
// RMenu::__DbgSetAllocFail
// ---------------------------------------------------------
//
EXPORT_C void RMenu::__DbgSetAllocFail
( RAllocator::TAllocFail /*aType*/, TInt /*aRate*/ )
    {
    }

#endif /* def _DEBUG */

// ---------------------------------------------------------
// RMenu::HandleCommandL
// ---------------------------------------------------------
//
CMenuOperation* RMenu::HandleCommandL(
        CMenuItem& aItem,
        const TDesC8& aCommand,
        const TDesC8& aParams,
        TRequestStatus& aStatus )
    {
    __ASSERT_DEBUG( iData, User::Invariant() );
    if ( !iData->iHandler )
        {
        // Create handler engine on demand - handlers not loaded unless needed.
        iData->iHandler = CMenuHandlerEng::NewL( *this );
        }
    return iData->iHandler->HandleCommandL
        ( aItem, aCommand, aParams, aStatus );
    }

// ---------------------------------------------------------
// RMenu::ConnectSession
// ---------------------------------------------------------
//
TInt RMenu::ConnectSession()
    {
    TVersion version( KMenuMajorVersion, KMenuMinorVersion, KMenuBuild );
    TInt err = CreateSession( KMenuSrvName, version );
    if ( KErrNotFound == err )
        {
        err = StartServer();
        if ( !err || KErrAlreadyExists == err ) // Deal with race conditions.
            {
            err = CreateSession( KMenuSrvName, version );
            }
        }
    return err;
    }

// ---------------------------------------------------------
// RMenu::GetAttributeL
// ---------------------------------------------------------
//
HBufC* RMenu::GetAttributeL( TInt aId, const TDesC& aAttrName )
    {
    __ASSERT_DEBUG( iData, User::Invariant() );
    __ASSERT_DEBUG( sizeof( iData->iBuf ) >= 2 * KMenuMaxAttrValueLen, \
        User::Invariant() ); // Must fit into the transfer buffer.
    
    RBuf ptr;
    ptr.CleanupClosePushL();
    ptr.CreateL(KMenuMaxAttrValueLen);
    TPckgBuf<TBool> attrExists( EFalse );
    TIpcArgs args( aId, &aAttrName, &attrExists, &ptr );
    User::LeaveIfError( SendReceive( EMenuItemGetAttribute, args ) );
    
    if( attrExists() )
    	{
    	HBufC* ret = ptr.AllocL();
    	CleanupStack::PopAndDestroy( &ptr );
    	return ret;
    	}
    else
    	{
    	CleanupStack::PopAndDestroy( &ptr );
    	return NULL;
    	}
    }
    


// ---------------------------------------------------------
// RMenu::GetAttributeL
// ---------------------------------------------------------
void RMenu::GetAttributeListL( TInt aId, RArray<TAttributeName>& aList )
    {
    __ASSERT_DEBUG( iData, User::Invariant() );
    __ASSERT_DEBUG( sizeof( iData->iBuf ) >= 2 * KMenuMaxAttrValueLen, \
        User::Invariant() ); // Must fit into the transfer buffer.

    RMenuBuf buf;
    TIpcArgs args( aId );
    User::LeaveIfError( buf.Open( *this, EMenuItemGetAttributeList, args ) );
    CleanupClosePushL( buf );
    RReadStream rs( &buf );
    
    TInt len;
    TAttributeName name;
    while ( ETrue )
        {

        len = rs.ReadInt32L();

        if ( len == 0 )
            {
            break;
            }

        rs.ReadL( name, len );
        aList.AppendL( name );
        }

    CleanupStack::PopAndDestroy( &buf );
    }

// ---------------------------------------------------------
// RMenu::GetHdrL
// ---------------------------------------------------------
//
const TMenuItem& RMenu::GetHdrL( TInt aId )
    {
    __ASSERT_DEBUG( iData, User::Invariant() );
    __ASSERT_DEBUG( sizeof( iData->iBuf ) >= sizeof( TMenuItem ), \
        User::Invariant() ); // Header must fit into the transfer buffer.
    TPckg<TMenuItem> pckg( (TMenuItem&)iData->iBuf );
    TIpcArgs args( aId, &pckg );
    User::LeaveIfError( SendReceive( EMenuGetHdr, args ) );
    return pckg(); // Returned object is in the transfer buffer.
    }