1 /*

     2 * Copyright (c) 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:  IETF SIMPLE Protocol implementation for XIMP Framework

    15 *

    16 */

    17 

    18 

    19 #include <e32std.h>

    20 #include <e32base.h>

    21 #include <s32strm.h>

    22 #include <e32def.h>

    23 #include <e32svr.h>

    24 #include <e32math.h> 

    25 #include <utf.h>

    26 #include <ximpbase.h>

    27 #include <ximpobjectfactory.h>

    28 #include <ximpobjectcollection.h>

    29 #include <presenceobjectfactory.h>

    30 #include <presenceinfo.h>

    31 #include <personpresenceinfo.h>

    32 #include <presenceinfofieldcollection.h>

    33 #include <presenceinfofield.h>

    34 #include <presenceinfofieldvaluetext.h>

    35 #include <presenceinfofieldvalueenum.h>

    36 #include <ximpidentity.h>

    37 #include <msimpledocument.h>

    38 #include <msimpleelement.h>

    39 #include <msimplepresencelist.h>

    40 #include <msimplemeta.h>

    41 #include <simpleutils.h>

    42 #include <presencecachewriter2.h>

    43 #include <presencebuddyinfo.h>

    44 #include <spsettings.h>

    45 #include <spentry.h>

    46 #include <spproperty.h>

    47 #include <spdefinitions.h>

    48 #include <avabilitytext.h>

    49 #include <cvimpstsettingsstore.h>

    50 

    51 #include "presenceplugindata.h"

    52 #include "presenceplugincommon.h"

    53 #include "presencepluginvirtualgroup.h"

    54 

    55 // ---------------------------------------------------------------------------

    56 // CPresencePluginData::CPresencePluginData

    57 // ---------------------------------------------------------------------------

    58 //

    59 CPresencePluginData::CPresencePluginData( 

    60 	MPresencePluginConnectionObs& aObs,

    61 	TInt aServiceId ):

    62 	iConnObs( aObs ), 

    63 	iServiceId( aServiceId ),

    64 	iPresenceCacheWriter( NULL )

    65     {

    66     }

    67 

    68 // ---------------------------------------------------------------------------

    69 // CPresencePluginData::~CPresencePluginData

    70 // ---------------------------------------------------------------------------

    71 //

    72 CPresencePluginData::~CPresencePluginData()

    73     {

    74     DP_SDA("CPresencePluginData::~CPresencePluginData");

    75     delete iPresenceCacheWriter;

    76     }

    77 

    78 // ---------------------------------------------------------------------------

    79 // CPresencePluginData::NewL

    80 // ---------------------------------------------------------------------------

    81 //

    82 CPresencePluginData* CPresencePluginData::NewL( 

    83 	MPresencePluginConnectionObs& aObs, TInt aServiceId )

    84     {

    85     CPresencePluginData* self = CPresencePluginData::NewLC( 

    86 		aObs,

    87 		aServiceId );

    88     CleanupStack::Pop( self );

    89     return self;

    90     }

    91 

    92 

    93 // ---------------------------------------------------------------------------

    94 // CPresencePluginData::ConstructL

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

    96 //

    97 void CPresencePluginData::ConstructL()

    98     {

    99     DP_SDA("CPresencePluginData::ConstructL");

   100     iPresenceCacheWriter =  MPresenceCacheWriter2::CreateWriterL();

   101     }

   102 

   103 // ---------------------------------------------------------------------------

   104 // CPresencePluginData::NewLC

   105 // ---------------------------------------------------------------------------

   106 //

   107 CPresencePluginData* CPresencePluginData::NewLC(

   108     MPresencePluginConnectionObs& aObs, TInt aServiceId )

   109     {

   110     CPresencePluginData* self =

   111     	new( ELeave ) CPresencePluginData( aObs, aServiceId );

   112     CleanupStack::PushL( self );

   113     self->ConstructL();

   114     return self;

   115     }

   116 

   117 // ---------------------------------------------------------------------------

   118 // CPresencePluginData::NotifyToBlockedToXIMPL

   119 // ---------------------------------------------------------------------------

   120 //

   121 void CPresencePluginData::NotifyToBlockedToXIMPL(

   122     MPresenceObjectFactory& aPresenceFactory,

   123     MPresenceInfo& aPrInfo,

   124     const TDesC& aUnicodeNoteContent )

   125     {

   126     DP_SDA("CPresencePluginData::NotifyToBlockedToXIMPL");

   127     MPersonPresenceInfo* persInfo =

   128         aPresenceFactory.NewPersonPresenceInfoLC();

   129     MPresenceInfoFieldCollection& coll = persInfo->Fields();

   130     

   131     //Set pending

   132     using namespace NPresenceInfo::NFieldType;

   133     using namespace NPresencePlugin::NPresenceStates;

   134     

   135     MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

   136     field->SetFieldTypeL( KAvailabilityEnum );

   137         

   138     // use mapped enums to pass status    

   139     MPresenceInfoFieldValueEnum* enumField = 

   140         aPresenceFactory.NewEnumInfoFieldLC();

   141     

   142     // HOX: BLOCKED ENUM NEEDED TO XIMP

   143     enumField->SetValueL( NPresenceInfo::ENotAvailable ); 

   144     field->SetFieldValue( enumField );

   145         

   146     coll.AddOrReplaceFieldL( field );

   147     CleanupStack::Pop( 2 );            // >> field, enumField      

   148     

   149     // Add status msg field

   150     MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC();

   151     noteField->SetFieldTypeL( KStatusMessage );

   152         

   153     MPresenceInfoFieldValueText* textField = 

   154         aPresenceFactory.NewTextInfoFieldLC();

   155     textField->SetTextValueL( aUnicodeNoteContent );

   156     

   157     noteField->SetFieldValue( textField );

   158         

   159     coll.AddOrReplaceFieldL( noteField );

   160     CleanupStack::Pop( 2 );            // >> noteField, enumField      

   161     

   162     aPrInfo.SetPersonPresenceL( persInfo );

   163     CleanupStack::Pop();   // >> persInfo

   164     DP_SDA("CPresencePluginData::NotifyToBlockedToXIMPL end");

   165     }

   166 

   167 // ---------------------------------------------------------------------------

   168 // CPresencePluginData::NotifyToPendingToXIMPL

   169 // ---------------------------------------------------------------------------

   170 //

   171 void CPresencePluginData::NotifyToPendingToXIMPL(

   172     MPresenceObjectFactory& aPresenceFactory,

   173     MPresenceInfo& aPrInfo,

   174     const TDesC& aUnicodeNoteContent )

   175     {

   176     DP_SDA("CPresencePluginData::NotifyToPendingToXIMP");

   177     MPersonPresenceInfo* persInfo =

   178         aPresenceFactory.NewPersonPresenceInfoLC();

   179     MPresenceInfoFieldCollection& coll = persInfo->Fields();

   180     

   181     //Set pending

   182     using namespace NPresenceInfo::NFieldType;

   183     using namespace NPresencePlugin::NPresenceStates;

   184     

   185     MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

   186     field->SetFieldTypeL( KAvailabilityEnum );

   187         

   188     // use mapped enums to pass status    

   189     MPresenceInfoFieldValueEnum* enumField = 

   190         aPresenceFactory.NewEnumInfoFieldLC();

   191     enumField->SetValueL( NPresenceInfo::ERemotePending );

   192     field->SetFieldValue( enumField );

   193         

   194     coll.AddOrReplaceFieldL( field );

   195     CleanupStack::Pop( 2 );            // >> field, enumField      

   196     

   197     // Add status msg field

   198     MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC();

   199     noteField->SetFieldTypeL( KStatusMessage );

   200         

   201     MPresenceInfoFieldValueText* textField = 

   202         aPresenceFactory.NewTextInfoFieldLC();

   203     textField->SetTextValueL( aUnicodeNoteContent );

   204     

   205     noteField->SetFieldValue( textField );

   206         

   207     coll.AddOrReplaceFieldL( noteField );

   208     CleanupStack::Pop( 2 );            // >> noteField, enumField      

   209     

   210     aPrInfo.SetPersonPresenceL( persInfo );

   211     CleanupStack::Pop();   // >> persInfo

   212     DP_SDA("CPresencePluginData::NotifyToPendingToXIMP end");

   213     }

   214 

   215 // ---------------------------------------------------------------------------

   216 // CPresencePluginData::NotifyActiveToPrInfoL

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

   218 //

   219 void CPresencePluginData::NotifyToActiveToXIMPL(

   220     MPresenceObjectFactory& aPresenceFactory,

   221     MPresenceInfo& aPrInfo,

   222     const TDesC& aUnicodeNoteContent,

   223     NPresenceInfo::TAvailabilityValues aAvailability )

   224     {

   225     DP_SDA("CPresencePluginData::NotifyToActiveToXIMPL");

   226     MPersonPresenceInfo* persInfo =

   227         aPresenceFactory.NewPersonPresenceInfoLC();

   228     MPresenceInfoFieldCollection& coll = persInfo->Fields();

   229     

   230     //Set pending

   231     using namespace NPresenceInfo::NFieldType;

   232     using namespace NPresencePlugin::NPresenceStates;

   233     

   234     MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

   235     field->SetFieldTypeL( KAvailabilityEnum );

   236         

   237     // use mapped enums to pass status    

   238     MPresenceInfoFieldValueEnum* enumField = 

   239         aPresenceFactory.NewEnumInfoFieldLC();

   240     enumField->SetValueL( aAvailability );

   241     field->SetFieldValue( enumField );

   242         

   243     coll.AddOrReplaceFieldL( field );

   244     CleanupStack::Pop( 2 );            // >> field, enumField      

   245     

   246     // Add status msg field

   247     MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC();

   248     noteField->SetFieldTypeL( KStatusMessage );

   249         

   250     MPresenceInfoFieldValueText* textField = 

   251         aPresenceFactory.NewTextInfoFieldLC();

   252     textField->SetTextValueL( aUnicodeNoteContent );

   253     

   254     noteField->SetFieldValue( textField );

   255         

   256     coll.AddOrReplaceFieldL( noteField );

   257     CleanupStack::Pop( 2 );            // >> noteField, enumField      

   258     

   259     aPrInfo.SetPersonPresenceL( persInfo );

   260     CleanupStack::Pop();   // >> persInfo

   261     DP_SDA("CPresencePluginData::NotifyToActiveToXIMPL end");

   262     }

   263         

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

   265 // CPresencePluginData::NotifyTerminatedToPrInfoL

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

   267 //

   268 void CPresencePluginData::NotifyTerminatedToXIMPL(

   269     MPresenceObjectFactory& aPresenceFactory,

   270     MPresenceInfo& aPrInfo,

   271     const TDesC& aUnicodeNoteContent )

   272     {

   273     DP_SDA("CPresencePluginData::NotifyTerminatedToXIMPL");

   274     MPersonPresenceInfo* persInfo =

   275         aPresenceFactory.NewPersonPresenceInfoLC();

   276     MPresenceInfoFieldCollection& coll = persInfo->Fields();

   277     

   278     //Set pending

   279     using namespace NPresenceInfo::NFieldType;

   280     using namespace NPresencePlugin::NPresenceStates;

   281     

   282     MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

   283     field->SetFieldTypeL( KAvailabilityEnum );

   284         

   285     // use mapped enums to pass status    

   286     MPresenceInfoFieldValueEnum* enumField = 

   287         aPresenceFactory.NewEnumInfoFieldLC();

   288     enumField->SetValueL( NPresenceInfo::EOffline );

   289     field->SetFieldValue( enumField );

   290         

   291     coll.AddOrReplaceFieldL( field );

   292     CleanupStack::Pop( 2 );            // >> field, enumField      

   293     

   294     // Add status msg field

   295     MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC();

   296     noteField->SetFieldTypeL( KStatusMessage );

   297         

   298     MPresenceInfoFieldValueText* textField = 

   299         aPresenceFactory.NewTextInfoFieldLC();

   300     textField->SetTextValueL( aUnicodeNoteContent );

   301     

   302     noteField->SetFieldValue( textField );

   303         

   304     coll.AddOrReplaceFieldL( noteField );

   305     CleanupStack::Pop( 2 );            // >> noteField, enumField      

   306     

   307     aPrInfo.SetPersonPresenceL( persInfo );

   308     CleanupStack::Pop();   // >> persInfo

   309     DP_SDA("CPresencePluginData::NotifyTerminatedToXIMPL end");

   310     }

   311 

   312 // ---------------------------------------------------------------------------

   313 // CPresencePluginData::NotifyToPrInfoL

   314 // ---------------------------------------------------------------------------

   315 //

   316 void CPresencePluginData::NotifyToPrInfoL(

   317     MXIMPObjectFactory& /*aFactory*/,

   318     MPresenceObjectFactory& aPresenceFactory,

   319     MSimpleDocument& aDocument,

   320     MPresenceInfo& aPrInfo )

   321     {

   322     DP_SDA("CPresencePluginData::NotifyToPrInfoL");

   323     MPersonPresenceInfo* persInfo =

   324         aPresenceFactory.NewPersonPresenceInfoLC();

   325     DP_SDA("CPresencePluginData::NotifyToPrInfoL persInfo");

   326 

   327     if( !aDocument.EntityURI() )

   328     	{

   329     	DP_SDA("CPresencePluginData::NotifyToPrInfoL entity URL not valid");

   330     	User::Leave( KErrCancel );

   331     	}

   332  

   333     MPresenceInfoFieldCollection& coll = persInfo->Fields();

   334     

   335     DP_SDA("CPresencePluginData::NotifyToPrInfoL collection");

   336     // Search own person info. Notice: Extend supported attributes later

   337     TBool basicElementFound = EFalse;

   338     TBool activitiesElementFound = EFalse;

   339     TBool noteElemFound = EFalse;

   340         

   341     DP_SDA("CPresencePluginData::NotifyToPrInfoL RPointerArray");

   342     RPointerArray<MSimpleElement> elems;

   343     DP_SDA("CPresencePluginData::NotifyToPrInfoL Push elems");

   344     CleanupClosePushL( elems );

   345     DP_SDA("CPresencePluginData::NotifyToPrInfoL aDocument");

   346     TInt err = aDocument.SimpleElementsL( elems );

   347     

   348     DP_SDA2("CPresencePluginData::NotifyToPrInfoL err %d", err);

   349     

   350     RPointerArray<MSimpleElement> basicElems;

   351 	CleanupClosePushL( basicElems );

   352 	MSimpleElement* basicSimpleElem(NULL);

   353 	

   354 	RPointerArray<MSimpleElement> activitiesElems;

   355 	CleanupClosePushL( activitiesElems );

   356 	MSimpleElement* activitiesSimpleElem(NULL);

   357 	MSimpleElement* noteSimpleElem(NULL);

   358 		

   359     if ( !err )

   360         {

   361         DP_SDA("CPresencePluginData::NotifyToPrInfoL, elements ok");       

   362         TInt count = elems.Count();

   363         DP_SDA2("CPresencePluginData::NotifyToPrInfoL, element count: %d", count );       

   364         

   365         using namespace NPresencePlugin::NPresence;

   366 

   367         MSimpleElement* elem = NULL;

   368         TPtrC8 p8;

   369 

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

   371             {

   372             DP_SDA2("CPresencePluginData::NotifyToPrInfoL, handling elem[%d]", i );

   373             

   374             elem = elems[i];

   375             p8.Set( elem->LocalName());

   376             if (!( p8.CompareF( KPresencePerson8 )) ||

   377                 !( p8.CompareF( KPresenceTuple8 )) )

   378                 {

   379                 // person element found

   380                 RPointerArray<MSimpleElement> elems2;

   381                 CleanupClosePushL( elems2 );

   382                 elem->SimpleElementsL( elems2 );

   383                 TInt count2 = elems2.Count();

   384                 DP_SDA2("CPresencePluginData::NotifyToPrInfoL count2 %d", count2);

   385                 for ( TInt j = 0; j < count2; j++ )

   386                     {

   387                     DP_SDA("CPresencePluginData::NotifyToPrInfoL 4");

   388                     //

   389                     MSimpleElement* elem2 = elems2[j];

   390                     

   391                     //FIND BASIC/ACTIVITIES ELEMENT

   392                     if ( !elem2->LocalName().CompareF( KPresenceStatus8 ) &&

   393                         !basicElementFound )

   394              	        {

   395              	        DP_SDA("NotifyToPrInfoL PresenceStatus");

   396              	        //Get elem2 childs

   397 			            elem2->SimpleElementsL( basicElems );

   398 			            TInt count3 = basicElems.Count();  //Child count

   399 			            for ( TInt k = 0; k < count3; k++ )

   400 			                {

   401 			                MSimpleElement* tempElem = basicElems[k];

   402 			                if ( !tempElem->LocalName().CompareF( 

   403 			                		KPresenceBasic8 ))

   404 			                    {

   405 			                    DP_SDA("NotifyToPrInfoL basic elem true");

   406 			                    basicSimpleElem = basicElems[k];

   407 			                    basicElementFound = ETrue;

   408 			                    }

   409 			                else if( !tempElem->LocalName().CompareF( 

   410 			                		KPresenceActivities8 ))

   411 			                    {

   412 			                    DP_SDA("NotifyToPrInfoL activities under basic");

   413 			                    activitiesSimpleElem = basicElems[k];

   414 			                    activitiesElementFound = ETrue;

   415 			                    }

   416 			                } 

   417              	        }

   418              	    

   419                     //FIND ACTIVITIES ELEMENT

   420              	    if ( basicElementFound  && 

   421              	        !elem2->LocalName().CompareF( KPresenceActivities8 ) )

   422              	        {

   423              	        DP_SDA("NotifyToPrInfoL activities found outside basic");

   424 			            elem2->SimpleElementsL( activitiesElems );

   425 			            TInt count4 = activitiesElems.Count();

   426 			            for ( TInt l = 0; l < count4; l++ )

   427 			                {

   428 			                activitiesSimpleElem = activitiesElems[l];

   429 			                activitiesElementFound = ETrue;

   430 			                DP_SDA("CPresencePluginData::NotifyToPrInfoL 6");

   431 			                }

   432              	        }

   433              	    // Check note field    

   434              	    if ( basicElementFound  && 

   435              	        !elem2->LocalName().CompareF( KPresenceNote8 ) )

   436              	        {

   437              	        DP_SDA("NotifyToPrInfoL note field found inside tuple");

   438 			            noteSimpleElem = elem2;

   439              	        }             	    

   440                     }   

   441                 DP_SDA("NotifyToPrInfoL ALL DONE"); 

   442                 CleanupStack::PopAndDestroy( &elems2 );

   443                 

   444                 if( basicElementFound && activitiesElementFound && noteElemFound )

   445                     {

   446                     DP_SDA("NotifyToPrInfoL ALL DONE break out"); 

   447                     //Just handle first status information from document

   448                     // In future server should support <timestamp>

   449                     //Also client should be can handle timestaps if there are present

   450                     break;

   451                     }

   452                 }

   453      	    // Check note field    

   454      	    else if ( basicElementFound && !( p8.CompareF( KPresenceNote8 )) &&

   455      	         !noteSimpleElem )

   456      	        {

   457      	        DP_SDA("NotifyToPrInfoL note field found outside tuple");

   458 	            noteSimpleElem = elem;

   459      	        }             	    

   460             }                

   461         }

   462     

   463     if ( basicElementFound )

   464     	{

   465     	DP_SDA("NotifyToPrInfoL basic proceed to handling");

   466     	SingleUserStatusToXIMPL( 

   467             aPresenceFactory, basicSimpleElem, 

   468     		activitiesSimpleElem, noteSimpleElem, coll );  

   469     	}

   470     CleanupStack::PopAndDestroy( &activitiesElems );

   471     CleanupStack::PopAndDestroy( &basicElems );

   472     CleanupStack::PopAndDestroy( &elems );

   473 

   474     aPrInfo.SetPersonPresenceL( persInfo );

   475     CleanupStack::Pop();   // >> persInfo

   476     

   477     // TODO2: Notice: the following crashes in old PrFW version

   478     /*

   479     aPrInfo.AddDevicePresenceL ( NULL );

   480     aPrInfo.AddServicePresenceL( NULL );

   481     */

   482     DP_SDA("CPresencePluginData::NotifyToPrInfoL end");        

   483     }

   484 

   485 // ---------------------------------------------------------------------------

   486 // CPresencePluginData::CacheEntriesFromPrInfo

   487 // ---------------------------------------------------------------------------

   488 //

   489 void CPresencePluginData::CacheEntriesFromPrInfo(

   490     MPresenceInfo& aPrInfo,

   491     MPresenceBuddyInfo2::TAvailabilityValues& aAvailability,

   492     TPtr& aExtendedAvailability,

   493     TPtr& aStatusMessage )

   494     {

   495     DP_SDA("CPresencePluginData::CacheEntriesFromPrInfoL");

   496     

   497     DP_SDA(" -> CacheEntriesFromPrInfoL, fetch status enum field");

   498     MPresenceInfoField* statusEnumInfoField = NULL;

   499     MPersonPresenceInfo* presInfo = aPrInfo.PersonPresence();

   500     if ( presInfo )

   501         {

   502         DP_SDA(" -> CacheEntriesFromPrInfoL, has person presence, get field");

   503         presInfo->Fields().LookupFieldByFieldType( 

   504             statusEnumInfoField, 

   505             NPresenceInfo::NFieldType::KAvailabilityEnum );

   506         DP_SDA(" -> CacheEntriesFromPrInfoL, fetch status enum field done, check item");

   507         if ( statusEnumInfoField )

   508             {

   509             DP_SDA(" -> status enum field found");

   510             const MPresenceInfoFieldValueEnum* availability = 

   511             TXIMPGetInterface< const MPresenceInfoFieldValueEnum >::From( 

   512                 statusEnumInfoField->FieldValue(), MXIMPBase::EPanicIfUnknown );

   513              switch( availability->Value() )

   514                 {

   515                 case NPresenceInfo::EAvailable:

   516                     {

   517                     DP_SDA(" -> status enum field => available");

   518                     aAvailability = MPresenceBuddyInfo2::EAvailable;

   519                     aExtendedAvailability.Copy( KDefaultAvailableStatus() );

   520                     }

   521                     break;

   522                     

   523                 case NPresenceInfo::EBusy:

   524                     {

   525                     DP_SDA(" -> status enum field => busy");

   526                     aAvailability = MPresenceBuddyInfo2::EBusy;

   527                     aExtendedAvailability.Copy( KDndState() );

   528                     }

   529                     break;

   530                     

   531                 case NPresenceInfo::EOnPhone:

   532                     {

   533                     DP_SDA(" -> status enum field => on phone");

   534                     aAvailability = MPresenceBuddyInfo2::EBusy;

   535                     aExtendedAvailability.Copy( KOnPhoneState() );

   536                     }

   537                     break;

   538                     

   539                 case NPresenceInfo::EAway:

   540                     {

   541                     DP_SDA(" -> status enum field => away");

   542                     aAvailability = MPresenceBuddyInfo2::EBusy;

   543                     aExtendedAvailability.Copy( KAwayState() );

   544                     }

   545                     break;

   546                 

   547                 case NPresenceInfo::EDoNotDisturb:

   548                     {

   549                     DP_SDA(" -> status enum field => dnd");

   550                     aAvailability = MPresenceBuddyInfo2::EBusy;

   551                     aExtendedAvailability.Copy( KDndState() );

   552                     }

   553                     break;

   554                 

   555                 case NPresenceInfo::EOffline:

   556                 case NPresenceInfo::ENotAvailable:

   557                 default:

   558                     {

   559                     DP_SDA(" -> status enum field => offline/not available/default");

   560                     aAvailability = MPresenceBuddyInfo2::ENotAvailable;

   561                     aExtendedAvailability.Copy( KInvisibleState() );

   562                     }

   563                     break;

   564                 }        

   565             }

   566         else

   567             {

   568             DP_SDA(" -> status enum not found => set unknown");

   569             aAvailability = MPresenceBuddyInfo2::EUnknownAvailability;

   570             aExtendedAvailability.Copy( KNullDesC() );

   571             }

   572         DP_SDA(" -> fetch status message field");    

   573         MPresenceInfoField* statusMsgInfoField = NULL;

   574         presInfo->Fields().LookupFieldByFieldType( 

   575             statusMsgInfoField, 

   576             NPresenceInfo::NFieldType::KStatusMessage );

   577         DP_SDA(" -> CacheEntriesFromPrInfoL, fetch status message field done, check item");    

   578         if ( statusMsgInfoField )

   579             {

   580             DP_SDA(" -> status msg field found");

   581             const MPresenceInfoFieldValueText* statusMsg = 

   582             TXIMPGetInterface< const MPresenceInfoFieldValueText >::From( 

   583                 statusMsgInfoField->FieldValue(), MXIMPBase::EPanicIfUnknown );

   584             if ( statusMsg && statusMsg->TextValue().Length() )

   585                 {

   586                 DP_SDA(" -> status msg field found, copy content");

   587                 aStatusMessage.Copy( statusMsg->TextValue() );

   588                 }

   589             }

   590         else

   591             {

   592             DP_SDA(" -> status msg field not found, set empty");

   593             aStatusMessage.Copy( KNullDesC() );

   594             }

   595         }

   596         

   597     DP_SDA("CPresencePluginData::CacheEntriesFromPrInfoL out");    

   598     }

   599 

   600 // ---------------------------------------------------------------------------

   601 // CPresencePluginData::SingleUserStatusToXIMPL

   602 // ---------------------------------------------------------------------------

   603 //

   604 void CPresencePluginData::SingleUserStatusToXIMPL(

   605     MPresenceObjectFactory& aPresenceFactory,

   606     MSimpleElement* aBasicElement,

   607     MSimpleElement* aActivitiesElement,

   608     MSimpleElement* aNoteElement,

   609     MPresenceInfoFieldCollection& aCollection )

   610     {

   611     DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL");

   612 

   613     using namespace NPresenceInfo::NFieldType;

   614     using namespace NPresencePlugin::NPresenceStates;

   615     

   616     //Get aBasicElem content 

   617     HBufC* nodeContent = aBasicElement->ContentUnicodeL();

   618     CleanupStack::PushL( nodeContent );

   619     

   620     TBuf<KBufSize100> basicContentBuf; 

   621     basicContentBuf.Copy( *nodeContent );

   622     DP_SDA2("SingleUserStatusToXIMPL basicContent %S", &basicContentBuf);

   623     

   624     TBuf<KBufSize100> activitiesContentBuf;

   625     

   626     if ( !aActivitiesElement )

   627         {

   628         activitiesContentBuf.Copy( KPresenceUnknow );

   629         DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL activities NULL");

   630         }

   631     else

   632         {

   633         activitiesContentBuf.Copy( aActivitiesElement->LocalName() );

   634         DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL else");

   635         }

   636         

   637     if ( nodeContent )

   638         {

   639         using namespace NPresenceInfo::NFieldType;

   640         MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

   641         field->SetFieldTypeL( KAvailabilityEnum );

   642         

   643         // use mapped enums to pass status    

   644         MPresenceInfoFieldValueEnum* enumField = 

   645             aPresenceFactory.NewEnumInfoFieldLC();

   646 

   647         // Busy case

   648         if ( !nodeContent->Des().CompareF( KPresenceOpen ) &&

   649             !activitiesContentBuf.CompareF ( KPresenceBusy ) )

   650             {

   651             DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL open/busy");

   652             enumField->SetValueL( NPresenceInfo::EBusy );

   653             }

   654         // On-The-Phone case

   655         else if ( !nodeContent->Des().CompareF( KPresenceOpen ) &&

   656             !activitiesContentBuf.CompareF ( KPresenceOnThePhone ) )

   657             {

   658             DP_SDA("CPresencePluginData::SingleUserStatusToXIMPL open/on-the-phone");

   659             enumField->SetValueL( NPresenceInfo::EOnPhone );

   660             }

   661         //Away case  

   662         else if ( !nodeContent->Des().CompareF( KPresenceOpen ) &&

   663             !activitiesContentBuf.CompareF ( KPresenceAway ) )

   664             {

   665             DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL open/away");

   666             enumField->SetValueL( NPresenceInfo::EAway );

   667             }

   668         //Dnd case  

   669         else if ( !nodeContent->Des().CompareF( KPresenceOpen ) &&

   670             !activitiesContentBuf.CompareF ( KPresenceDoNotDisturb ) )

   671             {

   672             DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL open/dnd");

   673             enumField->SetValueL( NPresenceInfo::EDoNotDisturb );

   674             }            

   675         // Unknown open

   676         else if ( !nodeContent->Des().CompareF( KPresenceOpen ) &&

   677             !activitiesContentBuf.CompareF ( KPresenceUnknow ) )

   678             {

   679             DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL open/unknown");

   680             enumField->SetValueL( NPresenceInfo::EAvailable );

   681             }

   682         // availale open

   683         else if ( !nodeContent->Des().CompareF( KPresenceOpen ) &&

   684             !activitiesContentBuf.CompareF ( KPresenceAvailable ) )

   685             {

   686             DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL open/available");

   687             enumField->SetValueL( NPresenceInfo::EAvailable );

   688             }            

   689         //Unknown closed

   690         else if ( !nodeContent->Des().CompareF( KPresenceClosed ) &&

   691             !activitiesContentBuf.CompareF ( KPresenceUnknow ) )

   692             {

   693             DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL closed/unknown");

   694             enumField->SetValueL( NPresenceInfo::EOffline );

   695             }

   696         //Else set status according to basic status

   697         else

   698             {

   699             if ( !nodeContent->Des().CompareF( KPresenceOpen ) )

   700                 {

   701                 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL else open");

   702                 enumField->SetValueL( NPresenceInfo::EAvailable );

   703                 }

   704             else

   705                 {

   706                 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL else closed");

   707                 enumField->SetValueL( NPresenceInfo::ENotAvailable );

   708                 }

   709             }

   710         

   711         field->SetFieldValue( enumField );        

   712         aCollection.AddOrReplaceFieldL( field );

   713         

   714         CleanupStack::Pop( 2 );            // >> field, enumField      

   715         

   716         DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL check for note");

   717         // Handle notes field if found

   718         if ( aNoteElement )

   719             {

   720             DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL note elems found");

   721             // consider mapping note text to enum value if value not mapped

   722             UserNoteToXIMPL( aPresenceFactory, aNoteElement, 

   723                 aCollection );

   724             }

   725         }

   726     CleanupStack::PopAndDestroy( nodeContent );

   727     DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL end");

   728     }

   729 

   730 // ---------------------------------------------------------------------------

   731 // CPresencePluginData::UserNoteToXIMPL

   732 // ---------------------------------------------------------------------------

   733 //

   734 void CPresencePluginData::UserNoteToXIMPL(

   735     MPresenceObjectFactory& aPresenceFactory,

   736     MSimpleElement* aElement,

   737     MPresenceInfoFieldCollection& aCollection )

   738     {

   739     DP_SDA(" CPresencePluginData::UserNoteToXIMPL IN");

   740     HBufC* nodeContent = aElement->ContentUnicodeL();

   741     CleanupStack::PushL( nodeContent );

   742     if ( nodeContent )

   743         {

   744         DP_SDA(" CPresencePluginData::UserNoteToXIMPL - content found");

   745         // Save note, convert from unicode

   746         // notice: consider xml::lang-attribute

   747         // note <-> KStatusMessage

   748         // notice: no need to consider namespaces in XML?

   749         using namespace NPresenceInfo::NFieldType;

   750         

   751         DP_SDA(" CPresencePluginData::UserNoteToXIMPL - create fields");

   752         MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

   753         field->SetFieldTypeL( KStatusMessage );

   754         MPresenceInfoFieldValueText* text =

   755         	aPresenceFactory.NewTextInfoFieldLC();

   756         text->SetTextValueL( nodeContent->Des() );

   757         field->SetFieldValue( text );

   758         CleanupStack::Pop();            // >> text

   759         aCollection.AddOrReplaceFieldL( field );

   760         CleanupStack::Pop();            // >> field     

   761         DP_SDA("  -> fields added to collection");

   762         }

   763     CleanupStack::PopAndDestroy( nodeContent );

   764     DP_SDA(" CPresencePluginData::UserNoteToXIMPL OUT");

   765     }

   766 

   767 // ---------------------------------------------------------------------------

   768 // CPresencePluginData::NotifyListToPrInfoL

   769 // ---------------------------------------------------------------------------

   770 //

   771 void CPresencePluginData::NotifyListToPrInfoL(

   772     MXIMPObjectFactory& aFactory,

   773     MPresenceObjectFactory& aPresenceFactory,

   774     MSimplePresenceList& aList,

   775     RPointerArray<MPresenceInfo>& aEntities,

   776     RPointerArray<MXIMPIdentity>& aActives,

   777     RPointerArray<MXIMPIdentity>& aTerminated )

   778     {

   779     DP_SDA(" CPresencePluginData::NotifyListToPrInfoL");

   780     // Split array into individual prInfos

   781 

   782     aEntities.Reset();

   783     RPointerArray<MSimpleDocument> docs;

   784     CleanupClosePushL( docs );

   785     // get documents, ownership is not transferred.

   786     aList.GetDocuments( docs );

   787 

   788     TInt count = docs.Count();

   789 

   790     // active presentities

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

   792         {

   793         MPresenceInfo* info =

   794             aPresenceFactory.NewPresenceInfoLC();//<< info

   795         aEntities.Append( info );

   796         // aEntities may contain entries even this method leaves

   797         CleanupStack::Pop();// >> info

   798 

   799         NotifyToPrInfoL( aFactory, aPresenceFactory, *docs[i], *info );

   800         // Add SIp identity to active users list

   801         MXIMPIdentity* active = aFactory.NewIdentityLC();// << active

   802         aActives.Append( active );

   803         CleanupStack::Pop();// >> active

   804 

   805         // Convert SIP entity URI from UTF to Unicode.

   806         const TDesC8* pUri8 = (docs[i])->EntityURI();

   807         HBufC16* uri16 = NULL;

   808         uri16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L( *pUri8 );

   809         CleanupStack::PushL( uri16 );  // << uri16

   810         active->SetIdentityL( uri16->Des() );

   811         CleanupStack::PopAndDestroy( uri16 );// >> uri16

   812         }

   813 

   814     using namespace NPresencePlugin::NPresence;

   815 

   816     // Search "terminated" presentities

   817     MSimpleMeta* meta = aList.MetaData();

   818     // ownership in not transferred

   819     if ( meta && !meta->LocalName().CompareF( KPresenceList8 ))

   820         {

   821         // list element found

   822         RPointerArray<MSimpleElement> elems2;

   823         CleanupClosePushL( elems2 );

   824         meta->SimpleElementsL( elems2);

   825         TInt count2 = elems2.Count();

   826 

   827         for ( TInt i = 0; i < count2; i++ )

   828             {

   829             MSimpleElement* elem2 = elems2[i];

   830             if ( !elem2->LocalName().CompareF( KPresenceResource8 ))

   831                 {

   832                 // resource element

   833                 RPointerArray<MSimpleElement> elems3;

   834                 CleanupClosePushL( elems3 );

   835                 meta->SimpleElementsL( elems3 );

   836                 TInt count3 = elems3.Count();

   837 

   838                 for ( TInt j=0; j < count3; j++ )

   839                     {

   840                     MSimpleElement* elem3 = elems3[i];

   841 

   842                     if ( !elem3->LocalName().CompareF( KPresenceInstance8 ))

   843                         {

   844                         // instance element

   845                         const TDesC8* stateVal =

   846                             elem3->AttrValue( KPresenceState8 );

   847                         if ( stateVal && stateVal->

   848                             CompareF( KPresenceTerminated8 ))

   849                             {

   850                             // get next entity if this is not state="terminated"

   851                             break;

   852                             }

   853                         // Save resource element URI into list of

   854                         // "terminated" users.

   855                         const TDesC8* uri8 = elem2->AttrValue( KPresenceUri8 );

   856                         MXIMPIdentity* terminated =

   857                             aFactory.NewIdentityLC();// << terminated

   858                         aTerminated.Append( terminated );

   859                         CleanupStack::Pop();                   // >> terminated

   860 

   861                         // Convert SIP entity URI from UTF to Unicode.

   862                         HBufC16* uri16 = NULL;

   863                         uri16 =

   864                             CnvUtfConverter::ConvertToUnicodeFromUtf8L( *uri8 );

   865                         CleanupStack::PushL( uri16 );  // << uri16

   866                         terminated->SetIdentityL( uri16->Des() );

   867                         CleanupStack::PopAndDestroy( uri16 );  // >> uri16

   868                         }

   869                     }

   870                 CleanupStack::PopAndDestroy( &elems3 );

   871                 } // resource element

   872             }// for (i); list element subelement

   873         CleanupStack::PopAndDestroy( &elems2 );

   874         }

   875 

   876     CleanupStack::PopAndDestroy( &docs );

   877     DP_SDA(" CPresencePluginData::NotifyListToPrInfoL end");

   878     }

   879 

   880 // ---------------------------------------------------------------------------

   881 // CPresencePluginData::AddPrPersToSimpleDocumentL

   882 // ---------------------------------------------------------------------------

   883 //

   884 void CPresencePluginData::AddPrPersToSimpleDocumentL(

   885     const MPersonPresenceInfo* aInfo,

   886     MSimpleDocument& aDocument,

   887     const TDesC8& aSipId, TInt aTupleId )

   888     {

   889     DP_SDA("CPresencePluginData::AddPrPersToSimpleDocumentL start");

   890     iNumBuf = aTupleId;

   891     // notice: later: generate random id.

   892 

   893     using namespace NPresencePlugin::NPresence;

   894     using namespace NPresenceInfo::NFieldType;

   895 

   896     const MPresenceInfoFieldCollection& coll = aInfo->Fields();

   897 

   898     const MPresenceInfoField* statusEmumField = NULL;

   899     const MPresenceInfoField* messageField = NULL;

   900 

   901     TInt myCount = coll.FieldCount();

   902     for ( TInt i = 0; i < myCount; i++ )

   903         {

   904         DP_SDA("CPresencePluginData::AddPrPersToSimpleDocumentL 1");

   905         

   906         const MPresenceInfoField& field =  coll.FieldAt( i );

   907         const TDesC8& fieldType = field.FieldType();

   908         TBuf<KBufSize100> printBuf;

   909         printBuf.Copy( fieldType );

   910    

   911         if ( !fieldType.Compare( KAvatar ) )

   912            {

   913            // Do nothing in sawfis, maybe later?

   914            }

   915         else if ( !fieldType.Compare( KAvailabilityEnum ) )

   916             {

   917             DP_SDA("AddPrPersToSimpleDocumentL Avaibility");

   918             statusEmumField = &field;

   919             DP_SDA("AddPrPersToSimpleDocumentL Avaibility done");

   920             }          

   921         else if ( !fieldType.Compare( KStatusMessage ) )

   922             {

   923             DP_SDA("AddPrPersToSimpleDocumentL statusmessage");

   924             messageField = &field;

   925             }

   926         }

   927     if ( statusEmumField )

   928         {

   929         DoCreateDocumentL( aDocument, aSipId, 

   930             statusEmumField, messageField );            

   931         }

   932     

   933         

   934     DP_SDA("CPresencePluginData::AddPrPersToSimpleDocumentL end");

   935     }

   936     

   937     

   938 // ---------------------------------------------------------------------------

   939 // CPresencePluginData::CreatePresenceUri8LC

   940 // ---------------------------------------------------------------------------

   941 //

   942 HBufC8* CPresencePluginData::CreatePresenceUri8LC( 

   943     const TDesC8& aPresentityUri )

   944     {

   945     DP_SDA("CPresencePluginData::CreatePresenceUri8LC ");

   946     const TInt KMyLenSipPrefix = 4;

   947     const TInt KMyLenSipsPrefix = 5;

   948     _LIT8( KMySip8, "sip:" );

   949     _LIT8( KMySips8, "sips:" ); 

   950     TInt uriLen = aPresentityUri.Length();

   951     DP_SDA2( "CPresencePluginData::CreatePresenceUri8LC - param length: %d ", uriLen );

   952     

   953     //For debugging purposes

   954     //TBuf<256> tmpPresentityUri; 

   955     //tmpPresentityUri.Copy( aPresentityUri );

   956     //DP_SDA2( "CPresencePluginData::CreatePresenceUri8LC - URI: %S ", &tmpPresentityUri );

   957     

   958     HBufC8* buf = HBufC8::NewLC( uriLen );

   959     TPtr8 pBuf( buf->Des() );

   960     

   961     //SIP uri check

   962     if ( !aPresentityUri.Left( KMyLenSipPrefix ).CompareF( KMySip8 ) )

   963         {

   964         DP_SDA("CPresencePluginData::CreatePresenceUri8LC (sip:) prefix in SIP URI ");

   965         pBuf.Append( aPresentityUri );

   966         }

   967     else if ( !aPresentityUri.Left( KMyLenSipsPrefix ).CompareF( KMySips8 ) )

   968         {

   969         DP_SDA( "CPresencePluginData::CreatePresenceUri8LC (sips:) prefix in SIP URI " );

   970         pBuf.Append( aPresentityUri );

   971         }

   972     else // No prefix, strange ...

   973         {

   974         DP_SDA( "CPresencePluginData::CreatePresenceUri8LC NO prefix in SIP URI, adding... " );

   975         // Maybe should check which prefix to use,

   976         // but assume that no secure is used if prefix missing

   977         TInt len = aPresentityUri.Length() + KMyLenSipPrefix;

   978         buf = buf->ReAllocL( len );

   979         //update pointer after realloc

   980         CleanupStack::Pop( buf );

   981         CleanupStack::PushL( buf );

   982         // Since realloc may have changed the location in memory

   983         // we must also reset ptr

   984         pBuf.Set( buf->Des() );

   985         pBuf.Append( KMySip8 );

   986         pBuf.Append( aPresentityUri );

   987         }   

   988     return buf; 

   989     } 

   990     

   991 // ---------------------------------------------------------------------------

   992 // CPresencePluginData::RemovePrefixLC

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

   994 //

   995 HBufC16* CPresencePluginData::RemovePrefixLC( 

   996     const TDesC& aPresentityUri )

   997     {

   998     DP_SDA2("CPresencePluginData::RemovePrefixLC, uri: %S", &aPresentityUri );

   999 

  1000     HBufC* withouPrefix = HBufC::NewLC( KBufSize255 );

  1001     TPtr withouPrefixPtr( withouPrefix->Des() );

  1002     

  1003     TInt prefixLocation = aPresentityUri.Locate( ':' );

  1004     DP_SDA2("CPresencePluginData::RemovePrefixLC, prefix pos: %d", prefixLocation );

  1005     if ( KErrNotFound != prefixLocation )

  1006         {

  1007         DP_SDA("CPresencePluginData::RemovePrefixLC - has prefix");        

  1008         withouPrefixPtr.Copy( aPresentityUri.Mid( prefixLocation+1 ) );

  1009         DP_SDA("CPresencePluginData::RemovePrefixLC - copy ok");        

  1010         }

  1011     else

  1012         {

  1013         DP_SDA("CPresencePluginData::RemovePrefixLC - has no prefix");        

  1014         withouPrefixPtr.Copy( aPresentityUri );

  1015         }    

  1016         

  1017     //DP_SDA2("CPresencePluginData::RemovePrefixLC - returns %S", *withouPrefix );            

  1018     return withouPrefix;

  1019     }     

  1020        

  1021 // ---------------------------------------------------------------------------

  1022 // CPresencePluginData::DoCreateDocumentL()

  1023 // ---------------------------------------------------------------------------

  1024 //    

  1025 void CPresencePluginData::DoCreateDocumentL( 

  1026     MSimpleDocument& aDocument,

  1027     const TDesC8& aSipId,

  1028     const MPresenceInfoField* aStatusField,

  1029     const MPresenceInfoField* aMessageField )

  1030     {    

  1031     DP_SDA("CPresencePluginData::DoCreateDocumentL ");

  1032     const TInt KNumBuf = 20;

  1033     const TInt KTupleBuf = 10;

  1034     

  1035     using namespace NPresencePlugin::NPresence;

  1036     using namespace NPresencePlugin::NPresenceStates;

  1037     using namespace NPresenceInfo::NFieldType;

  1038 

  1039     TBuf<KNumBuf> numBuf;

  1040     TBuf<KTupleBuf> tupleBuf;

  1041 

  1042     tupleBuf.Copy( KIndent );

  1043     numBuf.Num( iNumBuf );

  1044     tupleBuf.Append( numBuf );

  1045     DP_SDA2("CPresencePluginData::DoCreateDocumentL id %d", iNumBuf);

  1046 	DP_SDA("CPresencePluginData::DoCreateDocumentL 2");

  1047     

  1048 	//Add tuple id to document

  1049     MSimpleElement* tuple = aDocument.AddSimpleElementL( KPresenceTuple8 );

  1050     CleanupClosePushL( *tuple );

  1051     tuple->AddAttrL( KPresenceId8, tupleBuf);

  1052     

  1053     //Presence status field

  1054     MSimpleElement* status = tuple->AddSimpleElementL( KPresenceStatus8 );

  1055     CleanupClosePushL( *status );

  1056     

  1057     //basic field

  1058     MSimpleElement* basic = status->AddSimpleElementL( KPresenceBasic8 );

  1059     CleanupClosePushL( *basic );

  1060     

  1061     basic->SetContentUnicodeL( DoCheckBasicStatusValueL( *aStatusField ) );

  1062     

  1063     DP_SDA("CPresencePluginData::DoCreateDocumentL Basic ok, check msg"); 

  1064     

  1065     if ( aMessageField )

  1066         {

  1067         DP_SDA("CPresencePluginData::DoCreateDocumentL message field"); 

  1068         //Creating note 

  1069         MSimpleElement* note =

  1070             aDocument.AddSimpleElementL( KPresenceNote8 );

  1071         CleanupClosePushL( *note );        

  1072         

  1073         // Get status msg field from info field

  1074         const MPresenceInfoFieldValueText* textField = 

  1075             TXIMPGetInterface< 

  1076                 const MPresenceInfoFieldValueText >::From(

  1077                 aMessageField->FieldValue(), 

  1078                     MXIMPBase::EPanicIfUnknown );

  1079         note->SetContentUnicodeL( textField->TextValue() );

  1080         CleanupStack::PopAndDestroy( note );

  1081         }

  1082 

  1083     /* Basic model example

  1084     <tuple id="c8dqui">

  1085           <status>

  1086             <basic>open</basic>

  1087           </status>

  1088              <ts:basic>closed</ts:basic>

  1089           </ts:timed-status>

  1090           <contact>sip:someone@example.com</contact>

  1091         </tuple>

  1092     <note>sleeping</note>    

  1093     </presence>

  1094     */

  1095     

  1096     DP_SDA("CPresencePluginData::DoCreateDocumentL Rich presence person");

  1097     //Creatin person presence field

  1098     MSimpleElement* pers =

  1099     	aDocument.AddSimpleElementL( KSimpleNsPDM, KPresencePerson8 );

  1100     CleanupClosePushL( *pers );

  1101     TBuf<KBufSize10> buf;

  1102     TBuf<KBufSize20> personId;

  1103     personId.Copy( KPersonId );

  1104     buf.Num( iNumBuf );

  1105     personId.Append( buf );

  1106     pers->AddAttrL( KPresenceId8, personId );

  1107     DP_SDA("CPresencePluginData::DoCreateDocumentL Rich presence person ok");

  1108     

  1109     HBufC8* urlBuf = CreatePresenceUri8LC( aSipId );

  1110     DP_SDA("CPresencePluginData::DoCreateDocumentL Push urlBuf"); 

  1111       

  1112     aDocument.SetEntityURIL( urlBuf->Des() );

  1113     DP_SDA("CPresencePluginData::DoCreateDocumentL 2");

  1114 

  1115     DP_SDA("CPresencePluginData::DoCreateDocumentLC Rich presence activities");

  1116     MSimpleElement* activ = pers->AddSimpleElementL( 

  1117         KSimpleNsRPID, KPresenceActivities8 );

  1118     CleanupClosePushL( *activ );

  1119     

  1120     //unknown used if person presence is just open or closed

  1121     MSimpleElement* unknown = activ->AddSimpleElementL( 

  1122         KSimpleNsRPID, DoCheckActivitiesValueL( *aStatusField ) );

  1123     DP_SDA("CPresencePluginData::DoCreateDocumentL, unknown/status element created");  

  1124     CleanupClosePushL( *unknown );

  1125    

  1126     DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy unknown");  

  1127     CleanupStack::PopAndDestroy( unknown );

  1128     DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy activ");  

  1129     CleanupStack::PopAndDestroy( activ ); 

  1130     

  1131     DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy urlBuf");

  1132     CleanupStack::PopAndDestroy( urlBuf );

  1133 

  1134     DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy pers");