diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/plugins/alftranseffect/alftranseffectplugin/src/alfpolicyhandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/plugins/alftranseffect/alftranseffectplugin/src/alfpolicyhandler.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,1031 @@ +/* +* Copyright (c) 2006 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: implementation of policy handler +* +*/ + + + +#include "alfpolicyhandler.h" +#include "alfpolicyrequesthandler.h" +#include + +// ======== HELPER CLASS ======== + +NONSHARABLE_CLASS(TFullScreenBlock) + { +public: + TUid iFromUid; + TUid iToUid; + + }; + +// ======== MEMBER FUNCTIONS ======== + +CPolicyHandler* CPolicyHandler::NewL() + { + __ALFFXLOGSTRING("CPolicyHandler::NewL >>"); + CPolicyHandler* self = new (ELeave) CPolicyHandler(); + CleanupStack::PushL(self); + self->iClientRequestHandler = new (ELeave) CPolicyClientRequestHandler(self); + CleanupStack::Pop(self); + __ALFFXLOGSTRING("CPolicyHandler::NewL <<"); + return self; + } + +CPolicyHandler::~CPolicyHandler() + { + __ALFFXLOGSTRING("CPolicyHandler::~CPolicyHandler >>"); + delete iClientRequestHandler; + + iFullscreenPolicies.ResetAndDestroy(); + + iControlPolicies.ResetAndDestroy(); + + iFullScreenBlocks.ResetAndDestroy(); + + iListBoxPolicies.ResetAndDestroy(); + __ALFFXLOGSTRING("CPolicyHandler::~CPolicyHandler <<"); + } + +CPolicyHandler::CPolicyHandler() + { + } + +// --------------------------------------------------------------------------- +// Insert the new policy in the list of existing ones. The list is kept +// sorted according to specificity, ie. how much is specified in the policy. +// --------------------------------------------------------------------------- +// +void CPolicyHandler::RegisterListBoxKmlL( const TUid& aUid, + const TThreadId& aThreadId, + const CAlfTransitionServerClient::TListBoxType aListBoxType, + const TDesC& aResourceDir, + const TDesC& aBackgroundFilename, + const TDesC& aItemFilename, + TInt aCachePriority, + TInt aWantedTime , TInt aMinTime ) + { + __ALFFXLOGSTRING2("CPolicyHandler::RegisterListBoxKmlL - aUid 0x%x, aThreadId >>", aUid, aThreadId.Id()); + 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, + aBackgroundFilename, + aItemFilename, + aCachePriority, + aWantedTime, + aMinTime ); + 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; + } + } + + iListBoxPolicies.InsertL( policy, i ); + + CleanupStack::Pop(); + __ALFFXLOGSTRING("CPolicyHandler::RegisterListBoxKmlL <<"); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::UnregisterListBoxKml( const TUid& aUid, + CAlfTransitionServerClient::TListBoxType aListBoxType ) + { + __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; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::UnregisterListBoxKml( const TThreadId& aThreadId ) + { + __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, + const CAlfTransitionServerClient::TListBoxType aListBoxType, + TPtrC& aResourceDir, + TPtrC& aBackgroundFilename, + TPtrC& aItemFilename, + TInt& aCachePriority, TInt& aWantedTime, + 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( TPtrC() ); + aBackgroundFilename.Set( TPtrC() ); + aItemFilename.Set( TPtrC() ); + + for ( i = 0; i < count; i++ ) + { + CListBoxPolicy* curr = iListBoxPolicies[i]; + TInt uid = curr->Uid().iUid; + CAlfTransitionServerClient::TListBoxType listType = curr->ListBoxType(); + + if ( ( !uid || uid == aAppId.iUid ) && + ( listType == CAlfTransitionServerClient::EListTypeAny || + listType == aListBoxType ) ) + { + hit = ETrue; + break; + } + } + + if ( !hit ) + { + __ALFFXLOGSTRING("CPolicyHandler::GetListBoxKml - return KErrNotFound <<"); + return KErrNotFound; + } + + 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; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CPolicyHandler::RegisterFullscreenKmlL(TUint aAction, const TUid& aUid, const TThreadId& aThreadId, + 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 <<"); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::UnregisterFullscreenKml(TUint aAction, const TUid& aUid) + { + __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; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::UnregisterFullscreenKml(const TThreadId& aThreadId) + { + __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; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::UnregisterAllKml(const TThreadId& aThreadId) + { + __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); + return err; + } + + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::GetFullscreenKml( TUint aAction, const TUid& aToUid, const TUid& aFromUid, + TPtrC& aResourceDir, TPtrC& aFilename, + TInt& aCachePriority, TInt& aWantedTime, TInt& aMinTime) + { + __ALFFXLOGSTRING3("CPolicyHandler::GetFullscreenKml - aAction: %d, aToUid: %d, aFromUid :%d", aAction, aToUid, aFromUid ); + __ALFFXLOGSTRING2("CPolicyHandler::GetFullscreenKml - aResourceDir: %S, aFilename :%S", &aResourceDir, &aFilename ); + + // 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); + __ALFFXLOGSTRING("CPolicyHandler::GetFullscreenKml - return KErrNone <<"); + return KErrNone; + } + } + // 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; + } + + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::BlockFullScreenUid(const TUid& aUid, TBool aBlockFrom, TBool aBlockTo) + { + __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; + } + __ALFFXLOGSTRING1("CPolicyHandler::BlockFullScreenUid - return: %d <<", err); + return err; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::RegisterControlAction(const TUid aUid, TUint aAction, const TDesC& aActionString) + { + __ALFFXLOGSTRING3("CPolicyHandler::RegisterControlAction - aUid: 0x%x, aAction: %d, aActionString: %S", aUid, aAction, &aActionString ); + TInt index = 0; + CControlPolicy* pData = NULL; + CActionPolicy* pPolicy = NULL; + + // TEST!!!!!!!!!! + // First see if we have an empty entry that means a new KML has been registered + // Adding just a KML does not remove the old one, the old one gets removed only + // after we add an action to the new KML + + // The double action of first registering a KML file and then registering the action + // should be replaced with single call where the control file and action are defined + // in one call + + TInt count = iControlPolicies.Count(); + index = -1; // Setting index to negative value to use as check if match found. + TInt i = 0; + TInt j = 0; + TInt k = 0; + + // We stop when we find a matching empty entry + // But first old non-empty entries are deleted + for( i = count - 1; i >= 0 && index == -1; i-- ) + { + pData = iControlPolicies[i]; + if( pData->Uid() == aUid ) + { + if ( pData->iControlPolicies.Count() == 0 ) + { + index = i; + // We have found an empty definition. + // This means a new effect definition file has been added, and the new action + // should be attached to it. + // But first we have to remove the possible old effect file + for ( j = count - 1; j >= 0; j-- ) + { + pData = iControlPolicies[j]; + if ( pData->Uid() == aUid ) + { + for ( k = 0; pData && k < pData->iControlPolicies.Count(); k++ ) + { + pPolicy = pData->iControlPolicies[k]; + if ( pPolicy->iAction == aAction ) + { + // Old definition found, remove the whole policy entry + iControlPolicies.Remove( j ); + count--; // this value is referred later. It must be kept up to date. + delete pData; + pData = NULL; + } + } + } + } + } + } + } + + if( index >= 0 ) + { + index = -1; // paranoid... + // find the empty entry again - if it exists + // our indexes may have got messed up if we removed something + // so we must recheck the index + // We only accept entries with no policies, as we just checked + // the existence of an entry with matching policy + for( i = count - 1; i >= 0 && index == -1; i-- ) + { + pData = iControlPolicies[i]; + if( pData->Uid() == aUid ) + { + if ( pData->iControlPolicies.Count() == 0 ) + { + index = i; + } + } + } + } +// Now we have checked if we have an effect file definition that has no entries yet, +// and if we found one, we deleted old effect file definitions for this UID. +// Now we check if we just update an old action or add a new one to the existing entry + + // First checking if we need to update a policy. + // If we have an empty entry, we must use it, not add our action to a different entry + // even if if has the same UID. + // So we must not try to find an existing entry if we have already decided to use an + // empty entry + + if ( index < 0 ) + { + if(FindControlPolicy(aAction, aUid, pPolicy, index) == KErrNone) + { + // If we get here and pPolicy == NULL, something is really wrong outside of + // our control. + pPolicy->iAction = aAction; + // Setting the action string is a leaving method. + // Trap it here to avoid the rest of the system to become + // leaving to. + TRAPD(err, pPolicy->SetActionStringL(aActionString)); + if(KErrNone != err) + { + __ALFFXLOGSTRING1("CPolicyHandler::RegisterControlAction - return: %d <<", err); + return err; + } + pPolicy->iPolicy = ESupported; + iClientRequestHandler->RegisterControlAction( aUid, aAction); + __ALFFXLOGSTRING("CPolicyHandler::RegisterControlAction - return KErrNone <<"); + return KErrNone; + } + } + + if( index < 0 ) + { + __ALFFXLOGSTRING("CPolicyHandler::RegisterControlAction - return KErrNotFound <<"); + return KErrNotFound; + } + + pData = iControlPolicies[index]; + pPolicy = new CActionPolicy(); + if(!pPolicy) + { + __ALFFXLOGSTRING("CPolicyHandler::RegisterControlAction - return KErrNoMemory <<"); + return KErrNoMemory; + } + + // Assign some values + pPolicy->iAction = aAction; + pPolicy->iPolicy = ESupported; + TRAPD(err, pPolicy->SetActionStringL(aActionString)); + if(KErrNone != err) + { + delete pPolicy; + __ALFFXLOGSTRING1("CPolicyHandler::RegisterControlAction - return: %d <<", err); + return err; + } + + // Then add it to the list. + err = pData->iControlPolicies.Append(pPolicy); + if(err != KErrNone) + { + delete pPolicy; + pPolicy = NULL; + __ALFFXLOGSTRING1("CPolicyHandler::RegisterControlAction - return: %d <<", err); + return err; + } + iClientRequestHandler->RegisterControlAction(aUid, aAction); + __ALFFXLOGSTRING1("CPolicyHandler::RegisterControlAction - return: %d <<", err); + return err; + } + + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::UnregisterControlAction(const TUid aUid, TUint aAction) + { + __ALFFXLOGSTRING2("CPolicyHandler::UnregisterControlAction - aUid %d, aAction: %d >>", aUid, aAction); + CControlPolicy* pData = NULL; + CActionPolicy* pPolicy = NULL; + + TInt count = iControlPolicies.Count(); + + // Removing policy for action. + for(TInt counter = 0; counter < count; counter++) + { + pData = iControlPolicies[counter]; + if(pData->Uid() == aUid) + { + TInt polActionCount = pData->iControlPolicies.Count(); + // Iterating the list from first. No problem since we only delete one item! + for(TInt j = 0; j < polActionCount; j++) + { + pPolicy = pData->iControlPolicies[j]; + if(pPolicy->iAction == aAction) + { + // Call this before removing data permanently! + iClientRequestHandler->RemoveControlPolicy( aUid, aAction); + delete pPolicy; + pPolicy = NULL; + pData->iControlPolicies.Remove(j); + __ALFFXLOGSTRING("CPolicyHandler::UnregisterControlAction - return KErrNone<<"); + return KErrNone; + } + } + } + } + __ALFFXLOGSTRING("CPolicyHandler::UnregisterControlAction - return KErrNotFound<<"); + return KErrNotFound; + } + + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CPolicyHandler::RegisterControlKmlL(const TUid &aUid, const TThreadId &aThreadId, + const TDesC& aResourceDir, const TDesC& aFilename, + const TInt aWantedTime, const TInt aMinTime) + { + + __ALFFXLOGSTRING2("CPolicyHandler::RegisterControlKmlL - aUid :%d aThread.Id :%d", aUid, aThreadId.Id() ); + __ALFFXLOGSTRING2("CPolicyHandler::RegisterControlKmlL - aResourceDir: %S, aFilename :%S", &aResourceDir, &aFilename ); + + CControlPolicy* policy = NULL; + 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... + + // Check if the action was already is registered and if so, delete it. + +// TEST!!!!!!!!!!!! Don't delete before action is added +// Only delete if the entry has no policies, then we are replacing the xml file +// though we have added no actions yet + TInt count = iControlPolicies.Count()-1; + for(; count >= 0; count--) + { + if( iControlPolicies[count]->Uid() == aUid) + { + policy = iControlPolicies[count]; + if ( policy->iControlPolicies.Count() == 0 ) + { + iControlPolicies.Remove(count); + delete policy; + policy = NULL; + } + } + } + + // Create the new action and add it. + policy = CControlPolicy::NewL(aUid, aThreadId, aResourceDir, aFilename, cachePriority, aWantedTime, aMinTime); + CleanupStack::PushL(policy); + iControlPolicies.AppendL(policy); + CleanupStack::Pop(policy); + __ALFFXLOGSTRING("CPolicyHandler::RegisterControlKmlL <<"); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::RemoveControlKml(const TUid &aUid) + { + __ALFFXLOGSTRING1("CPolicyHandler::RemoveControlKml - aUid: %d ", aUid); + + TInt err = KErrNotFound; + CControlPolicy* ptr = NULL; + CActionPolicy* action = NULL; + TInt policyCount = iControlPolicies.Count(); + // We may remove several KMLs if different actions have different effect files + for( TInt i = policyCount - 1; i >= 0; i--) + { + ptr = iControlPolicies[i]; + if(ptr->Uid() == aUid) + { + // making sure that policies get removed from the running clients as well! + TInt count = ptr->iControlPolicies.Count(); + if( count > 0) + { + for(TInt j = 0; j < count; j++) + { + action = ptr->iControlPolicies[j]; + iClientRequestHandler->RemoveControlPolicy(aUid, action->iAction); + } + } + iControlPolicies.Remove(i); + delete ptr; + ptr = NULL; + err = KErrNone; + } + } + __ALFFXLOGSTRING1("CPolicyHandler::RemoveControlKml - return: %d <<", err); + return err; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::UnregisterControlKml(const TThreadId &aThreadId) + { + __ALFFXLOGSTRING1("CPolicyHandler::UnregisterControlKml - aThreadId: %d ", aThreadId.Id() ); + CControlPolicy* ptr = NULL; + CActionPolicy* action = NULL; + TInt err = KErrNotFound; + TThreadId tid; + TInt policyCount = iControlPolicies.Count(); + + for( TInt i = policyCount - 1; i >= 0; i--) + { + ptr = iControlPolicies[i]; + tid = ptr->ThreadId(); + + if(tid.Id() == aThreadId.Id()) + { + // making sure that policies get removed from the running clients as well! + TInt count = ptr->iControlPolicies.Count(); + if(count > 0) + { + for(TInt j = 0; j < count; j++) + { + action = ptr->iControlPolicies[j]; + iClientRequestHandler->RemoveControlPolicy(ptr->Uid(), action->iAction); + } + } + iControlPolicies.Remove(i); + delete ptr; + ptr = NULL; + err = KErrNone; + } + } + __ALFFXLOGSTRING1("CPolicyHandler::UnregisterControlKml - return: %d <<", err); + return err; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::GetControlKml( TUid aUid, TUint aAction, TPtrC& aResourceDir, + TPtrC& aFileName, TPtrC& aActionString, TInt& aCachePriority, + TInt& aWantedTime, TInt& aMinTime) + { + __ALFFXLOGSTRING2("CPolicyHandler::GetControlKml - aAction: %d aUid :0x%x", aAction, aUid ); + __ALFFXLOGSTRING3("CPolicyHandler::GetControlKml - aResourceDir: %S, aFilename :%S, aActionString: %S", &aResourceDir, &aFileName, &aActionString ); + + CControlPolicy* ptr = NULL; + CActionPolicy* pPolicy = NULL; + aResourceDir.Set( TPtrC() ); + aFileName.Set( TPtrC() ); + aActionString.Set( TPtrC() ); + + TInt itemCount = iControlPolicies.Count(); + for(TInt i = 0; i < itemCount; i++) + { + ptr = iControlPolicies[i]; + if( ptr->Uid() == aUid) + { + aResourceDir.Set( ptr->ResourceDir() ); + aFileName.Set( ptr->Filename() ); + aCachePriority = ptr->CachePriority(); + aWantedTime = ptr->WantedTime(); + aMinTime = ptr->MinTime(); + TInt actionCount = ptr->iControlPolicies.Count(); + for(TInt j = 0; j < actionCount; j++) + { + pPolicy = ptr->iControlPolicies[j]; + if(pPolicy->iAction == aAction) + { + aActionString.Set( pPolicy->ActionString() ); + // For now, this entry should have no priority over others + ptr->SetCachePriority(0); + __ALFFXLOGSTRING("CPolicyHandler::GetControlKml - return KErrNone <<"); + return KErrNone; + } + } + } + } + __ALFFXLOGSTRING("CPolicyHandler::GetControlKml - return KErrNotFound <<"); + return KErrNotFound; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::GetAllControlPolicies(RPointerArray& aControlPolicies) + { + __ALFFXLOGSTRING("CPolicyHandler::GetAllControlPolicies >>"); + TInt err = KErrNone; + + TInt itemCount = iControlPolicies.Count(); + if( 0 >= itemCount) + { + __ALFFXLOGSTRING("CPolicyHandler::GetAllControlPolicies - return KErrNotFound <<"); + return KErrNotFound; + } + + for(TInt i = 0; i < itemCount; i++) + { + CClientControlPolicy* ptr = new CClientControlPolicy(); + if ( ptr == NULL ) + { + __ALFFXLOGSTRING("CPolicyHandler::GetAllControlPolicies - return KErrNoMemory <<"); + return KErrNoMemory; + } + ptr->iUid = iControlPolicies[i]->Uid(); + HBufC* fname = HBufC::New(iControlPolicies[i]->Filename().Length()); + if ( fname == NULL ) + { + delete ptr; + __ALFFXLOGSTRING("CPolicyHandler::GetAllControlPolicies - return KErrNoMemory <<"); + return KErrNoMemory; + } + fname->Des().Copy(iControlPolicies[i]->Filename()); + ptr->iFilename.Assign(fname); + HBufC* resdir = HBufC::New(255); + if ( resdir == NULL ) + { + delete ptr; + __ALFFXLOGSTRING("CPolicyHandler::GetAllControlPolicies - return KErrNoMemory <<"); + return KErrNoMemory; + } + ptr->iResourceDir.Assign(resdir); + // In order to actually copy the pointers to the policy data, we + // need to iterate through the entire list. + TInt count = iControlPolicies[i]->iControlPolicies.Count(); + if(count > 0) + { + for( TInt j = 0; j < count; j++) + { + err = ptr->iControlPolicies.Append(iControlPolicies[i]->iControlPolicies[j]); + if(KErrNone != err) + { + delete ptr; + __ALFFXLOGSTRING1("CPolicyHandler::GetAllControlPolicies - return: %d <<", err); + return err; + } + } + err = aControlPolicies.Append(ptr); + if(KErrNone != err) + { + delete ptr; + __ALFFXLOGSTRING1("CPolicyHandler::GetAllControlPolicies - return: %d <<", err); + return err; + } + } + else + { + delete ptr; + ptr = NULL; + } + } + __ALFFXLOGSTRING("CPolicyHandler::GetAllControlPolicies - return KErrNotFound<<"); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::RequestPolicy(const RMessage2& aMessage) + { + return iClientRequestHandler->RequestPolicy(aMessage); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::GetPolicyL( TThreadId aClientId, TInt aPolicyCount, TPtr8& aOutBuf ) + { + return iClientRequestHandler->GetPolicyL( aClientId, aPolicyCount, aOutBuf ); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CPolicyHandler::RemoveClient( TThreadId aClientId ) + { + iClientRequestHandler->RemoveClient( aClientId ); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +/* +void CPolicyHandler::RemoveDeadClients() + { + iClientRequestHandler->RemoveDeadClients(); + } +*/ + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +/* +void CPolicyHandler::DumpClientsL(RFileWriteStream& aFile) + { + iClientRequestHandler->DumpClientsL(aFile); + } +*/ + + +//============== PRIVATE METHODS =================/ + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CPolicyHandler::FindControlPolicy(TUint aAction, TUid aUid, CActionPolicy*& aPolicy, TInt& aIndex) + { + __ALFFXLOGSTRING3("CPolicyHandler::FindControlPolicy - aAction: %d, aUid: 0x%x, aIndex: %d", aAction, aUid, aIndex ); + + TInt count = iControlPolicies.Count(); + aIndex = -1; // Setting index to low value to avoid accidental insertion. + + CControlPolicy* pData = NULL; + for(TInt i = 0; i < count; i++) + { + pData = iControlPolicies[i]; + if(pData->Uid() == aUid) + { + aIndex = i; + TInt j = pData->iControlPolicies.Count(); + CActionPolicy* pPolicy = NULL; + for(TInt q = 0; q < j; q++) + { + pPolicy = pData->iControlPolicies[q]; + if(pPolicy->iAction == aAction) + { + aPolicy = pPolicy; + __ALFFXLOGSTRING("CPolicyHandler::FindControlPolicy - return KErrNone <<"); + return KErrNone; + } + } + } + } + __ALFFXLOGSTRING("CPolicyHandler::FindControlPolicy - return KErrNotFound <<"); + return KErrNotFound; + } + + +// --- EOF --- + + + +