1 /*

     2 * Copyright (c) 2006 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 "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:  Implementation of CCmManagerImpl.

    15 *

    16 */

    17 

    18 #include "cmmanagerimpl.h"

    19 #include <cmpluginbaseeng.h>

    20 #include <cmpluginbase.h>

    21 #include <cmdestination.h>

    22 #include <cmdestinationext.h>

    23 #include "cmdestinationimpl.h"

    24 #include "cmtransactionhandler.h"

    25 #include "cmlogger.h"

    26 #include "cmmanager.hrh"

    27 #include <cmcommonconstants.h>

    28 #include <cmmanagerext.h>

    29 #include <cmpluginembdestinationdef.h>

    30 #include "cmobjectpool.h"

    31 #include "cmcommsdatnotifier.h"

    32 

    33 #include <sysutil.h>

    34 #include <featmgr.h>

    35 #include <wlancontainer.h>  // CCDWlanServiceRecord

    36 #include <StringLoader.h>

    37 #include <commsdattypesv1_1.h>

    38 #include <e32cmn.h>

    39 #include <bautils.h>        // BaflUtils

    40 #include <cmmanager.rsg>    // resource

    41 #include <data_caging_path_literals.hrh>

    42 #include <ecom/ecom.h>        // For REComSession

    43 #include <cmmanagerext.h> 

    44 

    45 #include <cmmanager.mbg>   // icons

    46 #include <AknsUtils.h>

    47 

    48 #include <commsdattypesv1_1.h>

    49 #include <rconnmon.h>

    50 

    51 using namespace CMManager;

    52 using namespace CommsDat;

    53 

    54 // CONSTANTS

    55 

    56 const TInt KResFileGranularity = 5;

    57 const TInt KPluginGranularity = 3;

    58 // if a CmId is grater than KMaxIapId, than it has no iap record

    59 // Otherwise cmId is the same as the IapId

    60 const TUint32 KMaxIapID = 255;

    61 // Safety margin when checking disk space

    62 const TUint32 KBytesToWrite = 8000; 

    63 

    64 const TUint32 KEndOfArray = KMaxTUint;

    65 /**

    66 * This array lists all the bearerspecific attributes.

    67 * The bearerspecific attributes can be queried via both 

    68 * the manager interface's and connection method interface's ::Get functions.

    69 */

    70 static const TUint32 KBearerSpecificAttributes[]=

    71     {

    72     /**

    73     */

    74     ECmCoverage,                        

    75     ECmDefaultPriority,                        

    76     ECmDestination,     

    77     ECmBearerHasUi,   

    78     ECmIPv6Supported,           

    79     ECmDefaultUiPriority,

    80     ECmBearerIcon,

    81     ECmBearerAvailableIcon,

    82     ECmBearerAvailableName,

    83     ECmBearerSupportedName,

    84     ECmBearerAvailableText,                        

    85     ECmBearerNamePopupNote,

    86     ECmCommsDBBearerType,   

    87     ECmBearerSettingName,

    88     ECmVirtual,

    89     ECmExtensionLevel,

    90     ECmAddToAvailableList,

    91     KEndOfArray

    92     };

    93 

    94 // -----------------------------------------------------------------------------

    95 // Test functions

    96 // -----------------------------------------------------------------------------

    97 //

    98 /*#ifdef _DEBUG

    99 void DumIapTableL( CMDBSession& aSession )

   100     {

   101     CMDBRecordSet<CCDIAPRecord>*  ptrRecordSet = 

   102                     new (ELeave) CMDBRecordSet<CCDIAPRecord>( KCDTIdIAPRecord );

   103     CleanupStack::PushL( ptrRecordSet );

   104     

   105     TRAP_IGNORE( ptrRecordSet->LoadL( aSession ) );

   106     

   107     TInt iapRecords = ptrRecordSet->iRecords.Count();

   108     CLOG_WRITE_1_PTR( NULL, "Dumping IAP Table\nNo. of IAPs: [%d]", iapRecords );

   109     for ( TInt i = 0; i < iapRecords; i++ )

   110         {

   111         CCDIAPRecord* iapRecord = (*ptrRecordSet)[i];

   112 

   113         CLOG_WRITE_4_PTR( NULL, "Rec id:[%d] - Name: [%S] - Service Type: [%S] - Bearer Type: [%S]",

   114                                 iapRecord->RecordId(),

   115                                 &FIELD_TO_TDESC( iapRecord->iRecordName ),

   116                                 &FIELD_TO_TDESC( iapRecord->iServiceType ),

   117                                 &FIELD_TO_TDESC( iapRecord->iBearerType )

   118                                 );

   119         }

   120 

   121     CleanupStack::PopAndDestroy( ptrRecordSet );

   122     }

   123 #endif */ // _DEBUG

   124 

   125 //=============================================================================

   126 // CONSTRUCTION / DESTRUCTION API

   127 //=============================================================================

   128 //

   129 

   130 //-----------------------------------------------------------------------------

   131 //  CCmManagerImpl::NewL()

   132 //-----------------------------------------------------------------------------

   133 //

   134 CCmManagerImpl* CCmManagerImpl::NewL( TBool aCreateTables )

   135     {

   136     CCmManagerImpl* self = new (ELeave) CCmManagerImpl();

   137     CleanupStack::PushL( self );

   138     self->iCreateTables = aCreateTables;

   139     self->ConstructL();

   140     CleanupStack::Pop( self );   // self

   141     

   142     return self;

   143     }

   144 

   145 //-----------------------------------------------------------------------------

   146 //  CCmManagerImpl::CCmManagerImpl()

   147 //-----------------------------------------------------------------------------

   148 //

   149 CCmManagerImpl::CCmManagerImpl()

   150 :iDefConnSupported(EFalse),iCreateTables(ETrue)

   151     {

   152     CLOG_CREATE;

   153 

   154     Dll::SetTls( this );

   155     }

   156 

   157 //-----------------------------------------------------------------------------

   158 //  CCmManagerImpl::CCmManagerImpl()

   159 //-----------------------------------------------------------------------------

   160 //

   161 CCmManagerImpl::~CCmManagerImpl()

   162     {

   163     CLOG_WRITE( "CCmManagerImpl::~CCmManagerImpl" );

   164     

   165     if ( iBearerPriorityArray )

   166         {

   167         CleanupGlobalPriorityArray( *iBearerPriorityArray );

   168         delete iBearerPriorityArray;

   169         }

   170 

   171     if ( iPlugins )

   172         {

   173         iPlugins->ResetAndDestroy();

   174         delete iPlugins;

   175         }

   176     

   177     

   178     if ( iResourceFiles )

   179         {

   180         TInt resCount = iResourceFiles->Count();

   181         for ( TInt i = 0; i < resCount; ++i )

   182             {

   183             // close the resource file

   184             (*iResourceFiles)[0]->iFile.Close();

   185             // delete the structure

   186             delete (*iResourceFiles)[0];

   187             // delete array item

   188             iResourceFiles->Delete( 0 );

   189             }

   190             

   191         iResourceFiles->Reset();        

   192         delete iResourceFiles;

   193         }

   194     

   195     iFs.Close();

   196     

   197     delete iPluginImpl;

   198 

   199     delete &Session();

   200     delete iTrans;

   201 

   202     if( iIsFeatureManagerInitialised )

   203         {

   204         FeatureManager::UnInitializeLib();

   205         }

   206 

   207     REComSession::FinalClose();

   208     

   209     delete iObjectPool;

   210     

   211     delete iCommsDatIapNotifier;

   212     delete iCommsDatSnapNotifier;

   213 

   214     CLOG_CLOSE;

   215     }

   216 

   217       

   218 // -----------------------------------------------------------------------------

   219 // CCmManagerImpl::CheckTablesL()

   220 // -----------------------------------------------------------------------------

   221 //     

   222 void CCmManagerImpl::CheckTablesL()

   223     {

   224     LOGGER_ENTERFN( "CCmManagerImpl::CheckDestinationNetworkTableL" );

   225     

   226     TInt err( 0 );

   227 

   228     CLOG_WRITE( "Destination network" );

   229     if (iCreateTables)

   230         {

   231         TRAP( err, iDestinationTableId = 

   232                         CCDDataMobilitySelectionPolicyRecord::TableIdL( Session() ));

   233         CLOG_WRITE_1( "err: [%d]", err );

   234         if( err == KErrNotFound )

   235             {

   236             iDestinationTableId = 

   237                        CCDDataMobilitySelectionPolicyRecord::CreateTableL( Session() );

   238             }

   239         else

   240             {

   241             User::LeaveIfError( err );

   242             }        

   243         }

   244     else

   245         {

   246         iDestinationTableId = 

   247                         CCDDataMobilitySelectionPolicyRecord::TableIdL( Session() );        

   248         }

   249         

   250     CLOG_WRITE( "Global Bearer Type Priorization Table" );

   251     TRAP( err, iBearerTypePriorizationTableId = 

   252                 CCDGlobalBearerTypePriorizationRecord::TableIdL( Session() ) );

   253     CLOG_WRITE_1( "err: [%d]", err );

   254     if( err == KErrNotFound )

   255         {

   256         iBearerTypePriorizationTableId = 

   257                CCDGlobalBearerTypePriorizationRecord::CreateTableL( Session() );

   258         }

   259     else

   260         {

   261         User::LeaveIfError( err );

   262         }

   263     

   264     CLOG_WRITE( "Destination network - Icon table" );        

   265     TRAP( err, iIconTableId = CCDSNAPMetadataRecord::TableIdL( Session() ) );

   266     if( err == KErrNotFound )

   267         {

   268         iIconTableId = CCDSNAPMetadataRecord::CreateTableL( Session() );

   269         }

   270     else

   271         {

   272         User::LeaveIfError( err );

   273         }

   274         

   275     CLOG_WRITE( "Seamlessness table" );

   276     TRAP( err, iSeamlessnessTableId = CCDIAPMetadataRecord::TableIdL( Session() ) );

   277     CLOG_WRITE_1( "err: [%d]", err );

   278     if( err == KErrNotFound )

   279         {

   280         iSeamlessnessTableId = CCDIAPMetadataRecord::CreateTableL( Session() );

   281         }

   282     else

   283         {

   284         User::LeaveIfError( err );

   285         }

   286     if ( IsDefConnSupported() )

   287         {

   288         CLOG_WRITE( "Default connection table" );

   289         TRAP( err, iDefConnTableId = CCDDefConnRecord::TableIdL( Session() ) );

   290         CLOG_WRITE_1( "err: [%d]", err );

   291         if( err == KErrNotFound )

   292             {

   293             iDefConnTableId = CCDDefConnRecord::CreateTableL( Session() );

   294             }

   295         else

   296             {

   297             User::LeaveIfError( err );

   298             }   

   299         }

   300     }

   301      

   302 //-----------------------------------------------------------------------------

   303 //  CCmManagerImpl::CreateBearerPriorityArrayL()

   304 //-----------------------------------------------------------------------------

   305 //

   306 void CCmManagerImpl::CreateBearerPriorityArrayL()

   307     {

   308     LOGGER_ENTERFN( "CCmManagerImpl:CreateBearerPriorityArray" );

   309 

   310     iBearerPriorityArray = 

   311                 new ( ELeave ) RArray<TBearerPriority>( KCmArrayBigGranularity );

   312 

   313     CMDBRecordSet<CCmBearerPriRec>* bpRS = 

   314                 new (ELeave) CMDBRecordSet<CCmBearerPriRec>( 

   315                                                iBearerTypePriorizationTableId );

   316     CleanupStack::PushL( bpRS );

   317         

   318     OpenTransactionLC();        

   319     TRAP_IGNORE( bpRS->LoadL( Session() ) );

   320     RollbackTransaction();

   321     

   322     TInt bpCount = bpRS->iRecords.Count();

   323     TInt i( 0 );

   324     

   325     while ( i < bpCount ) // loop the Bearer Priority table

   326         {

   327         // Bearer Priority record ID

   328         HBufC* bpServiceType = QUERY_HBUFC_FIELD( (*bpRS)[i], 

   329                                                   KCDTIdGlobalServiceType );

   330         

   331         TInt bpPriority = ( QUERY_INT_FIELD( (*bpRS)[i], 

   332                                              KCDTIdGlobalServicePriority ) );

   333         TInt uiPriority = ( QUERY_INT_FIELD( (*bpRS)[i], 

   334                                              KCDTIdGlobalServiceUIPriority ) );                                    

   335         CLOG_WRITE( "Bearer Priority Table Values" );

   336         CLOG_WRITE_1( "Service Type: [%S]", bpServiceType );

   337         CLOG_WRITE_1( "Bearer Priority: [%d]", bpPriority );

   338         CLOG_WRITE_1( "UI Priority: [%d]", uiPriority );                          

   339         TBearerPriority bp;

   340         bp.iServiceType = bpServiceType->AllocL();

   341         bp.iPriority = bpPriority;

   342         bp.iUIPriority = uiPriority;

   343         iBearerPriorityArray->AppendL( bp );

   344         i++;

   345         }

   346     

   347     CleanupStack::PopAndDestroy( bpRS );

   348     }

   349 

   350 //-----------------------------------------------------------------------------

   351 //  CCmManagerImpl::BearerPriorityArrayL()

   352 //-----------------------------------------------------------------------------

   353 //

   354 void CCmManagerImpl::BearerPriorityArrayL( RArray<TBearerPriority>& aArray ) const

   355     {

   356     LOGGER_ENTERFN( "CCmManagerImpl:BearerPriorityArray" );

   357     TRAPD( err, CopyBearerPriorityArrayL( aArray ) );

   358     if( err )

   359         // in case of any problem we clean up this array

   360         {

   361         User::Leave( err );

   362         }

   363     }

   364 

   365 //-----------------------------------------------------------------------------

   366 //  CCmManagerImpl::CopyBearerPriorityArrayL()

   367 //-----------------------------------------------------------------------------

   368 //

   369 void CCmManagerImpl::CopyBearerPriorityArrayL( 

   370                                         RArray<TBearerPriority>& aArray ) const

   371     {

   372     LOGGER_ENTERFN( "CCmManagerImpl:BearerPriorityArray" );

   373     for ( TInt i = 0; i < iBearerPriorityArray->Count(); i++ )

   374         {

   375         TBearerPriority item;

   376         

   377         TBearerPriority* orgItem = &(*iBearerPriorityArray)[i];

   378         

   379         item.iServiceType = HBufC::NewLC( orgItem->iServiceType->Length() );

   380         item.iServiceType->Des().Copy( *orgItem->iServiceType );

   381         item.iPriority = orgItem->iPriority;

   382         item.iUIPriority = orgItem->iUIPriority;

   383                           

   384         User::LeaveIfError( aArray.Append( item ) );

   385         

   386         CleanupStack::Pop(); // item->iServiceType

   387         }

   388     }

   389 

   390 //-----------------------------------------------------------------------------

   391 //  CCmManagerImpl::UpdateBearerPriorityArrayL()

   392 //-----------------------------------------------------------------------------

   393 //

   394 void CCmManagerImpl::UpdateBearerPriorityArrayL( 

   395                                         const RArray<TBearerPriority>& aArray )

   396     {

   397     LOGGER_ENTERFN( "CCmManagerImpl::UpdateBearerPriorityArray" );    

   398     

   399     OpenTransactionLC();

   400 

   401     CMDBRecordSet<CCmBearerPriRec>* bpRS = new (ELeave) 

   402             CMDBRecordSet<CCmBearerPriRec>( iBearerTypePriorizationTableId );

   403     CleanupStack::PushL( bpRS ); // 1

   404     TRAP_IGNORE( bpRS->LoadL( Session() ) );

   405     

   406     // Delete the old record

   407     for ( TInt i = 0; i < bpRS->iRecords.Count(); ++i )

   408         {

   409         bpRS->iRecords[i]->DeleteL( Session() );

   410         }

   411     

   412     CleanupGlobalPriorityArray( *iBearerPriorityArray );

   413             

   414     CleanupStack::PopAndDestroy( bpRS );

   415     bpRS = NULL;

   416     

   417     // Add the new content

   418     CCmBearerPriRec* bpRcd = 

   419             new (ELeave) CCmBearerPriRec( iBearerTypePriorizationTableId );

   420     CleanupStack::PushL( bpRcd ); // 2

   421 

   422     CLOG_WRITE( "Store bearer info to table" );

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

   424         {        

   425         bpRcd->SetRecordId( KCDNewRecordRequest );

   426         

   427         HBufC* serviceTypeVal = aArray[i].iServiceType;

   428         TInt priorityVal = aArray[i].iPriority;

   429         TInt uiPriorityVal = aArray[i].iUIPriority;

   430         

   431         CLOG_WRITE_FORMAT( "Set service type: [%S   ]", serviceTypeVal );

   432         SET_HBUFC_FIELD(    bpRcd, 

   433                             KCDTIdGlobalServiceType, 

   434                             serviceTypeVal );

   435         CLOG_WRITE_1( "Set priority: [%d]", priorityVal );

   436         SET_INT_FIELD(  bpRcd, 

   437                         KCDTIdGlobalServicePriority, 

   438                         priorityVal );

   439         CLOG_WRITE_1( "Set uipriority: [%d]", uiPriorityVal );

   440         SET_INT_FIELD(  bpRcd, 

   441                         KCDTIdGlobalServiceUIPriority, 

   442                         uiPriorityVal );                        

   443         bpRcd->StoreL( Session() );

   444         

   445         TBearerPriority item;

   446         

   447         item.iServiceType = serviceTypeVal->AllocLC();

   448         item.iPriority = priorityVal;

   449         item.iUIPriority = uiPriorityVal;

   450         iBearerPriorityArray->AppendL( item );

   451         CleanupStack::Pop( item.iServiceType );

   452         }

   453 

   454     CleanupStack::PopAndDestroy( bpRcd );

   455 

   456     CommitTransactionL( KErrNone );

   457     }

   458     

   459 //-----------------------------------------------------------------------------

   460 //  CCmManagerImpl::GlobalBearerPriority()

   461 //-----------------------------------------------------------------------------

   462 //

   463 TInt CCmManagerImpl::GlobalBearerPriority( TBool aUiPriority, 

   464                                            const TDesC& aServiceType ) const

   465     {

   466     for ( TInt i = 0; i < iBearerPriorityArray->Count(); ++i )

   467         {

   468         if ( !aServiceType.CompareF( *(*iBearerPriorityArray)[i].iServiceType ) )

   469             {

   470             if( aUiPriority )

   471                 {

   472                 return (*iBearerPriorityArray)[i].iUIPriority;

   473                 }

   474             else

   475                 {

   476                 return (*iBearerPriorityArray)[i].iPriority;

   477                 }

   478             }

   479         }

   480         

   481     return KDataMobilitySelectionPolicyPriorityWildCard;

   482     }

   483 

   484 //-----------------------------------------------------------------------------

   485 //  CCmManagerImpl::CleanupGlobalPriorityArray()

   486 //-----------------------------------------------------------------------------

   487 //

   488 void CCmManagerImpl::CleanupGlobalPriorityArray(

   489                                         RArray<TBearerPriority>& aArray ) const

   490     {

   491     LOGGER_ENTERFN( "CCmManagerImpl::CleanupGlobalPriorityArray" );

   492 

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

   494         {

   495         delete aArray[i].iServiceType;

   496         }

   497         

   498     aArray.Reset();

   499     aArray.Close();

   500     }

   501     

   502 //-----------------------------------------------------------------------------

   503 //  CCmManagerImpl::AddResourceFileL()

   504 //-----------------------------------------------------------------------------

   505 //

   506 void CCmManagerImpl::AddResourceFileL( TFileName& aName )

   507     {

   508     LOGGER_ENTERFN( "CCmManagerImpl::AddResourceFileL" );

   509     

   510     TInt index = FindResourceFile( aName );

   511     

   512     if ( index != KErrNotFound )

   513         {

   514         ++(*iResourceFiles)[index]->iRefs;

   515         return;

   516         }

   517         

   518     TResourceFiles* newRes = new (ELeave) TResourceFiles;

   519     CleanupStack::PushL( newRes );

   520 

   521     RResourceFile resFile;

   522     resFile.OpenL( iFs, aName );

   523     CleanupClosePushL( resFile );

   524     

   525     resFile.ConfirmSignatureL(0); 

   526     

   527     newRes->iFile = resFile;

   528     newRes->iFName.Copy( aName );

   529     newRes->iRefs = 1;  // 1 reference to this resource file

   530     

   531     iResourceFiles->AppendL( newRes );

   532     

   533     CleanupStack::Pop( 2 ); // resFile, newRes

   534     }

   535 

   536 //-----------------------------------------------------------------------------

   537 //  CCmManagerImpl::RemoveResourceFile()

   538 //-----------------------------------------------------------------------------

   539 //

   540 void CCmManagerImpl::RemoveResourceFile( TFileName& aName )

   541     {

   542     LOGGER_ENTERFN( "CCmManagerImpl::RemoveResourceFile" );

   543 

   544     TInt index = FindResourceFile( aName );

   545     

   546     if ( index == KErrNotFound )

   547         {

   548         return;

   549         }

   550         

   551     if ( !--(*iResourceFiles)[index]->iRefs )

   552         // it was the last reference

   553         {

   554         (*iResourceFiles)[index]->iFile.Close();

   555         delete (*iResourceFiles)[index];

   556         

   557         iResourceFiles->Delete( index );

   558         }

   559     }

   560 

   561 //-----------------------------------------------------------------------------

   562 //  CCmManagerImpl::FindResourceFile()

   563 //-----------------------------------------------------------------------------

   564 //

   565 TInt CCmManagerImpl::FindResourceFile( TFileName& aName ) const

   566     {

   567     LOGGER_ENTERFN( "CCmManagerImpl::FindResourceFile" );

   568 

   569     BaflUtils::NearestLanguageFile( iFs, aName );

   570     

   571     for ( TInt i = 0; i < iResourceFiles->Count(); ++i )

   572         {

   573         if ( !(*iResourceFiles)[i]->iFName.CompareF( aName ) )

   574             {

   575             return i;

   576             }

   577         }

   578     

   579     return KErrNotFound;

   580     }

   581     

   582 //-----------------------------------------------------------------------------

   583 //  CCmManagerImpl::AllocReadL()

   584 //-----------------------------------------------------------------------------

   585 //

   586 HBufC* CCmManagerImpl::AllocReadL( TInt aResourceId ) const

   587     {

   588     LOGGER_ENTERFN( "CCmManagerImpl::AllocReadL" );

   589 

   590     HBufC* retVal = NULL;

   591     

   592     // Scan all resource files to find owner

   593     for (TInt i=0; i < iResourceFiles->Count(); i++)

   594         { 

   595         RResourceFile& file=(*iResourceFiles)[i]->iFile;

   596         if ( file.OwnsResourceId(aResourceId) )

   597             {

   598             HBufC8* readBuffer = file.AllocReadLC( aResourceId );

   599             // as we are expecting HBufC16...

   600             const TPtrC16 ptrReadBuffer( (TText16*) readBuffer->Ptr(),

   601                                          readBuffer->Length() >> 1 );

   602             retVal=HBufC16::NewL( ptrReadBuffer.Length() );

   603             retVal->Des().Copy( ptrReadBuffer );

   604             CleanupStack::PopAndDestroy( readBuffer ); // readBuffer

   605             

   606             // exit from loop

   607             break;

   608             }

   609         }

   610 

   611     return retVal;

   612     }

   613 

   614 //-----------------------------------------------------------------------------

   615 //  CCmManagerImpl::ConstructL()

   616 //-----------------------------------------------------------------------------

   617 //

   618 void CCmManagerImpl::ConstructL()

   619     {

   620     LOGGER_ENTERFN( "CCmManagerImpl::ConstructL" );

   621     CLOG_NAME_1( _L("ManagerImpl_0x%x"), this );

   622     

   623     iObjectPool = new (ELeave) CCMObjectPool(*this);

   624             

   625     FeatureManager::InitializeLibL();

   626     iIsFeatureManagerInitialised = ETrue;

   627     iHelp = FeatureManager::FeatureSupported( KFeatureIdHelp ); 

   628     iDefConnSupported = ETrue;

   629     //iDefConnSupported = FeatureManager::FeatureSupported( KFeatureIdDefaultConnection );    

   630     iWLan = FeatureManager::FeatureSupported( KFeatureIdProtocolWlan );

   631 

   632     CMDBSession* db = CMDBSession::NewL( KCDVersion1_2 );

   633     

   634     iTrans = CCmTransactionHandler::NewL( *db );

   635     CLOG_ATTACH( iTrans, this );

   636     

   637     User::LeaveIfError( iFs.Connect() );

   638   

   639     iResourceFiles = new (ELeave) CArrayPtrFlat<TResourceFiles>( 

   640                                                           KResFileGranularity );

   641     

   642     TParse fp;

   643     TInt err = fp.Set( KACMManagerResDirAndFileName, 

   644                         &KDC_RESOURCE_FILES_DIR, 

   645                         NULL ); 

   646     CLOG_WRITE_1( "Set: [%d]", err );

   647     if ( err != KErrNone)

   648         {

   649         User::Leave( err );

   650         }

   651         

   652     TFileName fName;

   653     

   654     fName.Copy( fp.FullName() );

   655     

   656     AddResourceFileL( fName );

   657         

   658     CheckTablesL();

   659     CreateBearerPriorityArrayL();

   660         

   661     BuildPluginArrayL();

   662         

   663     TCmPluginInitParam params( *this );

   664     

   665     params.iParentDest = NULL;

   666     iPluginImpl = CCmConnectionMethodInfo::NewL( &params );

   667     CLOG_ATTACH( iPluginImpl, this );

   668     }

   669 

   670 // ---------------------------------------------------------------------------

   671 // CCmManagerImpl::OpenTransactionLC

   672 // ---------------------------------------------------------------------------

   673 //

   674 void CCmManagerImpl::OpenTransactionLC( TBool aSetAttribs )

   675     {

   676     LOGGER_ENTERFN( "CCmManagerImpl::OpenTransactionL" );

   677 

   678     iTrans->OpenTransactionLC(  aSetAttribs );

   679     }

   680 

   681 // ---------------------------------------------------------------------------

   682 // CCmDestinationImpl::CommitTransactionL

   683 // ---------------------------------------------------------------------------

   684 //

   685 void CCmManagerImpl::CommitTransactionL( TInt aError )

   686     {

   687     LOGGER_ENTERFN( "CCmManagerImpl::CommitTransactionL" );

   688 

   689     iTrans->CommitTransactionL( aError );

   690     }

   691 

   692 // ---------------------------------------------------------------------------

   693 // CCmDestinationImpl::CommitTransactionL

   694 // ---------------------------------------------------------------------------

   695 //

   696 void CCmManagerImpl::RollbackTransaction()

   697     {

   698     LOGGER_ENTERFN( "CCmManagerImpl::RollbackTransaction" );

   699     CleanupStack::Pop( iTrans );

   700     iTrans->Close();

   701     }

   702 

   703 // ---------------------------------------------------------------------------

   704 // CCmDestinationImpl::StartCommsDatNotifier

   705 // ---------------------------------------------------------------------------

   706 //

   707 void CCmManagerImpl::StartCommsDatNotifierL()

   708     {

   709     // Two instances of class CCmCommsDatNotifier are created here and

   710     // referred by all watchers in CmManager. One is to watch change in Iap Table

   711     // and the other is to watch change in Snap Table.

   712     iCommsDatIapNotifier = CCmCommsDatNotifier::NewL( KCDTIdIAPRecord );

   713     

   714     TUint32 snapTableId = GetSnapTableIdL();

   715     iCommsDatSnapNotifier = CCmCommsDatNotifier::NewL( snapTableId );

   716     }

   717 

   718 //=============================================================================

   719 // CREATION / DELETION API

   720 //=============================================================================

   721 //

   722 

   723 //-----------------------------------------------------------------------------

   724 //  CCmManagerImpl::CreateDestinationL( const TDesC& aName )

   725 //-----------------------------------------------------------------------------

   726 //

   727 CCmDestinationImpl* CCmManagerImpl::CreateDestinationL( const TDesC& aName )

   728     {

   729     LOGGER_ENTERFN( "CCmManagerImpl::CreateDestinationL" );

   730     

   731     CheckAvailableSpaceL();

   732     

   733     if ( aName.Length() == 0 )

   734         {

   735         User::Leave( KErrArgument );

   736         }

   737     

   738     return iObjectPool->GetDestinationL( aName );

   739     }

   740 

   741 //-----------------------------------------------------------------------------

   742 //  CCmManagerImpl::CreateDestinationL( const TDesC& aName, TUint32

   743 //  aDestId )

   744 //-----------------------------------------------------------------------------

   745 //

   746 CCmDestinationImpl* CCmManagerImpl::CreateDestinationL(

   747     const TDesC& aName,

   748     TUint32 aDestId )

   749     {

   750     LOGGER_ENTERFN( "CCmManagerImpl::CreateDestinationL" );

   751 

   752     CheckAvailableSpaceL();

   753     

   754     if ( aName.Length() == 0 )

   755         {

   756         User::Leave( KErrArgument );

   757         }

   758 

   759     if ( aDestId == 0 )

   760         {

   761         return CreateDestinationL( aName );

   762         }

   763 

   764     return iObjectPool->CreateDestinationL( aName, aDestId );

   765     }

   766 

   767 

   768 //-----------------------------------------------------------------------------

   769 //  CCmManagerImpl::DestinationUpdated( CCmDestinationImpl* aDestination )

   770 //-----------------------------------------------------------------------------

   771 //

   772 void CCmManagerImpl::DestinationUpdated( CCmDestinationImpl* aDestination )

   773     {

   774     LOGGER_ENTERFN( "CCmManagerImpl::DestinationUpdatedL" );

   775     iObjectPool->DestinationUpdated( aDestination );

   776     }

   777 

   778 // --------------------------------------------------------------------------

   779 // CCmManagerImpl::CreateConnectionMethodL()

   780 // --------------------------------------------------------------------------

   781 //  

   782 CCmPluginBase* 

   783         CCmManagerImpl::CreateConnectionMethodL( CCmPluginBaseEng* pluginBaseEng )

   784     {

   785     LOGGER_ENTERFN( "CCmManagerImpl::CreateConnectionMethodL 2" );

   786 

   787     CheckAvailableSpaceL();        

   788 

   789     return iObjectPool->CreateConnectionMethodL( pluginBaseEng );

   790     }

   791 

   792 // --------------------------------------------------------------------------

   793 // CCmManagerImpl::InsertConnectionMethodL()

   794 // --------------------------------------------------------------------------

   795 //

   796 void CCmManagerImpl::InsertConnectionMethodL( CCmPluginBaseEng* pluginBaseEng )

   797     {

   798     iObjectPool->InsertConnectionMethodL( pluginBaseEng );

   799     }

   800 

   801 // --------------------------------------------------------------------------

   802 // CCmManagerImpl::CreateConnectionMethodL()

   803 // --------------------------------------------------------------------------

   804 //  

   805 CCmPluginBase* 

   806         CCmManagerImpl::CreateConnectionMethodL( TUint32 aImplementationUid,

   807                                     CCmDestinationImpl* aParentDestination )

   808     {

   809     LOGGER_ENTERFN( "CCmManagerImpl::CreateConnectionMethodL" );

   810     

   811     CheckAvailableSpaceL();

   812     

   813     TCmPluginInitParam params( *this );

   814     if (aParentDestination)

   815         {

   816         params.iParentDest = aParentDestination->Id();        

   817         }

   818 

   819     return iObjectPool->CreateConnectionMethodL( aImplementationUid, params );

   820     }

   821 

   822 // --------------------------------------------------------------------------

   823 // CCmManagerImpl::CreateConnectionMethodL()

   824 // --------------------------------------------------------------------------

   825 //  

   826 CCmPluginBase* 

   827         CCmManagerImpl::CreateConnectionMethodL( TUint32 aImplementationUid,

   828                                     TUint32 aConnMethodId,

   829                                     CCmDestinationImpl* aParentDestination )

   830     {

   831     LOGGER_ENTERFN( "CCmManagerImpl::CreateConnectionMethodL" );

   832     

   833     CheckAvailableSpaceL();

   834          

   835     TCmPluginInitParam params( *this );

   836     if ( aParentDestination )

   837         {

   838         params.iParentDest = aParentDestination->Id();        

   839         }

   840 

   841     return iObjectPool->CreateConnectionMethodL( aImplementationUid,

   842     		                                     params,

   843     		                                     aConnMethodId);

   844     }

   845 

   846 // --------------------------------------------------------------------------

   847 // CCmManagerImpl::DoCreateConnectionMethodL()

   848 // --------------------------------------------------------------------------

   849 //  

   850 CCmPluginBaseEng* 

   851         CCmManagerImpl::DoCreateConnectionMethodL( TUint32 aImplementationUid,

   852                                      TCmPluginInitParam& aParams )

   853     {

   854     LOGGER_ENTERFN( "CCmManagerImpl::DoCreateConnectionMethodL" );

   855 

   856     const TUid KMCMmImplementationUid = { aImplementationUid };    

   857     TAny* ptr = REComSession::CreateImplementationL( KMCMmImplementationUid, 

   858                                                      _FOFF( CCmPluginBaseEng, 

   859                                                             iDtor_ID_Key ), 

   860                                                      (TAny*)&aParams );

   861 

   862     CCmPluginBaseEng* plugin = STATIC_CAST( CCmPluginBaseEng*, ptr );

   863     CleanupStack::PushL( plugin );

   864 

   865     plugin->CreateNewL(); 

   866     plugin->SetIdValidity(EFalse);   

   867     CleanupStack::Pop( plugin );  // plugin

   868         

   869     return plugin;

   870     }

   871 

   872 // --------------------------------------------------------------------------

   873 // CCmManagerImpl::DoCreateConnectionMethodL()

   874 // --------------------------------------------------------------------------

   875 //  

   876 CCmPluginBaseEng* 

   877    CCmManagerImpl::DoCreateConnectionMethodL( TUint32 aImplementationUid,

   878                                               TCmPluginInitParam& aParams,

   879                                               TUint32 aConnMethodId )

   880     {

   881     LOGGER_ENTERFN( "CCmManagerImpl::DoCreateConnectionMethodL" );

   882 

   883     const TUid KMCMmImplementationUid = { aImplementationUid };    

   884     TAny* ptr = REComSession::CreateImplementationL( KMCMmImplementationUid, 

   885                                                     _FOFF( CCmPluginBaseEng, 

   886                                                            iDtor_ID_Key ), 

   887                                                     (TAny*)&aParams );

   888 

   889     CCmPluginBaseEng* plugin = STATIC_CAST( CCmPluginBaseEng*, ptr );

   890     CleanupStack::PushL( plugin );

   891 

   892     plugin->CreateNewL(); 

   893     plugin->SetIdValidity( EFalse );

   894     plugin->SetPreDefinedId( aConnMethodId );

   895     CleanupStack::Pop( plugin );  // plugin

   896 

   897     return plugin;

   898     }

   899 

   900 //-----------------------------------------------------------------------------

   901 //  CCmManagerImpl::ConnectionMethodL( TUint aId )

   902 //-----------------------------------------------------------------------------

   903 //

   904 EXPORT_C CCmPluginBaseEng* 

   905                       CCmManagerImpl::ConnectionMethodL( TUint32 /*aCmId*/ )

   906     {

   907     LOGGER_ENTERFN( "Error: Obsolete function CCmManagerImpl::ConnectionMethodL used" );

   908     User::Panic( _L("CMManager"), KErrNotSupported );

   909     return NULL;    

   910     }

   911 

   912 //-----------------------------------------------------------------------------

   913 //  CCmManagerImpl::GetConnectionMethodL( TUint aId )

   914 //-----------------------------------------------------------------------------

   915 //

   916 EXPORT_C CCmPluginBase* 

   917                       CCmManagerImpl::GetConnectionMethodL( TUint32 aCmId )

   918     {

   919     LOGGER_ENTERFN( "CCmManagerImpl::GetConnectionMethodL" );

   920     

   921     CCmPluginBase* plugin = DoFindConnMethodL( aCmId, NULL );

   922                                       

   923     return plugin;

   924     }

   925 

   926 

   927 //-----------------------------------------------------------------------------

   928 //  CCmManagerImpl::AppendUncatCmListL

   929 //-----------------------------------------------------------------------------

   930 //

   931 void CCmManagerImpl::AppendUncatCmListL( RPointerArray<CCmPluginBase>& aCMArray,

   932                                         TBool aCheckBearerType,

   933                                         TBool aLegacyOnly,

   934                                         TBool aEasyWlan,

   935                                         TBool aSortByBearer )

   936     {

   937     LOGGER_ENTERFN( "CCmManagerImpl::AppendUncatCmListL" );

   938 

   939     RArray<TUint32> cmUidArray;

   940     CleanupClosePushL(cmUidArray);

   941     ConnectionMethodL(cmUidArray, aCheckBearerType, aLegacyOnly, aEasyWlan, aSortByBearer);

   942     AppendCmListFromUidsL( cmUidArray, aCMArray );

   943 

   944     CleanupStack::PopAndDestroy(&cmUidArray);

   945     }

   946     

   947 //-----------------------------------------------------------------------------

   948 //  CCmManagerImpl::AppendUncatCmListLC

   949 //-----------------------------------------------------------------------------

   950 //

   951 void CCmManagerImpl::AppendUncatCmListLC( RPointerArray<CCmPluginBase>& aCMArray,

   952                                         TBool aCheckBearerType,

   953                                         TBool aLegacyOnly,

   954                                         TBool aEasyWlan,

   955                                         TBool aSortByBearer )

   956     {

   957     LOGGER_ENTERFN( "CCmManagerImpl::AppendUncatCmListLC" );

   958 

   959     AppendUncatCmListL( aCMArray, aCheckBearerType, aLegacyOnly, aEasyWlan, aSortByBearer);

   960     

   961     CleanupResetAndDestroyPushL< RPointerArray<CCmPluginBase> >( aCMArray );

   962     }

   963         

   964 // -----------------------------------------------------------------------------

   965 // CCmDestinationImpl::AppendCmListLC

   966 // -----------------------------------------------------------------------------

   967 //     

   968 void CCmManagerImpl::AppendCmListLC( TUint32 aDestintaionId, RPointerArray<CCmPluginBase>& aCMArray )

   969     {

   970     LOGGER_ENTERFN( "CCmManagerImpl::AppendCmListLC" );

   971 

   972     AppendCmListL( aDestintaionId, aCMArray );

   973     CCmManagerImpl::CleanupResetAndDestroyPushL< RPointerArray<CCmPluginBase> >( aCMArray );

   974     }

   975          

   976 // -----------------------------------------------------------------------------

   977 // CCmDestinationImpl::AppendCmListL

   978 // -----------------------------------------------------------------------------

   979 //     

   980 void CCmManagerImpl::AppendCmListL( TUint32 aDestintaionId, RPointerArray<CCmPluginBase>& aCMArray )

   981     {

   982     LOGGER_ENTERFN( "CCmManagerImpl::AppendCmListL" );

   983 

   984     CCmDestinationImpl* dest = DestinationL( aDestintaionId );

   985     CleanupStack::PushL(dest); 

   986     RArray<TUint32> cmIdList;

   987     CleanupClosePushL(cmIdList);

   988     dest->ConnectMethodIdArrayL( cmIdList );

   989     AppendCmListFromUidsL( cmIdList, aCMArray );

   990     CleanupStack::PopAndDestroy(&cmIdList);  

   991     CleanupStack::PopAndDestroy(dest);  

   992     }

   993 // -----------------------------------------------------------------------------

   994 // CCmDestinationImpl::AppendCmListFromUidsL

   995 // -----------------------------------------------------------------------------

   996 //     

   997 void CCmManagerImpl::AppendCmListFromUidsL( RArray<TUint32>& cmIdList, RPointerArray<CCmPluginBase>& aCMArray )

   998     {

   999     LOGGER_ENTERFN( "CCmManagerImpl::AppendCmListFromUidsL" );

  1000 

  1001     TInt count = cmIdList.Count();

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

  1003         {

  1004         CCmPluginBase* cm = NULL;

  1005         TRAPD( err,cm = GetConnectionMethodL( cmIdList[i] ));

  1006         if (err == KErrNone)

  1007             {

  1008             aCMArray.AppendL( cm );

  1009             }

  1010         }

  1011     }

  1012     

  1013 //-----------------------------------------------------------------------------

  1014 //  CCmManagerImpl::ConnectionMethodL

  1015 //-----------------------------------------------------------------------------

  1016 //

  1017 EXPORT_C void CCmManagerImpl::ConnectionMethodL( RArray<TUint32>& aCMArray,

  1018                                         TBool aCheckBearerType,

  1019                                         TBool aLegacyOnly,

  1020                                         TBool aEasyWlan,

  1021                                         TBool aSortByBearer )

  1022     {

  1023     LOGGER_ENTERFN( "CCmManagerImpl::ConnectionMethodL" );

  1024 

  1025     OpenTransactionLC();

  1026     

  1027     CMDBRecordSet<CCDIAPRecord>* ptrRecordSet = AllIapsL();

  1028     CleanupStack::PushL( ptrRecordSet );

  1029     

  1030     TInt iapRecords = ptrRecordSet->iRecords.Count();

  1031     CLOG_WRITE_1_PTR( NULL, "Record num [%d]", iapRecords );

  1032     

  1033     // Time optimization to load the entire destination table

  1034     TInt destTblId = DestinationTableId();

  1035     CMDBRecordSet<CCDDataMobilitySelectionPolicyRecord>*  ptrDestSet = 

  1036             new (ELeave) CMDBRecordSet<CCDDataMobilitySelectionPolicyRecord>( 

  1037                                                                     destTblId );

  1038     CleanupStack::PushL( ptrDestSet );

  1039     TRAP_IGNORE( ptrDestSet->LoadL( Session() ) );

  1040     

  1041     for ( TInt i = 0; i < iapRecords; i++ )

  1042         {

  1043         TUint32 iapId = (*ptrRecordSet)[i]->RecordId();

  1044         CLOG_WRITE_1_PTR( NULL, "IAP ID [%d]", iapId );

  1045         if ( aCheckBearerType )

  1046             {

  1047             TUint32 bearerType( 0 );

  1048             TRAPD( err, 

  1049                    bearerType = BearerTypeFromIapRecordL( (*ptrRecordSet)[i] ));

  1050             if ( !err && bearerType )

  1051                 {

  1052                 // append the IAP id - if aLegacyOnly is ETrue, only for legacy IAPs

  1053                 if ( !aLegacyOnly || 

  1054                      !NumOfConnMethodReferencesL( iapId, ptrDestSet ) )

  1055                     {

  1056                     if( !aEasyWlan && IsEasyWLanL( (*ptrRecordSet)[i] ) )

  1057                         {

  1058                         continue;

  1059                         }

  1060                         

  1061                     aCMArray.Append( iapId );

  1062                     }

  1063                 }

  1064             }

  1065         else

  1066             {

  1067             // append the IAP id - if aLegacyOnly is ETrue, only for legacy IAPs

  1068             if ( !aLegacyOnly ||

  1069                  !NumOfConnMethodReferencesL( iapId, ptrDestSet ) )

  1070                 {

  1071                 if( !aEasyWlan && IsEasyWLanL( (*ptrRecordSet)[i] ) )

  1072                     {

  1073                     continue;

  1074                     }

  1075                     

  1076                 aCMArray.Append( iapId );

  1077                 }

  1078             }

  1079         }

  1080     

  1081     // Re-order the array according to the global bearer ordering rules

  1082     if ( aSortByBearer )

  1083         {        

  1084         RArray<TUint32> bearers( KCmArrayMediumGranularity );

  1085         CleanupClosePushL( bearers );

  1086         SupportedBearersL( bearers );

  1087         

  1088         TInt prevInsertedPos = -1;

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

  1090             {

  1091             for ( TInt j = prevInsertedPos + 1; j < aCMArray.Count(); j++ )

  1092                 {

  1093                 // Check if CM belongs to this bearer

  1094                 TUint cmBearerId = GetConnectionMethodInfoIntL( aCMArray[j],

  1095                                                              ECmBearerType );

  1096                 if ( cmBearerId == bearers[i] )

  1097                     {

  1098                     // copy the cm id to the next 'sorted position' in the array

  1099                     // the item removed will always be after the insertion position

  1100                     TUint cmId = aCMArray[j];

  1101                     aCMArray.Remove(j);                    

  1102                     aCMArray.Insert( cmId, ++prevInsertedPos );

  1103                     }

  1104                 }

  1105             }

  1106         

  1107         CleanupStack::PopAndDestroy( &bearers );

  1108         }

  1109     

  1110     CleanupStack::PopAndDestroy( 2, ptrRecordSet );

  1111     

  1112     RollbackTransaction();

  1113     }

  1114 

  1115 //-----------------------------------------------------------------------------

  1116 //  CCmManagerImpl::DoFindConnMethodL

  1117 //-----------------------------------------------------------------------------

  1118 //

  1119 CCmPluginBase* CCmManagerImpl::DoFindConnMethodL( TUint32 aCmId, 

  1120                                       CCmDestinationImpl* aParentDest )

  1121     {

  1122     LOGGER_ENTERFN( "CCmManagerImpl::DoFindConnMethodL" );

  1123     return iObjectPool->GetConnectionMethodL(aCmId, aParentDest);        

  1124     }

  1125 

  1126 //-----------------------------------------------------------------------------

  1127 //  CCmManagerImpl::FindConnMethodL

  1128 //-----------------------------------------------------------------------------

  1129 //

  1130 CCmPluginBaseEng* CCmManagerImpl::DoFindConnMethL( TUint32 aCmId, 

  1131                                        CCmDestinationImpl* aParentDest )

  1132     {

  1133     LOGGER_ENTERFN( "CCmManagerImpl::FindConnMethodL" );