/*

* 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 "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 Application

*                Interworking Framework. 

*

*/

#include <eikenv.h>

#include <aiwservicehandler.rsg>

#include <eikon.hrh>

#include "AiwMenuBinding.h"

#include "AiwServiceHandlerImpl.h"

#include "AiwMenu.h"

#include "AiwUids.hrh"

#include "AiwCommon.hrh"

#include "AiwMenuSlot.hrh"

#include "AiwEcomMonitor.h"

#include "AiwTlsData.h"

#include "data_caging_path_literals.hrh"

// 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(KAiwResourceFile, "AiwServiceHandler.rSC");

_LIT(KAiwZDrive, "z:");

const TInt KMaxMenuTitleSize = 100;

// Command id space reserved for single placeholder.

const TInt KPlaceholderCmdIdRange = 200;

void Cleanup(TAny* aAny);

void InterestCleanup(TAny* aAny);

void IntArrayCleanup(TAny* aAny);

void FilteredCleanup(TAny* aAny);

//

// AiwServiceHandler

//

CAiwServiceHandlerImpl* CAiwServiceHandlerImpl::NewL()

    {

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

    CleanupStack::PushL( handler );

    handler->ConstructL();

    CleanupStack::Pop(); // handler

    return handler;

    }

CAiwServiceHandlerImpl::CAiwServiceHandlerImpl()

    {

    // Nothing to do here.

    }

void CAiwServiceHandlerImpl::ConstructL()

    {

    TFileName resFile;

    TCallBack callBack(SynchronizeCallBack, this);

    iEcomMonitor = CAiwEcomMonitor::NewL(callBack);

    resFile.Copy(KAiwZDrive);

    resFile.Append(KDC_RESOURCE_FILES_DIR);

    resFile.Append(KAiwResourceFile);

    iCoeEnv = CCoeEnv::Static();

    // 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)

        {

        iResourceOffset = iCoeEnv->AddResourceFileL(resFile);

        }

    // CAiwTlsData 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 CAiwTlsData::Instance().

    CAiwTlsData* data = CAiwTlsData::OpenL();

    iTlsDataOpened = ETrue;

    // CEikMenuPane informs all menu launch observers

    // when an options menu is launched.

    data->AddMenuLaunchObserverL( this );

    }

CAiwServiceHandlerImpl::~CAiwServiceHandlerImpl()

    {

    if (iResourceOffset && iCoeEnv)

        {

        iCoeEnv->DeleteResourceFile(iResourceOffset);

        }

    Reset();

    delete iEcomMonitor;

    if ( iTlsDataOpened )

        {

        CAiwTlsData* data = CAiwTlsData::Instance();

        data->RemoveMenuLaunchObserver( this );

        CAiwTlsData::Close();

        }

    }

void CAiwServiceHandlerImpl::Reset()

    {

    iInterestList.ResetAndDestroy();

    iMenuBindings.ResetAndDestroy();

    iBaseBindings.ResetAndDestroy();

    iProviders.ResetAndDestroy();

    iLastInitialized.Reset();

    iMenuPanes.ResetAndDestroy();

    delete iInParams;

    iInParams = NULL;

    delete iOutParams;

    iOutParams = NULL;

    }

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

    CAiwCriteriaItem& aItem)

    {

    TInt i;

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

        {   

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

            {

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

            }

        }

    }

TInt CAiwServiceHandlerImpl::NbrOfProviders(const CAiwCriteriaItem* 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 CAiwServiceHandlerImpl::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);

    filtered.Reset();

    CleanupStack::Pop(); // filtered

    CleanupStack::Pop(); // interest

    }

void CAiwServiceHandlerImpl::AttachL(const RCriteriaArray& aInterest)

    {

    RCriteriaArray interest, filtered;

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

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

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

        {

        CAiwCriteriaItem* item = CAiwCriteriaItem::NewLC();

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

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

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

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

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

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

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

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

        CleanupStack::Pop(item); 

        }

    FilterInterestListL(interest, filtered);        

    DoAttachL(filtered);

    filtered.Reset();

    CleanupStack::Pop(); // filtered

    CleanupStack::Pop(); // interest

    }

void CAiwServiceHandlerImpl::DoAttachL(const RCriteriaArray& aInterest)

    {

    CAiwBinding* bind;

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

        {

        bind = CAiwBinding::NewLC();

        if (ResolveProvidersL(bind, aInterest[i]))

            {

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

            CleanupStack::Pop(); // 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("AIW PROVIDER ERROR: CAiwServiceIfBase::InitialiseL() failed, leave code:%d"), err);

#endif                    

                    }

                }

            }

        else

            {

            CleanupStack::PopAndDestroy(); // bind

            }

        }

    }

void CAiwServiceHandlerImpl::GetInterest(RCriteriaArray& aInterest)

    {

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

        {

        if (aInterest.Append(iInterestList[i]) != KErrNone)

            {

            return;

            }

        }

    }

void CAiwServiceHandlerImpl::DetachL(const RCriteriaArray& aInterest)

    {

    // First, remove relevant criteria items from relevat base bindings.

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

        {

        for (TInt j = 0; j < iBaseBindings.Count(); j++)

            {

            TInt index = iBaseBindings[j]->HasCriteriaItem(*aInterest[i]);

            if (index != KErrNotFound)

                {

                iBaseBindings[j]->RemoveCriteria(index);

                }                           

            }

        }

    // Second pass removes empty bindings.

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

        {

        if (iBaseBindings[i]->Interest().Count() == 0)

            {

            delete iBaseBindings[i];

            iBaseBindings.Remove(i);

            i--;

            }

        }

    // Then check if there were left obselete criteria items and remove them.   

    RemoveObsoleteCriteriaItems();

    // Finally check if there were left obselete providers and remove them.

    }

void CAiwServiceHandlerImpl::DetachL(TInt aInterestResourceId)

    { 

    // CCoeEnv/CEikonEnv needs to be accessible.

    if(!iCoeEnv)

        {

        User::Leave(KErrNotSupported);

        }

    RCriteriaArray interest;

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

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC(reader, aInterestResourceId);

    ReadInterestListL(reader, interest);

    CleanupStack::PopAndDestroy(); // reader

    DetachL( interest );

    interest.ResetAndDestroy();

    CleanupStack::Pop(); // interest

    }

const CAiwCriteriaItem* CAiwServiceHandlerImpl::GetCriteria(TInt aId)

    {

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

        {

        if (iInterestList[i]->Id() == aId)

            {

            return iInterestList[i];

            }

        }

    return NULL;  

    }

TInt CAiwServiceHandlerImpl::NumAlreadyInitializedPaneIdsL() const

    {

    TInt ret = 0;

    TInt paneIds[KMaxPaneIds] = {0};

    TBool found = EFalse;

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

        {

        found = EFalse;

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

            {

            if (iLastInitialized[i]->MenuResourceId() == paneIds[j])

                {

                found = ETrue;

                break;              

                }

            }

        if (!found) 

            {

            // Create new item.

            if (ret >= KMaxPaneIds)

                {

#ifdef _DEBUG

                RDebug::Print(_L("ERROR: OVERFLOW in CAiwServiceHandlerImpl::NumAlreadyInitializedPaneIdsL()"));

#endif

                User::Leave(KErrOverflow);

                }

            paneIds[ret] = iLastInitialized[i]->MenuResourceId();

            ret++;

            }                       

        }

    return ret;         

    }    

void CAiwServiceHandlerImpl::InitializeMenuPaneL(

    CEikMenuPane& aMenuPane,

    TInt aMenuResourceId, 

    TInt aBaseMenuCmdId,

    const CAiwGenericParamList& aInParamList)

    {

    InitializeMenuPaneL(aMenuPane, aMenuResourceId, aBaseMenuCmdId, 

        aInParamList, EFalse, EFalse);    

    }        

void CAiwServiceHandlerImpl::InitializeMenuPaneL(

    CEikMenuPane& aMenuPane,

    TInt aMenuResourceId, 

    TInt aBaseMenuCmdId,

    const CAiwGenericParamList& aInParamList,

    TBool aUseSubmenuTextsIfAvailable)

    {

    InitializeMenuPaneL(aMenuPane, aMenuResourceId, aBaseMenuCmdId, aInParamList, aUseSubmenuTextsIfAvailable, EFalse);

    }