/*
* Copyright (c) 2007 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:  Batch ext plugin implementation
*
*/


#include "alfbatchextplugin.h"
#include "alfbatchextpluginconstants.h"
#include <implementationproxy.h>
#include <alf/alfconstants.h>
#include <alf/alflayouthandlers.h>

class CAlfBatchExtPluginExtension : public CBase, public MAlfExtension
    {
    public:
        ~CAlfBatchExtPluginExtension();
        virtual void Release();
        virtual TAny* GetInterface( const THuiInterfaceSupport& aInterface );
        virtual void HandleCmdL( TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse );
    private:
        RArray<TInt> iReceived;
    };

MAlfExtension* TAlfBatchExtPlugin::CreateExtensionL(
        const TInt aObjectId, 
        const TDesC8& /*aInitialParams*/, 
        MAlfInterfaceProvider& /*aResolver*/ )
    {
    MAlfExtension* result = 0;
    switch( aObjectId )
        {
        case EAlfBatchExtPluginCreateExtension:
            {
            result = new (ELeave) CAlfBatchExtPluginExtension;
            break;
            }  

        default:
            User::Leave( KErrNotSupported );
        }
    return result;
    }

void TAlfBatchExtPlugin::Release()
    {
    delete this;
    }

CAlfBatchExtPluginExtension::~CAlfBatchExtPluginExtension()
    {
    iReceived.Close();
    }

void CAlfBatchExtPluginExtension::Release()
    {
    delete this;
    }

TAny* CAlfBatchExtPluginExtension::GetInterface( const THuiInterfaceSupport& /*aInterface*/ )
    {
    return NULL;
    }

void CAlfBatchExtPluginExtension::HandleCmdL( TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse )
    {
    switch ( aCommandId )
        {
        case EAlfBatchExtensionCmdReset:
            iReceived.Close();
            break;

        case EAlfBatchExtensionCmdGetCount:
            {
            TPckgBuf<TInt> countPckg( iReceived.Count() );
            aResponse.Copy( countPckg );
            }
            break;

        case EAlfBatchExtensionCmdGetIndex:
            {
            TInt* param = (TInt*)aInputBuffer.Ptr();

            if ( *param >= 0 && *param < iReceived.Count() )
                {
                TPckgBuf<TInt> result( iReceived[ *param ] );
                aResponse.Copy( result );
                }
            else
                {
                User::Leave( KErrArgument );
                }
            }
            break;

        case EAlfBatchExtensionCmdInteger:
            {
            TInt* param = (TInt*)aInputBuffer.Ptr();
            iReceived.AppendL( *param );
            }
            break;

        case EAlfBatchExtensionCmdReal:
            {
            TReal32* param = (TReal32*)aInputBuffer.Ptr();
            TInt asInteger = *param;
            iReceived.AppendL( asInteger );
            }
            break;

        case EAlfBatchExtensionCmdNotSupported:
            User::Leave( KErrNotSupported );
            break;

        default:
            {
            if ( aCommandId >= EAlfBatchExtensionCmdBufferMin && 
                 aCommandId <= EAlfBatchExtensionCmdBufferMax )
                {
                const TInt length = aCommandId - EAlfBatchExtensionCmdBufferMin;
                
                if ( aInputBuffer.Length() == length )
                    {
                    for ( TInt ii = 0; ii < length; ii++ )
                        {
                        TUint8 val = (TUint8)ii;
                        if ( aInputBuffer[ ii ] != val )
                            {
                            User::Leave( KErrArgument );
                            }
                        }
                    iReceived.AppendL( aCommandId );
                    }
                else
                    {
                    User::Leave( KErrArgument );
                    }
                }
            else
                {
                User::Leave( KErrNotSupported );
                }
            }
            break;
        }
    }

// Global functions:

MAlfExtensionFactory* Instance()
    {
    TAlfBatchExtPlugin* me = NULL;
    me = new TAlfBatchExtPlugin;
    return me;
    }

const TImplementationProxy ImplementationTable[] =
    {
#ifdef __EABI__
    {{KAlfBatchExtPluginImplementationId}, (TFuncPtr)Instance}
#else
    {{KAlfBatchExtPluginImplementationId}, Instance}
#endif
    };

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
    {
    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy) ;
    return ImplementationTable;
    }