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:    Presence Settings API designed for creating and editing

    15 *  setting sets for presence. Usually used by UI components.

    16 *

    17 */

    18 

    19 

    20 

    21 

    22 // Includes

    23 #include <centralrepository.h>

    24 

    25 #include "pressettingsapi.h"

    26 #include "pressettingsapilogger.h"

    27 

    28 

    29 // ---------------------------------------------------------------------------

    30 // PresSettingsApi::GetAllSetsNamesLC

    31 // ---------------------------------------------------------------------------

    32 //

    33 EXPORT_C CDesCArray* PresSettingsApi::GetAllSetsNamesLC( RArray<TInt>& aSetIds )

    34     {

    35     OPENG_DP(D_OPENG_LIT( "PresSettingsApi::GetAllSetsNamesLC"));

    36     

    37     CDesCArrayFlat* sets = new ( ELeave ) CDesCArrayFlat(KPresNormalListLength);

    38     CleanupStack::PushL( sets );

    39     

    40     CRepository* repository = CRepository::NewL( KCRUIDSimpleOTA );

    41     CleanupStack::PushL( repository );

    42     

    43     RArray<TUint32> idKeys;

    44     TInt error = repository->FindL( KSimpleSetId, KOnlyColumnInfo, idKeys );

    45     CleanupClosePushL( idKeys );

    46     

    47     TInt idCount = idKeys.Count();

    48     

    49     OPENG_DP(D_OPENG_LIT( " idCount = %d"), idCount);

    50     

    51     TBuf<KPresSetNameMaxLength> setName;   

    52     TInt setId(NULL); 

    53     

    54     TInt errID(KErrNone);

    55     TInt errName(KErrNone);

    56     TUint32 error2(KErrNone);

    57     TUint32 row;

    58     

    59     for( TInt i = 0;i < idCount;i++ )

    60         {

    61         // avoid the 0th and 256th rows

    62         if ((idKeys[i]<KUnitRow) || (idKeys[i]>KLastUseableRow))

    63             continue;

    64         

    65         row = idKeys[i] & KOnlyRowInfo;

    66 

    67         errName = repository->Get( row + KSimpleSetName, setName );

    68         errID = repository->Get( idKeys[i], setId );

    69         

    70         if( (errName != KErrNone) || (errID != KErrNone)) // if some error in getting

    71             {

    72             // try deleting the troubled row

    73             repository->Delete( row, KOnlyRowInfo, error2);            

    74             OPENG_DP(D_OPENG_LIT( "     Error in Get(name): i = %d"),i);

    75             OPENG_DP(D_OPENG_LIT( "     Error in Get(id)  : i = %d"),i);

    76             continue;

    77             }

    78         else

    79             {

    80             sets->AppendL(setName);

    81             aSetIds.Append(setId);

    82             }

    83         setName.Zero();           

    84         }

    85 

    86     CleanupStack::PopAndDestroy(&idKeys);   //idKeys

    87     CleanupStack::PopAndDestroy(repository); //repository

    88     return sets;

    89     

    90     }

    91 

    92 // ---------------------------------------------------------------------------

    93 // PresSettingsApi::CreateSetL

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

    95 //

    96 EXPORT_C TInt PresSettingsApi::CreateSetL(TPresSettingsSet aSet )

    97     {

    98     OPENG_DP(D_OPENG_LIT( "PresSettingsApi::CreateSetL"));

    99     CRepository* repository = CRepository::NewL( KCRUIDSimpleOTA );

   100     CleanupStack::PushL( repository );

   101     

   102     TUint32 row = GetFreshRawInHex(repository);

   103     OPENG_DP(D_OPENG_LIT( " row: %d"),row);

   104     TInt error(KErrNone);

   105     TUint32 error2(KErrNone);

   106 

   107     

   108     // Create the set id in different way

   109     TInt id = CreateUniqueIdL( repository, row );

   110     

   111     OPENG_DP(D_OPENG_LIT( " id: %d"),id);

   112     

   113     error = error + repository->Create( row+KSimpleSetName, aSet.iSetName);

   114     error = error + repository->Create( row+KSimpleSipProfile, aSet.iSipProfile );

   115     error = error + repository->Create( row+KSimpleXDMSet, aSet.iXDMSetting );

   116     error = error + repository->Create( row+KSimpleClientObjDataLimit, aSet.iObjectSize );

   117     error = error + repository->Create( row+KSimpleContentSvrAdd, aSet.iContSrvrAdd );

   118     error = error + repository->Create( row+KSimpleStatusofProps, aSet.iStatusOfProps );

   119     error = error + repository->Create( row+KSimpleSourceThrottlePublish, aSet.iPublicationInt );

   120     error = error + repository->Create( row+KSimpleMaxNbrPresenceSubs, aSet.iMaxSubscriptions );

   121     error = error + repository->Create( row+KSimpleMaxNbrSubsInList, aSet.iMaxContactsInList );

   122     error = error + repository->Create( row+KSimpleServiceUriTemplate, aSet.iDomainSyntax );

   123     error = error + repository->Create( row+KSimpleProviderID, aSet.iProviderID );

   124 

   125     if (error<0) // was there one of more errors then try deleting this currupt row

   126         {

   127         error = repository->Delete( row, KOnlyRowInfo, error2);

   128         User::Leave(KErrCorrupt);

   129         }

   130 

   131     CleanupStack::PopAndDestroy(repository);  //repository

   132     

   133     OPENG_DP(D_OPENG_LIT( " id: %d"),id);

   134     return id;

   135     }

   136     

   137 // ---------------------------------------------------------------------------

   138 // PresSettingsApi::UpdateSetL

   139 // ---------------------------------------------------------------------------

   140 //

   141 EXPORT_C TInt PresSettingsApi::UpdateSetL(TPresSettingsSet aSet, TInt aSetID)

   142     {

   143     OPENG_DP(D_OPENG_LIT( "PresSettingsApi::UpdateSetL(%d)"),aSetID);

   144     

   145     CRepository* repository = CRepository::NewL( KCRUIDSimpleOTA );

   146     CleanupStack::PushL( repository );

   147     

   148     TInt ret(KErrNotFound);

   149     TInt error(KErrNone);

   150     TUint32 error2(KErrNone);

   151     

   152     TUint32 row =  PresSettingsApi::GetRawInHexL(repository,aSetID);

   153     OPENG_DP(D_OPENG_LIT( " row: %d, id: %d"),row, aSetID);

   154     if(row>0) // if a valid row is found

   155         {

   156         error = error + repository->Set( row+KSimpleSetName, aSet.iSetName);

   157         error = error + repository->Set( row+KSimpleSipProfile, aSet.iSipProfile );

   158         error = error + repository->Set( row+KSimpleXDMSet, aSet.iXDMSetting );

   159         error = error + repository->Set( row+KSimpleClientObjDataLimit, aSet.iObjectSize );

   160         error = error + repository->Set( row+KSimpleContentSvrAdd, aSet.iContSrvrAdd );

   161         error = error + repository->Set( row+KSimpleStatusofProps, aSet.iStatusOfProps );

   162         error = error + repository->Set( row+KSimpleSourceThrottlePublish, aSet.iPublicationInt );

   163         error = error + repository->Set( row+KSimpleMaxNbrPresenceSubs, aSet.iMaxSubscriptions );

   164         error = error + repository->Set( row+KSimpleMaxNbrSubsInList, aSet.iMaxContactsInList );

   165         error = error + repository->Set( row+KSimpleServiceUriTemplate, aSet.iDomainSyntax );

   166         error = error + repository->Set( row+KSimpleProviderID, aSet.iProviderID );

   167 

   168         

   169         if (error<0) // was there one of more errors then try deleting this currupt row

   170             {

   171             error = repository->Delete( row, KOnlyRowInfo, error2);

   172             ret = KErrCorrupt;

   173             }

   174         else

   175             ret = KErrNone;

   176         }

   177     

   178     CleanupStack::PopAndDestroy(repository);   //repository

   179     

   180     OPENG_DP(D_OPENG_LIT( " ret: %d"),ret);

   181     return ret;

   182     }

   183 

   184 // ---------------------------------------------------------------------------

   185 // PresSettingsApi::RemoveSetL

   186 // ---------------------------------------------------------------------------

   187 //

   188 EXPORT_C TInt PresSettingsApi::RemoveSetL( TInt aSetID )

   189     {

   190     OPENG_DP(D_OPENG_LIT( "PresSettingsApi::RemoveSetL"));

   191     

   192     CRepository* repository = CRepository::NewL( KCRUIDSimpleOTA );

   193     CleanupStack::PushL( repository );

   194     

   195     TInt ret(KErrNotFound);

   196     TUint32 error(KErrNone);

   197     TUint32 error2(KErrNone);

   198     

   199     TUint32 row =  PresSettingsApi::GetRawInHexL(repository,aSetID);

   200     OPENG_DP(D_OPENG_LIT( " row: %d, id: %d"),row, aSetID);

   201     if(row>0) // if a valid row is found

   202         {

   203         //Delete all entries on the row

   204         TInt retError = repository->Delete( row, KOnlyRowInfo, error);

   205         if (retError<0) // was there one of more errors then try deleting this currupt row

   206             {

   207             error = repository->Delete( row, KOnlyRowInfo, error2);

   208             ret = KErrCorrupt;

   209             }

   210         else

   211             ret = KErrNone;

   212         }

   213     

   214     CleanupStack::PopAndDestroy(repository);   //repository

   215     

   216     OPENG_DP(D_OPENG_LIT( " ret: %d"),ret);

   217     return ret;

   218     }

   219     

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

   221 // PresSettingsApi::UpdatePropertyL

   222 // ---------------------------------------------------------------------------

   223 //

   224 EXPORT_C TInt PresSettingsApi::UpdatePropertyL( TInt aSetID, 

   225                                             TPresSettingsProperty aPropertyName,

   226                                             TInt aPropValueInt

   227                                             )

   228     {

   229     OPENG_DP(D_OPENG_LIT( "PresSettingsApi::UpdatePropertyL"));

   230     

   231     CRepository* repository = CRepository::NewL( KCRUIDSimpleOTA );

   232     CleanupStack::PushL( repository );

   233     

   234     TInt ret(KErrNotFound);

   235     TInt error(KErrNone);

   236     TUint32 error2(KErrNone);

   237     

   238     TUint32 row =  PresSettingsApi::GetRawInHexL(repository,aSetID);

   239     OPENG_DP(D_OPENG_LIT( " row: %d, id: %d"),row, aSetID);

   240     if(row>0) // if a valid row is found

   241         {

   242         if((IsStr(aPropertyName))||(aPropertyName==EPresPropSetID))

   243             {

   244             // because property and its value doesnt match

   245             ret = KErrArgument;

   246             }

   247         else

   248             {

   249             error = repository->Set( row+aPropertyName, aPropValueInt );

   250             if (error<0) // was there one of more errors then try deleting this currupt row

   251                 {

   252                 error = repository->Delete( row, KOnlyRowInfo, error2);

   253                 ret = KErrCorrupt;

   254                 }

   255             else

   256                 ret = KErrNone;

   257             }

   258         }

   259     

   260     CleanupStack::PopAndDestroy(repository);   //repository

   261     

   262     OPENG_DP(D_OPENG_LIT( " ret: %d"),ret);

   263     return ret;

   264     }

   265 

   266 // ---------------------------------------------------------------------------

   267 // PresSettingsApi::UpdatePropertyL

   268 // ---------------------------------------------------------------------------

   269 //

   270 EXPORT_C TInt PresSettingsApi::UpdatePropertyL( TInt aSetID, 

   271                                             TPresSettingsProperty aPropertyName,

   272                                             const TDesC& aPropValueDes

   273                                             )

   274     {

   275     OPENG_DP(D_OPENG_LIT( "PresSettingsApi::UpdatePropertyL"));

   276     

   277     CRepository* repository = CRepository::NewL( KCRUIDSimpleOTA );

   278     CleanupStack::PushL( repository );

   279     

   280     TInt ret(KErrNotFound);

   281     TInt error(KErrNone);

   282     TUint32 error2(KErrNone);

   283     

   284     TUint32 row =  PresSettingsApi::GetRawInHexL(repository,aSetID);

   285     OPENG_DP(D_OPENG_LIT( " row: %d, id: %d"),row, aSetID);

   286     if(row>0) // if a valid row is found

   287         {

   288         if((!IsStr(aPropertyName))||(aPropertyName==EPresPropSetID))

   289             {

   290             // because property and its value doesnt match

   291             ret = KErrArgument;

   292             }

   293         else

   294             {

   295             error = repository->Set( row+aPropertyName, aPropValueDes );

   296             if (error<0) // was there one of more errors then try deleting this currupt row

   297                 {

   298                 error = repository->Delete( row, KOnlyRowInfo, error2);

   299                 ret = KErrCorrupt;

   300                 }

   301             else

   302                 ret = KErrNone;

   303             }

   304         }

   305     

   306     CleanupStack::PopAndDestroy(repository);   //repository

   307     OPENG_DP(D_OPENG_LIT( " ret: %d"),ret);

   308     return ret;

   309     }

   310 

   311 // ---------------------------------------------------------------------------

   312 // PresSettingsApi::SettingsSetL

   313 // ---------------------------------------------------------------------------

   314 //

   315 EXPORT_C TInt PresSettingsApi::SettingsSetL(TInt aSetID, TPresSettingsSet& aSet)

   316     {

   317     OPENG_DP(D_OPENG_LIT( "PresSettingsApi::SettingsSetL"));

   318     

   319     CRepository* repository = CRepository::NewL( KCRUIDSimpleOTA );

   320     CleanupStack::PushL( repository );

   321     

   322     TInt ret(KErrNotFound);

   323     TInt error(KErrNone);

   324     TUint32 error2(KErrNone);

   325     

   326     TUint32 row =  PresSettingsApi::GetRawInHexL(repository,aSetID);

   327     OPENG_DP(D_OPENG_LIT( " row: %d, id: %d"),row, aSetID);

   328     if(row>0) // if a valid row is found

   329         {

   330         error = error + repository->Get( row+KSimpleSetName, aSet.iSetName);

   331         error = error + repository->Get( row+KSimpleSipProfile, aSet.iSipProfile );

   332         error = error + repository->Get( row+KSimpleXDMSet, aSet.iXDMSetting );

   333         error = error + repository->Get( row+KSimpleClientObjDataLimit, aSet.iObjectSize );

   334         error = error + repository->Get( row+KSimpleContentSvrAdd, aSet.iContSrvrAdd );

   335         error = error + repository->Get( row+KSimpleStatusofProps, aSet.iStatusOfProps );

   336         error = error + repository->Get( row+KSimpleSourceThrottlePublish, aSet.iPublicationInt );

   337         error = error + repository->Get( row+KSimpleMaxNbrPresenceSubs, aSet.iMaxSubscriptions );

   338         error = error + repository->Get( row+KSimpleMaxNbrSubsInList, aSet.iMaxContactsInList );

   339         error = error + repository->Get( row+KSimpleServiceUriTemplate, aSet.iDomainSyntax );

   340         error = error + repository->Get( row+KSimpleProviderID, aSet.iProviderID );

   341         

   342         if (error<0) // was there one of more errors then try deleting this currupt row

   343             {

   344             error = repository->Delete( row, KOnlyRowInfo, error2);

   345             ret = KErrCorrupt;

   346             }

   347         else

   348             ret = KErrNone;

   349         }

   350     

   351     CleanupStack::PopAndDestroy(repository);   //repository

   352     OPENG_DP(D_OPENG_LIT( " ret: %d"),ret);

   353     return ret;

   354     }

   355     

   356 // ---------------------------------------------------------

   357 // PresSettingsApi::DecodePropertyStatus

   358 // ---------------------------------------------------------

   359 //

   360 EXPORT_C TPresPropStatus PresSettingsApi::DecodePropertyStatus(TInt aStatusOfProps,

   361                                               TPresSettingsProperty aPropertyName)

   362     {

   363     TInt shiftNumber = (aPropertyName-1) * 2;

   364     TInt maskNumber = 0x3 << shiftNumber; 

   365     return TPresPropStatus((aStatusOfProps & maskNumber)>>shiftNumber);  

   366     }

   367                                               

   368 // ---------------------------------------------------------

   369 // PresSettingsApi::EncodePropertyStatus

   370 // ---------------------------------------------------------

   371 //

   372 EXPORT_C void PresSettingsApi::EncodePropertyStatus(TInt& aStatusOfProps,

   373                                               TPresPropStatus aPropertyStatus,

   374                                            TPresSettingsProperty aPropertyName)

   375     {

   376     TInt shiftNumber = (aPropertyName-1) * 2;

   377     TInt maskNumber = (0x3 << shiftNumber)^KFullValue;

   378     aStatusOfProps = (aStatusOfProps & maskNumber) | (aPropertyStatus << shiftNumber);

   379     }

   380     

   381 // ---------------------------------------------------------

   382 // PresSettingsApi::IsStr

   383 // ---------------------------------------------------------

   384 //

   385 EXPORT_C TBool PresSettingsApi::IsStr( TPresSettingsProperty aProperty )

   386     {

   387     OPENG_DP(D_OPENG_LIT( "PresSettingsApi::IsStr"));

   388     TBool ret(EFalse);

   389     if((aProperty==KSimpleSetName)||(aProperty==KSimpleContentSvrAdd)||

   390        (aProperty==KSimpleProviderID)||(aProperty==KSimpleServiceUriTemplate))

   391         ret = ETrue;

   392     

   393     OPENG_DP(D_OPENG_LIT( " ret: %d"),ret);

   394     return ret;   

   395     }    

   396     

   397 // ---------------------------------------------------------------------------

   398 // PresSettingsApi::GetRawInHexL

   399 // ---------------------------------------------------------------------------

   400 //

   401 TUint32 PresSettingsApi::GetRawInHexL( CRepository* aRepository, TInt aSetID )

   402     {

   403     OPENG_DP(D_OPENG_LIT( " PresSettingsApi::GetRawInHexL"));

   404     TInt error(KErrNone);

   405     TInt tempValue(0);

   406     TUint32 ret(0);

   407     

   408     // Find all SetId keys

   409     RArray<TUint32> idKeys;

   410     error = aRepository->FindL( KSimpleSetId, KOnlyColumnInfo, idKeys );

   411     CleanupClosePushL( idKeys );

   412     User::LeaveIfError(error);

   413     

   414     TInt count = idKeys.Count();

   415     OPENG_DP(D_OPENG_LIT( "     count: %d"),count);

   416 

   417     // start from 1st row and search the whole range of rows

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

   419         {

   420         // avoid the 0th and 256th rows

   421         if ((idKeys[i]<KUnitRow) || (idKeys[i]>KLastUseableRow))

   422             continue;

   423         error = aRepository->Get(idKeys[i], tempValue);

   424         User::LeaveIfError(error);

   425         

   426         if(tempValue == aSetID)

   427             {

   428             ret = idKeys[i] & KOnlyRowInfo; // remove column info and return

   429             break;

   430             }

   431         }

   432     

   433     CleanupStack::PopAndDestroy(); //idKeys

   434     OPENG_DP(D_OPENG_LIT( "     ret: %d"),ret);

   435     return ret;

   436     }

   437     

   438 // ---------------------------------------------------------

   439 // PresSettingsApi::CreateUniqueIdL

   440 // ---------------------------------------------------------

   441 //

   442 TInt PresSettingsApi::CreateUniqueIdL( CRepository* aRepository, 

   443                                                         TUint32 aRowInHex )

   444     {

   445     OPENG_DP(D_OPENG_LIT( " PresSettingsApi::CreateUniqueIdL aRowInHex:%d"),aRowInHex);

   446 

   447     TInt error(KErrNone);

   448     

   449     // At row = KLastRow(0x10000), column = KSimpleSetId, we store the Set Ids which have been allocated

   450     // each time we +1 to get a fresh Set Id

   451     TInt setId(0);

   452     error = aRepository->Get(KLastRow+KSimpleSetId, setId);

   453     if (error==KErrNotFound) // first time writing

   454         {

   455         error = aRepository->Create(KLastRow+KSimpleSetId, setId);

   456         }

   457     //if we cant create nor get then leave

   458     User::LeaveIfError(error);

   459     

   460     //increase the id to have the next one

   461     setId++;

   462     

   463     // set this id back to allocated ids storage

   464     error = aRepository->Set(KLastRow+KSimpleSetId, setId);

   465     User::LeaveIfError(error);

   466     

   467     //put id to the provided row

   468     error = aRepository->Create( aRowInHex+KSimpleSetId, setId );

   469     User::LeaveIfError(error);

   470     

   471     OPENG_DP(D_OPENG_LIT( "     setId: %d"),setId);

   472     return setId;

   473     }

   474 

   475 // ---------------------------------------------------------

   476 // PresSettingsApi::GetFreshRawInHex

   477 // ---------------------------------------------------------

   478 //

   479 TUint32 PresSettingsApi::GetFreshRawInHex( CRepository* aRepository )

   480     {

   481     OPENG_DP(D_OPENG_LIT( " PresSettingsApi::GetFreshRawInHex"));

   482     TInt error(KErrNone);

   483     TInt tempValue(NULL);

   484     TUint32 i(NULL);

   485     

   486     //search for ids on all rows

   487     for (i=KUnitRow+KSimpleSetId; i<KLastRow; i+=KUnitRow)

   488         {

   489         error = aRepository->Get(i, tempValue);

   490         

   491         // if this value is 0 or row doesnt exists

   492         if((tempValue==0)||(error==KErrNotFound))

   493             {

   494             OPENG_DP(D_OPENG_LIT( " found at, error:%d, i:%d"),error, i);

   495             error = KErrNone;

   496             break;

   497             }

   498         

   499         tempValue = NULL;    

   500         

   501         //break if there is any other error

   502         if(error<0)

   503             return error;

   504         }

   505     i = i & KOnlyRowInfo; // remove the column info from row

   506     OPENG_DP(D_OPENG_LIT( "     i: %d"),i);

   507     return i;

   508     }

   509     

   510 //end of file