/*

* Copyright (c) 2003-2005 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:       Implements API for consumer application to access Language

*                Interworking Framework. 

*

*/

#include <eikenv.h>

#include <bautils.h>    // file helpers

#include <liwservicehandler.rsg>

#include "liwmenubinding.h"

#include "liwservicehandler.h"

#include "liwservicehandlerimpl.h"

#include "liwmenu.h"

#include "liwuids.hrh"

#include "liwcommon.hrh"

#include "liwmenuslot.hrh"

#include "liwecommonitor.h"

#include "liwtlsdata.h"

#include "data_caging_path_literals.hrh"

#include "liwxmlhandler.h"

#include "liwservicedata.h"

#include <rtsecmgrscriptsession.h>

// CONSTANTS

// Max number of empty menu resource slots.

const TInt KMaxMenuResources = 16;

// This value tells how many times consumer can call InitializeMenuPaneL() without 

// closing the Options-menu.

const TInt KMaxPaneIds = KMaxMenuResources;

// The range reserved for individual menu pane.

const TInt KIndividualMenuPaneIdRange = 10000;

// The whole range that is reserved to all menu panes. Currently value is 170 000.

const TInt KMenuPaneCommandRange = (KMaxMenuResources + 1) * KIndividualMenuPaneIdRange; 

_LIT(KLiwResourceFile, "liwServiceHandler.rsc");

_LIT(KLiwZDrive, "z:");

_LIT8(KDataSeparator, "||");

_LIT(KPerExtension,".per");

const TInt KMaxMenuTitleSize = 100;

// Command id space reserved for single placeholder.

const TInt KPlaceholderCmdIdRange = 200;

const TInt KMaxLength=255;

const TReal KDefVersion = 1.0;

const TReal KUnspVersion = 0.0;

void Cleanup(TAny* aAny);

void InterestCleanup(TAny* aAny);

void IntArrayCleanup(TAny* aAny);

void FilteredCleanup(TAny* aAny);

void Int32ArrayCleanup(TAny* aAny);

void InterfaceCleanup(TAny* aAny);

_LIT8(KResolverInterface, "IResolver");

_LIT8(KResolverDomain, "ServiceManager");

_LIT8(serviceCmdSeparator, "::");

const TInt KDummySrvCmd=1;

_LIT(KCapabilityCommDD,"CDD");

_LIT(KCapabilityPowerMgmt,"PMT");

_LIT(KCapabilityMultimediaDD,"MDD");

_LIT(KCapabilityReadDeviceData,"RDD");

_LIT(KCapabilityWriteDeviceData,"WDD");

_LIT(KCapabilityDRM,"DRM");

_LIT(KCapabilityTrustedUI,"TUI");

_LIT(KCapabilityProtServ,"PSV");

_LIT(KCapabilityDiskAdmin,"DAD");

_LIT(KCapabilityNetworkControl,"NWC");

_LIT(KCapabilityAllFiles,"ALF");

_LIT(KCapabilitySwEvent,"SWE");

_LIT(KCapabilityNetworkServices,"NWS");

_LIT(KCapabilityLocalServices,"LOS");

_LIT(KCapabilityReadUserData,"RUD");

_LIT(KCapabilityWriteUserData,"WUD");

_LIT(KCapabilityLocation,"LOC");

_LIT(KCapabilitySurroundingsDD,"SDD");

_LIT(KCapabilityUserEnvironment,"USE");

using namespace LIW;

//

// LiwServiceHandler

//

CLiwServiceHandlerImpl* CLiwServiceHandlerImpl::NewL()

    {

    CLiwServiceHandlerImpl* handler = new (ELeave) CLiwServiceHandlerImpl();

    CleanupStack::PushL( handler );

    handler->ConstructL();

    CleanupStack::Pop(handler); // handler

    return handler;

    }

CLiwServiceHandlerImpl::CLiwServiceHandlerImpl()

    {

    // Nothing to do here.

    }

void CLiwServiceHandlerImpl::ConstructL()

    {

    TFileName resFile;

    TCallBack callBack(SynchronizeCallBack, this);

    iEcomMonitor = CLiwEcomMonitor::NewL(callBack);

    iCoeEnv = CCoeEnv::Static();

    RFs rFs;

    TInt err = rFs.Connect();

    TFileName dllName;

    Dll::FileName(dllName);

    TBuf<2> drive = dllName.Left(2);

    resFile.Copy(drive);

    resFile.Append(KDC_RESOURCE_FILES_DIR);

    resFile.Append(KLiwResourceFile);	

    TBool fileExists( BaflUtils::FileExists(rFs, resFile) );

    if ( ! fileExists )

    {

	resFile.Copy(KLiwZDrive);

	resFile.Append(KDC_RESOURCE_FILES_DIR);

	resFile.Append(KLiwResourceFile);

    }

    rFs.Close();

    // A Service Handler instance can be created also when CCoeEnv is not 

    // available (e.g. from server applications). In this case, the methods 

    // needing CCoeEnv/CEikonEnv will leave with KErrNotSupported.

    if(iCoeEnv)

        {

        // This is commented to avoid resource file getting locked affecting the IAD update. 

	// Also, there is no use of resource file since LIW does not support menu related services

        // iResourceOffset = iCoeEnv->AddResourceFileL(resFile);

        }

    // CLiwTlsData has a reference count so each OpenL call

    // must have a matching Close call (done in destructor).

    // OpenL is called only here, the TLS data object can be

    // referenced by calling CLiwTlsData::Instance().

    CLiwTlsData* data = CLiwTlsData::OpenL();

    iTlsDataOpened = ETrue;

    // CEikMenuPane informs all menu launch observers

    // when an options menu is launched.

    data->AddMenuLaunchObserverL( this );

    }

CLiwServiceHandlerImpl::~CLiwServiceHandlerImpl()

    {

    if (iResourceOffset && iCoeEnv)

        {

	// This is commented to avoid resource file getting locked affecting the IAD update. 

	// Also, there is no use of resource file since LIW does not support menu related services

        // iCoeEnv->DeleteResourceFile(iResourceOffset);

        }

    Reset();

    delete iEcomMonitor;

    if ( iTlsDataOpened )

        {

        CLiwTlsData* data = CLiwTlsData::Instance();

        data->RemoveMenuLaunchObserver( this );

        CLiwTlsData::Close();

        }

    }

void CLiwServiceHandlerImpl::Reset()

    {

    iInterestList.ResetAndDestroy();

    iMenuBindings.ResetAndDestroy();

    iBaseBindings.ResetAndDestroy();

    iProviders.ResetAndDestroy();

    iLastInitialized.Reset();

    iMenuPanes.ResetAndDestroy();

    delete iInParams;

    iInParams = NULL;

    delete iOutParams;

    iOutParams = NULL;

    }

void CLiwServiceHandlerImpl::AttachServiceManagerPluginsL()

{

  CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(KDummySrvCmd, KResolverInterface, KResolverDomain);

  crit->SetServiceClass(TUid::Uid(KLiwClassBase));

  RCriteriaArray a;

  a.AppendL(crit);

  AttachL(a);

  CleanupStack::Pop(crit); // crit

  a.ResetAndDestroy();

}  

void CLiwServiceHandlerImpl::ServiceManagerPlugin_ListImplementationsL(RArray<TInt32>& aArray,

                                                                       CLiwCriteriaItem* aItem)

{

  CLiwGenericParamList* inps = &(InParamListL());

  CLiwGenericParamList* outps = &(OutParamListL());

  CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(KDummySrvCmd, KResolverInterface, KResolverDomain);

  crit->SetServiceClass(TUid::Uid(KLiwClassBase));

  ExecuteServiceCmdL(*crit, *inps, *outps);  

  CleanupStack::PopAndDestroy(crit); // crit

  TInt pos = 0;

  MLiwInterface* ifp;

  const TLiwGenericParam* p = outps->FindFirst(pos, KResolverInterface, EVariantTypeInterface);

  if (p) {

    ifp = p->Value().AsInterface();

    CleanupStack::PushL(TCleanupItem(InterfaceCleanup, ifp));

  }

  else

    return;

  outps->Reset();

  inps->Reset();

  _LIT8(KId,"id");

  _LIT8(KCmd,"cmd");

  _LIT8(KCmdStr,"cmd_str");

  _LIT8(KType,"type");

  _LIT8(KListImpl,"ListImplementations");

  inps->AppendL(TLiwGenericParam(KId, TLiwVariant(aItem->Id())));

  inps->AppendL(TLiwGenericParam(KCmd, TLiwVariant(aItem->ServiceCmd())));

  inps->AppendL(TLiwGenericParam(KCmdStr, TLiwVariant(aItem->ServiceCmdStr())));

  inps->AppendL(TLiwGenericParam(KType, TLiwVariant(aItem->ContentType())));

  ifp->ExecuteCmdL(KListImpl, *inps, *outps);

  pos = 0;

  p = outps->FindFirst(pos, EGenericParamError);

  if (p && (p->Value().AsTInt32() == KErrNone)) {

    pos = 0;

    const CLiwList* list;

    _LIT8(KIdList,"id_list");

    p = outps->FindFirst(pos, KIdList, EVariantTypeList);

    if (p) {

      list = p->Value().AsList();

      for (TInt i = 0; i < list->Count(); i++) {

        TLiwVariant v;

        v.PushL();

        list->AtL(i, v);

        aArray.AppendL(v.AsTInt32());

        CleanupStack::Pop(&v);

        v.Reset();

      }

    }

  }

  CleanupStack::Pop(ifp); // ifp

  ifp->Close();

}

CLiwServiceIfBase* CLiwServiceHandlerImpl::ServiceManagerPlugin_CreateImplementationL(TInt32 aImplUid)

{

  CLiwGenericParamList* inps = &(InParamListL());

  CLiwGenericParamList* outps = &(OutParamListL());

  CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(KDummySrvCmd, KResolverInterface, KResolverDomain);

  crit->SetServiceClass(TUid::Uid(KLiwClassBase));

  ExecuteServiceCmdL(*crit, *inps, *outps);  

  CleanupStack::PopAndDestroy(crit); // crit

  TInt pos = 0;

  MLiwInterface* ifp = NULL;

  const TLiwGenericParam* p = outps->FindFirst(pos, KResolverInterface, EVariantTypeInterface);

  if (p) {

    ifp = p->Value().AsInterface();

    CleanupStack::PushL(TCleanupItem(InterfaceCleanup, ifp));

  }

  else

    User::Leave(KErrNotFound);

  outps->Reset();

  inps->Reset();

  _LIT8(KUid,"uid");

  _LIT8(KCreateImpl,"CreateImplementation");

  inps->AppendL(TLiwGenericParam(KUid, TLiwVariant(aImplUid)));

  ifp->ExecuteCmdL(KCreateImpl, *inps, *outps);

  pos = 0;

  p = outps->FindFirst(pos, EGenericParamError);

  User::LeaveIfError(p->Value().AsTInt32());

  pos = 0;

  CLiwServiceIfBase* iface = NULL;

  _LIT8(KImplPtr, "impl_ptr");

  p = outps->FindFirst(pos, KImplPtr, EVariantTypeDesC8);

  if (p) {

    TPtrC8 buf = p->Value().AsData();

    if (buf.Size() == sizeof(iface))

      Mem::Copy(&iface, buf.Ptr(), buf.Size());

    else

      User::Leave(KErrNotFound);

  }

  else

    User::Leave(KErrNotFound);

  CleanupStack::Pop(ifp); // ifp

  ifp->Close();

  return iface;

}

void CLiwServiceHandlerImpl::ListProvidersForCriteriaL(RArray<TInt>& aResult, 

    CLiwCriteriaItem& aItem)

    {

    TInt i;

    for (i = 0; i < iProviders.Count(); i++)

        {   

        if (iProviders[i]->HasCriteria(aItem))

            {

            User::LeaveIfError(aResult.Append(iProviders[i]->ImplementationUid().iUid));

            }

        }

    }

TInt CLiwServiceHandlerImpl::NbrOfProviders(const CLiwCriteriaItem* aCriteria)

    {

    if(!aCriteria)

        {

        return 0;

        }

    TInt i, j;

    for (i = 0; i < iBaseBindings.Count(); i++)

        {

        for (j = 0; j < iBaseBindings[i]->Interest().Count(); j++)

            {

            if ((*iBaseBindings[i]->Interest()[j]) == (*aCriteria))

                {

                return iBaseBindings[i]->NumberOfProviders();

                }

            }

        }

    for (i = 0; i < iMenuBindings.Count(); i++)

        {

        for (j = 0; j < iMenuBindings[i]->Interest().Count(); j++)

            {

            if ((*iMenuBindings[i]->Interest()[j]) == (*aCriteria))

                {

                return iMenuBindings[i]->NumberOfProviders();

                }

            }       

        }

    return 0;

    }

void CLiwServiceHandlerImpl::AttachL(TInt aInterestResourceId)

    {

    // CCoeEnv/CEikonEnv needs to be accessible.

    if(!iCoeEnv)

        {

        User::Leave(KErrNotSupported);

        }

    RCriteriaArray interest, filtered;

    CleanupStack::PushL( TCleanupItem( InterestCleanup, &interest ) );

    CleanupStack::PushL( TCleanupItem( FilteredCleanup, &filtered ) );

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC(reader, aInterestResourceId);

    ReadInterestListL(reader, interest);

    CleanupStack::PopAndDestroy(); //reader

    FilterInterestListL(interest, filtered);

    DoAttachL(filtered,NULL);

    filtered.Reset();

    CleanupStack::Pop(&filtered); // filtered

    CleanupStack::Pop(&interest); // interest

    }

TInt CLiwServiceHandlerImpl::AttachL(const RCriteriaArray& aInterest)

    {

    	return (this->AttachL(aInterest,NULL));

    }

TInt CLiwServiceHandlerImpl::AttachL(const RCriteriaArray& aInterest ,CRTSecMgrScriptSession* aSecMgrScriptSession)

    {

    RCriteriaArray interest, filtered;

    CleanupStack::PushL( TCleanupItem( InterestCleanup, &interest ) );

    CleanupStack::PushL( TCleanupItem( FilteredCleanup, &filtered ) );

    for(TInt i = 0; i < aInterest.Count(); i++)

        {

        CLiwCriteriaItem* item = CLiwCriteriaItem::NewLC();

        item->SetId(               aInterest[i]->Id()                    );

        if (aInterest[i]->ServiceCmd() == KLiwCmdAsStr)

          item->SetServiceCmdL(    aInterest[i]->ServiceCmdStr()         );

        else

          item->SetServiceCmd(     aInterest[i]->ServiceCmd()            );

        item->SetContentTypeL(     aInterest[i]->ContentType()           );

        item->SetServiceClass(     aInterest[i]->ServiceClass()          );

        item->SetOptions(          aInterest[i]->Options()               );

		//Setting the imetadataOptions of item

		TLiwVariant metadataOption;

		metadataOption.PushL();

        aInterest[i]->GetMetaDataOptions(metadataOption);

		item->SetMetaDataOptions(metadataOption);

		metadataOption.Reset();

        item->SetDefaultProvider( (aInterest[i]->DefaultProvider()).iUid );

        item->SetMaxProviders(     aInterest[i]->MaxProviders()          ); 

        User::LeaveIfError(interest.Append(item));

        CleanupStack::Pop(&metadataOption); 

        CleanupStack::Pop(item); 

        }

    FilterInterestListL(interest, filtered);        

	TInt result = DoAttachL(filtered,aSecMgrScriptSession);

    filtered.Reset();

    CleanupStack::Pop(&filtered); // filtered

    CleanupStack::Pop(&interest); // interest

    return result;

    }

TInt CLiwServiceHandlerImpl::DoAttachL(const RCriteriaArray& aInterest,CRTSecMgrScriptSession* aSecMgrScriptSession)

    {

    CLiwBinding* bind;

    TInt success = -1;

    for (TInt i = 0; i < aInterest.Count(); i++)

        {

        bind = CLiwBinding::NewLC();

        success = ResolveProvidersL(bind, aInterest[i],aSecMgrScriptSession);

        if (success == KLiwServiceLoadSuccess)

            {

            User::LeaveIfError(iBaseBindings.Append( bind ));

            CleanupStack::Pop(bind); // bind

            bind->AddCriteriaL(aInterest[i]);

            // Initialise providers.

            for (TInt k = 0; k < bind->NumberOfProviders(); k++)

                {

                // Trap the initialisation. If not done, a leaving provider

                // could prevent the initialisation of other providers.

                TRAPD(err, bind->BaseProvider(k)->InitialiseL(*this, bind->Interest()));

                if(err)

                    {

#ifdef _DEBUG                    

                    RDebug::Print(_L("LIW PROVIDER ERROR: CLiwServiceIfBase::InitialiseL() failed, leave code:%d"), err);

#endif                    

                    }

                }

            }

        else

            {

            CleanupStack::PopAndDestroy(bind); // bind

            }

        }

    	return success; // returns status of 'n'th criteria in interest