1 /*

     2 * Copyright (c) 2002-2007 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:  Stores and loads CRCSEAudioCodecRegistry to/from data storage.

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <featmgr.h>

    22 

    23 #include "crcseaudiocodecregistry.h"

    24 #include "crcseaudiocodecentry.h"

    25 #include "rcsepanic.h"

    26 #include "rcseconstants.h"

    27 #include "rcseprivatecrkeys.h"

    28 #include "rcselogger.h"

    29 

    30 // CONSTANTS

    31 

    32 // ============================ MEMBER FUNCTIONS ===============================

    33 // -----------------------------------------------------------------------------

    34 // CRCSEAudioCodecRegistry::NewLC

    35 // Two-phased constructor.

    36 // -----------------------------------------------------------------------------

    37 //

    38 EXPORT_C CRCSEAudioCodecRegistry* CRCSEAudioCodecRegistry::NewLC()

    39     {

    40     CRCSEAudioCodecRegistry* self = new( ELeave ) CRCSEAudioCodecRegistry();

    41     CleanupStack::PushL( self );

    42     self->ConstructL();

    43     return self;

    44     }

    45 

    46 // -----------------------------------------------------------------------------

    47 // CRCSEAudioCodecRegistry::NewL

    48 // Two-phased constructor.

    49 // -----------------------------------------------------------------------------

    50 //

    51 EXPORT_C CRCSEAudioCodecRegistry* CRCSEAudioCodecRegistry::NewL()

    52     {

    53     CRCSEAudioCodecRegistry* self = CRCSEAudioCodecRegistry::NewLC();

    54     CleanupStack::Pop( self );

    55     return self;

    56     }

    57     

    58 // -----------------------------------------------------------------------------

    59 // CRCSEAudioCodecRegistry::ConstructL

    60 // Symbian 2nd phase constructor can leave.

    61 // -----------------------------------------------------------------------------

    62 //

    63 void CRCSEAudioCodecRegistry::ConstructL()

    64     {

    65     // Check VoIP support from feature manager

    66     FeatureManager::InitializeLibL();

    67     TBool support = FeatureManager::FeatureSupported( KFeatureIdCommonVoip );

    68     FeatureManager::UnInitializeLib();

    69     if (!support)

    70         {

    71         User::Leave(KErrNotSupported);

    72         }

    73 

    74     BaseConstructL();

    75     }

    76 

    77 // -----------------------------------------------------------------------------

    78 // CRCSEAudioCodecRegistry::CRCSEAudioCodecRegistry

    79 // C++ default constructor can NOT contain any code, that

    80 // might leave.

    81 // -----------------------------------------------------------------------------

    82 //

    83 CRCSEAudioCodecRegistry::CRCSEAudioCodecRegistry()

    84     : CRCSERegistryBase( EAudioCodecSetting )

    85     {

    86     }

    87 

    88 // Destructor

    89 EXPORT_C CRCSEAudioCodecRegistry::~CRCSEAudioCodecRegistry()

    90     {

    91     RCSELOGSTRING( 

    92         "CRCSEAudioCodecRegistry::~CRCSEAudioCodecRegistry() - IN/OUT" );

    93     }

    94 

    95 // -----------------------------------------------------------------------------

    96 // CRCSEAudioCodecRegistry::AddL

    97 // Start addition of audio codec entry.

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

    99 //

   100 EXPORT_C TUint32 CRCSEAudioCodecRegistry::AddL( 

   101     const CRCSEAudioCodecEntry& aNewEntry )

   102     {

   103     RCSELOGSTRING( "CRCSEAudioCodecRegistry::AddL() - IN" );

   104 

   105     BeginL();

   106 

   107     TUint32 id( KNoEntryId );

   108 

   109     // Add entry to storage

   110     AddOrUpdateEntryL( id, aNewEntry );

   111 

   112     __ASSERT_ALWAYS( KNoEntryId < id , User::Leave( KErrCorrupt ) );

   113 

   114     EndL();

   115 

   116     RCSELOGSTRING( "CRCSEAudioCodecRegistry::AddL() - OUT" );

   117     return id;

   118     }

   119 

   120 // -----------------------------------------------------------------------------

   121 // CRCSEAudioCodecRegistry::FindL

   122 // Start search of audio codec entry by ID.

   123 // -----------------------------------------------------------------------------

   124 //

   125 EXPORT_C void CRCSEAudioCodecRegistry::FindL( 

   126     TUint32 aCodecId, 

   127     CRCSEAudioCodecEntry& aFoundEntry )

   128     {

   129     RCSELOGSTRING2( "CRCSEAudioCodecRegistry::FindL(%d) - IN", aCodecId );

   130 

   131     BeginL();

   132 

   133     FindEntryL( aCodecId, aFoundEntry );

   134 

   135     EndL();

   136 

   137     RCSELOGSTRING2( "CRCSEAudioCodecRegistry::FindL(%d) - OUT", aCodecId );

   138     }

   139 

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

   141 // CRCSEAudioCodecRegistry::DeleteL

   142 // Deletes a codec entry which codec id is aCodecId.

   143 // -----------------------------------------------------------------------------

   144 //

   145 EXPORT_C void CRCSEAudioCodecRegistry::DeleteL( TUint32 aCodecId )

   146     {

   147     RCSELOGSTRING2( "CRCSEAudioCodecRegistry::DeleteL() - IN", aCodecId );

   148 

   149     BeginL();

   150 

   151     iCenRepDb->DeleteEntryL( aCodecId );

   152 

   153     EndL();

   154 

   155     RCSELOGSTRING2( "CRCSEAudioCodecRegistry::DeleteL() - OUT", aCodecId );

   156     }

   157 

   158 // -----------------------------------------------------------------------------

   159 // CRCSEAudioCodecRegistry::UpdateL

   160 // Updates codec entry, which codec identifier is aCodecId.

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

   162 //

   163 EXPORT_C void CRCSEAudioCodecRegistry::UpdateL(

   164     TUint32 aCodecId,

   165     const CRCSEAudioCodecEntry& aUpdateData )

   166     {

   167     RCSELOGSTRING2( "CRCSEAudioCodecRegistry::UpdateL() - IN", aCodecId );

   168 

   169     __ASSERT_ALWAYS( KNoEntryId < aCodecId, User::Leave( KErrArgument ) );

   170 

   171     BeginL();

   172 

   173     AddOrUpdateEntryL( aCodecId, aUpdateData );

   174 

   175     EndL();

   176 

   177     RCSELOGSTRING2( "CRCSEAudioCodecRegistry::UpdateL() - OUT", aCodecId );

   178     }

   179 

   180 // -----------------------------------------------------------------------------

   181 // CRCSEAudioCodecRegistry::GetDefaultCodec

   182 // Resets a default profile values.

   183 // -----------------------------------------------------------------------------

   184 //

   185 EXPORT_C void CRCSEAudioCodecRegistry::GetDefaultCodec( 

   186     CRCSEAudioCodecEntry& aDefaultCodec ) const

   187     {

   188     aDefaultCodec.ResetDefaultCodecValues();

   189     }

   190 

   191 // -----------------------------------------------------------------------------

   192 // CRCSEAudioCodecRegistry::GetAllIdsL

   193 // Gets all codec identifiers.

   194 // -----------------------------------------------------------------------------

   195 //

   196 EXPORT_C void CRCSEAudioCodecRegistry::GetAllCodecIdsL( RArray<TUint32>& aAllIds )

   197     {

   198     RCSELOGSTRING( "CRCSEAudioCodecRegistry::GetAllCodecIdsL() - IN" );

   199 

   200     BeginL();

   201 

   202     FindAllIdsL( aAllIds );

   203 

   204     EndL();

   205 

   206     RCSELOGSTRING( "CRCSEAudioCodecRegistry::GetAllCodecIdsL() - OUT" );

   207     }

   208 

   209 // ---------------------------------------------------------------------------

   210 // CRCSEAudioCodecRegistry::AddL

   211 // Add bunch of entries to store

   212 // ---------------------------------------------------------------------------

   213 //

   214 void CRCSEAudioCodecRegistry::AddL( 

   215     RPointerArray<CRCSEAudioCodecEntry>& aEntries )

   216     {

   217     RCSELOGSTRING2( 

   218         "CRCSEAudioCodecRegistry::AddL(%d entries) - IN", aEntries.Count() );

   219 

   220     BeginL();

   221 

   222     TInt count( aEntries.Count() );

   223 

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

   225         {

   226         TUint32 id( KNoEntryId );

   227         AddOrUpdateEntryL( id, *aEntries[ i ] );

   228         aEntries[ i ]->iCodecId = id;

   229         }

   230 

   231     EndL();

   232 

   233     RCSELOGSTRING( "CRCSEAudioCodecRegistry::AddL(entries) - OUT" );

   234     }

   235 

   236 // ---------------------------------------------------------------------------

   237 // CRCSEAudioCodecRegistry::DeleteL

   238 // Delete bunch of entries from store in one trasaction.

   239 // ---------------------------------------------------------------------------

   240 //

   241 void CRCSEAudioCodecRegistry::DeleteL( const RArray<TUint32>& aIds )

   242     {

   243     TInt count( aIds.Count() );

   244 

   245     RCSELOGSTRING2( 

   246         "CRCSEAudioCodecRegistry::DeleteL(%d entries) - IN", count );

   247 

   248     BeginL();

   249 

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

   251         {

   252         TRAPD( e, iCenRepDb->DeleteEntryL( aIds[ i ] ) );

   253         __ASSERT_ALWAYS( 

   254             KErrNone == e || KErrNotFound == e, User::Leave( e ) );

   255         }

   256 

   257     EndL();

   258 

   259     RCSELOGSTRING( "CRCSEAudioCodecRegistry::DeleteL(entries) - OUT" );

   260     }

   261 

   262 

   263 

   264 // -----------------------------------------------------------------------------

   265 // CRCSEAudioCodecRegistry::FindEntryL

   266 // Do actual search of audio codec entry

   267 // -----------------------------------------------------------------------------

   268 //

   269 void CRCSEAudioCodecRegistry::FindEntryL( 

   270     TUint32 aCodecId, 

   271     CRCSEAudioCodecEntry& aFoundEntry )

   272     {

   273     RCSELOGSTRING2( "CRCSEAudioCodecRegistry::FindEntryL(%d) - IN", aCodecId );

   274 

   275     RIpAppPropArray properties;

   276 	TCleanupItem cleanup( CRCSERegistryBase::CleanupDbPropArray, &properties );

   277 	CleanupStack::PushL( cleanup );

   278 

   279     User::LeaveIfError( iCenRepDb->FindEntryL( aCodecId, properties ) );

   280     ConvertPropertiesToEntryL( aFoundEntry, properties );

   281     aFoundEntry.iCodecId = aCodecId;

   282 

   283     CleanupStack::PopAndDestroy( &properties );

   284 

   285     RCSELOGSTRING2( "CRCSEAudioCodecRegistry::FindEntryL(%d) - OUT", aCodecId );

   286     }

   287 

   288 // -----------------------------------------------------------------------------

   289 // CRCSEAudioCodecRegistry::AddOrUpdateEntryL

   290 // Adds new entry or updates values of existing enry

   291 // -----------------------------------------------------------------------------

   292 //

   293 void CRCSEAudioCodecRegistry::AddOrUpdateEntryL( 

   294     TUint32& aId, 

   295     const CRCSEAudioCodecEntry& aEntry )

   296     {

   297     RCSELOGSTRING( "CRCSEAudioCodecRegistry::AddOrUpdateEntryL() - IN" );

   298 

   299     TInt id( aId );

   300 

   301     RIpAppPropArray properties;

   302 

   303 	TCleanupItem cleanup( CRCSERegistryBase::CleanupDbPropArray, &properties );

   304 	CleanupStack::PushL( cleanup );

   305 

   306     ConvertEntryToPropertiesL( aEntry, properties );

   307     

   308     if ( KNoEntryId == id ) // Add new one

   309         {

   310         RCSELOGSTRING( "-- Add --" );

   311         iCenRepDb->AddEntryL( id, properties );

   312         }

   313     else                    // Update existing entry

   314         {

   315         RCSELOGSTRING( "-- Update --" );

   316         User::LeaveIfError( iCenRepDb->UpdateEntryL( id, properties ) );

   317         }

   318 

   319     aId = id;

   320 

   321     CleanupStack::PopAndDestroy( &properties );

   322     

   323     RCSELOGSTRING( "CRCSEAudioCodecRegistry::AddOrUpdateEntryL() - OUT" );

   324     }

   325 

   326 

   327 

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

   329 // CRCSEAudioCodecRegistry::GetEntryL

   330 // Get values for audio codec entry from repository

   331 // -----------------------------------------------------------------------------

   332 //

   333 void CRCSEAudioCodecRegistry::ConvertPropertiesToEntryL( 

   334     CRCSEAudioCodecEntry& aEntry,

   335     RIpAppPropArray& aProperties  )

   336     {

   337     RCSELOGSTRING( 

   338         "CRCSEAudioCodecRegistry::ConvertPropertiesToEntryL() - IN" );

   339 

   340     aEntry.ResetDefaultCodecValues();

   341 

   342     TBuf<KDesLength256> value;

   343 

   344     //TInt32 id( KNoEntryId );

   345     //GetL( aRow, KColAudioCodecId, id );

   346     //aEntry.iCodecId = id;

   347 

   348     GetPropertyValueL( KColMediaTypeName, value, aProperties );

   349     aEntry.iMediaTypeName.Copy( value );

   350     

   351     GetPropertyValueL( KColMediaSubTypeName, value, aProperties );

   352     aEntry.iMediaSubTypeName.Copy( value );

   353 

   354     GetPropertyValueL( KColJitterBufferSize, value, aProperties );

   355     aEntry.iJitterBufferSize = ToTInt32L( value );

   356 

   357     GetPropertyValueL( KColOctetAlign, value, aProperties );

   358     aEntry.iOctetAlign = static_cast<CRCSEAudioCodecEntry::TOnOff>( ToTInt32L( value ) );

   359 

   360     GetPropertyValueL( KColModeSet, value, aProperties );

   361 

   362     TLex lex( value );

   363     while( !lex.Eos() )

   364         {

   365         // Extract the number as unsigned int 32, which can be 

   366         // converted to value wanted (template)

   367         TUint32 num;

   368         lex.Val( num, EDecimal );

   369         aEntry.iModeSet.AppendL( static_cast<TUint32>( num ) );

   370         // Skip characters to space char.

   371         lex.SkipCharacters();

   372         if ( !lex.Eos() ) // Check that End of string is not next char.

   373             {

   374             // Go over the space character.

   375             lex.Inc( 1 );

   376             }

   377         }

   378 

   379     GetPropertyValueL( KColModeChangePeriod, value, aProperties );

   380     aEntry.iModeChangePeriod = ToTInt32L( value );

   381 

   382     GetPropertyValueL( KColModeChangeNeighbor, value, aProperties );

   383     aEntry.iModeChangeNeighbor = static_cast<CRCSEAudioCodecEntry::TOnOff>( ToTInt32L( value ) );

   384 

   385     GetPropertyValueL( KColPtime, value, aProperties );

   386     aEntry.iPtime = ToTInt32L( value );

   387 

   388     GetPropertyValueL( KColMaxptime, value, aProperties );

   389     aEntry.iMaxptime = ToTInt32L( value );

   390 

   391     GetPropertyValueL( KColCrc, value, aProperties );

   392     aEntry.iCrc = static_cast<CRCSEAudioCodecEntry::TOnOff>( ToTInt32L( value ) );

   393 

   394     GetPropertyValueL( KColRobustSorting, value, aProperties );

   395     aEntry.iRobustSorting = static_cast<CRCSEAudioCodecEntry::TOnOff>( ToTInt32L( value ) );

   396 

   397     GetPropertyValueL( KColInterLeaving, value, aProperties );

   398     aEntry.iInterLeaving = ToTInt32L( value );

   399 

   400     GetPropertyValueL( KColChannels, value, aProperties );

   401 

   402     TLex lex2( value );

   403     while( !lex2.Eos() )

   404         {

   405         // Extract the number as unsigned int 32, which can be 

   406         // converted to value wanted (template)

   407         TUint32 num;

   408         lex2.Val( num, EDecimal );

   409         aEntry.iChannels.AppendL( static_cast<TUint32>( num ) );

   410         // Skip characters to space char.

   411         lex2.SkipCharacters();

   412         if ( !lex2.Eos() ) // Check that End of string is not next char.

   413             {

   414             // Go over the space character.

   415             lex2.Inc( 1 );

   416             }

   417         }

   418 

   419     GetPropertyValueL( KColVAD, value, aProperties );

   420     aEntry.iVAD = static_cast<CRCSEAudioCodecEntry::TOnOff>( ToTInt32L( value ) );

   421 

   422     GetPropertyValueL( KColDTX, value, aProperties );

   423     aEntry.iDTX = static_cast<CRCSEAudioCodecEntry::TOnOff>( ToTInt32L( value ) );

   424 

   425     GetPropertyValueL( KColSamplingRate, value, aProperties );

   426     aEntry.iSamplingRate = ToTInt32L( value );

   427 

   428     GetPropertyValueL( KColAnnexb, value, aProperties );

   429     aEntry.iAnnexb = static_cast<CRCSEAudioCodecEntry::TOnOff>( ToTInt32L( value ) );

   430 

   431     GetPropertyValueL( KColModeChangeCapability, value, aProperties );

   432     aEntry.iModeChangeCapability = ToTInt32L( value );

   433 

   434     GetPropertyValueL( KColMaxRed, value, aProperties );

   435     aEntry.iMaxRed = ToTInt32L( value );

   436 

   437     RCSELOGSTRING( "CRCSEAudioCodecRegistry::GetEntryValuesL() - OUT" );

   438     }

   439 

   440 

   441 // -----------------------------------------------------------------------------

   442 // CRCSEProfileRegistry::AddEntryL

   443 // Do actual addition or update of entry

   444 // -----------------------------------------------------------------------------

   445 //

   446 void CRCSEAudioCodecRegistry::ConvertEntryToPropertiesL( 

   447     const CRCSEAudioCodecEntry& aEntry,

   448     RIpAppPropArray& aProperties )

   449     {

   450     RCSELOGSTRING(

   451          "CRCSEAudioCodecRegistry::ConvertEntryToPropertiesL() - IN" );

   452 

   453     // Descriptor for value conversion

   454     TBuf<KDesLength128> des;

   455 

   456     CreatePropertyL( KColMediaTypeName,

   457                      aEntry.iMediaTypeName,

   458                      aProperties );

   459 

   460     CreatePropertyL( KColMediaSubTypeName,

   461                      aEntry.iMediaSubTypeName,

   462                      aProperties );

   463 

   464     CreatePropertyL( KColJitterBufferSize,

   465                      ToDes( aEntry.iJitterBufferSize, des ),

   466                      aProperties );

   467 

   468     TInt32 octetAlign( aEntry.iOctetAlign ); // TOnOff

   469     CreatePropertyL( KColOctetAlign,

   470                      ToDes( octetAlign, des ),

   471                      aProperties );

   472 

   473     TInt msCount = aEntry.iModeSet.Count(); // Array type

   474     des.Zero();

   475     for ( TInt i( 0 ); i < msCount; i++ )

   476         {

   477         des.AppendNum( static_cast<TUint32>( aEntry.iModeSet[i] ) );

   478         if ( i < msCount - 1 )

   479             {

   480             des.Append( KSpace );

   481             }

   482         }

   483 

   484     CreatePropertyL( KColModeSet,

   485                      des,

   486                      aProperties );

   487 

   488     CreatePropertyL( KColModeChangePeriod, 

   489                      ToDes( aEntry.iModeChangePeriod, des ),

   490                      aProperties );

   491 

   492     TInt32 modeChangeNeighbor( aEntry.iModeChangeNeighbor ); // TOnoff

   493     CreatePropertyL( KColModeChangeNeighbor,

   494                      ToDes( modeChangeNeighbor, des ),

   495                      aProperties );

   496 

   497     CreatePropertyL( KColPtime,

   498                      ToDes( aEntry.iPtime, des ),

   499                      aProperties );

   500 

   501     CreatePropertyL( KColMaxptime,

   502                      ToDes( aEntry.iMaxptime, des ),

   503                      aProperties );

   504 

   505     TInt32 crc( aEntry.iCrc ); // TOnOff

   506     CreatePropertyL( KColCrc,

   507                      ToDes( crc, des ),

   508                      aProperties );

   509 

   510     TInt32 robustSorting( aEntry.iRobustSorting ); // TOnOff

   511     CreatePropertyL( KColRobustSorting,

   512                      ToDes( robustSorting, des ),

   513                      aProperties );

   514 

   515     CreatePropertyL( KColInterLeaving,

   516                      ToDes( aEntry.iInterLeaving, des ),

   517                      aProperties );

   518 

   519     TInt cCount = aEntry.iChannels.Count(); // Array type

   520     des.Zero();

   521     for ( TInt j( 0 ); j < cCount; j++ )

   522         {

   523         des.AppendNum( static_cast<TUint32>( aEntry.iChannels[j] ) );

   524         if ( j < cCount - 1 )

   525             {

   526             des.Append( KSpace );

   527             }

   528         }

   529 

   530     CreatePropertyL( KColChannels,

   531                      des,

   532                      aProperties );

   533 

   534     TInt32 vad( aEntry.iVAD ); // TOnOff

   535     CreatePropertyL( KColVAD,

   536                      ToDes( vad, des ),

   537                      aProperties );

   538 

   539     TInt32 dtx( aEntry.iDTX );

   540     CreatePropertyL( KColDTX,

   541                      ToDes( dtx, des ),

   542                      aProperties );

   543 

   544     CreatePropertyL( KColSamplingRate,

   545                      ToDes( aEntry.iSamplingRate, des ),

   546                      aProperties );

   547 

   548     TInt32 annexB( aEntry.iAnnexb ); // TOnOff

   549     CreatePropertyL( KColAnnexb,

   550                      ToDes( annexB, des ),

   551                      aProperties );

   552 

   553     CreatePropertyL( KColModeChangeCapability,

   554                      ToDes( aEntry.iModeChangeCapability, des ),

   555                      aProperties );

   556 

   557     CreatePropertyL( KColMaxRed,

   558                      ToDes( aEntry.iMaxRed, des ),

   559                      aProperties );

   560 

   561     RCSELOGSTRING(

   562          "CRCSEAudioCodecRegistry::ConvertEntryToPropertiesL() - OUT" );

   563     }

   564 

   565 

   566 //  End of File