diff -r 000000000000 -r 62f9d29f7211 webservices/wsidentitymanager/src/senmultiuseridentitymanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsidentitymanager/src/senmultiuseridentitymanager.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,303 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:        
+*
+*/
+
+
+
+
+
+
+
+#include <s32mem.h>
+#include <s32file.h>
+#include <sysutil.h>
+
+#include "senmultiuseridentitymanager.h"
+
+#include "senlogger.h"
+#include "SenXmlUtils.h"
+
+namespace
+    {
+    _LIT8(KUser, "User");
+    _LIT8(KUsers, "Users");
+    _LIT8(KUserName, "username");
+    _LIT8(KPIN, "PIN");
+    _LIT8(KActive, "active");
+    _LIT8(KTrue, "1");
+    _LIT8(KFalse, "0");
+    _LIT8(KUsersStart, "<Users>");
+    _LIT8(KUsersEnd, "</Users>");
+    _LIT8(KUserStartFmt, "<User username=\"%S\" PIN=\"%S\" active=\"%d\">");
+    _LIT8(KUserEnd, "</User>");
+    const TInt KFLATBUF_SIZE = 128;
+    const TInt KActiveValueSize = 1;
+    
+    const TInt KStateParsingIdentity = 100;
+    }
+
+
+EXPORT_C CSenMultiUserIdentityManager* CSenMultiUserIdentityManager::NewL(
+                                            MSenCoreServiceManager& aManager)
+    {
+    CSenMultiUserIdentityManager* pNew = NewLC(aManager);
+    CleanupStack::Pop();
+    return(pNew) ;
+    }
+
+EXPORT_C CSenMultiUserIdentityManager* CSenMultiUserIdentityManager::NewLC(
+                                            MSenCoreServiceManager& aManager)
+    {
+    CSenMultiUserIdentityManager* pNew =
+                        new (ELeave) CSenMultiUserIdentityManager(aManager);
+    CleanupStack::PushL(pNew);
+    pNew->ConstructL();
+    return pNew;
+    }
+                              
+CSenMultiUserIdentityManager::CSenMultiUserIdentityManager(
+                                            MSenCoreServiceManager& aManager)
+    : CSenBaseIdentityManager(aManager)
+    {
+    }
+
+EXPORT_C CSenMultiUserIdentityManager::~CSenMultiUserIdentityManager()
+    {
+    iUsers.ResetAndDestroy();
+    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenMultiUserIdentityManager::~CSenMultiUserIdentityManager");        
+    }
+
+void CSenMultiUserIdentityManager::ConstructL()
+    {
+    CSenBaseIdentityManager::ConstructL();
+    //db was empty, take default one from Base class(loaded during Base::Contructl)
+    if (!iActiveIdentity)
+        {
+        iActiveIdentity = iIdentity;
+        iActiveUser = CSenUser::NewL(KNullDesC8, KNullDesC8, ETrue);    
+        iActiveUser->Identites().Append(iActiveIdentity);
+        iUsers.Append(iActiveUser);
+        }
+    else
+        {
+        //parsing from CSenBaseIdentityManager::ConstructL()
+        //  caused, that iActiveIdentity is already set (because has been set by below "StartElement" method).
+        //  So, orginal iIdentity should be replaced by iActiveIdentity (used by UpdateTouch functionality)
+        delete iIdentity;
+        iIdentity = NULL;
+        iIdentity = iActiveIdentity;
+        };
+        
+    }
+
+void CSenMultiUserIdentityManager::StartElementL(
+                                          const TDesC8& /*aNsUri*/,
+                                          const TDesC8& aLocalName,
+                                          const TDesC8& /*aQName*/,
+                                          const RAttributeArray& aAttributes
+                                          )
+    {
+    switch (iState)
+        {
+        case KStateIgnore:
+            {
+            if (aLocalName == KUser)
+                {
+                TPtrC8 userName = SenXmlUtils::AttrValue(aAttributes, KUserName);
+                TPtrC8 pin = SenXmlUtils::AttrValue(aAttributes, KPIN);
+                TPtrC8 active = SenXmlUtils::AttrValue(aAttributes, KActive);
+                if (active == KTrue)
+                    {
+                    iParsedUser = CSenUser::NewL(userName, pin, ETrue);    
+                    }
+                else
+                    {
+                    iParsedUser = CSenUser::NewL(userName, pin);
+                    }
+                
+                if (active == KTrue)
+                    {
+                    //2nd time active user?? within db
+                    __ASSERT_ALWAYS(!iActiveUser, User::Panic(KSenUser, KErrAlreadyExists));
+                    iActiveUser = iParsedUser;
+                    }
+                iUsers.Append(iParsedUser);
+                iState = KStateParsingIdentity;
+                }
+            }
+            break;
+        
+        case KStateParsingIdentity:
+            {
+            if (aLocalName ==  KIdentityElementLocalName)
+                {
+                CSenBaseIdentity* identity = CSenBaseIdentity::NewLC(ipDeviceID->Des());
+                identity->SetAttributesL(aAttributes);
+                identity->SetReader(*Reader());
+                DelegateParsingL(*identity);
+                __ASSERT_ALWAYS(iParsedUser, User::Panic(KSenUser, KErrAlreadyExists));
+                iParsedUser->Identites().Append(identity);
+                
+                //current parsed user is active
+                if (iParsedUser == iActiveUser)
+                    {
+                    iActiveIdentity = identity;
+                    }
+                CleanupStack::Pop(identity);
+                }
+            }
+            break;
+            
+        default:
+            break;
+        }
+    }
+void CSenMultiUserIdentityManager::EndElementL(
+    const TDesC8& /*aNsUri*/,
+    const TDesC8& aLocalName,
+    const TDesC8& /*aQName*/)
+    {
+    switch (iState)
+        {
+        case KStateIgnore:
+            {
+            if (aLocalName ==  KUsers)//end parsing
+                {
+                if (iUsers.Count() == 1)
+                    {
+                    CSenUser* user = iUsers[0];
+                    iActiveUser = user;
+                    iActiveIdentity = iActiveUser->Identites()[0];
+                    }
+                }
+            break;
+            }
+        case KStateParsingIdentity:
+            {
+            if (aLocalName ==  KUser)
+                {
+                iState = KStateIgnore;    
+                }
+            }
+            break;
+        }
+    }
+        
+
+MSenIdentity& CSenMultiUserIdentityManager::IdentityL()
+    {
+    return (MSenIdentity&)*iActiveIdentity;
+    }
+
+TInt CSenMultiUserIdentityManager::UserNameL(HBufC8*& aUserName)
+    {
+    delete aUserName;
+    aUserName = NULL;
+    aUserName = iActiveUser->UserName().AllocL();
+    return KErrNone;
+    }
+
+
+
+
+
+TInt CSenMultiUserIdentityManager::WriteConfigurationToL( const TDesC& aFile )
+    {
+    // First, collect everything into MEMORY
+    CBufFlat *pBuf = CBufFlat::NewL(KFLATBUF_SIZE);
+    CleanupStack::PushL(pBuf);
+
+    RBufWriteStream bufWs(*pBuf);
+    CleanupClosePushL(bufWs);
+    bufWs.WriteL(KUsersStart);
+
+
+//############# main loop #########
+    TInt count = iUsers.Count();
+    for (TInt i=0; i<count; i++)
+        {
+        RBuf8 userTag;
+        CSenUser* user = iUsers[i];
+        userTag.CreateL(KUserStartFmt().Length() + 
+                     user->PIN().Length() + 
+                     user->UserName().Length() + 
+                     KActiveValueSize //1
+                     );
+    
+        if (user->Active())
+            {
+            userTag.Format(KUserStartFmt, &(user->UserName()),  &(user->PIN()), KTrue); 
+            }
+        else
+            {
+            userTag.Format(KUserStartFmt, &(user->UserName()),  &(user->PIN()), KFalse);
+            }
+        
+                     
+        bufWs.WriteL(userTag);
+        TInt count2 = iUsers[i]->Identites().Count();
+        for (TInt j=0; j<count2; j++)
+            {
+            CSenBaseIdentity* identity = iUsers[i]->Identites()[j];
+            identity->WriteAsXMLToL(bufWs);
+            }
+        bufWs.WriteL(KUserEnd);
+        userTag.Close();
+        }
+
+//#############
+    bufWs.WriteL(KUsersEnd);
+
+    TPtrC8 p8 = pBuf->Ptr(0);
+
+    CleanupStack::PopAndDestroy(1); // bufWs
+
+    // Everything in MEMORY ok, prepare to write into file
+    RFs fss;
+    User::LeaveIfError(fss.Connect());
+    CleanupClosePushL(fss);
+
+    RFileWriteStream fileOutStream;
+    CleanupClosePushL(fileOutStream);
+
+
+    if(!SysUtil::FFSSpaceBelowCriticalLevelL(&fss, p8.Length()) )
+        {
+        // note, this will zero-length the file(!)
+        // it is better to require that 2xfilesize is available and not to
+        // dangerously zero the old file and find out
+        // that there is no space left..
+
+        //Data caging 2 implementation
+#if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )
+        TBuf<KMaxPath> file;
+        fss.CreatePrivatePath(EDriveC);
+        fss.PrivatePath(file);
+        file.Append(aFile);
+        fileOutStream.Replace(fss, file, EFileWrite);
+#else
+        fileOutStream.Replace(fss, aFile, EFileWrite);
+#endif
+        // finally write the UTF-8 into the file. 
+        fileOutStream.WriteL(p8);
+        }
+    CleanupStack::PopAndDestroy(3);
+    return KErrNone;
+    }
+
+	
+			
+// End of file