1 /*

     2 * Copyright (c) 2003-2005 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:       Implements API for consumer application to access Language

    15 *                Interworking Framework. 

    16 *

    17 */

    18 

    19 

    20 

    21 

    22 

    23 

    24 #include <eikenv.h>

    25 #include <bautils.h>    // file helpers

    26 #include <liwservicehandler.rsg>

    27 #include "liwmenubinding.h"

    28 #include "liwservicehandler.h"

    29 #include "liwservicehandlerimpl.h"

    30 #include "liwmenu.h"

    31 #include "liwuids.hrh"

    32 #include "liwcommon.hrh"

    33 #include "liwmenuslot.hrh"

    34 #include "liwecommonitor.h"

    35 #include "liwtlsdata.h"

    36 #include "data_caging_path_literals.hrh"

    37 

    38 #include "liwxmlhandler.h"

    39 #include "liwservicedata.h"

    40 

    41 #include <rtsecmgrscriptsession.h>

    42 

    43 // CONSTANTS

    44 // Max number of empty menu resource slots.

    45 const TInt KMaxMenuResources = 16;

    46 

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

    48 // closing the Options-menu.

    49 const TInt KMaxPaneIds = KMaxMenuResources;

    50 

    51 // The range reserved for individual menu pane.

    52 const TInt KIndividualMenuPaneIdRange = 10000;

    53 

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

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

    56 

    57 _LIT(KLiwResourceFile, "liwServiceHandler.rsc");

    58 _LIT(KLiwZDrive, "z:");

    59 _LIT8(KDataSeparator, "||");

    60 _LIT(KPerExtension,".per");

    61 

    62 const TInt KMaxMenuTitleSize = 100;

    63 

    64 // Command id space reserved for single placeholder.

    65 const TInt KPlaceholderCmdIdRange = 200;

    66 

    67 const TInt KMaxLength=255;

    68 

    69 const TReal KDefVersion = 1.0;

    70 const TReal KUnspVersion = 0.0;

    71 

    72 void Cleanup(TAny* aAny);

    73 void InterestCleanup(TAny* aAny);

    74 void IntArrayCleanup(TAny* aAny);

    75 void FilteredCleanup(TAny* aAny);

    76 void Int32ArrayCleanup(TAny* aAny);

    77 void InterfaceCleanup(TAny* aAny);

    78 

    79 _LIT8(KResolverInterface, "IResolver");

    80 _LIT8(KResolverDomain, "ServiceManager");

    81 _LIT8(serviceCmdSeparator, "::");

    82 

    83 const TInt KDummySrvCmd=1;

    84 _LIT(KCapabilityCommDD,"CDD");

    85 _LIT(KCapabilityPowerMgmt,"PMT");

    86 _LIT(KCapabilityMultimediaDD,"MDD");

    87 _LIT(KCapabilityReadDeviceData,"RDD");

    88 _LIT(KCapabilityWriteDeviceData,"WDD");

    89 _LIT(KCapabilityDRM,"DRM");

    90 _LIT(KCapabilityTrustedUI,"TUI");

    91 _LIT(KCapabilityProtServ,"PSV");

    92 _LIT(KCapabilityDiskAdmin,"DAD");

    93 _LIT(KCapabilityNetworkControl,"NWC");

    94 _LIT(KCapabilityAllFiles,"ALF");

    95 _LIT(KCapabilitySwEvent,"SWE");

    96 _LIT(KCapabilityNetworkServices,"NWS");

    97 _LIT(KCapabilityLocalServices,"LOS");

    98 _LIT(KCapabilityReadUserData,"RUD");

    99 _LIT(KCapabilityWriteUserData,"WUD");

   100 _LIT(KCapabilityLocation,"LOC");

   101 _LIT(KCapabilitySurroundingsDD,"SDD");

   102 _LIT(KCapabilityUserEnvironment,"USE");

   103 

   104 using namespace LIW;

   105 //

   106 // LiwServiceHandler

   107 //

   108 

   109 CLiwServiceHandlerImpl* CLiwServiceHandlerImpl::NewL()

   110     {

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

   112     CleanupStack::PushL( handler );

   113     handler->ConstructL();

   114     CleanupStack::Pop(handler); // handler

   115     return handler;

   116     }

   117 

   118 

   119 

   120 CLiwServiceHandlerImpl::CLiwServiceHandlerImpl()

   121     {

   122     // Nothing to do here.

   123     }

   124 

   125 

   126 

   127 void CLiwServiceHandlerImpl::ConstructL()

   128     {

   129     TFileName resFile;

   130     TCallBack callBack(SynchronizeCallBack, this);

   131     iEcomMonitor = CLiwEcomMonitor::NewL(callBack);

   132 	

   133     

   134     iCoeEnv = CCoeEnv::Static();

   135     RFs rFs;

   136     TInt err = rFs.Connect();

   137     

   138     TFileName dllName;

   139     Dll::FileName(dllName);

   140 

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

   142     resFile.Copy(drive);

   143     resFile.Append(KDC_RESOURCE_FILES_DIR);

   144     resFile.Append(KLiwResourceFile);	

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

   146     if ( ! fileExists )

   147     {

   148 	resFile.Copy(KLiwZDrive);

   149 	resFile.Append(KDC_RESOURCE_FILES_DIR);

   150 	resFile.Append(KLiwResourceFile);

   151     }

   152     rFs.Close();

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

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

   155     // needing CCoeEnv/CEikonEnv will leave with KErrNotSupported.

   156     if(iCoeEnv)

   157         {

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

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

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

   161         }

   162     // CLiwTlsData has a reference count so each OpenL call

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

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

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

   166     CLiwTlsData* data = CLiwTlsData::OpenL();

   167     iTlsDataOpened = ETrue;

   168 

   169     // CEikMenuPane informs all menu launch observers

   170     // when an options menu is launched.

   171     data->AddMenuLaunchObserverL( this );

   172     }

   173 

   174 

   175 

   176 CLiwServiceHandlerImpl::~CLiwServiceHandlerImpl()

   177     {

   178     if (iResourceOffset && iCoeEnv)

   179         {

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

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

   182         // iCoeEnv->DeleteResourceFile(iResourceOffset);

   183         }

   184     Reset();

   185 

   186     delete iEcomMonitor;

   187 

   188     if ( iTlsDataOpened )

   189         {

   190         CLiwTlsData* data = CLiwTlsData::Instance();

   191         data->RemoveMenuLaunchObserver( this );

   192         CLiwTlsData::Close();

   193         }

   194     }

   195 

   196 

   197 

   198 void CLiwServiceHandlerImpl::Reset()

   199     {

   200     iInterestList.ResetAndDestroy();

   201     iMenuBindings.ResetAndDestroy();

   202     iBaseBindings.ResetAndDestroy();

   203     iProviders.ResetAndDestroy();

   204 

   205     iLastInitialized.Reset();

   206 

   207     iMenuPanes.ResetAndDestroy();

   208 

   209     delete iInParams;

   210     iInParams = NULL;

   211     delete iOutParams;

   212     iOutParams = NULL;

   213     }

   214 

   215 void CLiwServiceHandlerImpl::AttachServiceManagerPluginsL()

   216 {

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

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

   219   

   220   RCriteriaArray a;

   221   a.AppendL(crit);

   222   

   223   AttachL(a);

   224   

   225   CleanupStack::Pop(crit); // crit

   226   a.ResetAndDestroy();

   227 }  

   228 

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

   230                                                                        CLiwCriteriaItem* aItem)

   231 {

   232   CLiwGenericParamList* inps = &(InParamListL());

   233   CLiwGenericParamList* outps = &(OutParamListL());

   234   

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

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

   237 

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

   239   CleanupStack::PopAndDestroy(crit); // crit

   240 

   241   TInt pos = 0;

   242   MLiwInterface* ifp;

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

   244   if (p) {

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

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

   247   }

   248   else

   249     return;

   250   

   251   outps->Reset();

   252   inps->Reset();

   253   

   254   _LIT8(KId,"id");

   255   _LIT8(KCmd,"cmd");

   256   _LIT8(KCmdStr,"cmd_str");

   257   _LIT8(KType,"type");

   258   _LIT8(KListImpl,"ListImplementations");

   259   

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

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

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

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

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

   265   

   266   pos = 0;

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

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

   269     pos = 0;

   270     const CLiwList* list;

   271     _LIT8(KIdList,"id_list");

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

   273     if (p) {

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

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

   276         TLiwVariant v;

   277         v.PushL();

   278         list->AtL(i, v);

   279         aArray.AppendL(v.AsTInt32());

   280         CleanupStack::Pop(&v);

   281         v.Reset();

   282       }

   283     }

   284   }

   285 

   286   CleanupStack::Pop(ifp); // ifp

   287   ifp->Close();

   288 }

   289 

   290 CLiwServiceIfBase* CLiwServiceHandlerImpl::ServiceManagerPlugin_CreateImplementationL(TInt32 aImplUid)

   291 {

   292   CLiwGenericParamList* inps = &(InParamListL());

   293   CLiwGenericParamList* outps = &(OutParamListL());

   294   

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

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

   297 

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

   299   CleanupStack::PopAndDestroy(crit); // crit

   300 

   301   TInt pos = 0;

   302   MLiwInterface* ifp = NULL;

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

   304   if (p) {

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

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

   307   }

   308   else

   309     User::Leave(KErrNotFound);

   310   

   311   outps->Reset();

   312   inps->Reset();

   313   _LIT8(KUid,"uid");

   314   _LIT8(KCreateImpl,"CreateImplementation");

   315   

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

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

   318   

   319   pos = 0;

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

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

   322 

   323   pos = 0;

   324   CLiwServiceIfBase* iface = NULL;

   325   _LIT8(KImplPtr, "impl_ptr");

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

   327   if (p) {

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

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

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

   331     else

   332       User::Leave(KErrNotFound);

   333   }

   334   else

   335     User::Leave(KErrNotFound);

   336 

   337   CleanupStack::Pop(ifp); // ifp

   338   ifp->Close();

   339 

   340   return iface;

   341 }

   342 

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

   344     CLiwCriteriaItem& aItem)

   345     {

   346     TInt i;

   347 

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

   349         {   

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

   351             {

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

   353             }

   354         }

   355     }

   356 

   357 

   358 

   359 TInt CLiwServiceHandlerImpl::NbrOfProviders(const CLiwCriteriaItem* aCriteria)

   360     {

   361     if(!aCriteria)

   362         {

   363         return 0;

   364         }

   365     

   366     TInt i, j;

   367 

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

   369         {

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

   371             {

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

   373                 {

   374                 return iBaseBindings[i]->NumberOfProviders();

   375                 }

   376             }

   377         }

   378 

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

   380         {

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

   382             {

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

   384                 {

   385                 return iMenuBindings[i]->NumberOfProviders();

   386                 }

   387             }       

   388         }

   389 

   390     return 0;

   391     }

   392 

   393 

   394 

   395 void CLiwServiceHandlerImpl::AttachL(TInt aInterestResourceId)

   396     {

   397     // CCoeEnv/CEikonEnv needs to be accessible.

   398     if(!iCoeEnv)

   399         {

   400         User::Leave(KErrNotSupported);

   401         }

   402     

   403     RCriteriaArray interest, filtered;

   404 

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

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

   407 

   408     TResourceReader reader;

   409     iCoeEnv->CreateResourceReaderLC(reader, aInterestResourceId);

   410     ReadInterestListL(reader, interest);

   411     CleanupStack::PopAndDestroy(); //reader

   412 

   413     FilterInterestListL(interest, filtered);

   414     

   415     DoAttachL(filtered,NULL);

   416 

   417     filtered.Reset();

   418 

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

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

   421     }

   422 

   423 

   424 

   425 TInt CLiwServiceHandlerImpl::AttachL(const RCriteriaArray& aInterest)

   426     {

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

   428     }

   429 

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

   431     {

   432     RCriteriaArray interest, filtered;

   433     

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

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

   436         

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

   438         {

   439         CLiwCriteriaItem* item = CLiwCriteriaItem::NewLC();

   440         	

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

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

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

   444         else

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

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

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

   448         

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

   450 		

   451 		//Setting the imetadataOptions of item

   452 		TLiwVariant metadataOption;

   453 		metadataOption.PushL();

   454 		

   455         aInterest[i]->GetMetaDataOptions(metadataOption);

   456 		item->SetMetaDataOptions(metadataOption);

   457 		metadataOption.Reset();

   458 				

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

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

   461         

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

   463         CleanupStack::Pop(&metadataOption); 

   464         CleanupStack::Pop(item); 

   465         }

   466         

   467     FilterInterestListL(interest, filtered);        

   468 

   469 	TInt result = DoAttachL(filtered,aSecMgrScriptSession);

   470 

   471     filtered.Reset();

   472 		

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

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

   475     

   476     return result;

   477     }

   478 

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

   480     {

   481     CLiwBinding* bind;

   482     TInt success = -1;

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

   484         {

   485         bind = CLiwBinding::NewLC();

   486         

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

   488         

   489         if (success == KLiwServiceLoadSuccess)

   490             {

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

   492             CleanupStack::Pop(bind); // bind

   493             bind->AddCriteriaL(aInterest[i]);

   494 

   495             // Initialise providers.

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

   497                 {

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

   499                 // could prevent the initialisation of other providers.

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

   501                 

   502                 

   503                 

   504                 if(err)

   505                     {

   506 #ifdef _DEBUG                    

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

   508 #endif                    

   509                     }

   510                 }

   511             }

   512         else

   513             {

   514             CleanupStack::PopAndDestroy(bind); // bind

   515             }

   516         }

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

   518     }

   519 

   520 

   521 void CLiwServiceHandlerImpl::GetInterest(RCriteriaArray& aInterest)

   522     {

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

   524         {

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

   526             {

   527             return;

   528             }

   529         }

   530     }

   531     

   532     

   533 

   534 void CLiwServiceHandlerImpl::DetachL(const RCriteriaArray& aInterest)

   535     {

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

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

   538         {

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

   540             {

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

   542             if (index != KErrNotFound)

   543                 {

   544                 iBaseBindings[j]->RemoveCriteria(index);

   545                 }                           

   546             }

   547         }

   548 

   549     // Second pass removes empty bindings.

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

   551         {

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

   553             {

   554             delete iBaseBindings[i];

   555             iBaseBindings.Remove(i);

   556             i--;

   557             }

   558         }

   559 

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

   561     RemoveObsoleteCriteriaItems();

   562     

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

   564     RemoveObsoleteProviders();        

   565     }

   566 

   567 

   568 

   569 void CLiwServiceHandlerImpl::DetachL(TInt aInterestResourceId)

   570     { 

   571     // CCoeEnv/CEikonEnv needs to be accessible.

   572     if(!iCoeEnv)

   573         {

   574         User::Leave(KErrNotSupported);

   575         }

   576     

   577     RCriteriaArray interest;

   578 

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

   580 

   581     TResourceReader reader;

   582     iCoeEnv->CreateResourceReaderLC(reader, aInterestResourceId);

   583     ReadInterestListL(reader, interest);

   584     CleanupStack::PopAndDestroy(); //reader

   585 

   586     DetachL( interest );

   587 

   588     interest.ResetAndDestroy();

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

   590     }

   591 

   592 

   593 const CLiwCriteriaItem* CLiwServiceHandlerImpl::GetCriteria(TInt aId)

   594     {

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

   596         {

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

   598             {

   599             return iInterestList[i];

   600             }

   601         }

   602 

   603     return NULL;  

   604     }

   605     

   606 TInt CLiwServiceHandlerImpl::NumAlreadyInitializedPaneIdsL() const

   607     {

   608     TInt ret = 0;

   609     TInt paneIds[KMaxPaneIds] = {0};

   610     TBool found = EFalse;

   611     

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

   613         {

   614         found = EFalse;

   615         

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

   617             {

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

   619                 {

   620                 found = ETrue;

   621                 break;              

   622                 }

   623             }

   624                 

   625         if (!found) 

   626             {

   627             // Create new item.

   628             if (ret >= KMaxPaneIds)

   629                 {

   630 #ifdef _DEBUG

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

   632 #endif

   633                 User::Leave(KErrOverflow);

   634                 }

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

   636             ret++;

   637             }                       

   638         }

   639     return ret;         

   640     }    

   641 

   642 void CLiwServiceHandlerImpl::InitializeMenuPaneL(

   643     CEikMenuPane& aMenuPane,

   644     TInt aMenuResourceId, 

   645     TInt aBaseMenuCmdId,

   646     const CLiwGenericParamList& aInParamList)

   647     {

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

   649     }        

   650         

   651 void CLiwServiceHandlerImpl::InitializeMenuPaneL(

   652     CEikMenuPane& aMenuPane,

   653     TInt aMenuResourceId, 

   654     TInt aBaseMenuCmdId,

   655     const CLiwGenericParamList& aInParamList,

   656     TBool aUseSubmenuTextsIfAvailable)

   657     {        

   658     // CCoeEnv/CEikonEnv needs to be accessible.

   659     if(!iCoeEnv)

   660         {

   661         User::Leave(KErrNotSupported);

   662         }

   663     

   664     if (!iMenuBindings.Count())

   665         {

   666         // Either no menu is attached to interest or menu was attached but

   667         // it didn't contain any placeholders for criteria items. So

   668         // nothing to do, get out.

   669         return;

   670         }

   671 

   672     TInt index;

   673     TInt slotcmd;

   674     TBuf <KMaxMenuTitleSize> subTitle;

   675     TBool titleLocked;

   676     TInt paneOffset = NumAlreadyInitializedPaneIdsL() * KIndividualMenuPaneIdRange;

   677 

   678     iSubmenuCmd = aBaseMenuCmdId + KMenuPaneCommandRange;

   679     slotcmd = SlotItemCmd(aMenuPane);

   680     if (slotcmd >= 0)

   681         {

   682         // aMenuPane is liw submenu. At this point it is empty and we must

   683         // copy provider menu items to it.

   684         CLiwMenuPane* liwPane = MenuPaneForSlotCmd(slotcmd);

   685         if (liwPane)

   686             {

   687             CopyMenuItemsL(liwPane, aMenuPane, 0, ETrue);

   688             aMenuPane.DeleteMenuItem(slotcmd);

   689             iSubmenu = liwPane;

   690             }

   691         }

   692     else

   693         {

   694         iSubmenu = NULL;

   695         

   696         const TInt bindcount = iMenuBindings.Count();

   697         for (TInt i = 0; i < bindcount; i++)

   698             {

   699             if  ((iMenuBindings[i]->MenuId() == aMenuResourceId) &&

   700                 (aMenuPane.MenuItemExists(iMenuBindings[i]->MenuCmd(), index)))

   701                 {

   702                 CLiwMenuPane* liwPane = iMenuBindings[i]->MenuPane();

   703                 TInt menuResourceId = -1;

   704                 if(liwPane)

   705                     {

   706                     // An LIW menu pane already exists (this means that a normal

   707                     // non-LIW submenu with LIW items has been opened more than once). 

   708                     // In this case we use the existing resource slot id.

   709                     menuResourceId = liwPane->ResourceSlotId();

   710                     paneOffset = liwPane->PaneOffset();

   711                     DeleteLiwMenuPane(liwPane);

   712                     liwPane = NULL;

   713                     }

   714                 liwPane = CreateEmptyLiwMenuPaneL(aBaseMenuCmdId, menuResourceId);

   715                 CleanupStack::PushL(liwPane);

   716                 liwPane->SetPaneOffset(paneOffset);

   717                 paneOffset += KPlaceholderCmdIdRange;

   718                 iMenuBindings[i]->SetMenuPane(liwPane);     

   719 

   720                 // Clean previous service commands from list.

   721                 CLiwGenericParamList& list = const_cast<CLiwGenericParamList&>(aInParamList);

   722                 while (list.Remove(EGenericParamServiceCommand)) 

   723                     {

   724                     // Intentionally left empty.    

   725                     }

   726 

   727                 // Add service commands for current placeholder.

   728                 const TInt icount = iMenuBindings[i]->Interest().Count();

   729                 for (TInt k = 0; k < icount; k++)

   730                     {

   731                     list.AppendL(TLiwGenericParam(EGenericParamServiceCommand,

   732                         TLiwVariant(iMenuBindings[i]->Interest()[k]->ServiceCmd())));

   733                     }

   734 

   735                 // Loop from last entry to first entry always inserting to same index.

   736                 // Default provider is the first item in list, so if there is a default

   737                 // provider defined, it will be the first one to appear in menus.               

   738                 for (TInt j = iMenuBindings[i]->NumberOfProviders() - 1; j >= 0; j--)

   739                     {

   740                     liwPane->SetInitializingOwner(iMenuBindings[i]->MenuProvider(j));

   741                     iMenuBindings[i]->MenuProvider(j)->InitializeMenuPaneHookL(liwPane,

   742                         0, 0, aInParamList);

   743                     }

   744 

   745                 GetSubmenuTitle(liwPane->MenuPane(), subTitle);

   746             

   747                 TLiwPlaceholderType phtype = PlaceholderType(aMenuPane, 

   748                     iMenuBindings[i]->MenuCmd(), titleLocked);

   749 

   750                 if ((phtype == ELiwPlaceholderCascade) ||

   751                     (phtype == ELiwPlaceholderIntelligentCascade))

   752                     {

   753                     if (liwPane->MenuPane().NumberOfItemsInPane() == 1)

   754                         {

   755                         // Remove placeholder item.

   756                         aMenuPane.DeleteMenuItem(iMenuBindings[i]->MenuCmd());

   757                         CleanupStack::PopAndDestroy(liwPane); // liwPane

   758                         continue;

   759                         }

   760                     else if ((liwPane->MenuPane().NumberOfItemsInPane() == 2) &&

   761                         (phtype == ELiwPlaceholderIntelligentCascade))

   762                         {

   763                         UnCascadeL(aMenuPane, iMenuBindings[i]->MenuCmd(), *liwPane);

   764                         User::LeaveIfError(iLastInitialized.Append(liwPane));

   765                         }

   766                     else

   767                         {

   768                         if (titleLocked)

   769                             {

   770                             subTitle.Zero();

   771                             }

   772                         ConvertPlaceholderL(aMenuPane, iMenuBindings[i]->MenuCmd(), *liwPane, 

   773                             subTitle);

   774                         }       

   775                     }

   776                 else

   777                     {

   778                     // Remove placeholder item.

   779                     aMenuPane.DeleteMenuItem(iMenuBindings[i]->MenuCmd());

   780         

   781                     // Copy menu items to actual menu pane

   782                     CopyMenuItemsL(liwPane, aMenuPane, index, aUseSubmenuTextsIfAvailable);

   783                     User::LeaveIfError(iLastInitialized.Append(liwPane));

   784                     }

   785                 liwPane->SetMenuResourceId(aMenuResourceId);

   786                 User::LeaveIfError(iMenuPanes.Append(liwPane));

   787                 CleanupStack::Pop(liwPane); // liwPane

   788                 }

   789             }

   790         }

   791     }

   792 

   793 

   794 

   795 

   796 TInt CLiwServiceHandlerImpl::ServiceCmdByMenuCmd(TInt aMenuCmdId) const

   797     {

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

   799         {

   800         if ((IsInLastInitialized(iMenuBindings[i]->MenuPane())) &&

   801             (iMenuBindings[i]->MenuPane()->IsCmdInRange(KPlaceholderCmdIdRange, aMenuCmdId)))

   802             {

   803             return iMenuBindings[i]->MenuPane()->ServiceCmdId(aMenuCmdId); 

   804             }

   805         }

   806 

   807     return 0;   

   808     }

   809 

   810 

   811 

   812 void CLiwServiceHandlerImpl::ExecuteMenuCmdL(

   813     TInt aMenuCmdId,

   814     const CLiwGenericParamList& aInParamList,

   815     CLiwGenericParamList& aOutParamList,

   816     TUint aCmdOptions,

   817     MLiwNotifyCallback* aCallback)

   818     {

   819     // CCoeEnv/CEikonEnv needs to be accessible.

   820     if(!iCoeEnv)

   821         {

   822         User::Leave(KErrNotSupported);

   823         }

   824     

   825     if (!iMenuBindings.Count())

   826         {

   827         return;

   828         }   

   829 

   830     // Handle real menu providers.

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

   832         {

   833         CLiwMenuPane* menuPane = iMenuBindings[i]->MenuPane();

   834 

   835         if (IsInLastInitialized(menuPane))

   836             {

   837             for (TInt j = 0; j < iMenuBindings[i]->NumberOfProviders(); j++)

   838                 {

   839                 if ((menuPane->IsCmdInRange(KPlaceholderCmdIdRange, aMenuCmdId)) && 

   840                     (menuPane->CommandOwner(aMenuCmdId) == iMenuBindings[i]->MenuProvider(j)))

   841                     {

   842                     iMenuBindings[i]->MenuProvider(j)->HandleMenuCmdHookL(

   843                         menuPane, 

   844                         aMenuCmdId, 

   845                         aInParamList, 

   846                         aOutParamList, 

   847                         aCmdOptions, 

   848                         aCallback); 

   849                     return;

   850                     }

   851                 }

   852             }

   853         }

   854     }

   855 

   856 

   857 

   858 void CLiwServiceHandlerImpl::AttachMenuL(TInt aMenuResourceId, TInt aInterestResourceId)

   859     {

   860     // CCoeEnv/CEikonEnv needs to be accessible.

   861     if(!iCoeEnv)

   862         {

   863         User::Leave(KErrNotSupported);

   864         }

   865     

   866     RCriteriaArray interest, filtered;

   867     TResourceReader reader;

   868 

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

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

   871     iCoeEnv->CreateResourceReaderLC(reader, aInterestResourceId);

   872     ReadInterestListL(reader, interest);

   873     CleanupStack::PopAndDestroy(); //reader

   874     FilterInterestListL(interest, filtered);

   875 

   876     iCoeEnv->CreateResourceReaderLC(reader, aMenuResourceId);

   877     DoAttachMenuL(reader, aMenuResourceId, filtered);

   878     filtered.Reset();

   879     CleanupStack::PopAndDestroy(); //reader

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

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

   882     }

   883 

   884 

   885 

   886 void CLiwServiceHandlerImpl::AttachMenuL(TInt aMenuResourceId, TResourceReader& aReader)

   887     {

   888     // CCoeEnv/CEikonEnv needs to be accessible.

   889     if(!iCoeEnv)

   890         {

   891         User::Leave(KErrNotSupported);

   892         }

   893     

   894     RCriteriaArray interest, filtered;

   895     TResourceReader reader;

   896 

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

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

   899     ReadInterestListL(aReader, interest);

   900     FilterInterestListL(interest, filtered);

   901 

   902     iCoeEnv->CreateResourceReaderLC(reader, aMenuResourceId);

   903     DoAttachMenuL(reader, aMenuResourceId, filtered);

   904     filtered.Reset();

   905     CleanupStack::PopAndDestroy(); //reader

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

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

   908     }

   909 

   910 void CLiwServiceHandlerImpl::AttachMenuL(TInt aMenuResourceId, const RCriteriaArray& aInterest)

   911     {

   912     // CCoeEnv/CEikonEnv needs to be accessible.

   913     if(!iCoeEnv)

   914         {

   915         User::Leave(KErrNotSupported);

   916         }    

   917     

   918     RCriteriaArray interest, filtered;

   919     TResourceReader reader;

   920     

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

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

   923         

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

   925         {

   926         CLiwCriteriaItem* item = CLiwCriteriaItem::NewLC();

   927         

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

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

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

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

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

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

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

   935         

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

   937         CleanupStack::Pop(item); 

   938         }

   939         

   940     FilterInterestListL(interest, filtered);        

   941 

   942     iCoeEnv->CreateResourceReaderLC(reader, aMenuResourceId);

   943     DoAttachMenuL(reader, aMenuResourceId, filtered);

   944     filtered.Reset();

   945     CleanupStack::PopAndDestroy(); //reader

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

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

   948     }   

   949 

   950 void CLiwServiceHandlerImpl::AttachMenuL(RArray<TInt>& aMenuEntries,

   951                                          TInt aMenuResourceId,

   952                                          RCriteriaArray& aInterest)

   953     {

   954     RCriteriaArray filtered;

   955 

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

   957     FilterInterestListL(aInterest, filtered);

   958     

   959     TInt menuCmd;

   960     TInt count = aMenuEntries.Count();

   961     TBool bound;

   962 

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

   964         {

   965         menuCmd = aMenuEntries[i];

   966         CLiwMenuBinding* bind = NULL;

   967         bound = EFalse;

   968 

   969         if (!menuCmd)

   970           continue;

   971 

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

   973             {           

   974             if (filtered[j]->Id() == menuCmd)

   975                 {                       

   976                 if (!bind)

   977                     {

   978                     bind = AlreadyBound(aMenuResourceId, menuCmd, i);

   979                     if (!bind)

   980                         {

   981                         bind = CLiwMenuBinding::NewLC(i, aMenuResourceId);

   982                         bind->SetMenuCmd( menuCmd );

   983                         }

   984                     else

   985                         {

   986                         bound = ETrue;

   987                         }

   988                     }

   989                 

   990                 if (bind->HasCriteriaItem(*(filtered[j])) == KErrNotFound)

   991                     {

   992                     	ResolveProvidersL(bind, filtered[j],NULL);

   993                     bind->AddCriteriaL(filtered[j]);

   994                     }

   995                 }

   996             }

   997 

   998         // Initialise providers.

   999         if (bind)

  1000             {

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

  1002                 {

  1003                 bind->MenuProvider(k)->InitialiseL(*this, bind->Interest());

  1004                 }

  1005             if (!bound)

  1006                 {

  1007                 User::LeaveIfError(iMenuBindings.Append( bind ));

  1008                 CleanupStack::Pop(bind);  // bind                       

  1009                 }

  1010             }

  1011         }

  1012 

  1013     filtered.Reset();

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

  1015     }

  1016 

  1017 void CLiwServiceHandlerImpl::DoAttachMenuL(TResourceReader& aReader, TInt aMenuId, 

  1018     RCriteriaArray& aInterest)

  1019     {

  1020     TInt menuCmd;

  1021     TInt count = aReader.ReadInt16();

  1022     TBool bound;

  1023 

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

  1025         {

  1026         menuCmd = aReader.ReadInt32();

  1027         CLiwMenuBinding* bind = NULL;

  1028         bound = EFalse;

  1029 

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

  1031             {           

  1032             if (aInterest[j]->Id() == menuCmd)

  1033                 {                       

  1034                 if (!bind)

  1035                     {

  1036                     bind = AlreadyBound(aMenuId, menuCmd, i);

  1037                     if (!bind)

  1038                         {

  1039                         bind = CLiwMenuBinding::NewLC(i, aMenuId);

  1040                         bind->SetMenuCmd( menuCmd );

  1041                         }

  1042                     else

  1043                         {

  1044                         bound = ETrue;

  1045                         }

  1046                     }

  1047                 

  1048                 if (bind->HasCriteriaItem(*(aInterest[j])) == KErrNotFound)

  1049                     {

  1050                     	ResolveProvidersL(bind, aInterest[j],NULL);

  1051                     bind->AddCriteriaL(aInterest[j]);

  1052                     }

  1053                 }

  1054             }

  1055 

  1056         // Initialise providers.

  1057         if (bind)

  1058             {

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

  1060                 {

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

  1062                 if(err)

  1063                     {

  1064 #ifdef _DEBUG

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

  1066 #endif                     

  1067                     // The provider failed to initialise.

  1068                     // Remove the failed provider from this menu binding.

  1069                     CLiwServiceIfMenu* provider = bind->MenuProvider(k);

  1070                     TInt implUid = provider->ImplementationUid().iUid;

  1071                     bind->RemoveProvider(implUid);

  1072                     

  1073                     // Remove the failed provider also from other menu bindings.

  1074                     for (TInt m = 0; m < iMenuBindings.Count(); m++)

  1075                         {

  1076                         iMenuBindings[m]->RemoveProvider(implUid);

  1077                         }

  1078 

  1079                     // Then remove provider from the owner list and delete it.

  1080                     for (TInt m = 0; m < iProviders.Count(); m++)

  1081                         {

  1082                         if (iProviders[m]->ImplementationUid().iUid == implUid)

  1083                             {

  1084                             delete iProviders[m];

  1085                             iProviders.Remove(m);

  1086                             m--;

  1087                             }

  1088                         }                    

  1089                     }

  1090                 }

  1091             if (!bound)

  1092                 {

  1093                 User::LeaveIfError(iMenuBindings.Append( bind ));

  1094                 CleanupStack::Pop(bind);  // bind                       

  1095                 }

  1096             }

  1097         SkipMenuFields(aReader);  // Jump to next menu item

  1098         }

  1099     }

  1100 

  1101 void CLiwServiceHandlerImpl::ReadInterestL(RCriteriaArray& aInterest, TInt aInterestResourceId)

  1102     {

  1103     CleanupStack::PushL( TCleanupItem( InterestCleanup, &aInterest ) );

  1104     TResourceReader reader;

  1105     iCoeEnv->CreateResourceReaderLC(reader, aInterestResourceId);

  1106     ReadInterestListL(reader, aInterest);

  1107     CleanupStack::PopAndDestroy(); //reader

  1108     CleanupStack::Pop(&aInterest);

  1109     }

  1110 

  1111 

  1112 void CLiwServiceHandlerImpl::DetachMenu(TInt aMenuResourceId, TInt aInterestResourceId)

  1113     {

  1114     // If interest resource id is null, then detach all items in the given menu.

  1115     if (!aInterestResourceId)

  1116         {

  1117         DoDetachMenu(aMenuResourceId);        

  1118         }

  1119     else

  1120         {

  1121         // CCoeEnv/CEikonEnv needs to be accessible.

  1122         if(!iCoeEnv)

  1123             {

  1124             // We cannot leave because this is a non-leaving method.

  1125             return; 

  1126             }    

  1127 

  1128         RCriteriaArray interest;

  1129         TRAPD(err, ReadInterestL(interest, aInterestResourceId));

  1130         if (err)

  1131             {

  1132             return;

  1133             }

  1134         

  1135         DoDetachMenu(aMenuResourceId, interest);