{

    TUid iFromUid;

    TUid iToUid;

    };

                                          const TThreadId& aThreadId,

                                          const TDesC& aBackgroundFilename, 

                                          const TDesC& aItemFilename,

                                          TInt aCachePriority, 

                                          TInt aWantedTime , TInt aMinTime )

    aCachePriority = 1;

    // For now, the cache priority is always 1 at registration time, and after

    // fetching the KML information from the policy, it gets set to 0. This is

    // used to trigger eviction from the KML cache. Newly registered KML:s have

    // priority over existing...

    CListBoxPolicy* policy = CListBoxPolicy::NewL( aUid, 

                                                   aThreadId, 

                                                   aListBoxType,

                                                   aResourceDir, 

    CleanupStack::PushL( policy );

    TInt spec = policy->Specificity();  

    TInt count = iListBoxPolicies.Count();

    TInt uid = aUid.iUid;

    TInt i;

    // This keeps the list with ListBox KMLs sorted after specifity, 

    // High specificity is in the beginning of the list and low at the end.

    // This means that when getting a ListBox KML it will find the more specified

    // values first. A Uid counts as more specific than a TListBoxType.

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

        {

        CListBoxPolicy* curr = iListBoxPolicies[i];

        TInt currspec = curr->Specificity();

        if ( uid == curr->Uid().iUid && aListBoxType == curr->ListBoxType() )

            {

            // Duplicate policy, delete the old one.

            iListBoxPolicies.Remove( i );

            delete curr;

            break;

            }

        else if ( spec > currspec )

            {

            break;

            }

        }

    }

    {

    __ALFFXLOGSTRING1("CPolicyHandler::UnregisterListBoxKml - Uid: 0x%x >>", aUid);

    for( TInt count = iListBoxPolicies.Count() - 1 ; count >= 0; count-- )

        {

        if( iListBoxPolicies[count]->Uid() == aUid &&

            iListBoxPolicies[count]->ListBoxType() == aListBoxType )

            {

            delete iListBoxPolicies[count];

            iListBoxPolicies.Remove( count );

            __ALFFXLOGSTRING("CPolicyHandler::UnregisterListBoxKml - return KErrNone<<");

            return KErrNone;

            }

        }

    __ALFFXLOGSTRING("CPolicyHandler::UnregisterListBoxKml - return KErrNotFound <<");

    return KErrNotFound;

    }

    {

    __ALFFXLOGSTRING1("CPolicyHandler::UnregisterListBoxKml - aThreadId: %d >>", aThreadId.Id());

    TThreadId tid;

    TInt err = KErrNotFound;

    for( TInt count = iListBoxPolicies.Count() - 1 ; count >= 0; count-- )

        {

        tid = iListBoxPolicies[count]->ThreadId();

        if( tid.Id() == aThreadId.Id() )

            {

            delete iListBoxPolicies[count];

            iListBoxPolicies.Remove( count );

            err = KErrNone;

            }

        }

    __ALFFXLOGSTRING1("CPolicyHandler::UnregisterListBoxKml - return: %d <<", err);

    return err;

    }

TInt CPolicyHandler::GetListBoxKml( const TUid& aAppId,

                                    TInt& aMinTime)

    {

    __ALFFXLOGSTRING3("CPolicyHandler::GetListBoxKml - aResourceDir: %S, aBackgroundFilename: %S, aItemFilename: %S >>", &aResourceDir, &aBackgroundFilename, &aItemFilename);

    TInt count = iListBoxPolicies.Count();

    TBool hit = EFalse;

    TInt i;

    aResourceDir.Set( iListBoxPolicies[i]->ResourceDir() );

    aBackgroundFilename.Set( iListBoxPolicies[i]->BackgroundFilename() );

    aItemFilename.Set( iListBoxPolicies[i]->ItemFilename() );

    aCachePriority = iListBoxPolicies[i]->CachePriority();

    aWantedTime = iListBoxPolicies[i]->WantedTime();

    aMinTime = iListBoxPolicies[i]->MinTime();

    // For now, this entry should have no priority over others

    iListBoxPolicies[i]->SetCachePriority( 0 );

    __ALFFXLOGSTRING("CPolicyHandler::GetListBoxKml - return KErrNone <<");

    return KErrNone;

    }

                                            const TDesC& aResourceDir, const TDesC& aFilename,

                                            TInt /*aCachePriority*/, TInt aWantedTime, TInt aMinTime)

    {

    __ALFFXLOGSTRING3("CPolicyHandler::RegisterFullscreenKmlL - aAction: %d aUid: 0x%x aThread.Id : %d", aAction, aUid, aThreadId.Id() );

    __ALFFXLOGSTRING2("CPolicyHandler::RegisterFullscreenKmlL - aResourceDir: %S, aFilename: %S", &aResourceDir, &aFilename );

    TInt cachePriority = 1; //aCachePriority; 

    // For now, the cache priority is always 1 at registration time, and after

    // fetching the KML information from the policy, it gets set to 0. This is

    // used to trigger eviction from the KML cache. Newly registered KML:s have

    // priority over existing...

    CFullscreenPolicy* policy = NULL;

    // Check if the action was already is registered and if so, delete it.

    TInt count = iFullscreenPolicies.Count()-1;

    for(; count >= 0; count--)

        {

        if( iFullscreenPolicies[count]->Action() == aAction && 

            iFullscreenPolicies[count]->Uid() == aUid)

            {

            policy = iFullscreenPolicies[count];

            iFullscreenPolicies.Remove(count);

            delete policy;

            policy = NULL;

            }

        } 

    // create and add the new action.

    policy = CFullscreenPolicy::NewL(aAction, aUid, aThreadId, aResourceDir, aFilename,

                                                        cachePriority, aWantedTime, aMinTime);

    CleanupStack::PushL(policy);

    iFullscreenPolicies.AppendL(policy);

    CleanupStack::Pop(policy);

    __ALFFXLOGSTRING("CPolicyHandler::RegisterFullscreenKmlL <<");

    }

    {

    __ALFFXLOGSTRING2("CPolicyHandler::UnregisterFullscreenKml - aAction: %d, aUid: 0x%x <<", aAction, aUid );

    TInt count = iFullscreenPolicies.Count() -1;

    for(; count >= 0; count--)

        {

        if(iFullscreenPolicies[count]->Action() == aAction && 

            iFullscreenPolicies[count]->Uid() == aUid)

            {

            CFullscreenPolicy* policy = iFullscreenPolicies[count];

            iFullscreenPolicies.Remove(count);

            delete policy;

            policy = NULL;

            __ALFFXLOGSTRING("CPolicyHandler::UnregisterFullscreenKml - return KErrNone <<");

            return KErrNone;

            }

        }

    __ALFFXLOGSTRING("CPolicyHandler::UnregisterFullscreenKml - return KErrNotFound <<");

    return KErrNotFound;

    }

    {

    __ALFFXLOGSTRING1("CPolicyHandler::UnregisterFullscreenKml - aThreadId: %d >>", aThreadId.Id());

    TInt count = iFullscreenPolicies.Count() -1;

    TInt err = KErrNotFound;

    TThreadId tid;

    for(; count >= 0; count--)

        {

        tid = iFullscreenPolicies[count]->ThreadId();

        if( tid.Id() == aThreadId.Id())

            {

            CFullscreenPolicy* policy = iFullscreenPolicies[count];

            iFullscreenPolicies.Remove(count);

            delete policy;

            policy = NULL;

            err = KErrNone;

            }

        }

    __ALFFXLOGSTRING1("CPolicyHandler::UnregisterFullscreenKml - return: %d <<", err);

    return err;

    }

    {

    __ALFFXLOGSTRING1("CPolicyHandler::UnregisterAllKml - aThreadId: <<", aThreadId.Id());

    TInt err = KErrNotFound;

    TInt err1 = UnregisterFullscreenKml(aThreadId);

    TInt err2 = UnregisterControlKml(aThreadId);

    if(err1 == KErrNone || err2 == KErrNone)

        err = KErrNone;

    TInt err3 = UnregisterListBoxKml(aThreadId);

    if(err3 == KErrNone)

        err = KErrNone;

    __ALFFXLOGSTRING1("CPolicyHandler::UnregisterAllKml - return: %d <<", err);

TInt CPolicyHandler::GetFullscreenKml(  TUint aAction, const TUid& aToUid, const TUid& aFromUid,

                                        TPtrC& aResourceDir, TPtrC& aFilename,

                                        TInt& aCachePriority, TInt& aWantedTime, TInt& aMinTime)

    {

    // Checking if the UID is blocked.

    TInt blockedUids = iFullScreenBlocks.Count();

    aResourceDir.Set( TPtrC() );

    aFilename.Set( TPtrC() );

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

        {

        if( iFullScreenBlocks[i]->iToUid == aToUid ||

            iFullScreenBlocks[i]->iFromUid == aFromUid)

            {

            __ALFFXLOGSTRING("CPolicyHandler::GetFullscreenKml - return KErrNotSupported <<");

            return KErrNotSupported;

            }

        }

    TInt count = iFullscreenPolicies.Count();

    // try to find it using both action and uid

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

        {

        if(iFullscreenPolicies[i]->Action() == aAction && 

            iFullscreenPolicies[i]->Uid() == aToUid)

            {

            aResourceDir.Set( iFullscreenPolicies[i]->ResourceDir() );

            aFilename.Set( iFullscreenPolicies[i]->Filename() );

            aCachePriority = iFullscreenPolicies[i]->CachePriority();

            aWantedTime = iFullscreenPolicies[i]->WantedTime();

            aMinTime = iFullscreenPolicies[i]->MinTime();

            // Check if theres a block on this UID/Action pair.

            if( aFilename.Length() == 0 ) 

                {

                __ALFFXLOGSTRING("CPolicyHandler::GetFullscreenKml - return KErrNotSupported <<");

                return KErrNotSupported;

                }

            // For now, this entry should have no priority over others

            iFullscreenPolicies[i]->SetCachePriority(0);

            }

        }

    // try to find the default (Uid == KNullUid)

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

        {

        if(iFullscreenPolicies[i]->Action() == aAction && 

            iFullscreenPolicies[i]->Uid() == KNullUid)

            {

            aResourceDir.Set( iFullscreenPolicies[i]->ResourceDir() );

            aFilename.Set( iFullscreenPolicies[i]->Filename() );

            aCachePriority = iFullscreenPolicies[i]->CachePriority();

            aWantedTime = iFullscreenPolicies[i]->WantedTime();

            aMinTime = iFullscreenPolicies[i]->MinTime();

            // For now, this entry should have no priority over others

            iFullscreenPolicies[i]->SetCachePriority(0); 

            __ALFFXLOGSTRING("CPolicyHandler::GetFullscreenKml - return KErrNone <<");

            return KErrNone;

            }

        }

    __ALFFXLOGSTRING("CPolicyHandler::GetFullscreenKml - return KErrNotFound <<");

    return KErrNotFound;

    }

    {

    __ALFFXLOGSTRING3("CPolicyHandler::BlockFullScreenUid - aUid: 0x%x, aBlockFrom: %d, aBlockTo: %d >>", aUid, aBlockFrom, aBlockTo ); 

    TFullScreenBlock* block = NULL;

    TInt blockedUids = iFullScreenBlocks.Count();

    if( blockedUids > 0)

        {

        // Looking for an existing To block.

        if(!aBlockTo && aBlockFrom )

            {

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

                {

                if(iFullScreenBlocks[i]->iFromUid == aUid)

                    {

                    __ALFFXLOGSTRING("CPolicyHandler::BlockFullScreenUid - return KErrNone <<");

                    return KErrNone;

                    }

                }

            }

        // Looking for an existing From block.

        else if(aBlockTo && !aBlockFrom)

            {

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

                {

                if(iFullScreenBlocks[i]->iToUid  == aUid)

                    {

                    __ALFFXLOGSTRING("CPolicyHandler::BlockFullScreenUid - return KErrNone <<");

                    return KErrNone;

                    }

                }

            }

        // Trying to unblock stuff.

        else if(!aBlockTo && !aBlockFrom)

            {

            for(TInt i = blockedUids -1; i >= 0; i--)

                {

                if( iFullScreenBlocks[i]->iToUid  == aUid ||

                    iFullScreenBlocks[i]->iFromUid == aUid )

                    {

                    block = iFullScreenBlocks[i];

                    iFullScreenBlocks.Remove(i);

                    delete block;

                    block = NULL;

                    }

                }

            __ALFFXLOGSTRING("CPolicyHandler::BlockFullScreenUid - return KErrNone <<");

            return KErrNone;

            }

        // Looking for an existing To and From block with the same UID's.

        else

            {

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

                {

                if( iFullScreenBlocks[i]->iToUid  == aUid &&

                    iFullScreenBlocks[i]->iFromUid == aUid )

                    {

                    __ALFFXLOGSTRING("CPolicyHandler::BlockFullScreenUid - return KErrNone <<");

                    return KErrNone;

                    }

                }

            }

        }

    // None found. Create!

    block = new TFullScreenBlock();

    if(NULL == block)

        {

        __ALFFXLOGSTRING("CPolicyHandler::BlockFullScreenUid - return KErrNoMemory <<");

        return KErrNoMemory;

        }

    if(aBlockTo)

        {

        block->iToUid = aUid;

        }

    if(aBlockFrom)

        {

        block->iFromUid = aUid;

        }

    TInt err = iFullScreenBlocks.Append(block);

    if(KErrNone != err)

        {

        delete block;

        block = NULL;

        }