1 /*

     2 * Copyright (c) 2009-2010 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:

    15 * Session side object representing a destination.

    16 *

    17 */

    18 

    19 

    20 #include <cmpluginbaseeng.h>

    21 #include <datamobilitycommsdattypes.h>

    22 #include <cmpluginembdestinationdef.h>

    23 

    24 #include "cmmdestinationinstance.h"

    25 #include "cmmsession.h"

    26 #include "cmmcache.h"

    27 #include "cmmconnmethodinstance.h"

    28 #include "cmmconnmethoditem.h"

    29 #include "cmmanagertextresolver.h"

    30 

    31 #include "OstTraceDefinitions.h"

    32 #ifdef OST_TRACE_COMPILER_IN_USE

    33 #include "cmmdestinationinstanceTraces.h"

    34 #endif

    35 

    36 

    37 // ---------------------------------------------------------------------------

    38 // Two phased construction.

    39 // ---------------------------------------------------------------------------

    40 //

    41 CCmmDestinationInstance* CCmmDestinationInstance::NewL(

    42         CCmmSession* aCmmSession,

    43         CCmmCache* aCache )

    44     {

    45     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_NEWL_ENTRY );

    46 

    47     CCmmDestinationInstance* self = CCmmDestinationInstance::NewLC( aCmmSession, aCache );

    48     CleanupStack::Pop( self );

    49 

    50     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_NEWL_EXIT );

    51     return self;

    52     }

    53 

    54 // ---------------------------------------------------------------------------

    55 // Two phased construction.

    56 // ---------------------------------------------------------------------------

    57 //

    58 CCmmDestinationInstance* CCmmDestinationInstance::NewLC(

    59         CCmmSession* aCmmSession,

    60         CCmmCache* aCache )

    61     {

    62     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_NEWLC_ENTRY );

    63 

    64     CCmmDestinationInstance* self = new( ELeave ) CCmmDestinationInstance( aCmmSession, aCache );

    65     CleanupClosePushL( *self );

    66     self->ConstructL();

    67 

    68     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_NEWLC_EXIT );

    69     return self;

    70     }

    71 

    72 // ---------------------------------------------------------------------------

    73 // Destructor.

    74 // ---------------------------------------------------------------------------

    75 //

    76 CCmmDestinationInstance::~CCmmDestinationInstance()

    77     {

    78     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_CCMMDESTINATIONINSTANCE_ENTRY );

    79 

    80     // Tell cache this handle is beeing closed. Cache will update it's own

    81     // bookkeeping accordingly.

    82     if ( iCache )

    83         {

    84         iCache->CloseDestination( *this );

    85         }

    86     delete iNetworkRecord;

    87     delete iDestApRecord;

    88     delete iMetadataRecord;

    89 

    90     iConnMethodItemArray.Close();

    91     iConnMethodsToBeDeleted.Close();

    92 

    93     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_CCMMDESTINATIONINSTANCE_EXIT );

    94     }

    95 

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

    97 // Constructor.

    98 // ---------------------------------------------------------------------------

    99 //

   100 CCmmDestinationInstance::CCmmDestinationInstance(

   101         CCmmSession* aCmmSession,

   102         CCmmCache* aCache )

   103         :

   104         iCmmSession( aCmmSession ),

   105         iCache( aCache )

   106     {

   107     OstTraceFunctionEntry0( DUP1_CCMMDESTINATIONINSTANCE_CCMMDESTINATIONINSTANCE_ENTRY );

   108 

   109     iNetworkRecord = NULL;

   110     iDestApRecord = NULL;

   111     iMetadataRecord = NULL;

   112 

   113     iNetworkRecordStatus = ECmmRecordStatusBlank;

   114     iDestApRecordStatus = ECmmRecordStatusBlank;

   115     iMetadataRecordStatus = ECmmRecordStatusBlank;

   116 

   117     iStatus = ECmmDestinationStatusChanged;

   118     iId = 0;

   119     iHandle = 0;

   120 

   121     iProtectionChanged = EFalse;

   122     iLastProtectionLevel = CMManager::EProtLevel0;

   123     iCurrentProtectionLevel = CMManager::EProtLevel0;

   124 

   125     OstTraceFunctionExit0( DUP1_CCMMDESTINATIONINSTANCE_CCMMDESTINATIONINSTANCE_EXIT );

   126     }

   127 

   128 // ---------------------------------------------------------------------------

   129 // Second phase constructor.

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

   131 //

   132 void CCmmDestinationInstance::ConstructL()

   133     {

   134     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_CONSTRUCTL_ENTRY );

   135     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_CONSTRUCTL_EXIT );

   136     }

   137 

   138 // ---------------------------------------------------------------------------

   139 // Set the destination ID.

   140 // ---------------------------------------------------------------------------

   141 //

   142 void CCmmDestinationInstance::SetId( const TUint32 aId )

   143     {

   144     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETID_ENTRY );

   145 

   146     iId = aId;

   147 

   148     // If this is the real ID (not the temporary ID of a new unsaved destination),

   149     // write it also into network record.

   150     if ( aId > KCmmDestIdIntervalMin && aId < KCmmDestIdIntervalMax )

   151         {

   152         iNetworkRecord->SetRecordId( aId - KCmDefaultDestinationAPTagId );

   153         iDestApRecord->iRecordTag = aId;

   154         iDestApRecord->iCustomSelectionPolicy = ( aId - KCmDefaultDestinationAPTagId );

   155         iMetadataRecord->iSNAP = aId;

   156         }

   157 

   158     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETID_EXIT );

   159     }

   160 

   161 // ---------------------------------------------------------------------------

   162 // Get the destination ID.

   163 // ---------------------------------------------------------------------------

   164 //

   165 TUint32 CCmmDestinationInstance::GetId() const

   166     {

   167     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETID_ENTRY );

   168     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETID_EXIT );

   169     return iId;

   170     }

   171 

   172 // ---------------------------------------------------------------------------

   173 // Set the current status of this destination.

   174 // ECmmDestinationStatusValid: Contents in sync with database.

   175 // ECmmDestinationStatusChanged: Contents differ from database contents.

   176 // ---------------------------------------------------------------------------

   177 //

   178 void CCmmDestinationInstance::SetStatus( const TCmmDestinationStatus& aStatus )

   179     {

   180     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETSTATUS_ENTRY );

   181 

   182     switch ( aStatus )

   183         {

   184         // Fallthrough intended

   185         case ECmmDestinationStatusValid:

   186         case ECmmDestinationStatusChanged:

   187             iStatus = aStatus;

   188             break;

   189         default:

   190             ASSERT(0); // Error, invalid status.

   191             break;

   192         }

   193 

   194     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETSTATUS_EXIT );

   195     }

   196 

   197 // ---------------------------------------------------------------------------

   198 // Gets the current status of this destination instance.

   199 // ---------------------------------------------------------------------------

   200 //

   201 TCmmDestinationStatus CCmmDestinationInstance::GetStatus() const

   202     {

   203     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETSTATUS_ENTRY );

   204     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETSTATUS_EXIT );

   205     return iStatus;

   206     }

   207 

   208 // ---------------------------------------------------------------------------

   209 // Get handle ID.

   210 // ---------------------------------------------------------------------------

   211 //

   212 TInt CCmmDestinationInstance::GetHandle() const

   213     {

   214     return iHandle;

   215     }

   216 

   217 // ---------------------------------------------------------------------------

   218 // Set handle ID.

   219 // ---------------------------------------------------------------------------

   220 //

   221 void CCmmDestinationInstance::SetHandle( const TInt aHandle )

   222     {

   223     iHandle = aHandle;

   224     }

   225 

   226 // ---------------------------------------------------------------------------

   227 // Set the record status for all records.

   228 // ---------------------------------------------------------------------------

   229 //

   230 void CCmmDestinationInstance::SetStatusForAllRecords( const TCmmRecordStatus& aStatus )

   231     {

   232     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETSTATUSFORALLRECORDS_ENTRY );

   233 

   234     iDestApRecordStatus = aStatus;

   235     iNetworkRecordStatus = aStatus;

   236     iMetadataRecordStatus = aStatus;

   237 

   238     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETSTATUSFORALLRECORDS_EXIT );

   239     }

   240 

   241 // ---------------------------------------------------------------------------

   242 // Get the destination element ID.

   243 // ---------------------------------------------------------------------------

   244 //

   245 TUint32 CCmmDestinationInstance::GetElementIdL()

   246     {

   247     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETELEMENTIDL_ENTRY );

   248 

   249     LoadRecordIfMissingL( ECmmDestNetworkRecord );

   250 

   251     if ( !iNetworkRecord )

   252         {

   253         User::Leave( KErrCorrupt );

   254         }

   255 

   256     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETELEMENTIDL_EXIT );

   257     return iNetworkRecord->ElementId() & KCDMaskShowField;

   258     }

   259 

   260 // ---------------------------------------------------------------------------

   261 // Get the destination access point record's record tag (destination ID).

   262 // ---------------------------------------------------------------------------

   263 //

   264 TUint32 CCmmDestinationInstance::GetRecordTagFromApRecordL()

   265     {

   266     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETRECORDTAGFROMAPRECORDL_ENTRY );

   267 

   268     LoadRecordIfMissingL( ECmmDestApRecord );

   269 

   270     if ( !iDestApRecord )

   271         {

   272         User::Leave( KErrCorrupt );

   273         }

   274 

   275     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETRECORDTAGFROMAPRECORDL_EXIT );

   276     return iDestApRecord->iRecordTag;

   277     }

   278 

   279 // ---------------------------------------------------------------------------

   280 // Sets a record pointer to the one given as parameter, Ownership is

   281 // transfered. Also deletes the previous pointer and sets the record status

   282 // to 'ECmmRecordStatusLoaded'.

   283 // ---------------------------------------------------------------------------

   284 //

   285 TInt CCmmDestinationInstance::SetRecordPointer(

   286         const TCmmDbRecords& aDestRecord,

   287         CommsDat::CCDRecordBase* aRecordPointer )

   288     {

   289     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETRECORDPOINTER_ENTRY );

   290 

   291     TInt ret( KErrNone );

   292     switch ( aDestRecord )

   293         {

   294         case ECmmDestNetworkRecord:

   295             {

   296             delete iNetworkRecord;

   297             iNetworkRecord = static_cast<CommsDat::CCDNetworkRecord*>( aRecordPointer );

   298             iNetworkRecordStatus = ECmmRecordStatusLoaded;

   299             }

   300             break;

   301         case ECmmDestApRecord:

   302             {

   303             delete iDestApRecord;

   304             iDestApRecord = static_cast<CommsDat::CCDAccessPointRecord*>( aRecordPointer );

   305             iDestApRecordStatus = ECmmRecordStatusLoaded;

   306             }

   307             break;

   308         case ECmmDestMetadataRecord:

   309             {

   310             delete iMetadataRecord;

   311             iMetadataRecord = static_cast<CCDSNAPMetadataRecord*>( aRecordPointer );

   312             iMetadataRecordStatus = ECmmRecordStatusLoaded;

   313             }

   314             break;

   315         default:

   316             {

   317             ret = KErrNotFound;

   318             }

   319             break;

   320         }

   321 

   322     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETRECORDPOINTER_EXIT );

   323     return ret;

   324     }

   325 

   326 // ---------------------------------------------------------------------------

   327 // Gets a reference to the requested record pointer.

   328 // ---------------------------------------------------------------------------

   329 //

   330 TInt CCmmDestinationInstance::GetRecordPointer(

   331         const TCmmDbRecords& aDestRecord,

   332         CommsDat::CCDRecordBase*& aRecordPointer )

   333     {

   334     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETRECORDPOINTER_ENTRY );

   335 

   336     TInt ret( KErrNone );

   337     aRecordPointer = NULL;

   338     switch ( aDestRecord )

   339         {

   340         case ECmmDestNetworkRecord:

   341             {

   342             aRecordPointer = static_cast<CommsDat::CCDRecordBase*>( iNetworkRecord );

   343             }

   344             break;

   345         case ECmmDestApRecord:

   346             {

   347             aRecordPointer = static_cast<CommsDat::CCDRecordBase*>( iDestApRecord );

   348             }

   349             break;

   350         case ECmmDestMetadataRecord:

   351             {

   352             aRecordPointer = static_cast<CommsDat::CCDRecordBase*>( iMetadataRecord );

   353             }

   354             break;

   355         default:

   356             {

   357             ASSERT( 0 );

   358             ret = KErrNotFound;

   359             }

   360             break;

   361         }

   362 

   363     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETRECORDPOINTER_EXIT );

   364     return ret;

   365     }

   366 

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

   368 // Save the contents of this destination into database. All connection methods

   369 // including embedded destination, that the client has open handles to, are

   370 // also updated.

   371 // ---------------------------------------------------------------------------

   372 //

   373 void CCmmDestinationInstance::UpdateL()

   374     {

   375     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_UPDATEL_ENTRY );

   376 

   377     if ( AllMandatoryRecordsContainData() )

   378         {

   379         // Check for metadata conflicts.

   380         if ( ConflictingMetadataFoundL() )

   381             {

   382             OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_UPDATEL_EXIT );

   383 

   384             User::Leave( KErrAlreadyExists );

   385             }

   386 

   387         // Check that the destination name is still valid and not in use already.

   388         if ( iCache->DestinationExistsWithNameL( iNetworkRecord->iRecordName.GetL(), iId ) )

   389             {

   390             OstTraceFunctionExit0( DUP1_CCMMDESTINATIONINSTANCE_UPDATEL_EXIT );

   391 

   392             User::Leave( KErrAlreadyExists );

   393             }

   394 

   395         iCache->UpdateDestinationL( *this );

   396         }

   397     else

   398         {

   399         User::Leave( KErrCorrupt );

   400         }

   401 

   402     OstTraceFunctionExit0( DUP2_CCMMDESTINATIONINSTANCE_UPDATEL_EXIT );

   403     }

   404 

   405 // ---------------------------------------------------------------------------

   406 // Get the destination name.

   407 // ---------------------------------------------------------------------------

   408 //

   409 TDesC& CCmmDestinationInstance::GetDestinationNameL()

   410     {

   411     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETDESTINATIONNAMEL_ENTRY );

   412 

   413     LoadRecordIfMissingL( ECmmDestNetworkRecord );

   414 

   415     if ( !iNetworkRecord )

   416         {

   417         OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETDESTINATIONNAMEL_EXIT );

   418 

   419         User::Leave( KErrCorrupt );

   420         }

   421 

   422     OstTraceFunctionExit0( DUP1_CCMMDESTINATIONINSTANCE_GETDESTINATIONNAMEL_EXIT );

   423     return iNetworkRecord->iRecordName.GetL();

   424     }

   425 

   426 // ---------------------------------------------------------------------------

   427 // Get the localised destination name.

   428 // ---------------------------------------------------------------------------

   429 //

   430 HBufC* CCmmDestinationInstance::GetLocalisedDestinationNameL()

   431     {

   432     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETLOCALISEDDESTINATIONNAMEL_ENTRY );

   433 

   434     LoadRecordIfMissingL( ECmmDestNetworkRecord );

   435 

   436     if ( !iNetworkRecord )

   437         {

   438         User::Leave( KErrCorrupt );

   439         }

   440 

   441     TUint32 purpose( 0 );

   442     GetMetadataL( CMManager::ESnapMetadataPurpose, purpose );

   443     HBufC* resolvedText( NULL );

   444     TBool isLocalised( EFalse );

   445     switch ( purpose )

   446         {

   447         case CMManager::ESnapPurposeInternet:

   448             {

   449             _LIT( KDestinationTextId, "txt_occ_dblist_internet");

   450             resolvedText = CCmManagerTextResolver::ResolveTextL( KDestinationTextId );

   451             isLocalised = ETrue;

   452             }

   453             break;

   454         case CMManager::ESnapPurposeOperator:

   455             {

   456             _LIT( KDestinationTextId, "txt_occ_dblist_operator_services");

   457             resolvedText = CCmManagerTextResolver::ResolveTextL( KDestinationTextId );

   458             isLocalised = ETrue;

   459             }

   460             break;

   461         case CMManager::ESnapPurposeIntranet:

   462             {

   463             _LIT( KDestinationTextId, "txt_occ_dblist_intranet");

   464             resolvedText = CCmManagerTextResolver::ResolveTextL( KDestinationTextId );

   465             isLocalised = ETrue;

   466             }

   467             break;

   468         default:

   469             break;

   470         }

   471 

   472     // Not Internet, operator or intranet, or something went wrong.

   473     if ( !isLocalised || ( isLocalised && !resolvedText ) )

   474         {

   475         resolvedText = TPtrC( iNetworkRecord->iRecordName ).AllocL();

   476         }

   477 

   478     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETLOCALISEDDESTINATIONNAMEL_EXIT );

   479     return resolvedText;

   480     }

   481 

   482 // ---------------------------------------------------------------------------

   483 // Set the destination name.

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

   485 //

   486 void CCmmDestinationInstance::SetDestinationNameL( const TDesC& aDestinationName )

   487     {

   488     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETDESTINATIONNAMEL_ENTRY );

   489 

   490     // Write action, load all records.

   491     LoadAllRecordsL();

   492 

   493     iNetworkRecord->iRecordName.SetL( aDestinationName );

   494     iDestApRecord->iRecordName.SetL( aDestinationName );

   495 

   496     iNetworkRecordStatus = ECmmRecordStatusModified;

   497     iDestApRecordStatus = ECmmRecordStatusModified;

   498     iStatus = ECmmDestinationStatusChanged;

   499 

   500     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETDESTINATIONNAMEL_EXIT );

   501     }

   502 

   503 // ---------------------------------------------------------------------------

   504 // Get the destination icon.

   505 // ---------------------------------------------------------------------------

   506 //

   507 HBufC* CCmmDestinationInstance::GetDestinationIconL()

   508     {

   509     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETDESTINATIONICONL_ENTRY );

   510 

   511     LoadRecordIfMissingL( ECmmDestMetadataRecord );

   512 

   513     if ( !iMetadataRecord )

   514         {

   515         User::Leave( KErrCorrupt );

   516         }

   517 

   518     HBufC* icon( NULL );

   519     icon = TPtrC( iMetadataRecord->iIconFileName ).AllocL();

   520 

   521     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETDESTINATIONICONL_EXIT );

   522     return icon;

   523     }

   524 

   525 // ---------------------------------------------------------------------------

   526 // Set the destination icon.

   527 // ---------------------------------------------------------------------------

   528 //

   529 void CCmmDestinationInstance::SetDestinationIconL( const TDesC& aDestinationIcon )

   530     {

   531     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETDESTINATIONICONL_ENTRY );

   532 

   533     // Write action, load all records.

   534     LoadAllRecordsL();

   535 

   536     iMetadataRecord->iIconFileName.SetL( aDestinationIcon );

   537 

   538     iMetadataRecordStatus = ECmmRecordStatusModified;

   539     iStatus = ECmmDestinationStatusChanged;

   540 

   541     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETDESTINATIONICONL_EXIT );

   542     }

   543 

   544 // ---------------------------------------------------------------------------

   545 // Get metadata of specified type.

   546 // ---------------------------------------------------------------------------

   547 //

   548 void CCmmDestinationInstance::GetMetadataL(

   549         const CMManager::TSnapMetadataField& aMetadataField,

   550         TUint32& aMetadata )

   551     {

   552     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETMETADATAL_ENTRY );

   553 

   554     LoadRecordIfMissingL( ECmmDestMetadataRecord );

   555 

   556     if ( !iMetadataRecord )

   557         {

   558         User::Leave( KErrCorrupt );

   559         }

   560 

   561     switch ( aMetadataField )

   562         {

   563         case CMManager::ESnapMetadataInternet:

   564             aMetadata = ( TUint32 )( iMetadataRecord->iMetadata ) &

   565                     CMManager::ESnapMetadataInternet;

   566             break;

   567         case CMManager::ESnapMetadataHighlight:

   568             aMetadata = ( TUint32 )( iMetadataRecord->iMetadata ) &

   569                     CMManager::ESnapMetadataHighlight;

   570             break;

   571         case CMManager::ESnapMetadataHiddenAgent:

   572             aMetadata = ( TUint32 )( iMetadataRecord->iMetadata ) &

   573                     CMManager::ESnapMetadataHiddenAgent;

   574             break;

   575         case CMManager::ESnapMetadataDestinationIsLocalised:

   576             aMetadata = ( ( TUint32 )( iMetadataRecord->iMetadata ) &

   577                     CMManager::ESnapMetadataDestinationIsLocalised ) >> 4;

   578             break;

   579         case CMManager::ESnapMetadataPurpose:

   580             aMetadata = ( ( TUint32 )( iMetadataRecord->iMetadata ) &

   581                     CMManager::ESnapMetadataPurpose ) >> 8;

   582             break;

   583         default:

   584             User::Leave( KErrArgument );

   585             break;

   586         }

   587 

   588     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETMETADATAL_EXIT );

   589     }

   590 

   591 // ---------------------------------------------------------------------------

   592 // Set metadata of specified type.

   593 // ---------------------------------------------------------------------------

   594 //

   595 void CCmmDestinationInstance::SetMetadataL(

   596         const CMManager::TSnapMetadataField& aMetadataField,

   597         const TUint32 aMetadata )

   598     {

   599     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETMETADATAL_ENTRY );

   600 

   601     // Write action, load all records.

   602     LoadAllRecordsL();

   603 

   604     switch ( aMetadataField )

   605         {

   606         case CMManager::ESnapMetadataInternet:

   607             SetMetadataInternetL( aMetadata );

   608             break;

   609         case CMManager::ESnapMetadataHighlight:

   610             SetMetadataHighlight( aMetadata );

   611             break;

   612         case CMManager::ESnapMetadataHiddenAgent:

   613             SetMetadataHiddenAgentL( aMetadata );

   614             break;

   615         case CMManager::ESnapMetadataDestinationIsLocalised:

   616             SetMetadataLocalizationL( aMetadata );

   617             break;

   618         case CMManager::ESnapMetadataPurpose:

   619             SetMetadataPurposeL( aMetadata );

   620             break;

   621         default:

   622             User::Leave( KErrArgument );

   623             break;

   624         }

   625 

   626     iMetadataRecordStatus = ECmmRecordStatusModified;

   627     iStatus = ECmmDestinationStatusChanged;

   628 

   629     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETMETADATAL_EXIT );

   630     }

   631 

   632 // ---------------------------------------------------------------------------

   633 // Get destination protection level.

   634 // ---------------------------------------------------------------------------

   635 //

   636 void CCmmDestinationInstance::GetProtectionL( CMManager::TProtectionLevel& aProtectionLevel )

   637     {

   638     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETPROTECTIONL_ENTRY );

   639 

   640     LoadRecordIfMissingL( ECmmDestMetadataRecord );

   641 

   642     if ( !iMetadataRecord )

   643         {

   644         User::Leave( KErrCorrupt );

   645         }

   646 

   647     TUint32 value = ( ( TUint32 )( iMetadataRecord->iMetadata ) &

   648             KDestProtectionLevelMask ) >> KBitsToShiftDestProtectionLevel;

   649     switch ( value )

   650         {

   651         case CMManager::EProtLevel0:

   652             aProtectionLevel = CMManager::EProtLevel0;

   653             break;

   654         case CMManager::EProtLevel1:

   655             aProtectionLevel = CMManager::EProtLevel1;

   656             break;

   657         case CMManager::EProtLevel2:

   658             aProtectionLevel = CMManager::EProtLevel2;

   659             break;

   660         case CMManager::EProtLevel3:

   661             aProtectionLevel = CMManager::EProtLevel3;

   662             break;

   663         default:

   664             User::Leave( KErrCorrupt );

   665             break;

   666         }

   667 

   668     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETPROTECTIONL_EXIT );

   669     }

   670 

   671 // ---------------------------------------------------------------------------

   672 // Set destination protection level.

   673 // ---------------------------------------------------------------------------

   674 //

   675 void CCmmDestinationInstance::SetProtectionL(

   676         CMManager::TProtectionLevel aProtectionLevel )

   677     {

   678     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETPROTECTIONL_ENTRY );

   679 

   680     // Write action, load all records.

   681     LoadAllRecordsL();

   682 

   683     // Protection level is saved to CommsDat during update-call, so we need to

   684     // keep track of both the original value and the currently set new value.

   685     iCurrentProtectionLevel = aProtectionLevel;

   686     if ( !iProtectionChanged )

   687         {

   688         GetProtectionL( iLastProtectionLevel );

   689         }

   690     if ( aProtectionLevel == iLastProtectionLevel )

   691         {

   692         iProtectionChanged = EFalse;

   693         }

   694     else

   695         {

   696         iProtectionChanged = ETrue;

   697         }

   698 

   699     // Read current metadata without protection bits.

   700     TUint32 currentMetadata =

   701             ( ( TUint32 )( iMetadataRecord->iMetadata ) & ( ~KDestProtectionLevelMask ) );

   702     // Add new protection bits.

   703     iMetadataRecord->iMetadata =

   704             currentMetadata | ( aProtectionLevel << KBitsToShiftDestProtectionLevel );

   705 

   706     iMetadataRecordStatus = ECmmRecordStatusModified;

   707     iStatus = ECmmDestinationStatusChanged;

   708 

   709     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETPROTECTIONL_EXIT );

   710     }

   711 

   712 // ---------------------------------------------------------------------------

   713 // Return true if protection level has been changed.

   714 // ---------------------------------------------------------------------------

   715 //

   716 TBool CCmmDestinationInstance::ProtectionChanged()

   717     {

   718     return iProtectionChanged;

   719     }

   720 

   721 // ---------------------------------------------------------------------------

   722 // Return the previous valid protection level of this connection method

   723 // instance.

   724 // ---------------------------------------------------------------------------

   725 //

   726 CMManager::TProtectionLevel CCmmDestinationInstance::LastProtectionLevel()

   727     {

   728     return iLastProtectionLevel;

   729     }

   730 

   731 // ---------------------------------------------------------------------------

   732 // Return the protection level currently set into this destination instance.

   733 // ---------------------------------------------------------------------------

   734 //

   735 CMManager::TProtectionLevel CCmmDestinationInstance::CurrentProtectionLevelL()

   736     {

   737     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_CURRENTPROTECTIONLEVELL_ENTRY );

   738 

   739     CMManager::TProtectionLevel protLevel( iCurrentProtectionLevel );

   740     if ( !iProtectionChanged )

   741         {

   742         GetProtectionL( protLevel );

   743         }

   744 

   745     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_CURRENTPROTECTIONLEVELL_EXIT );

   746     return protLevel;

   747     }

   748 

   749 // ---------------------------------------------------------------------------

   750 // Adds a connection method into this destination. Returns the index (priority)

   751 // in the connection method array where the connection method was added.

   752 // Embedded destinations can not be added with this method, use

   753 // AddEmbeddedDestinationL() instead.

   754 // ---------------------------------------------------------------------------

   755 //

   756 TInt CCmmDestinationInstance::AddConnMethodL(

   757         CCmmConnMethodInstance& aConnMethodInstance )

   758     {

   759     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_ADDCONNMETHODL_ENTRY );

   760 

   761     TUint32 connMethodId( aConnMethodInstance.GetId() );

   762 

   763     // Check that the connection method is not an embedded destination.

   764     if ( aConnMethodInstance.IsEmbeddedDestination() )

   765         {

   766         User::Leave( KErrArgument );

   767         }

   768 

   769     // Check that the connection method is not already inside this destination.

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

   771         {

   772         if ( connMethodId == iConnMethodItemArray[i].iId )

   773             {

   774             User::Leave( KErrAlreadyExists );

   775             }

   776         }

   777 

   778     // Remove the connection method from delete list, if found there.

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

   780         {

   781         if ( connMethodId == iConnMethodsToBeDeleted[i] )

   782             {

   783             iConnMethodsToBeDeleted.Remove( i );

   784             break;

   785             }

   786         }

   787 

   788     // Get the priority value of this connection method according to bearer.

   789     TUint32 bearerType( aConnMethodInstance.GetBearerType() );

   790     TUint bearerPriority( 0 );

   791     iCache->BearerPriorityFromIapRecordL(

   792             ( CommsDat::CCDIAPRecord* )aConnMethodInstance.GetPluginDataInstance()

   793                     ->iGenRecordArray[KIapRecordIndex],

   794             bearerPriority );

   795     TCmmConnMethodItem item( connMethodId, bearerType, bearerPriority, 0 );

   796 

   797     // Find out the correct position for the connection method inside this

   798     // destination.

   799 

   800     // If the destination contains 1 or more connection methods of the same

   801     // bearer type, position the new connection method after the last of these

   802     // connection methods.

   803     // If not, position the connection method before the first connection

   804     // method found that has an equal or greater bearer based priority.

   805 

   806     // The relevant connection method item count is the number of connection

   807     // methods excluding a possible embedded destination.

   808     TInt relevantCount = iConnMethodItemArray.Count();

   809     if ( relevantCount > 0 && iConnMethodItemArray[ relevantCount - 1 ].IsEmbedded() )

   810         {

   811         relevantCount--;

   812         }

   813     // The final position will be between 0 and relevantCount.

   814     TInt index( relevantCount );

   815 

   816     TBool positionFound( EFalse );

   817     TBool connMethodIsVirtual = aConnMethodInstance.GetBoolAttributeL( CMManager::ECmVirtual );

   818     if ( connMethodIsVirtual )

   819         {

   820         // Ask link information only if this is a virtual IAP.

   821         TUint32 linkedIapId = aConnMethodInstance.GetIntAttributeL( CMManager::ECmNextLayerIapId );

   822         if ( linkedIapId == 0 )

   823             {

   824             // If this is a virtual IAP that doesn't point to an IAP, position it at

   825             // the end of the list.

   826             item.iPriority = CMManager::KDataMobilitySelectionPolicyPriorityWildCard;

   827             index = relevantCount;

   828             positionFound = ETrue;

   829             }

   830         else

   831             {

   832             // If this is a virtual IAP that links to another IAP, position it

   833             // as if it was that IAP.

   834             TCmmConnMethodItem linkedItem;

   835             TInt err = iCache->GetConnMethodItem( linkedIapId, linkedItem );

   836             if ( err )

   837                 {

   838                 User::Leave( KErrArgument );

   839                 }

   840             if ( linkedItem.IsVirtual() )

   841                 {

   842                 // This is a virtual IAP linking to another virtual IAP.

   843                 index = relevantCount;

   844                 positionFound = ETrue;

   845                 }

   846             bearerType = linkedItem.iBearerType;

   847             bearerPriority = linkedItem.iBearerPriority;

   848             }

   849         }

   850 

   851     if ( !positionFound )

   852         {

   853         // Search for any connection methods with the same bearer type.

   854         for ( TInt i = 0; i < relevantCount; i++ )

   855             {

   856             if ( iConnMethodItemArray[i].iBearerType == bearerType )

   857                 {

   858                 index = i + 1;

   859                 positionFound = ETrue;

   860                 // Don't break, need find last item.

   861                 }

   862             }

   863         }

   864     if ( !positionFound )

   865         {

   866         // No connection method found with the same bearer type. Position

   867         // the connection method according to bearer priority.

   868         for ( TInt i = 0; i < relevantCount; i++ )

   869             {

   870             if ( iConnMethodItemArray[i].iBearerPriority >= bearerPriority )

   871                 {

   872                 index = i;

   873                 break;

   874                 }

   875             }

   876         }

   877 

   878     // Add the connection method item into this destination at the correct

   879     // position (priority).

   880     iConnMethodItemArray.InsertL( item, index );

   881 

   882     SetStatus( ECmmDestinationStatusChanged );

   883 

   884     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_ADDCONNMETHODL_EXIT );

   885     return index;

   886     }

   887 

   888 // ---------------------------------------------------------------------------

   889 // Adds an embedded destination into this destination. Returns the index in

   890 // the connection method array where the connection method was added.

   891 // ---------------------------------------------------------------------------

   892 //

   893 TInt CCmmDestinationInstance::AddEmbeddedDestinationL(

   894         const CCmmDestinationInstance& aEmbeddedDestinationInstance )

   895     {

   896     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_ADDEMBEDDEDDESTINATIONL_ENTRY );

   897 

   898     TUint32 embeddedDestinationId( aEmbeddedDestinationInstance.GetId() );

   899 

   900     // Check that not adding itself.

   901     if ( embeddedDestinationId == iId )

   902         {

   903         User::Leave( KErrArgument );

   904         }

   905 

   906     // Check that the embedded destination is not already an embedded

   907     // destination in this destination.

   908     if ( HasEmbeddedWithId( embeddedDestinationId ) )

   909         {

   910         User::Leave( KErrAlreadyExists );

   911         }

   912 

   913     // A destination can not be added into a destination that is itself an

   914     // embedded destination.

   915     if ( iCache->DestinationIsEmbedded( iId ) )

   916         {

   917         User::Leave( KErrNotSupported );

   918         }

   919 

   920     // A destination can not be added into a destination that already has an

   921     // embedded destination.

   922     if ( HasEmbedded() || iCache->DestinationHasEmbedded( iId ) )

   923         {

   924         User::Leave( KErrNotSupported );

   925         }

   926 

   927     // A destination that already has an embedded destination can not be added

   928     // into a destination.

   929     if ( aEmbeddedDestinationInstance.HasEmbedded() ||

   930             iCache->DestinationHasEmbedded( embeddedDestinationId ) )

   931         {

   932         User::Leave( KErrNotSupported );

   933         }

   934 

   935     // Check session side destination instances for all clients.

   936     // - Check that any destination instance does not contain aDestinationId as

   937     //   embedded destination.

   938     // - Check that any destination instance for aEmbeddedDestinationId does

   939     //   not contain an embedded destination.

   940     if ( iCmmSession->EmbeddedDestinationConflictsFromAllSessions( iId, embeddedDestinationId ) )

   941         {

   942         User::Leave( KErrAlreadyExists );

   943         }

   944 

   945     // Add the embedded destination at the end of the connection method item array.

   946     TInt index = iConnMethodItemArray.Count();

   947     TCmmConnMethodItem item(

   948             embeddedDestinationId,

   949             KUidEmbeddedDestination,

   950             CMManager::KDataMobilitySelectionPolicyPriorityWildCard,

   951             CMManager::KDataMobilitySelectionPolicyPriorityWildCard );

   952     iConnMethodItemArray.AppendL( item );

   953 

   954     SetStatus( ECmmDestinationStatusChanged );

   955 

   956     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_ADDEMBEDDEDDESTINATIONL_EXIT );

   957     return index;

   958     }

   959 

   960 // ---------------------------------------------------------------------------

   961 // Delete a connection method that belongs to this destination. If the

   962 // connection method belongs to any other destination, it is only removed from

   963 // this destination and not deleted. Does not call update.

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

   965 //

   966 void CCmmDestinationInstance::DeleteConnMethodFromDestinationL(

   967         const CCmmConnMethodInstance& aConnMethodInstance )

   968     {

   969     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_DELETECONNMETHODFROMDESTINATIONL_ENTRY );

   970 

   971     // Check that the connection method is inside this destination.

   972     TUint32 connMethodId( aConnMethodInstance.GetId() );

   973     TInt index( KErrNotFound );

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

   975         {

   976         if ( connMethodId == iConnMethodItemArray[i].iId )

   977             {

   978             index = i;

   979             break;

   980             }

   981         }

   982     if ( index < 0 )

   983         {

   984         User::Leave( KErrArgument );

   985         }

   986 

   987     // Check if the connection method removal is blocked by any virtual IAPs.

   988     if ( ConnMethodInDestinationButLocked( connMethodId ) )

   989         {

   990         User::Leave( KErrLocked );

   991         }

   992 

   993     // Check if any virtual IAP points to this connection method, thus blocking

   994     // the delete.

   995     if ( iCache->ConnMethodPointedToByVirtualIap( connMethodId ) )

   996         {

   997         User::Leave( KErrLocked );

   998         }

   999 

  1000     // Check that the connection method is not in use by an active connection.

  1001     if ( iCache->CheckIfCmConnected( connMethodId ) )

  1002         {

  1003         User::Leave( KErrInUse );

  1004         }

  1005 

  1006     // This will also remove an embedded destination.

  1007     iConnMethodItemArray.Remove( index );

  1008     SetStatus( ECmmDestinationStatusChanged );

  1009 

  1010     // If this connection method is an embedded destination, then removing it

  1011     // from this destination is enough. The destination is not deleted.

  1012     if ( !aConnMethodInstance.IsEmbeddedDestination() )

  1013         {

  1014         // Add connection method to delete list only if not referenced from any

  1015         // other destination (in database or in any destination handles for the

  1016         // client currently beeing served).

  1017         if ( !iCache->ConnMethodInOtherDestination( connMethodId, iId ) &&

  1018                 !iCmmSession->ConnMethodInOtherDestination( connMethodId, iId ) )

  1019             {

  1020             if ( iConnMethodsToBeDeleted.Find( connMethodId ) == KErrNotFound )

  1021                 {

  1022                 iConnMethodsToBeDeleted.AppendL( connMethodId );

  1023                 }

  1024             }

  1025         }

  1026 

  1027     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_DELETECONNMETHODFROMDESTINATIONL_EXIT );

  1028     }

  1029 

  1030 // ---------------------------------------------------------------------------

  1031 // Remove a connection method from this destination. If the second attribute

  1032 // aTestIfConnected is false, the test to check if connection method is in use

  1033 // is skipped. In this case this should have been already tested by the caller.

  1034 // ---------------------------------------------------------------------------

  1035 //

  1036 void CCmmDestinationInstance::RemoveConnMethodFromDestinationL(

  1037         const CCmmConnMethodInstance& aConnMethodInstance,

  1038         const TBool aTestIfConnected )

  1039     {

  1040     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_REMOVECONNMETHODFROMDESTINATIONL_ENTRY );

  1041 

  1042     // Check that the connection method is inside this destination.

  1043     TUint32 connMethodId( aConnMethodInstance.GetId() );

  1044     TInt index( KErrNotFound );

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

  1046         {

  1047         if ( connMethodId == iConnMethodItemArray[i].iId )

  1048             {

  1049             index = i;

  1050             break;

  1051             }

  1052         }

  1053     if ( index < 0 )

  1054         {

  1055         User::Leave( KErrArgument );

  1056         }

  1057 

  1058     // Check if the connection method removal is blocked by any virtual IAPs.

  1059     if ( ConnMethodInDestinationButLocked( connMethodId ) )

  1060         {

  1061         User::Leave( KErrLocked );

  1062         }

  1063 

  1064     if ( aTestIfConnected )

  1065         {

  1066         // Check that the connection method is not in use by an active connection.

  1067         if ( iCache->CheckIfCmConnected( connMethodId ) )

  1068             {

  1069             User::Leave( KErrInUse );

  1070             }

  1071         }

  1072 

  1073     // This will also remove an embedded destination.

  1074     iConnMethodItemArray.Remove( index );

  1075     SetStatus( ECmmDestinationStatusChanged );

  1076 

  1077     OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_REMOVECONNMETHODFROMDESTINATIONL_EXIT );

  1078     }

  1079 

  1080 // ---------------------------------------------------------------------------

  1081 // Modifies the priority of a connection method inside this destination.

  1082 // ---------------------------------------------------------------------------

  1083 //

  1084 void CCmmDestinationInstance::ModifyConnMethodPriorityL(

  1085         CCmmConnMethodInstance& aConnMethodInstance,

  1086         TUint aIndex )

  1087     {

  1088     OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_MODIFYCONNMETHODPRIORITYL_ENTRY );

  1089 

  1090     // Check index range.

  1091     if ( aIndex >= iConnMethodItemArray.Count() )

  1092         {

  1093         User::Leave( KErrArgument );

  1094         }

  1095 

  1096     // Check if the connection method is in this destination. Also store the

  1097     // current index of the connection method.

  1098     TInt oldIndex( KErrNotFound );

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

  1100         {

  1101         if ( iConnMethodItemArray[i].iId == aConnMethodInstance.GetId() )

  1102             {

  1103             oldIndex = i;

  1104             break;

  1105             }

  1106         }

  1107     if ( oldIndex == KErrNotFound )

  1108         {

  1109         User::Leave( KErrArgument );

  1110         }

  1111 

  1112     // If connection method is an embedded destination, just return silently.

  1113     if ( aConnMethodInstance.IsEmbeddedDestination() )

  1114         {

  1115         OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_MODIFYCONNMETHODPRIORITYL_EXIT );

  1116         return;

  1117         }

  1118 

  1119     // If connection method is a virtual IAP linking to a destination, just return silently.

  1120     if ( aConnMethodInstance.GetBoolAttributeL( CMManager::ECmVirtual ) &&

  1121             aConnMethodInstance.GetIntAttributeL( CMManager::ECmNextLayerIapId ) == 0 )

  1122         {

  1123         OstTraceFunctionExit0( DUP1_CCMMDESTINATIONINSTANCE_MODIFYCONNMETHODPRIORITYL_EXIT );

  1124         return;

  1125         }

  1126 

  1127     // If the given index points to any wildcard priority connection method,

  1128     // adjust it so it points to the last priority position.

  1129     TUint numberOfConnMethodsWithPriority( NumberOfConnMethodsWithPriority() );

  1130     if ( aIndex >= numberOfConnMethodsWithPriority )

  1131         {

  1132         if ( numberOfConnMethodsWithPriority == 0 )

  1133             {

  1134             // Can't be 0, since aConnMethodInstance is not a wildcard IAP and