/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  CSysinfoInterface class implementation

*

*/

//INCLUDES

#include <e32math.h>

#include <liwcommon.h>

#include <liwgenericparam.h> 

#include <numberconversion.h>

#include <PtiEngine.h>

#include "errormsgs.h"

#include "sysinfointerface.h"

#include "sysinfoservice.h"

#include "sysinfoobserver.h"

#include "../../inc/serviceerrno.h"

#include "sysinfoaiwparams.hrh"

#include "sysinfocallbackmap.h"

#include "sysinfolists.h"

using namespace LIW;

using namespace sysinfoaiwparams;

const TUint KMax64BitNumLen(24);

const TInt  KMaxVersionTxt = 10;

const TInt  KMinArgumentCount = 2;

const TInt  KMaxCommandName = 32;

_LIT(KDriveSeperator,":\\");

const TInt KMaxDriveLength = 5;

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

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

// CSysInfoInterface::NewL()

// Two-phased constructor.

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

//

CSysInfoInterface* CSysInfoInterface::NewL()

    {

    CSysInfoInterface* self = new (ELeave) CSysInfoInterface();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CSysInfoInterface::~CSysInfoInterface()

// Destructor.

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

//

CSysInfoInterface::~CSysInfoInterface()

    {

    delete iService;

    delete iObserver;        

    TInt count = iCallbackMap.Count();

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

        {

        delete(iCallbackMap[i]);

        }

    iCallbackMap.Close();

    }

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

// CSysInfoInterface::CSysInfoInterface()

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

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

//

CSysInfoInterface::CSysInfoInterface()

    {

    }

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

// CLandmarkFilter::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CSysInfoInterface::ConstructL()

    {

    //instantiate the service class

    iService = CSysInfoService::NewL();

    //instantiate observer to handle async requests.

    iObserver = CSysInfoObserver::NewL(this);

    }

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

// CSysInfoInterface::ExecuteCmdL( const TDesC8& aCmdName,

//                           const CLiwGenericParamList& aInParamList,

//                           CLiwGenericParamList& aOutParamList,

//                           TUint aCmdOptions,

//                           MLiwNotifyCallback* aCallback )

// This function is called by the user to handle the service commands.

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

//

void CSysInfoInterface::ExecuteCmdL( const TDesC8& aCmdName,

                                    const CLiwGenericParamList& aInParamList,

                                    CLiwGenericParamList& aOutParamList,

                                    TUint aCmdOptions,

                                    MLiwNotifyCallback* aCallback )

    {

    TInt err(KErrNone);

    iErrBuf.FillZ(0);

    iErrBuf.Append(KModuleName);

    TBuf<KMaxCommandName> CommandName; 

    if( aCmdName.Length() < KMaxCommandName )

        {

        CommandName.Copy( aCmdName ); 

        iErrBuf.Append(CommandName);

        iErrBuf.Append(KColon);

        //check if any of the service API's leave

        TRAP(err,SwitchCmdL(aCmdName,aInParamList,aOutParamList,

        aCmdOptions,aCallback));

        }

    else

        {

        err = SErrInvalidServiceArgument;

        iErrBuf.Append(SErrInvalidServiceArgument);

        }

    TInt SapiErr = SErrNone;

    if (err)

        {

        aOutParamList.AppendL(TLiwGenericParam( KErrorMsg, TLiwVariant(iErrBuf)));

        SapiErr = SapiError(err);

        }

    aOutParamList.AppendL(TLiwGenericParam(KErrorCode,TLiwVariant((TInt32)SapiErr)));

    }

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

// CSysInfoInterface::SapiError( )

// This function is called by the user to get mapped SAPI generic error code

// from symbian error codes .

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

//

TInt CSysInfoInterface::SapiError( TInt aSymbianErr )

    {

    TInt sapiErr(SErrGeneralError);

    switch (aSymbianErr)

        {

        case KErrBadName:			

        case KErrArgument:			

            {

            sapiErr = SErrBadArgumentType;

            break;

            }

        case KErrLanguageNotFound:

        case KErrNotSupported:

            {

            sapiErr = SErrServiceNotSupported;

            break;

            }   		

        case KErrInUse:	

            {

            sapiErr = SErrServiceInUse;

            break;

            }

        case KErrAccessDenied:

            {

            sapiErr = SErrAccessDenied;

            break;

            }   		

        case KErrAlreadyExists:

            {

            sapiErr = SErrEntryExists;

            break;

            }

        case KErrNotReady:

            {

            sapiErr = SErrServiceNotReady;

            break;

            }

        case KErrNotFound:

            {

            sapiErr = SErrNotFound;

            break;

            }

        case KErrPathNotFound:

            {

            sapiErr = SErrPathNotFound;

            break;

            }

        case SErrMissingArgument:

            {

            sapiErr = SErrMissingArgument;

            break;

            }

        case SErrInvalidServiceArgument:

            {

            sapiErr = SErrInvalidServiceArgument;

            break;

            }

        }

    return sapiErr;

    }

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

// CSysInfoInterface::Close( )

// This function is called by the user to close the interface.

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

//

void CSysInfoInterface::Close()

    {

    delete this;

    }

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

// CSysInfoInterface::GetCallbackAndRemove( TInt32 aTransactionId )

// This function returns the callback for the given transaction id and 

// removes it from the list.

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

//

MLiwNotifyCallback* CSysInfoInterface::GetCallbackAndRemove( TInt32 aTransactionId )

    {

    TInt count = iCallbackMap.Count();

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

        {

        MLiwNotifyCallback* callback;

        if ( iCallbackMap[i]->Get(aTransactionId,callback) )

            {        		

            delete(iCallbackMap[i]);

            iCallbackMap.Remove(i);

            return callback;

            }        

        }    

    return NULL;

    }

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

// CSysInfoInterface::GetCallback( TInt32 aTransactionId )

// This function returns the callback for the given transaction id

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

//

MLiwNotifyCallback* CSysInfoInterface::GetCallback( TInt32 aTransactionId )

    {

    TInt count = iCallbackMap.Count();

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

        {

        MLiwNotifyCallback* callback;

        if ( iCallbackMap[i]->Get(aTransactionId,callback) )

            {        		

            return callback;

            }        

        }

    return NULL;

    }

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

// CSysInfoInterface::SwitchCmdL( const TDesC8& aCmdName,

//                           const CLiwGenericParamList& aInParamList,

//                           CLiwGenericParamList& aOutParamList,

//                           TUint aCmdOptions,

//                           MLiwNotifyCallback* aCallback )

// This function calls the appropriate functions based on the command id.

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

//

void CSysInfoInterface::SwitchCmdL( const TDesC8& aCmdName,

                                    const CLiwGenericParamList& aInParamList,

                                    CLiwGenericParamList& aOutParamList,

                                    TUint aCmdOptions,

                                    MLiwNotifyCallback* aCallback )

    {

    if ( ( (KLiwOptASyncronous & aCmdOptions) && !aCallback) ||

            ( !((KLiwOptASyncronous|KLiwOptCancel) & aCmdOptions) && aCallback) )

        {

        iErrBuf.Append(KErrInCorrectSyncAsyncRequest);

        User::Leave(KErrArgument);        	

        }

    if ( aCmdName == KCancel && (KLiwOptCancel & aCmdOptions) )

        {

        CancelL (aInParamList, aOutParamList, aCmdOptions, aCallback );

        }

    else if ( !aCmdName.Compare(KGetInfo) )

        {

        GetInfoL(aInParamList,aOutParamList,aCmdOptions,aCallback);

        }

    else if ( !aCmdName.Compare(KSetInfo) )

        {

        if( aCallback )

            {

            iErrBuf.Append(KErrASyncVersionNotSupported);

            User::Leave(KErrArgument);        	

            }

        SetInfoL(aInParamList);

        }

    else if ( !aCmdName.Compare(KGetNotification) )

        {

        if( !aCallback )

            {

            iErrBuf.Append(KErrSyncVersionNotSupported);

            User::Leave(KErrArgument);        	

            }

        GetNotificationL(aInParamList,aOutParamList,aCmdOptions,aCallback);

        }

    else

        {

        // invalid command return error in outparam list

        iErrBuf.Append(KErrCmdNotSupported);

        User::Leave(KErrNotSupported);

        }

    }

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

// CSysInfoInterface::SetInfoL( const TDesC8& aCmdName,

//                           const CLiwGenericParamList& aInParamList,

//                           CLiwGenericParamList& aOutParamList,

//                           TUint aCmdOptions,

//                           MLiwNotifyCallback* aCallback )

// This function reads input params and calls core class SetInfoL function.

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

//

void CSysInfoInterface::SetInfoL(const CLiwGenericParamList& aInParamList)

    {

    TPtrC entity,key;

    CSysData* insysdata=NULL;

    ReadInputParamsL(aInParamList,entity,key,insysdata);

    //insysdata must be specified for setinfo operation.

    if(!insysdata)

        {

        iErrBuf.Append(KErrSystemDataMissing);

        User::Leave(SErrMissingArgument);

        }

    CleanupStack::PushL(insysdata);

    iService->SetInfoL(entity,key,insysdata);

    CleanupStack::PopAndDestroy(insysdata);

    }

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

// CLandmarkInterface::GetInfoL(const CLiwGenericParamList& aInParamList,

//                           CLiwGenericParamList& aOutParamList,

//                           TUint aCmdOptions,

//                           MLiwNotifyCallback* aCallback )

// This function parses input params and calls sync/async version of 

// core class GetInfoL function.

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

//

void CSysInfoInterface::GetInfoL( const CLiwGenericParamList& aInParamList,

                                        CLiwGenericParamList& aOutParamList, 

                                        TUint /*aCmdOptions*/,

                                        MLiwNotifyCallback* aCallback )

    {

    TPtrC entity,key;

    CSysData* insysdata=NULL;

    //Get entity,key and insysdata.

    ReadInputParamsL(aInParamList,entity,key,insysdata);

    CleanupStack::PushL(insysdata);

    //Async Call

    if ( aCallback )

        {

        //Get the transaction ID

        TInt32 transactionId(aCallback->GetTransactionID());

        CSysInfoCallbackMap* map = new (ELeave) CSysInfoCallbackMap(transactionId,aCallback);

        CleanupStack::PushL(map);

        iCallbackMap.AppendL(map);

        CleanupStack::Pop(map);

        iService->GetInfoL(entity,key,transactionId,iObserver,insysdata);

        aOutParamList.AppendL(TLiwGenericParam(KTransactionId,TLiwVariant(TInt32(transactionId))));

        }

    else

        {

        CSysData* outsysdata = NULL;

        iService->GetInfoL(entity,key,outsysdata,insysdata);

        //after this call outsysdata shouldn't be NULL.

        if(!outsysdata)

            {

            iErrBuf.Append(KErrReadingGetInfo);

            User::Leave(SErrGeneralError);

            }

        CleanupStack::PushL(outsysdata);

        //convert outsysdata into a liwmap.

        CLiwMap* outmapparam=NULL;

        CSysInfoInterface::ConvertSysData2AiwParamL(outsysdata,outmapparam);

        if((outsysdata->DataType() == CSysData::EAccessoryList) || 

            (outsysdata->DataType() == CSysData::EConnectionList))

            CleanupStack::Pop(outsysdata);

        else

            CleanupStack::PopAndDestroy(outsysdata);

        CleanupClosePushL(*outmapparam);

        // append entity and key.

        outmapparam->InsertL(KEntity,entity);

        outmapparam->InsertL(KKey,key);

        aOutParamList.AppendL(TLiwGenericParam(KReturnValue,TLiwVariant(outmapparam)));

        CleanupStack::PopAndDestroy(outmapparam);

        }

    CleanupStack::PopAndDestroy(insysdata);

    }

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

// CLandmarkInterface::GetNotificationL(const CLiwGenericParamList& aInParamList,

//                           CLiwGenericParamList& aOutParamList,

//                           TUint aCmdOptions,

//                           MLiwNotifyCallback* aCallback )

// This function parses input params and calls core class GetNotificationL 

// function.

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

//

void CSysInfoInterface::GetNotificationL( const CLiwGenericParamList& aInParamList,

                                            CLiwGenericParamList& aOutParamList, 

                                            TUint /*aCmdOptions*/,

                                            MLiwNotifyCallback* aCallback )

    {

	TPtrC entity,key;

	CSysData* insysdata=NULL;

	ReadInputParamsL(aInParamList,entity,key,insysdata);

	CleanupStack::PushL(insysdata);

    //Get the transaction ID

    TInt32 transactionId(aCallback->GetTransactionID());

    CSysInfoCallbackMap* map = new (ELeave) CSysInfoCallbackMap(transactionId,aCallback);

    CleanupStack::PushL(map);

    iCallbackMap.AppendL(map);

    CleanupStack::Pop(map);

    iService->GetNotificationL(entity,key,transactionId,iObserver,insysdata);

    aOutParamList.AppendL(TLiwGenericParam(KTransactionId,TLiwVariant(TInt32(transactionId))));

	CleanupStack::PopAndDestroy(insysdata);

    }

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

// CLandmarkInterface::ReadInputParamsL(const CLiwGenericParamList& aInParamList,

//                           TPtrC& aEntity,TPtrC& aKey,

//                           const CSysData*& aSysData)

// This function parses input params.

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

//

void CSysInfoInterface::ReadInputParamsL(const CLiwGenericParamList& aInParamList,

                                        TPtrC& aEntity,TPtrC& aKey,

                                        CSysData*& aSysData)

    {

    aSysData = NULL;

    //position to start search in input params.

    TInt index = 0;

    //Atleast Entity Key must be specified in input list.

    if ( aInParamList.Count() < KMinArgumentCount )

        {

        //leave since argument is improper

        iErrBuf.Append(KErrInsufficientArgs);

        User::Leave(SErrMissingArgument);

        }

    const TLiwGenericParam* param = &aInParamList[EIndex0];

    if ( param->Name() == KNullDesC8 )

        {

        //Position based parsing

        aEntity.Set(aInParamList[EIndex0].Value().AsDes());

        if(!(aEntity.Length()))

            {

            iErrBuf.Append(KErrEntityMissing);

            User::Leave(SErrMissingArgument);

            }

        aKey.Set(aInParamList[EIndex1].Value().AsDes());

        if(!(aKey.Length()))

            {

            iErrBuf.Append(KErrKeyMissing);

            User::Leave(SErrMissingArgument);

            }

        if( aInParamList.Count()>KMinArgumentCount )

            {

            const TLiwGenericParam aInputData = aInParamList[EIndex2]; 

            Convert2SysDataL(aInputData,aSysData);

            }

        }

    else

        {

        //Name based parsing

        //check for Entity.

        index = 0;

        param = aInParamList.FindFirst(index,KEntity);

        if( param )

            {

            aEntity.Set(param->Value().AsDes());

            }

        else

            {

            iErrBuf.Append(KErrEntityMissing);

            User::Leave(SErrMissingArgument);

            }

        //check for Key.

        index = 0;

        param = aInParamList.FindFirst(index,KKey);

        if(param)

            {

            aKey.Set(param->Value().AsDes());

            }

        else

            {

            iErrBuf.Append(KErrKeyMissing);

            User::Leave(SErrMissingArgument);

            }

        //check for SysData.

        index = 0;

        const TLiwGenericParam* aInputData = aInParamList.FindFirst(index,KSysData);

        if(aInputData)

            {

            Convert2SysDataL(*aInputData,aSysData);