diff -r 000000000000 -r 96612d01cf9f videofeeds/server/IptvServiceManager/src/CIptvServiceManager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/videofeeds/server/IptvServiceManager/src/CIptvServiceManager.cpp	Mon Jan 18 20:21:12 2010 +0200
@@ -0,0 +1,2421 @@
+/*
+* Copyright (c) 2005-2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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:    Offers interface to services database*
+*/
+
+
+
+
+#include <s32file.h>    // CFileStore & CPermanentFileStore
+#include <bautils.h>    // file helpers
+#include <eikenv.h>
+#include <sysutil.h>    // SysUtil
+#include "IptvDebug.h"
+#include <f32file.h>
+#include <sqldb.h>
+#include "CIptvDriveMonitor.h"
+
+#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+#include "CIptvUiEngine.h"
+#include <aspaclienthelper.h>
+#include "iptvlocalisationliterals.h"
+#include <ipvideo/IptvActivationMessage.h>
+#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+
+#include "CIptvService.h"
+#include "CIptvServices.h"
+#include "CIptvServiceManagementClient.h"
+#include "CIptvProvisioningProcessor.h"
+#include "CIptvServer.h"
+#include "IptvServer.pan"
+#include "MIptvServiceManagerObserver.h"
+#include "TIptvSmPassword.h"
+#include "CIptvServiceManager.h"
+
+const TInt KIptvServiceManagerFreeSpace = 512000; // 500 KB
+
+//all valid versions are > 0
+const TUint32 KIptvSmDbVersion = 3; //1 = Rel1, 2 = Rel2, Rel3, Rel4, 3 = Rel6/NFP1/Rel4 Touch
+
+#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+ const TUid KIptvMain = {0x102750E2};
+ const TInt KIptvMaxLengthOfEmptyThumbPath( 1 );
+#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManager::CIptvServiceManager
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CIptvServiceManager::CIptvServiceManager()
+    {
+   	iServicesDbOpen  = EFalse;
+   	iPasswordsDbOpen = EFalse;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManager::ConstructL
+// Second phase construction. Leaves, if RFs session cannot be created.
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManager::ConstructL()
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::ConstructL() begin");	
+
+    iObservers.Reset();
+	
+    User::LeaveIfError( iFsSession.Connect());
+
+    CIptvDriveMonitor* driveMonitor = CIptvDriveMonitor::NewL( iFsSession );
+    CleanupStack::PushL( driveMonitor ); // 1->
+    
+    for ( TInt i = 0; i < driveMonitor->iAvailableDrives.Count(); i++ )
+        {
+        CreateWritableRootDirL( static_cast<TDriveNumber>( driveMonitor->iAvailableDrives[i].iDrive ) );
+        }
+
+    CleanupStack::PopAndDestroy( driveMonitor ); // <-1
+            
+    // Services database to private folder, create private folder if it does not exist yet
+    iPrivatePath.Zero();
+    iServicesFile  = KIptvSmCDiskPrefix;
+    iPasswordsFile = KIptvSmCDiskPrefix;
+		
+    // Get private path
+    if ( iFsSession.PrivatePath( iPrivatePath ) )
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::ConstructL() can't get private path");	
+        User::Panic(KIptvServiceManager, KErrPathNotFound);
+        }
+	
+    // Append privatepath after drive letter
+    iServicesFile.Append( iPrivatePath );
+    iPasswordsFile.Append( iPrivatePath );
+	
+    if ( BaflUtils::CheckFolder(iFsSession, iServicesFile) != KErrNone )
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::ConstructL() Creating private path ");	
+		
+        if ( iFsSession.CreatePrivatePath( EDriveC ) != KErrNone )
+            {
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::ConstructL() can't create private path ");	
+            // This is fatal, owner process is always able to create its private folder
+            User::Panic( KIptvServiceManager, KErrDiskFull );
+            }
+			
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::ConstructL() Private path created");
+        }
+
+    iServicesFile.Append( KIptvSmServicesDbFileName );
+    iPasswordsFile.Append( KIptvSmPasswordsDbFileName );
+        
+    CheckSmDbVersionL();
+    OpenL();
+
+#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+ 	TRAPD( err, iActiveSpaceHelper = CActiveSpaceHelper::NewL() );
+ 	if ( err == KErrNotFound )
+ 	    {
+ 	    iActiveSpaceHelper = NULL;      // Active Space not found
+ 	    }
+#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+
+    //  Check if there is service update file and if found, do provisioning
+    TFileName serviceUpdateXml;
+    if (IsServiceUpdateFoundL(serviceUpdateXml))
+        {
+        ExecuteProvisioningL();
+        }
+
+    CompactDatabases();
+    Close();
+        
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::ConstructL() end");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManager::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+CIptvServiceManager* CIptvServiceManager::NewL()
+    {
+    CIptvServiceManager* self = new( ELeave ) CIptvServiceManager;
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+    
+// Destructor
+CIptvServiceManager::~CIptvServiceManager()
+    {
+    Close();  // Just in case, if the user does not close this explicitely
+    iFsSession.Close();
+    iObservers.Close();
+    delete iSearchUrl;
+    
+#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+    delete iActiveSpaceHelper;
+    REComSession::FinalClose();
+#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::OpenL()
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::OpenL()
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::OpenL()");	
+
+    CreateFilesL(ETrue /* do provisioning */);
+	  
+    if ( !iServicesDbOpen )
+        {
+        OpenServicesDbL();
+        }
+    if ( !iPasswordsDbOpen )
+        {
+        OpenPasswordsDbL();
+        }
+        
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::OpenL() exit");	
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::CreateFilesL()
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::CreateFilesL( TBool aDoProvisioning )
+    {
+    TBool servicesDbFileExists  = BaflUtils::FileExists( iFsSession, iServicesFile );
+    TBool passwordsDbFileExists = BaflUtils::FileExists( iFsSession, iPasswordsFile );
+
+    // Before creating any new databases, check that there is enough disk space.
+    if ( !servicesDbFileExists || !passwordsDbFileExists )
+        {
+        TBool checkResult = EFalse;
+        TRAPD( checkError, checkResult =
+            SysUtil::DiskSpaceBelowCriticalLevelL(
+                &iFsSession, KIptvServiceManagerFreeSpace, EDriveC ) );
+        if ( checkError != KErrNone || checkResult )
+            {
+            // Not enough space on disk, return immediately and do not create databases.
+            User::Leave( KErrDiskFull );
+            }
+        }
+    if ( servicesDbFileExists && passwordsDbFileExists )
+        {            
+        //do nothing
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Files exist, nothing done.");
+        return;
+        }
+    if ( !servicesDbFileExists && !passwordsDbFileExists )
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: pwd.dat & services.dat missing");
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: creating services.dat");
+        TRAPD( error, CreateServicesDbL() );
+        if( error != KErrNone )
+            {
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: couldn't create services.dat (%d)", error);
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: deleting services.dat");
+            iFsSession.Delete( iPasswordsFile );
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Panicing!");
+            User::Panic(KIptvServiceManager, EIptvSmCouldNotCreateServicesFile);
+            }
+        iServicesDbOpen = ETrue;
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: creating pwd.dat");
+        TRAP(error, CreatePasswordsDbL());
+        if ( error != KErrNone )
+            {
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: couldn't create pwd.dat (%d)", error);
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: deleting pwd.dat");
+            iFsSession.Delete(iPasswordsFile);
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Panicing!");
+            User::Panic(KIptvServiceManager, EIptvSmCouldNotCreatePasswordsFile);
+            }
+        iPasswordsDbOpen = ETrue;
+        if ( aDoProvisioning )
+            {
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: executing provisioning");
+            ExecuteProvisioningL();
+            }
+        return;
+        }
+
+    if ( servicesDbFileExists && !passwordsDbFileExists )
+        {
+        //create pwd.dat
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: pwd.dat missing");
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: creating pwd.dat");
+        TRAPD(error, CreatePasswordsDbL());
+        if(error != KErrNone)
+            {
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: couldn't create pwd.dat (%d)", error);
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: deleting pwd.dat");
+            iFsSession.Delete(iPasswordsFile);
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Panicing!");
+            User::Panic(KIptvServiceManager, EIptvSmCouldNotCreatePasswordsFile);
+            }
+        iPasswordsDbOpen = ETrue;
+        return;
+        }
+
+    if ( !servicesDbFileExists && passwordsDbFileExists )
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: services.dat missing, pwd.dat exists.");
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: deleting pwd.dat");
+        iFsSession.Delete(iPasswordsFile);
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: creating services.dat");
+        TRAPD(error, CreateServicesDbL());
+        if ( error != KErrNone )
+            {
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: couldn't create services.dat (%d)", error);
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: deleting services.dat");
+            iFsSession.Delete(iServicesFile);
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Panicing!");
+            User::Panic(KIptvServiceManager, EIptvSmCouldNotCreateServicesFile);
+            }
+        iServicesDbOpen = ETrue;
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: creating pwd.dat");
+        TRAP( error, CreatePasswordsDbL() );
+        if ( error != KErrNone )
+            {
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: couldn't create pwd.dat (%d)", error);
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: deleting pwd.dat");
+            iFsSession.Delete(iPasswordsFile);
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Panicing!");
+            User::Panic(KIptvServiceManager, EIptvSmCouldNotCreatePasswordsFile);
+            }
+        
+        iPasswordsDbOpen = ETrue;
+        if ( aDoProvisioning )
+            {
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: executing provisioning");
+            ExecuteProvisioningL();
+            }
+        
+        return;
+        }        
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::OpenServicesDbL()
+// Open Services database, it's already checked that file exists
+// ---------------------------------------------------------------------------
+void CIptvServiceManager::OpenServicesDbL()
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::OpenServicesDbL()");
+
+    if ( iServicesDbOpen )
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: was already open.");
+        return;
+        }
+        
+    //open Services database
+    TRAPD(error,
+        {
+        iServicesFileStore = CPermanentFileStore::OpenL(
+            iFsSession, iServicesFile, EFileRead|EFileWrite );
+        iServicesFileStore->SetTypeL( iServicesFileStore->Layout() );
+        iServicesDb.OpenL( iServicesFileStore, iServicesFileStore->Root() );
+        });
+    
+    if ( error != KErrNone )
+        {
+        IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManager:: Could not open services database(%d)", error);
+
+        if ( error != KErrNoMemory && 
+             error != KErrLocked && 
+             error != KErrDisMounted &&
+             error != KErrDiskFull &&
+             error != KErrNotReady )
+            {
+            // Delete and recreate database files. Cannot recover other way. 
+            RemoveDbL();
+            TRAPD( err, CreateFilesL( ETrue /* do provisioning */ ));
+            if ( err != KErrNone )
+                {
+                IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: couldnt recreate services.dat & pwd.dat -> panicing");
+                User::Panic(KIptvServiceManager, EIptvSmCouldNotOpenServicesDb);
+                }
+            }
+        else
+            {
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: leaving");
+            User::Leave(error);
+            }
+        }
+
+    iServicesDbOpen = ETrue;
+
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::OpenServicesDbL() exit");
+    return;
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::OpenPasswordsDbL()
+// Open Passwords database, its already checked that file exists
+// ---------------------------------------------------------------------------
+void CIptvServiceManager::OpenPasswordsDbL()
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::OpenPasswordsDbL()");
+    
+    if(iPasswordsDbOpen)
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: was already open.");
+        return;
+        }
+        
+    //open Passwords database
+    TRAPD(error,
+        { 
+        iPasswordsFileStore = CPermanentFileStore::OpenL(
+            iFsSession, iPasswordsFile, EFileRead|EFileWrite );
+        iPasswordsFileStore->SetTypeL( iPasswordsFileStore->Layout() );
+        iPasswordsDb.OpenL( iPasswordsFileStore, iPasswordsFileStore->Root() );
+        });
+
+    if(error != KErrNone)
+        {
+        if ( error != KErrNoMemory &&
+             error != KErrLocked &&
+             error != KErrDisMounted &&
+             error != KErrDiskFull &&
+             error != KErrNotReady )
+            {
+            // Delete and recreate database files. Cannot recover other way. 
+            IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManager:: Could not open password database(%d)", error);
+            RemoveDbL();
+            TRAPD( err, CreateFilesL( ETrue /* do provisioning */ ));
+            if ( err != KErrNone )
+                {
+                IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: couldnt recreate services.dat & pwd.dat -> panicing");
+                User::Panic(KIptvServiceManager, EIptvSmCouldNotOpenPasswordsDb);
+                }
+            }
+        else
+            {
+            // Database file might be ok, couldn't just temporarily open it
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: not removing database files, leaving");
+            User::Leave( error );
+            }
+        }
+        
+    iPasswordsDbOpen = ETrue;
+        
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::OpenPasswordsDbL() exit");
+    return;
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::CreateServicesDbL()
+// Create new Services database.
+// ---------------------------------------------------------------------------
+void CIptvServiceManager::CreateServicesDbL()
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::CreateServicesDbL()");
+        
+    IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManager:: Services db filename: %S", &iServicesFile);
+
+    SaveSmDbVersion();
+                
+    // Create empty services database file.
+    iServicesFileStore = CPermanentFileStore::ReplaceL(iFsSession, iServicesFile, EFileRead|EFileWrite);
+    iServicesFileStore->SetTypeL(iServicesFileStore->Layout()); // Set file store type
+    TStreamId id = iServicesDb.CreateL(iServicesFileStore);     // Create stream object
+    iServicesFileStore->SetRootL(id);                           // Keep database id as root of store
+    iServicesFileStore->CommitL();                              // Complete creation by commiting
+
+    CreateServicesTableL();
+    CreateServicesDbIndexL();
+     
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CreateServicesDbL() Exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::CreatePasswordsDbL()
+// Create new Passwords database.
+// ---------------------------------------------------------------------------
+void CIptvServiceManager::CreatePasswordsDbL()
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::CreatePasswordsDbL()");
+        
+    IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManager:: Passwords db filename: %S", &iPasswordsFile);
+    
+    // Create empty passwords database file.
+    iPasswordsFileStore = CPermanentFileStore::ReplaceL(iFsSession, iPasswordsFile, EFileRead|EFileWrite);
+    iPasswordsFileStore->SetTypeL(iPasswordsFileStore->Layout()); // Set file store type
+    TStreamId id = iPasswordsDb.CreateL(iPasswordsFileStore);    // Create stream object
+    iPasswordsFileStore->SetRootL(id);                           // Keep database id as root of store
+    iPasswordsFileStore->CommitL();                              // Complete creation by commiting
+
+    CreatePasswordsTableL();
+    CreatePasswordsDbIndexL();
+    
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CreatePasswordsDbL() Exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::RemoveDbL()
+// ---------------------------------------------------------------------------
+void CIptvServiceManager::RemoveDbL()
+    {
+    Close();
+
+    if ( BaflUtils::FileExists( iFsSession, iServicesFile ) )
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: deleting services.dat");
+        iFsSession.Delete( iServicesFile );
+        }
+
+    if ( BaflUtils::FileExists( iFsSession, iPasswordsFile ) )
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: deleting pwd.dat");
+        iFsSession.Delete( iPasswordsFile );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::Close()
+// Close databases.
+// ---------------------------------------------------------------------------
+void CIptvServiceManager::Close()
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::Close() start");
+
+    if ( iServicesDbOpen )
+        {        
+        iServicesDb.Close();
+        
+        delete iServicesFileStore;
+        iServicesFileStore = NULL;
+
+        iServicesDbOpen = EFalse;
+        }
+
+    if ( iPasswordsDbOpen )
+        {        
+        iPasswordsDb.Close();
+        
+        delete iPasswordsFileStore;
+        iPasswordsFileStore = NULL;
+
+        iPasswordsDbOpen = EFalse;
+        }
+        
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::Close() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::CreateServicesTableL()
+// Creates Services table. Leaves, if the table cannot be created.
+// ---------------------------------------------------------------------------
+void CIptvServiceManager::CreateServicesTableL()
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CreateServicesTableL()");
+    
+    // Specify columns for Services table
+    TDbCol idCol( KIptvSmServicesDbIdCol, EDbColUint32 );
+    idCol.iAttributes |= TDbCol::EAutoIncrement; 
+    TDbCol nameCol( KIptvSmServicesDbNameCol, EDbColText, KIptvSmServicesDbNameMaxLength );
+    TDbCol addressCol( KIptvSmServicesDbAddressCol, EDbColText, KIptvSmServicesDbAddressMaxLength );
+    TDbCol iconPathCol( KIptvSmServicesDbIconPathCol, EDbColText, KIptvSmServicesDbIconPathMaxLength );
+    TDbCol epgPluginUidCol( KIptvSmServicesDbEpgPluginUidCol, EDbColInt32 );
+    TDbCol vodPluginUidCol( KIptvSmServicesDbVodPluginUidCol, EDbColInt32 );
+    TDbCol iptvPluginUidCol( KIptvSmServicesDbIptvPluginUidCol, EDbColInt32 );
+    TDbCol typeCol( KIptvSmServicesDbTypeCol, EDbColUint8);
+    TDbCol iapListCol( KIptvSmServicesDbIapListCol, EDbColText8, KIptvSmServicesDbIapListMaxLength );
+    TDbCol descCol( KIptvSmServicesDbDescCol, EDbColLongText ); // Stream Data
+    TDbCol dateCol( KIptvSmServicesDbDateCol, EDbColDateTime );    
+    TDbCol flagsCol( KIptvSmServicesDbFlagsCol, EDbColUint32 );
+    TDbCol applicationUidCol( KIptvSmServicesDbApplicationUidCol, EDbColInt32 );
+    TDbCol displayOrderCol( KIptvSmServicesDbDisplayOrderCol, EDbColUint32 );
+    TDbCol providerIdCol( KIptvSmServicesDbProviderIdCol, EDbColText, KIptvSmServicesDbProviderIdMaxLength );
+    TDbCol accountManagementUrlCol( KIptvSmServicesDbAccountManagementUrlCol, EDbColText, KIptvSmServicesDbAccountManagementUrlMaxLength );
+    TDbCol epgUpdateTimeCol( KIptvSmServicesDbEpgUpdateTimeCol, EDbColDateTime );
+    epgUpdateTimeCol.iAttributes |= TDbCol::ENotNull;
+    TDbCol iapNameCol( KIptvSmServicesDbIapNameCol, EDbColText, KIptvSmServicesDbIapNameMaxLength );
+    TDbCol searchUrlCol( KIptvSmServicesDbSearchUrlCol, EDbColLongText, KIptvSmServicesDbSearchUrlMaxLength ); // Stream Data
+    TDbCol dlNetwork( KIptvSmServicesDbScheduledDlNetworkCol, EDbColUint32 );
+    TDbCol dlTime( KIptvSmServicesDbScheduledDlTimeCol, EDbColUint32 );
+    TDbCol dlType( KIptvSmServicesDbScheduledDlTypeCol, EDbColUint32 );
+    TDbCol lastDlTimeCol( KIptvSmServicesDbLastScheduledDlTime, EDbColDateTime );
+    TDbCol groupIdCol( KIptvSmServicesDbGroupIdCol, EDbColUint32 );
+    TDbCol useCateCol( KIptvSmServicesDbUseCategoryCol, EDbColUint8 );
+    TDbCol uploadCol( KIptvSmServicesDbUploadProviderCol, EDbColText, KIptvSmServicesDbNameMaxLength );
+    TDbCol iconUrlCol( KIptvSmServicesDbIconUrlCol, EDbColText, KIptvSmServicesDbAddressMaxLength );
+    TDbCol recordUrlCol( KIptvSmServicesDbRecordUrlCol, EDbColLongText, KIptvSmServicesDbRecordUrlMaxLength); // Stream Data
+
+    // Add columns to column set
+    CDbColSet* serviceColSet = CDbColSet::NewLC();
+    serviceColSet->AddL( idCol );                   // 1
+    serviceColSet->AddL( nameCol );                 // 2
+    serviceColSet->AddL( addressCol );              // 3
+    serviceColSet->AddL( iconPathCol );             // 4
+    serviceColSet->AddL( epgPluginUidCol );         // 5
+    serviceColSet->AddL( vodPluginUidCol );         // 6
+    serviceColSet->AddL( iptvPluginUidCol );        // 7
+    serviceColSet->AddL( typeCol );                 // 8
+    serviceColSet->AddL( iapListCol );              // 9
+    serviceColSet->AddL( descCol );                 // 10
+    serviceColSet->AddL( dateCol );                 // 11
+    serviceColSet->AddL( flagsCol );                // 12
+    serviceColSet->AddL( applicationUidCol );       // 13
+    serviceColSet->AddL( displayOrderCol );         // 14
+    serviceColSet->AddL( providerIdCol );           // 15
+    serviceColSet->AddL( accountManagementUrlCol ); // 16
+    serviceColSet->AddL( epgUpdateTimeCol );        // 17 //last item in vers 1
+    serviceColSet->AddL( iapNameCol );              // 18
+    serviceColSet->AddL( searchUrlCol );            // 19
+    serviceColSet->AddL( dlNetwork );               // 20
+    serviceColSet->AddL( dlTime );                  // 21
+    serviceColSet->AddL( dlType );                  // 22
+    serviceColSet->AddL( lastDlTimeCol );           // 23 //last item in vers 2
+    serviceColSet->AddL( groupIdCol );              // 24 
+    serviceColSet->AddL( useCateCol );              // 25 
+    serviceColSet->AddL( uploadCol );               // 26
+    serviceColSet->AddL( iconUrlCol );              // 27 //last item in vers 3
+    serviceColSet->AddL( recordUrlCol );            // 28 //last item in vers 3
+
+    // Create the Services table
+    User::LeaveIfError(
+        iServicesDb.CreateTable( KIptvSmServicesTable, *serviceColSet ) );
+    CleanupStack::PopAndDestroy( serviceColSet );
+    
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CreateServicesTableL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::CreatePasswordsTableL()
+// Creates Passwords table. Leaves, if the table cannot be created.
+// ---------------------------------------------------------------------------
+void CIptvServiceManager::CreatePasswordsTableL()
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CreatePasswordsTableL()");
+    
+    // Specify columns for Passwords table
+    TDbCol idCol( KIptvSmPasswordsDbIdCol, EDbColUint32 );
+    TDbCol userNameCol( KIptvSmPasswordsDbUserNameCol,
+        EDbColText, KIptvSmPasswordsDbUserNameMaxLength );
+    TDbCol passwordCol( KIptvSmPasswordsDbPasswordCol,
+        EDbColText, KIptvSmPasswordsDbPasswordMaxLength );
+
+    // Add columns to column set
+    CDbColSet* passwordColSet = CDbColSet::NewLC();
+    passwordColSet->AddL( idCol );
+    passwordColSet->AddL( userNameCol );
+    passwordColSet->AddL( passwordCol );
+
+    // Create the Passwords table
+    User::LeaveIfError(
+        iPasswordsDb.CreateTable( KIptvSmPasswordsTable, *passwordColSet ) );
+    CleanupStack::PopAndDestroy( passwordColSet );
+    
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CreatePasswordsTableL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::CreateServicesDbIndexL()
+// Creates an index for Services table. Leaves, if the index cannot be created.
+// ---------------------------------------------------------------------------
+void CIptvServiceManager::CreateServicesDbIndexL()
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CreateServicesDbIndexL()");
+
+    // Create index consisting of ID
+    TDbKeyCol idCol( KIptvSmServicesDbIdCol );
+
+    CDbKey* index = CDbKey::NewLC();   // create index key set
+    index->AddL( idCol );
+    index->MakeUnique();
+    User::LeaveIfError( iServicesDb.CreateIndex(
+        KIptvSmServicesDbIndexName, KIptvSmServicesTable, *index ) );
+    CleanupStack::PopAndDestroy( index );
+
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CreateServicesDbIndexL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::CreatePasswordsDbIndexL()
+// Creates an index for Passwords table in Passwords db. Leaves, if the index
+// cannot be created.
+// ---------------------------------------------------------------------------
+void CIptvServiceManager::CreatePasswordsDbIndexL()
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CreatePasswordsDbIndexL()");
+
+    // Create index consisting of ID
+    TDbKeyCol idCol( KIptvSmPasswordsDbIdCol );
+
+    CDbKey* index = CDbKey::NewLC();   // create index key set
+    index->AddL( idCol );
+    index->MakeUnique();
+    User::LeaveIfError( iPasswordsDb.CreateIndex(
+        KIptvSmPasswordsDbIndexName, KIptvSmPasswordsTable, *index ) );
+    CleanupStack::PopAndDestroy( index );
+
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CreatePasswordsDbIndexL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::AddOrUpdateServiceL
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::AddOrUpdateServiceL(
+    CIptvService& aService,
+    TUint32 aModeFlags )
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::AddOrUpdateServiceL()");
+    
+    if ( !( aModeFlags & EDontOpen ) )
+        {
+        OpenL();
+        CleanupClosePushL( *this ); // 1->
+        }
+    
+    CompactDatabases();
+    
+    RDbTable servicesTable;
+    RDbTable passwordsTable;
+
+    TBool sendServiceAddedEvent = EFalse;
+    TBool sendServiceModifiedEvent = EFalse;
+    TBool sendServiceScheduledEvent = EFalse;
+    TBool sendServiceSelectionModifiedEvent = EFalse;
+
+    // Create an updateable database table object
+    TInt err( servicesTable.Open(
+        iServicesDb, KIptvSmServicesTable, servicesTable.EUpdatable ) );
+    if ( err != KErrNone )
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Could not get services table, aborting!");
+        User::Leave( KErrGeneral );
+        }
+    CleanupClosePushL( servicesTable ); // 2->
+
+    err = passwordsTable.Open(
+        iPasswordsDb, KIptvSmPasswordsTable, passwordsTable.EUpdatable );
+    if ( err != KErrNone )
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Could not get passwords table, aborting!");
+        User::Leave( KErrGeneral );
+        }
+    CleanupClosePushL( passwordsTable ); // 3->
+
+    if ( servicesTable.CountL() >= KIptvSmMaxServices )
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: DB max entries exceeded, aborting!");
+        User::Leave( KErrOverflow );    
+        }
+        
+    CDbColSet* servicesColSet = servicesTable.ColSetL();
+    CleanupStack::PushL( servicesColSet );  // 4->
+    CDbColSet* passwordsColSet = passwordsTable.ColSetL();
+    CleanupStack::PushL( passwordsColSet ); // 5->
+
+    servicesTable.SetIndex( KIptvSmServicesDbIndexName );
+    servicesTable.Reset();
+    passwordsTable.SetIndex( KIptvSmPasswordsDbIndexName );
+    passwordsTable.Reset();
+
+    TUint serviceId = 0;
+    
+    if ( aModeFlags & EAddService )
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Adding a new service");
+		
+        // add new entry to Services table, ID is autoincrement
+        servicesTable.InsertL();
+        
+        // Get ID
+        serviceId = servicesTable.ColUint32(
+            servicesColSet->ColNo( KIptvSmServicesDbIdCol ) );
+
+        // Inform observers later if not grouped service
+        if ( !( aService.GetFlags() & CIptvService::EGroupedService ) )
+            {
+            sendServiceAddedEvent = ETrue;
+            }
+        
+        // Add id+1 as default display order value for service
+        servicesTable.SetColL( servicesColSet->ColNo(
+            KIptvSmServicesDbDisplayOrderCol ), serviceId + 1 );
+        
+        // Add new entry to Passwords db, use ID from Services table
+        passwordsTable.InsertL();
+        passwordsTable.SetColL( passwordsColSet->ColNo(
+            KIptvSmPasswordsDbIdCol ), serviceId );
+        
+        // Update new Service Id to the actual service.
+        aService.SetId( serviceId );
+        }
+    else
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("Updating existing service");
+        //Mode = EUpdateService 
+		
+        if ( aService.GetDisplayOrder() == 0 )
+            {
+            aService.SetDisplayOrder( MaxDisplayOrderL() );
+            }
+
+        //-> find the service item to update
+        if ( !servicesTable.SeekL( ( TInt )( aService.GetId() ) ) )
+            {
+            //not found
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: Service(%d) not found, aborting", aService.GetId() );			
+            User::Leave( KErrNotFound );
+            }
+
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Service entry found, updating..");
+        servicesTable.UpdateL();
+
+        if ( passwordsTable.SeekL( ( TInt )( aService.GetId() ) ) )
+            {
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Password entry found, updating..");
+            passwordsTable.UpdateL();
+            }
+        else
+            {
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: Passwords db does not contain ID: %d", aService.GetId() );
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Adding it.");
+            passwordsTable.InsertL();
+            passwordsTable.SetColL( passwordsColSet->ColNo(
+                KIptvSmPasswordsDbIdCol ), aService.GetId() );
+            }
+        }
+        
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbNameCol ), aService.GetName() );
+
+    //check if address is modified and do we need to send event
+    TPtrC address;
+    address.Set( servicesTable.ColDes(
+        servicesColSet->ColNo( KIptvSmServicesDbAddressCol ) ) );
+
+    if ( address != aService.GetAddress() ) //has address changed
+        {
+        if ( !( aModeFlags & EAddService ) ) //is this a modify call
+            {
+            sendServiceModifiedEvent = ETrue;
+            }
+        }
+
+    // check if the scheduled download settings have been changed and
+    TUint dlNetwork = servicesTable.ColUint32(
+        servicesColSet->ColNo( KIptvSmServicesDbScheduledDlNetworkCol ) );
+    TUint dlTime = servicesTable.ColUint32(
+        servicesColSet->ColNo( KIptvSmServicesDbScheduledDlTimeCol ) );
+    TUint dlType = servicesTable.ColUint32(
+        servicesColSet->ColNo( KIptvSmServicesDbScheduledDlTypeCol ) );
+    TTime dlLastTime = servicesTable.ColTime(
+        servicesColSet->ColNo( KIptvSmServicesDbLastScheduledDlTime ) );
+
+    if ( dlNetwork != aService.ScheduleDlNetwork() ||
+         dlTime != aService.ScheduleDlTime() ||
+         dlType != aService.ScheduleDlType() ||
+         dlLastTime != aService.GetScheduledLastDownloadTime() )
+        {
+        // changed, we need to send event
+        sendServiceScheduledEvent = ETrue;
+        }
+
+    // check if Selected flag is modified and do we need to send event
+    TUint newSelectedFlag = aService.GetFlags() & CIptvService::ESelected;
+    TUint oldSelectedFlag = servicesTable.ColUint32(
+        servicesColSet->ColNo( KIptvSmServicesDbFlagsCol ) ) & CIptvService::ESelected;
+    if ( newSelectedFlag != oldSelectedFlag )
+        {
+        sendServiceSelectionModifiedEvent = ETrue;
+        }
+
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbAddressCol ), aService.GetAddress() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbIconPathCol ), aService.GetIconPath() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbEpgPluginUidCol ), aService.GetEpgPluginUid().iUid );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbVodPluginUidCol ), aService.GetVodPluginUid().iUid );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbIptvPluginUidCol ), aService.GetIptvPluginUid().iUid );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbTypeCol), aService.GetType() );
+    
+    CIptvIapList& iapList = aService.GetIapList();
+    RDesWriteStream writeStream;
+    HBufC8* iapListDes = HBufC8::NewL( iapList.CountExternalizeSize() +1 );
+    CleanupStack::PushL( iapListDes ); // 5->
+    TPtr8 iapListPtr8( iapListDes->Des() );
+    writeStream.Open( iapListPtr8 );
+    CleanupClosePushL( writeStream ); // 6->
+    iapList.ExternalizeL( writeStream );
+    CleanupStack::PopAndDestroy( &writeStream ); // <-6
+    servicesTable.SetColL( servicesColSet->ColNo( KIptvSmServicesDbIapListCol ), iapListPtr8 );
+    CleanupStack::PopAndDestroy( iapListDes ); // <-5
+    
+    passwordsTable.SetColL( passwordsColSet->ColNo(
+        KIptvSmPasswordsDbUserNameCol ), aService.GetUserName() );
+    passwordsTable.SetColL( passwordsColSet->ColNo(
+        KIptvSmPasswordsDbPasswordCol ), aService.GetPassword() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbDescCol ), aService.GetDesc() );
+    
+    if ( aModeFlags & EAddService )
+        {
+        TTime time;	
+        time.HomeTime();
+        servicesTable.SetColL( servicesColSet->ColNo( KIptvSmServicesDbDateCol ), time );
+        }
+        
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbFlagsCol ), aService.GetFlags() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbApplicationUidCol ), aService.GetApplicationUid() );
+    
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbProviderIdCol ), aService.GetProviderId() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbAccountManagementUrlCol ), aService.GetAccountManagementUrl() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbEpgUpdateTimeCol ), aService.GetEpgUpdateTimeL() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbIapNameCol ), aService.GetIapNameL() );
+
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbSearchUrlCol ), aService.SearchUrl() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbScheduledDlNetworkCol ), aService.ScheduleDlNetwork() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbScheduledDlTimeCol ), aService.ScheduleDlTime() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbScheduledDlTypeCol ), aService.ScheduleDlType() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbLastScheduledDlTime ), aService.GetScheduledLastDownloadTime() );
+
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbGroupIdCol ), aService.GetGroupId() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbUseCategoryCol), aService.GetUseCategory() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbUploadProviderCol ), aService.GetUploadProvider() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbIconUrlCol ), aService.GetIconUrl() );
+    servicesTable.SetColL( servicesColSet->ColNo(
+        KIptvSmServicesDbRecordUrlCol ), aService.RecordUrl() );
+
+    //check if display order is modified
+    TUint32 sourceDisplayOrder = servicesTable.ColUint32( servicesColSet->ColNo( KIptvSmServicesDbDisplayOrderCol ) );
+    TUint32 targetDisplayOrder = aService.GetDisplayOrder();
+
+    if ( !( aModeFlags & EAddService ) 
+        && sourceDisplayOrder != targetDisplayOrder )
+        {
+        // Set defined display order value for service 
+        servicesTable.SetColL( servicesColSet->
+            ColNo( KIptvSmServicesDbDisplayOrderCol ), targetDisplayOrder );
+        sendServiceModifiedEvent = ETrue;
+        }
+                   
+    servicesTable.PutL();    // Complete changes (the insertion)			
+    passwordsTable.PutL();   // Complete changes (the insertion)			
+ 
+    CleanupStack::PopAndDestroy( passwordsColSet ); // <-5
+    CleanupStack::PopAndDestroy( servicesColSet );	// <-4           
+    
+    if ( !( aModeFlags & EAddService ) 
+        && sourceDisplayOrder != targetDisplayOrder )
+        {
+        for ( servicesTable.FirstL(); servicesTable.AtRow(); servicesTable.NextL() )
+            { 
+              //Get row
+            servicesTable.GetL();
+            servicesColSet = servicesTable.ColSetL();
+            CleanupStack::PushL( servicesColSet );
+            
+            TUint32 currentServiceId =
+                servicesTable.ColUint32( servicesColSet->ColNo( KIptvSmServicesDbIdCol ) ); 
+            
+            TUint32 currentDisplayOrder = 
+                servicesTable.ColUint32( servicesColSet->ColNo( KIptvSmServicesDbDisplayOrderCol ) );
+                
+            if ( currentServiceId != aService.GetId() )
+                {
+                servicesTable.UpdateL();
+                
+                if ( ( currentDisplayOrder <= targetDisplayOrder ) &&
+                     ( currentDisplayOrder >= sourceDisplayOrder ) )
+                    {
+                    currentDisplayOrder--;
+                    }
+                else if ( ( currentDisplayOrder >= targetDisplayOrder ) &&
+                          ( currentDisplayOrder <= sourceDisplayOrder ) ) 
+                    {
+                    currentDisplayOrder++;
+                    }
+                    
+                servicesTable.SetColL( servicesColSet->ColNo(
+                    KIptvSmServicesDbDisplayOrderCol ), currentDisplayOrder );
+                servicesTable.PutL(); 
+                }
+                
+            CleanupStack::PopAndDestroy( servicesColSet );
+            }
+        }    
+
+    CleanupStack::PopAndDestroy( &passwordsTable ); // <-3
+    CleanupStack::PopAndDestroy( &servicesTable );  // <-2
+
+    if ( !( aModeFlags & EDontOpen ) )
+        {
+        CleanupStack::PopAndDestroy( this );        // <-1
+        }
+
+    if ( sendServiceAddedEvent )
+        {
+        InformObserversL( CIptvSmEvent::EServiceAdded, serviceId, &aService );
+        }
+
+    if ( sendServiceModifiedEvent )
+        {
+        InformObserversL( CIptvSmEvent::EServiceModified, aService.GetId(), &aService );
+        }
+
+    if ( sendServiceScheduledEvent )
+        {
+        InformObserversL( CIptvSmEvent::EServiceScheduleModified, aService.GetId(), &aService );
+        }
+
+    if ( sendServiceSelectionModifiedEvent )
+        {
+        InformObserversL( CIptvSmEvent::EServiceSelectionModified, aService.GetId(), &aService );
+        }
+
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::AddOrUpdateServiceL() exit");
+    }
+
+#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+// -----------------------------------------------------------------------------
+// CIptvServiceManager::UpdateVideoStoreSpaceDbL()
+// Updates Video Store Service to active space database.
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManager::UpdateVideoStoreSpaceDbL( CIptvService& aService )
+    {
+    if ( !iActiveSpaceHelper )
+        {
+        User::Leave( KErrNotFound );
+        }
+
+    IPTVLOGSTRING_LOW_LEVEL( "IptvUiEngine ## CIptvServiceManager::UpdateSpaceDb() - Enter" );
+
+    CActiveSpaceBase* activeSpace = iActiveSpaceHelper->NewActiveSpaceL();
+    CleanupStack::PushL( activeSpace );
+    IPTVLOGSTRING_LOW_LEVEL( "IptvUiEngine ## CIptvServiceManager::UpdateSpaceDb() - CActiveSpace Created" );
+
+    // Create item to 6th category as Video Store.
+    TActiveSpaceDataProperties serviceProperties;
+    serviceProperties.iGenre = EActiveSpaceGenreWatch;
+    serviceProperties.iSource = EActiveSpaceSourceLocal;
+    serviceProperties.iOwner = EActiveSpaceOwnerCommercial;
+    serviceProperties.iFlags = EActiveSpaceFlagNone;
+    serviceProperties.iCategory = EActiveSpaceCategory6th;
+
+    // Create parent
+    CActiveSpaceDataBase* parentData = iActiveSpaceHelper->NewActiveSpaceDataL();
+    CleanupStack::PushL( parentData );
+    IPTVLOGSTRING_LOW_LEVEL( "IptvUiEngine ## CIptvServiceManager::UpdateVideoStoreSpaceDbL() - CActiveSpaceData Parent Created" );
+    parentData->SetParent( CActiveSpaceDataBase::EActiveSpaceRoot );		
+    parentData->SetName( EVideoTileNokiaVideoShop );
+    parentData->SetProperties( serviceProperties );
+
+    if ( ( aService.GetIconPath().Length() > KIptvMaxLengthOfEmptyThumbPath ) &&
+         BaflUtils::FileExists( iFsSession, aService.GetIconPath() ) )
+        {
+        parentData->SetIconL( aService.GetIconPath() );
+        IPTVLOGSTRING_LOW_LEVEL( "IptvUiEngine ## CIptvServiceManager::UpdateVideoStoreSpaceDbL() - Icon added" );
+        }
+    else
+        {
+        parentData->SetIcon( EAspaLogicalIconVideoTileDefault );
+        IPTVLOGSTRING_LOW_LEVEL( "IptvUiEngine ## CIptvServiceManager::UpdateVideoStoreSpaceDbL() - Default icon added" );
+        }
+
+    TInt parentId = activeSpace->AddDataL( parentData, CActiveSpaceDataBase::EActiveSpaceRoot );   	  
+    IPTVLOGSTRING_LOW_LEVEL("IptvUiEngine ## CIptvServiceManager::UpdateVideoStoreSpaceDbL() - Parent data added");  
+
+    if ( parentId > 0 )          // No error
+        {
+        // Create child
+        CActiveSpaceDataBase* childData = iActiveSpaceHelper->NewActiveSpaceDataL();
+        CleanupStack::PushL( childData );  
+        childData->SetParent( parentId );
+        childData->SetName( EVideoTileNokiaVideoShopAd );
+        serviceProperties.iCategory = EActiveSpaceCategory1st;
+        childData->SetProperties( serviceProperties );
+	    TInt childId = activeSpace->AddDataL( childData, parentId );
+	    IPTVLOGSTRING_LOW_LEVEL("IptvUiEngine ## CIptvServiceManager::UpdateVideoStoreSpaceDbL() - Child data added");
+	
+        CASpaAppLauncherActionDataBase* serviceData = iActiveSpaceHelper->NewAppLauncherActionDataL();
+	    CleanupStack::PushL( serviceData );
+
+	    TUid videoCenterAppUid = KIptvMain;
+	    TUid vodPlayerUid = TUid::Uid( KIptvVodStartPlayer );
+	
+        TIptvActivationMessage params;
+		params.iMsgType = TIptvActivationMessage::EOpenVideoShop;
+		params.iMsgSender = TIptvActivationMessage::EActiveSpace;
+		params.iFileId = 0;
+		params.iDrive = 0;
+		TPckg<TIptvActivationMessage> paramsPckg( params );
+	
+	    serviceData->SetApplicationUid( videoCenterAppUid );
+	    serviceData->SetApaLaunchingMethod(
+	        CASpaAppLauncherActionDataBase::
+            EApaLaunchMethodStartApaMessageWithTail );               
+	    serviceData->SetAdditionalDataL( paramsPckg );                 
+	    serviceData->SetMessageUid( vodPlayerUid );	
+	    
+	    const TInt KCASpaAppLauncherPlugin = 0x10282E5F;
+	    TUid AppLauncherPlugin( TUid::Uid( KCASpaAppLauncherPlugin ) );
+
+	    CActiveSpaceActionBase* serviceAction = iActiveSpaceHelper->NewActiveSpaceActionL();
+	    CleanupStack::PushL( serviceAction );
+
+	    serviceAction->SetType( EActiveSpaceActionTypeLaunchApplication );
+	    serviceAction->SetActionHandlerUid( TUid::Uid( KCASpaAppLauncherPlugin ) );	
+	    serviceAction->SetKeys( EActiveSpaceActionKeySelect );
+	    serviceAction->SetDataL( serviceData->GetBufferL() );
+		
+	    IPTVLOGSTRING_LOW_LEVEL("IptvUiEngine ## CIptvServiceManager::UpdateVideoStoreSpaceDbL() - CActiveSpaceAction Object Created"); 									
+										
+	    TInt actionId = activeSpace->AddActionL( serviceAction );
+	    activeSpace->BindActionToDataL( parentId, actionId );
+	    IPTVLOGSTRING_LOW_LEVEL("IptvUiEngine ## CIptvServiceManager::UpdateVideoStoreSpaceDbL() - Action binded");
+	
+	    CleanupStack::PopAndDestroy( serviceAction );
+	    CleanupStack::PopAndDestroy( serviceData );                        
+	    CleanupStack::PopAndDestroy( childData );
+	    }
+	CleanupStack::PopAndDestroy( parentData );	
+	CleanupStack::PopAndDestroy( activeSpace );
+
+	IPTVLOGSTRING_LOW_LEVEL("IptvUiEngine ## CIptvServiceManager::UpdateVideoStoreSpaceDbL() - Exit");
+	}
+#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::GetServicesL()
+// Get services from databases.
+// ---------------------------------------------------------------------------
+//
+CIptvServices* CIptvServiceManager::GetServicesL(
+    TUint32 aSearchLimitFlags,
+    CIptvServiceManagementClient::TOrder aOrder,
+    TInt aVersion )
+    {
+    IPTVLOGSTRING_LOW_LEVEL( "CIptvServiceManager::GetServicesL(aSearchLimitFlags, aOrder)" );
+
+    OpenL();
+    CleanupClosePushL( *this ); // 1->
+
+    CIptvServices* services = CIptvServices::NewL();
+    CleanupStack::PushL( services ); // 2->
+    
+    IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManager:: Search limit flags: %d", aSearchLimitFlags );	
+
+    TInt32 epgPluginUid, vodPluginUid, iptvPluginUid, applicationUid;
+    TUint32 id, flags, displayOrder;
+    TPtrC name, address, iconPath, providerId, accountManagementUrl, iapName;
+    TPtrC8 iapList;
+    TUint32 dlNetwork( 0 );
+    TUint32 dlTime( 0 );
+    TUint32 dlType( 0 );
+    TUint32 groupId( 0 );
+    TTime lastScheduledDlTime;
+    TUint8 type;
+    TUint8 useCategory( 0 );
+    TPtrC uploadProvider, iconUrl;
+    TBuf<KIptvSmServicesDbDescMaxLength> desc;
+    TTime epgUpdateTime;
+    
+    CIptvService* iptvService;
+    iptvService = CIptvService::NewL();
+    CleanupStack::PushL( iptvService ); // 3->
+
+    RDbView view;    // Create a view on the database
+
+/*
+SELECT "column_name"
+FROM "table_name"
+[WHERE "condition"]
+ORDER BY "column_name" [ASC, DESC]
+*/
+    const TInt32 KIptvSmServiceManagerSelectCmdLength = 32 + 20;
+    _LIT( KIptvSmSelectCmdFirstPart, "SELECT * FROM Services ORDER BY " );
+    _LIT( KIptvSmSelectCmdDateAsc, "Date ASC" );
+    _LIT( KIptvSmSelectCmdDateDescending, "Date DESC" );
+    _LIT( KIptvSmSelectCmdDisplayOrderAsc, "DisplayOrder ASC" );
+    _LIT( KIptvSmSelectCmdDisplayOrderDescending, "DisplayOrder DESC" );
+    
+    TBuf<KIptvSmServiceManagerSelectCmdLength> selectCmd;
+    
+    _LIT( KDesDesFormat, "%S%S" );
+    
+    switch ( aOrder )
+        {
+        case CIptvServiceManagementClient::EDateAscending:
+            selectCmd.Format( KDesDesFormat,
+                             &KIptvSmSelectCmdFirstPart,
+                             &KIptvSmSelectCmdDateAsc); 
+            break;
+        case CIptvServiceManagementClient::EDateDescending:
+            selectCmd.Format( KDesDesFormat, 
+                             &KIptvSmSelectCmdFirstPart,
+                             &KIptvSmSelectCmdDateDescending); 
+            break;
+        case CIptvServiceManagementClient::EDisplayOrderAscending:
+            selectCmd.Format( KDesDesFormat,
+                             &KIptvSmSelectCmdFirstPart,
+                             &KIptvSmSelectCmdDisplayOrderAsc); 
+            break;
+        case CIptvServiceManagementClient::EDisplayOrderDescending:
+            selectCmd.Format( KDesDesFormat,
+                             &KIptvSmSelectCmdFirstPart,
+                             &KIptvSmSelectCmdDisplayOrderDescending); 
+            break;
+            
+        default:
+            User::Leave( KErrArgument );
+        }
+             
+    User::LeaveIfError( view.Prepare( iServicesDb, TDbQuery( selectCmd, EDbCompareFolded ) ) );
+    User::LeaveIfError( view.EvaluateAll() );
+    CDbColSet* colSet = view.ColSetL();
+    CleanupStack::PushL( colSet ); // 4->
+    
+    for ( view.FirstL(); view.AtRow(); view.NextL() )
+        {
+        desc.Zero();
+        view.GetL();
+
+        //set variables and set pointers to point to db items
+        id = view.ColUint32( colSet->ColNo( KIptvSmServicesDbIdCol ) );
+        name.Set( view.ColDes( colSet->ColNo( KIptvSmServicesDbNameCol ) ) );
+        address.Set( view.ColDes( colSet->ColNo( KIptvSmServicesDbAddressCol ) ) );
+        iconPath.Set( view.ColDes( colSet->ColNo( KIptvSmServicesDbIconPathCol ) ) );        
+        epgPluginUid = view.ColInt32( colSet->ColNo( KIptvSmServicesDbEpgPluginUidCol ) );
+        vodPluginUid = view.ColInt32( colSet->ColNo( KIptvSmServicesDbVodPluginUidCol ) );
+        iptvPluginUid = view.ColInt32( colSet->ColNo( KIptvSmServicesDbIptvPluginUidCol ) );
+        type = view.ColUint8( colSet->ColNo( KIptvSmServicesDbTypeCol ) );
+        iapList.Set( view.ColDes8( colSet->ColNo( KIptvSmServicesDbIapListCol ) ) );
+        
+        TDbColNo descrColNo = colSet->ColNo( KIptvSmServicesDbDescCol );
+        RDbColReadStream readStream; // A stream object for long columns
+        readStream.OpenLC( view,descrColNo ); // 5->
+        readStream.ReadL( desc, view.ColLength( descrColNo ) );
+        readStream.Close();
+        CleanupStack::Pop(); // <-5
+				
+        //date not needed
+
+        flags = view.ColUint32( colSet->ColNo( KIptvSmServicesDbFlagsCol ) );
+        applicationUid = view.ColInt32( colSet->ColNo( KIptvSmServicesDbApplicationUidCol ) );
+        displayOrder = view.ColUint32( colSet->ColNo( KIptvSmServicesDbDisplayOrderCol ) );
+        providerId.Set( view.ColDes( colSet->ColNo( KIptvSmServicesDbProviderIdCol ) ) );
+        accountManagementUrl.Set( view.ColDes( colSet->ColNo( KIptvSmServicesDbAccountManagementUrlCol ) ) );
+        TInt colNum = colSet->ColNo( KIptvSmServicesDbEpgUpdateTimeCol );
+        
+        if ( aVersion >= 2 || aVersion == 0 )
+            {
+            epgUpdateTime = view.ColTime( colNum );
+            iapName.Set( view.ColDes( colSet->ColNo( KIptvSmServicesDbIapNameCol ) ) );
+            
+            delete iSearchUrl;
+            iSearchUrl = NULL;
+            TDbColNo searchUrlColNo = colSet->ColNo( KIptvSmServicesDbSearchUrlCol );
+            iSearchUrl = HBufC::NewL( view.ColLength( searchUrlColNo ) );
+            RDbColReadStream readStream;
+            readStream.OpenLC( view, searchUrlColNo ); // 6->
+            TPtr searchUrlPtr( iSearchUrl->Des() );
+            readStream.ReadL( searchUrlPtr, view.ColLength( searchUrlColNo ) );
+            readStream.Close();
+            CleanupStack::Pop(); // <-6
+
+            dlNetwork = view.ColUint32( colSet->ColNo( KIptvSmServicesDbScheduledDlNetworkCol ) );
+            dlTime = view.ColUint32( colSet->ColNo( KIptvSmServicesDbScheduledDlTimeCol ) );
+            dlType = view.ColUint32( colSet->ColNo( KIptvSmServicesDbScheduledDlTypeCol ) );
+            lastScheduledDlTime = view.ColTime( colSet->ColNo( KIptvSmServicesDbLastScheduledDlTime ) );
+            }
+            
+        if ( aVersion >= 3 || aVersion == 0 )
+            {
+            groupId = view.ColUint32( colSet->ColNo( KIptvSmServicesDbGroupIdCol ) );
+            useCategory = view.ColUint8( colSet->ColNo( KIptvSmServicesDbUseCategoryCol ) );
+            uploadProvider.Set( view.ColDes( colSet->ColNo( KIptvSmServicesDbUploadProviderCol ) ) );
+            iconUrl.Set( view.ColDes( colSet->ColNo( KIptvSmServicesDbIconUrlCol ) ) );
+
+            TDbColNo recordUrlColNo = colSet->ColNo( KIptvSmServicesDbRecordUrlCol );
+            delete iRecordUrl;
+            iRecordUrl = NULL;
+            iRecordUrl = HBufC::NewL( view.ColLength( recordUrlColNo ) );
+
+            RDbColReadStream readStreamRec;
+            readStreamRec.OpenLC( view, recordUrlColNo ); // 6-> 
+            TPtr recordUrlPtr( iRecordUrl->Des() );
+            readStreamRec.ReadL( recordUrlPtr, view.ColLength( recordUrlColNo ) );
+            readStreamRec.Close();
+            CleanupStack::Pop(); // <-6
+            }
+        
+        //construct CIptvService object using set methods
+        iptvService->SetId( id );
+        iptvService->SetName( name );
+        iptvService->SetAddress( address );
+        iptvService->SetIconPath( iconPath );        
+
+        TUid uid;
+        uid.iUid = epgPluginUid;
+        iptvService->SetEpgPluginUid( uid );
+        uid.iUid = vodPluginUid;
+        iptvService->SetVodPluginUid( uid );        
+        uid.iUid = iptvPluginUid;
+        iptvService->SetIptvPluginUid( uid );
+        iptvService->SetType( ( CIptvService::TServiceType)type );
+
+        //set IAP list        
+        RDesReadStream readStreamIap;
+        readStreamIap.Open( iapList );
+        CleanupClosePushL( readStreamIap ); // 6->
+        iptvService->iIapList->InternalizeL( readStreamIap );
+        CleanupStack::PopAndDestroy( &readStreamIap ); // <-6
+        
+        iptvService->SetDesc( desc );
+        iptvService->SetFlags( flags );
+        iptvService->SetApplicationUid( applicationUid );
+        iptvService->SetDisplayOrder( displayOrder );
+        iptvService->SetProviderId( providerId );
+        iptvService->SetAccountManagementUrl( accountManagementUrl );
+        
+        if ( aVersion >= 2 || aVersion == 0 )
+            {
+            iptvService->SetEpgUpdateTimeL( epgUpdateTime );
+            iptvService->SetIapNameL( iapName );
+
+            TPtr searchUrlPtr( iSearchUrl->Des() );
+            iptvService->SetSearchUrlL( searchUrlPtr );
+            delete iSearchUrl;
+            iSearchUrl = NULL;
+            iptvService->SetScheduleDlNetwork( dlNetwork );
+            iptvService->SetScheduleDlTime( dlTime );
+            iptvService->SetScheduleDlType( dlType );
+            iptvService->SetScheduledLastDownloadTime( lastScheduledDlTime );
+            }
+                
+        if ( aVersion >= 3 || aVersion == 0 )
+            {
+            iptvService->SetGroupId( groupId );
+            iptvService->SetUseCategory( useCategory );
+            iptvService->SetUploadProvider( uploadProvider );
+            iptvService->SetIconUrl( iconUrl );
+            TPtr recordUrlPtr( iRecordUrl->Des() );
+            iptvService->SetRecordUrlL( recordUrlPtr );
+            delete iRecordUrl;
+            iRecordUrl = NULL; 
+            }
+
+        // Copy service to services if limit flags allow, get stuff from Password db too
+        if ( IsServiceIncludedInSearch( aSearchLimitFlags, *iptvService ) )
+            {
+            TIptvSmPassword password;            
+            TRAPD(err, GetPasswordL(iptvService->GetId(), password));
+            
+            if ( err != KErrNone )
+                {
+                IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: could not get password, using empty descriptor!");
+                iptvService->SetPassword( KIptvEmptyDes );
+                iptvService->SetUserName( KIptvEmptyDes );
+                }
+            else
+                {
+                iptvService->SetPassword( password.iPassword );
+                iptvService->SetUserName( password.iUserName );                        
+                }
+            
+            services->AddL( *iptvService );
+            }
+
+        } //for(
+
+    view.Close();
+
+    CleanupStack::PopAndDestroy( colSet );     //<-4
+    CleanupStack::PopAndDestroy( iptvService );//<-3
+    CleanupStack::Pop( services );             //<-2 ownership moves to caller
+    CleanupStack::PopAndDestroy( this );       //<-1
+    
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::GetServicesL(aSearchLimitFlags, aOrder) exit");
+    return services;
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::GetServicesUsingIdL()
+// Get services from the database using index search.
+// ---------------------------------------------------------------------------
+//
+CIptvServices* CIptvServiceManager::GetServicesUsingIdL(
+    TUint32 aStartId,
+    TUint32 aEndId,
+    TBool aDoOpenClose)
+    {	    
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::GetServicesUsingIdL(aStartId, aEndId)");
+	
+	if ( aDoOpenClose )
+        {
+	    OpenL();
+	    CleanupClosePushL( *this ); // 1->
+        }
+        	  
+    TUint i;
+    RDbTable rowset;
+    TDbSeekKey seekKey;
+
+    TInt err( rowset.Open(iServicesDb, KIptvSmServicesTable, rowset.EReadOnly ) );		
+    if ( err != KErrNone )
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::GetServicesL(aStartId, aEndId, aResultArray) Can't open service DB, aborting!!!");
+        User::Leave( err );
+        }
+    
+    CleanupClosePushL( rowset ); // 2->
+    err = rowset.SetIndex( KIptvSmServicesDbIndexName );
+    if ( err != KErrNone )
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::GetServicesL(aStartId, aEndId, aResultArray) Can't use index, aborting!!!");
+        User::Leave( err );
+        }
+
+    IPTVLOGSTRING3_LOW_LEVEL("CIptvServiceManager:: startId = %d, endId = %d", aStartId, aEndId);
+    CDbColSet* colSet = rowset.ColSetL();
+    CleanupStack::PushL( colSet ); // 3->
+    
+    TInt idColumnNo                   = colSet->ColNo( KIptvSmServicesDbIdCol );
+    TInt nameColumnNo                 = colSet->ColNo( KIptvSmServicesDbNameCol );
+    TInt addressColumnNo              = colSet->ColNo( KIptvSmServicesDbAddressCol );
+    TInt iconPathColumnNo             = colSet->ColNo( KIptvSmServicesDbIconPathCol );
+    TInt epgPluginUidColumnNo         = colSet->ColNo( KIptvSmServicesDbEpgPluginUidCol );
+    TInt vodPluginUidColumnNo         = colSet->ColNo( KIptvSmServicesDbVodPluginUidCol );
+    TInt iptvPluginUidColumnNo        = colSet->ColNo( KIptvSmServicesDbIptvPluginUidCol );
+    TInt typeColumnNo                 = colSet->ColNo( KIptvSmServicesDbTypeCol );
+    TInt iapListColumnNo              = colSet->ColNo( KIptvSmServicesDbIapListCol );
+    TInt descColumnNo                 = colSet->ColNo( KIptvSmServicesDbDescCol );
+    TInt flagsColumnNo                = colSet->ColNo( KIptvSmServicesDbFlagsCol );
+    TInt applicationUidColumnNo       = colSet->ColNo( KIptvSmServicesDbApplicationUidCol );
+    TInt displayOrderColumnNo         = colSet->ColNo( KIptvSmServicesDbDisplayOrderCol );
+    TInt providerIdColumnNo           = colSet->ColNo( KIptvSmServicesDbProviderIdCol );
+    TInt accountManagementUrlColumnNo = colSet->ColNo( KIptvSmServicesDbAccountManagementUrlCol );
+    TInt epgUpdateTimeColumnNo        = colSet->ColNo( KIptvSmServicesDbEpgUpdateTimeCol );
+    TInt iapNameColumnNo              = colSet->ColNo( KIptvSmServicesDbIapNameCol );
+    TInt searchUrlColumnNo            = colSet->ColNo( KIptvSmServicesDbSearchUrlCol );
+    TInt dlNetworklColumnNo           = colSet->ColNo( KIptvSmServicesDbScheduledDlNetworkCol );
+    TInt dlTimeColumnNo               = colSet->ColNo( KIptvSmServicesDbScheduledDlTimeCol );
+    TInt dlTypeColumnNo               = colSet->ColNo( KIptvSmServicesDbScheduledDlTypeCol );
+    TInt dlLastTimeColumnNo           = colSet->ColNo( KIptvSmServicesDbLastScheduledDlTime );
+    TInt groupIdColumnNo              = colSet->ColNo( KIptvSmServicesDbGroupIdCol );
+    TInt useCatColumnNo               = colSet->ColNo( KIptvSmServicesDbUseCategoryCol );
+    TInt uploadColumnNo               = colSet->ColNo( KIptvSmServicesDbUploadProviderCol );
+    TInt iconUrlColumnNo              = colSet->ColNo( KIptvSmServicesDbIconUrlCol );
+    TInt recordUrlColumnNo            = colSet->ColNo(KIptvSmServicesDbRecordUrlCol);
+
+    CleanupStack::PopAndDestroy( colSet ); // <-3
+    CIptvServices* services = CIptvServices::NewL();
+    CleanupStack::PushL( services ); // 3->
+
+    CIptvService* service = CIptvService::NewL();
+    CleanupStack::PushL( service ); // 4->
+	
+    for ( i = aStartId; i <= aEndId; i++ )
+        {
+        seekKey = i;
+		
+        // Search the index
+        if ( rowset.SeekL( seekKey ) )
+            {
+            TUid uid;
+
+            rowset.GetL();
+            service->SetId( rowset.ColUint32( idColumnNo ) );
+            service->SetName( rowset.ColDes( nameColumnNo ) );
+            service->SetAddress( rowset.ColDes( addressColumnNo ) );
+            service->SetIconPath( rowset.ColDes( iconPathColumnNo ) );
+
+      	    uid.iUid = rowset.ColInt32( epgPluginUidColumnNo );
+            service->SetEpgPluginUid( uid );
+            uid.iUid = rowset.ColInt32( vodPluginUidColumnNo );
+            service->SetVodPluginUid( uid );
+            uid.iUid = rowset.ColInt32( iptvPluginUidColumnNo );
+            service->SetIptvPluginUid( uid );
+
+            service->SetType( ( CIptvService::TServiceType )( rowset.ColUint8( typeColumnNo ) ) );
+            
+            //set IAP-list
+            RDesReadStream readStreamIap;
+            readStreamIap.Open(rowset.ColDes8( iapListColumnNo ) );
+            CleanupClosePushL( readStreamIap ); // 5->
+            service->iIapList->InternalizeL( readStreamIap );
+            CleanupStack::PopAndDestroy( &readStreamIap ); // <-5
+                        
+            TBuf<KIptvSmServicesDbDescMaxLength> desc;
+            RDbColReadStream readStream;       // A stream object for long columns
+            readStream.OpenLC( rowset,descColumnNo ); // 5->
+            readStream.ReadL( desc, rowset.ColLength( descColumnNo ) );
+            CleanupStack::PopAndDestroy( &readStream ); // <-5
+
+            service->SetDesc( desc );
+
+            service->SetFlags(rowset.ColUint32( flagsColumnNo ) );
+            service->SetApplicationUid( rowset.ColInt32( applicationUidColumnNo ) );
+            service->SetDisplayOrder( rowset.ColUint32( displayOrderColumnNo ) );
+            service->SetProviderId( rowset.ColDes( providerIdColumnNo ) );
+            service->SetAccountManagementUrl( rowset.ColDes( accountManagementUrlColumnNo ) );
+            service->SetEpgUpdateTimeL( rowset.ColTime( epgUpdateTimeColumnNo ) );
+            service->SetIapNameL( rowset.ColDes( iapNameColumnNo ) );
+
+            delete iSearchUrl;
+            iSearchUrl = NULL;
+            iSearchUrl = HBufC::NewL( rowset.ColLength( searchUrlColumnNo ) );
+            TPtr searchUrlPtr( iSearchUrl->Des() );
+            readStream.OpenLC( rowset, searchUrlColumnNo ); // 5->
+            readStream.ReadL( searchUrlPtr, rowset.ColLength( searchUrlColumnNo ) );
+            CleanupStack::PopAndDestroy( &readStream ); // <-5
+            service->SetSearchUrlL( searchUrlPtr );
+            delete iSearchUrl;
+            iSearchUrl = NULL;
+            
+            service->SetScheduleDlNetwork( rowset.ColUint32( dlNetworklColumnNo ) );
+            service->SetScheduleDlTime( rowset.ColUint32( dlTimeColumnNo ) );
+            service->SetScheduleDlType( rowset.ColUint32( dlTypeColumnNo ) );
+            service->SetScheduledLastDownloadTime( rowset.ColTime( dlLastTimeColumnNo ) );
+
+            service->SetGroupId( rowset.ColUint32( groupIdColumnNo ) );
+            service->SetUseCategory( ( CIptvService::TServiceType )( rowset.ColUint8( useCatColumnNo ) ) );
+            service->SetUploadProvider( rowset.ColDes( uploadColumnNo ) );
+            service->SetIconUrl( rowset.ColDes( iconUrlColumnNo ) );
+
+            delete iRecordUrl;
+            iRecordUrl = NULL;
+            iRecordUrl = HBufC::NewL( rowset.ColLength(recordUrlColumnNo) );
+            TPtr recordUrlPtr( iRecordUrl->Des() );
+            readStream.OpenLC(rowset, recordUrlColumnNo); // 5->
+            readStream.ReadL(recordUrlPtr, rowset.ColLength(recordUrlColumnNo));
+            CleanupStack::PopAndDestroy(&readStream); // <-5
+            service->SetRecordUrlL( recordUrlPtr );
+            delete iRecordUrl;
+            iRecordUrl = NULL;
+            
+            //get password and user name from Passwords DB
+            TIptvSmPassword password;
+            TRAP( err, GetPasswordL( service->GetId(), password ) )
+            if ( err != KErrNone )
+                {
+                IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: Couldn't get password, using empty descriptor");
+                service->SetUserName(KIptvEmptyDes);
+                service->SetPassword(KIptvEmptyDes);
+                }
+            else
+                {
+                service->SetUserName( password.iUserName );
+                service->SetPassword( password.iPassword );
+                }
+                
+            services->AddL( *service );
+            }
+        else
+            {
+            /* was not found, that's ok, there might be gaps in indexes */
+            }
+
+        if ( i == 0xffffffff )
+            {
+            //this is necessarry since 0xffffffff + 0x01 = 0x00 -> for loop gets messed.
+            break; //break from for()
+            }
+
+        } //for()
+	
+    CleanupStack::PopAndDestroy( service ); // <-4	
+    CleanupStack::Pop( services );          // <-3 ownership moves to caller
+    CleanupStack::PopAndDestroy( &rowset ); // <-2
+
+	if ( aDoOpenClose )
+        {
+        CleanupStack::PopAndDestroy( this ); // <-1
+        }
+            
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::GetServicesUsingIdL(aStartId, aEndId) exit");
+
+    return services;
+    }
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::DeleteServiceL()
+//
+// Delete a service using id and RDbUpdate (DML)
+// ---------------------------------------------------------------------------
+TInt CIptvServiceManager::DeleteServiceL( TUint32 aId )
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::DeleteServiceL()");
+    
+    OpenL();
+
+    CompactDatabases();
+            
+    const TInt KIptvSmIdDesMaxSize = 20;
+    TBuf<KIptvSmIdDesMaxSize> idDes;
+    idDes.Zero();
+    idDes.Num(aId);
+
+    IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManager:: idDes = %S", &idDes);
+    
+    _LIT(KIptvSmSqlDeleteCmd, "DELETE FROM %S WHERE %S = ");
+               	
+    // Sql: DELETE FROM Services WHERE %S LIKE 'aId'
+    TBuf<KIptvSmCustomSqlMaxLength+KIptvSmIdDesMaxSize> sqlStr;
+    sqlStr.Format(KIptvSmSqlDeleteCmd, 
+                  &KIptvSmServicesTable,
+                  &KIptvSmServicesDbIdCol);
+
+    sqlStr.Append(idDes);
+
+    TInt servicesDbDeleteError = ExecuteSqlCmd(sqlStr, iServicesDb);
+
+    sqlStr.Format(KIptvSmSqlDeleteCmd, 
+                  &KIptvSmPasswordsTable,
+                  &KIptvSmPasswordsDbIdCol);
+
+    sqlStr.Append(idDes);
+
+    TInt passwordsDbDeleteError = ExecuteSqlCmd(sqlStr, iPasswordsDb);
+    
+    Close();
+    
+    InformObserversL(CIptvSmEvent::EServiceDeleted, aId, NULL);
+
+    TInt error = KErrNone;
+        
+    if(servicesDbDeleteError != KErrNone)
+        {
+        IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManager:: error in deleting from Services db: %d", servicesDbDeleteError);
+        error = servicesDbDeleteError;
+        }
+    if(passwordsDbDeleteError != KErrNone)
+        {
+        IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManager:: error in deleting from Passwords db: %d", passwordsDbDeleteError);
+        error = passwordsDbDeleteError;
+        }
+
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::DeleteServiceL() exit");
+    return error;
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::IsServiceIncludedInSearch()
+//
+// Decides if the service is included in the search. 
+// ---------------------------------------------------------------------------
+//
+TBool CIptvServiceManager::IsServiceIncludedInSearch(
+    TUint32 aSearchLimitFlags,
+    CIptvService& aIptvService ) const
+    {
+        
+    if ( aSearchLimitFlags == 0 )
+        {
+        return ETrue;
+        }
+        
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::ESelectedServices ) &&
+        !( aIptvService.GetFlags() & CIptvService::ESelected ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EMainServices ) &&
+        !( aIptvService.GetFlags() & CIptvService::EMainService ) )
+        {
+        return EFalse;
+        }
+            
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::ESubServices ) &&
+         ( aIptvService.GetFlags() & CIptvService::EMainService ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EVod ) &&
+         ( aIptvService.GetType() != CIptvService::EVod ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EVodCast ) &&
+         ( aIptvService.GetType() != CIptvService::EVodCast ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::ELiveTv ) &&
+         ( aIptvService.GetType() != CIptvService::ELiveTv ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EBrowser ) &&
+         ( aIptvService.GetType() != CIptvService::EBrowser ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EVideoRemote ) &&
+         ( aIptvService.GetType() != CIptvService::EVideoRemote ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EApplication ) &&
+         ( aIptvService.GetType() != CIptvService::EApplication ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EMobileTv ) &&
+         ( aIptvService.GetType() != CIptvService::EMobileTv ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EVodServices ) &&
+         ( aIptvService.GetType() != CIptvService::EVod ) &&
+         ( aIptvService.GetType() != CIptvService::EVodCast ) &&
+         ( aIptvService.GetType() != CIptvService::EServiceGroup ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EServiceGroup ) &&
+         ( aIptvService.GetType() != CIptvService::EServiceGroup ||
+           aIptvService.GetGroupId() == 0 ) )
+        {
+        return EFalse;
+        }
+    
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EGroupedServices ) &&
+       ( !( aIptvService.GetFlags() & CIptvService::EGroupedService ) ||
+           aIptvService.GetGroupId() == 0 ) )
+        {
+        return EFalse;
+        }
+
+    if ( ( aSearchLimitFlags & CIptvServiceManagementClient::EOther ) &&
+         ( aIptvService.GetType() != CIptvService::EOther ) )
+        {
+        return EFalse;
+        }
+        
+    return ETrue;
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::GetServiceL()
+// ---------------------------------------------------------------------------
+//
+CIptvService* CIptvServiceManager::GetServiceL(
+    TUint32 aServiceId,
+    TBool aDoOpenClose )
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::GetServiceL()");
+
+    if ( aDoOpenClose )
+        {
+        OpenL();
+        CleanupClosePushL( *this ); // 1->
+        }
+        
+    CIptvServices* services = GetServicesUsingIdL( aServiceId, aServiceId, aDoOpenClose );
+    
+    CIptvService* service = NULL;
+
+    if ( services )
+        {
+        CleanupStack::PushL( services ); // 2->
+        
+        if ( services->Count() != 1 )
+            {
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: Could not get service data from Service Manager with ID: %x, returning NULL", aServiceId);
+            }
+        else
+            {    
+            service = services->GetServiceL( 0 );
+            }
+        
+        CleanupStack::PopAndDestroy( services ); //<-2
+        }
+        
+    if ( aDoOpenClose )
+        {
+        CleanupStack::PopAndDestroy( this ); //<-1
+        }
+            
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::GetServiceL() exit");            
+    return service;
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::RegisterObserver()
+// ---------------------------------------------------------------------------
+//
+TInt CIptvServiceManager::RegisterObserver(MIptvServiceManagerObserver* aObserver)
+    {
+    return iObservers.Append(aObserver);
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::DeRegisterObserver()
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::DeRegisterObserver(MIptvServiceManagerObserver* aObserver)
+    {
+    TInt i;
+    for(i = 0; i < iObservers.Count(); i++)
+        {
+        if(aObserver == iObservers[i])
+            {
+            iObservers.Remove(i);
+            return;
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::InformObserversL()
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::InformObserversL(
+    CIptvSmEvent::TEvent aEvent,
+    TUint32 aServiceId,
+    CIptvService* aService)
+    {
+    CIptvSmEvent* event = CIptvSmEvent::NewL();
+    CleanupStack::PushL(event); // 1->
+
+    event->iEvent = aEvent;
+    event->iServiceId = aServiceId;
+    event->iService = aService;
+
+    TInt i;
+    for ( i = 0; i < iObservers.Count(); i++ )
+        {
+        iObservers[i]->HandleSmEvent( *event );
+        }
+    CleanupStack::PopAndDestroy( event ); // <-1
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::GetServicesL()
+// ---------------------------------------------------------------------------
+//
+CIptvServices* CIptvServiceManager::GetServicesL(
+    const TDesC& aProviderId,
+    TBool aDoOpenClose)
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::GetServicesL(aProviderId)");
+
+    if ( aDoOpenClose )
+        {
+        OpenL();
+        CleanupClosePushL( *this ); // 1->
+        }
+    
+    // Create a view on the database    
+    RDbView view;
+
+    _LIT(KSelectCmdFormat, "SELECT ID FROM Services WHERE ProviderId = '%S' ORDER BY ID");
+    const TInt KSelectCmdFormatLength = 70;
+    TBuf<KIptvSmServicesDbProviderIdMaxLength + KSelectCmdFormatLength> selectCmd;
+    selectCmd.Format(KSelectCmdFormat, &aProviderId);
+    User::LeaveIfError(view.Prepare(iServicesDb, TDbQuery(selectCmd, EDbCompareFolded)));
+    User::LeaveIfError(view.EvaluateAll());
+
+    CDbColSet* colSet = view.ColSetL();
+    CleanupStack::PushL(colSet); // 2->
+    
+    CIptvService* service   = NULL;
+    CIptvServices* services = CIptvServices::NewL();
+    CleanupStack::PushL(services); // 3->
+    
+    TUint32 id;
+    for (view.FirstL(); view.AtRow(); view.NextL())
+        {
+        view.GetL();
+        id = view.ColUint32(colSet->ColNo(KIptvSmServicesDbIdCol));
+        IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: found ID: %d", id);
+        service = GetServiceL(id, aDoOpenClose);
+        if ( service )
+            {
+            CleanupStack::PushL(service); // 4->
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: got service for the id.");
+            TInt err = services->AddL(*service);
+            if(err == KErrNone)
+                {
+                IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: added to the list");
+                }
+            else
+                {
+                IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: failed to add to the list");
+                }
+            CleanupStack::PopAndDestroy(service); // <-4
+            service = NULL;
+            }
+        else
+            {
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: failed to get service for the ID");
+            }
+        }
+
+    view.Close();
+
+    CleanupStack::Pop(services);         // <-3
+    CleanupStack::PopAndDestroy(colSet); // <-2
+    
+    if (aDoOpenClose)
+        {
+        CleanupStack::PopAndDestroy(this); // <-1
+        }
+        
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::GetServicesL(aProviderId) exit");
+    return services;
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::GetPasswordL()
+// Databases are already open when this func is called
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::GetPasswordL( TUint32 aId, TIptvSmPassword& aPassword )
+    {    
+    RDbTable passwordsTable;
+    TDbSeekKey seekKey;
+    	
+    TInt err = passwordsTable.Open(iPasswordsDb, KIptvSmPasswordsTable, passwordsTable.EReadOnly);
+    if(err != KErrNone)
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Could not get passwords table, aborting!");
+        User::Leave(KErrGeneral);
+        }
+    CleanupClosePushL(passwordsTable); // 1->
+
+    err = passwordsTable.SetIndex(KIptvSmPasswordsDbIndexName);
+
+    if(err != KErrNone)
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: could not set index for password table");
+        User::Leave(err);
+        }
+
+    // Search the index
+    seekKey = (TUint)aId;
+    if(!passwordsTable.SeekL(seekKey))
+        {
+        IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: could not find id %d from passwords table", aId);
+        User::Leave(KErrNotFound);
+        }
+
+    passwordsTable.GetL();
+
+    CDbColSet* colSet = passwordsTable.ColSetL();
+    CleanupStack::PushL(colSet); // 2->
+    
+    aPassword.iUserName = passwordsTable.ColDes(colSet->ColNo(KIptvSmPasswordsDbUserNameCol));
+    aPassword.iPassword = passwordsTable.ColDes(colSet->ColNo(KIptvSmPasswordsDbPasswordCol));
+    
+    CleanupStack::PopAndDestroy(colSet);          // <-2
+    CleanupStack::PopAndDestroy(&passwordsTable); // <-1    
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::ExecuteSqlCmd()
+// ---------------------------------------------------------------------------
+//
+TInt CIptvServiceManager::ExecuteSqlCmd(const TDesC& aSqlCmd, RDbStoreDatabase& aDb)
+    {    
+    // Initialize execution and perform the first step.
+    // Note: Execute() returns 0 (=KErrNone), but it does not affect database
+    //       until Next() is called.
+    RDbUpdate updOp;
+    TInt incStat = updOp.Execute(aDb, aSqlCmd, EDbCompareFolded);
+    incStat = updOp.Next(); // This will leave, if Execute() failed.
+
+    while( incStat == 1 ) // Just in case, if the operation has more steps
+        {
+        incStat = updOp.Next();
+        }
+    updOp.RowCount();
+    updOp.Close();
+    return incStat;
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::ExecuteProvisioningL()
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::ExecuteProvisioningL()
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: doing provisioning");
+
+    TFileName servicesXmlFile;
+    TBool foundFile = EFalse;
+    TBool updateFound = EFalse;
+
+    //  Check if there is update file
+    foundFile = IsServiceUpdateFoundL(servicesXmlFile);
+    updateFound = foundFile;
+
+    if (!foundFile)
+        {
+        //  Update file not found, look service file from c-disk
+        servicesXmlFile.Zero();
+        servicesXmlFile.Append(KIptvSmCDiskPrefix);
+        servicesXmlFile.Append(iPrivatePath);
+        servicesXmlFile.Append(KIptvSmServicesXmlFile);
+                
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: looking xml-file from c-disk");
+        foundFile = BaflUtils::FileExists(iFsSession, servicesXmlFile);
+        }
+
+    if (!foundFile)
+        {
+        //  Wasn't on the c-disk, look service file from z-disk
+        servicesXmlFile.Zero();
+        servicesXmlFile.Append(KIptvSmZDiskPrefix);
+        servicesXmlFile.Append(iPrivatePath);
+        servicesXmlFile.Append(KIptvSmServicesXmlFile);
+                
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: looking xml-file from z-disk");
+        foundFile = BaflUtils::FileExists(iFsSession, servicesXmlFile);
+        }
+
+    if (foundFile)
+        {
+        //  Some file found, provision it
+        DoProvisioningL(servicesXmlFile);
+
+        //  Was it update file
+        if (updateFound)
+            {
+            //  Yes, remove it
+            iFsSession.Delete(servicesXmlFile);
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::IsServiceUpdateFoundL()
+// ---------------------------------------------------------------------------
+//
+TBool CIptvServiceManager::IsServiceUpdateFoundL(TFileName& aServicesXmlFile)
+    {
+    //  Look update file from c-disk
+    aServicesXmlFile.Zero();
+    aServicesXmlFile.Append(KIptvSmCDiskPrefix);
+    aServicesXmlFile.Append(iPrivatePath);
+    aServicesXmlFile.Append(KIptvSmServicesUpdateXmlFile);
+            
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: looking update xml-file from c-disk");
+
+    return BaflUtils::FileExists(iFsSession, aServicesXmlFile);
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::DoProvisioningL()
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::DoProvisioningL(const TDesC& aServicesXmlFile)
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::DoProvisioning()");
+
+    CIptvProvisioningProcessor* provisioningProcessor = CIptvProvisioningProcessor::NewL();
+    CleanupStack::PushL(provisioningProcessor); // 1->
+
+    CIptvServices* services = NULL;
+    TInt provisionError( KErrNone );
+    TRAPD(error, services = provisioningProcessor->LocalProvisionL(aServicesXmlFile, provisionError));
+    
+    if ( error == KErrNone && provisionError == KErrNone && services )
+        {
+        IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManager:: services got from xml-file: %d", services->Count());
+
+        CleanupStack::PushL(services); // 2->
+        TInt i;
+        for(i = 0; i < services->Count(); i++)
+            {
+            AddServiceL(services->GetServiceRefL(i), EFalse /* dont do open/close */);
+            }
+        CleanupStack::PopAndDestroy(services); // <-2
+        }
+    else
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager:: error while executing LocalProvisionL()");
+        }
+
+    CleanupStack::PopAndDestroy(provisioningProcessor); // <-1
+
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManager::DoProvisioning() exit");
+    }
+    
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::CreateWritableRootDirL
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::CreateWritableRootDirL(TDriveNumber aDrive)
+    {
+    //Create private writable root path to aDrive if it does not exist yet
+    TFileName rootPath;
+    TRAPD( err,
+           CIptvUtil::GetPathL( iFsSession, EIptvPathWritableRoot, rootPath, aDrive ) );
+		
+    if ( err != KErrNone ) 
+        {
+        if ( aDrive == EDriveC )
+            {
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Can't create writable root path to C:, panicing");	
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: system wide error code = %d", err);	
+            // This is fatal, we need this folder
+            User::Panic(KIptvServiceManager, EIptvSmCouldNotCreateWritableRootPath);
+            }
+        else
+            {
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: Can't create writable root path to E:, skipping");
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::CheckSmDbVersionL
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::CheckSmDbVersionL(void)
+    {         
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CheckSmDbVersionL() start");
+
+    TFileName smDbVersionFileName;
+    
+    smDbVersionFileName = KIptvSmCDiskPrefix;			
+    smDbVersionFileName.Append(iPrivatePath);
+    smDbVersionFileName.Append(KSmDbVersionFileName);
+
+    TUint32 dbVersion = 0;
+    RFile versionFile;
+
+    TInt err = versionFile.Open(iFsSession, smDbVersionFileName, EFileRead);
+    if (err == KErrNone)
+        {
+        const TInt KVersionLength = 4;
+        
+        TBuf8<KVersionLength> data;
+        err = versionFile.Read(data, KVersionLength);
+        versionFile.Close();
+        
+        if ( data.Length() == KVersionLength  && err == KErrNone )
+            {
+            dbVersion |= (data[0] << 24);
+            dbVersion |= (data[1] << 16);
+            dbVersion |= (data[2] << 8);
+            dbVersion |= data[3];
+            }
+        else
+            {
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: version file is corrupted -> 0 version assumed (= unknown format), err: %d", err);
+            }
+        }
+    
+    if ( dbVersion != 0 )
+        {
+        if ( dbVersion != KIptvSmDbVersion )
+            {
+            IPTVLOGSTRING3_HIGH_LEVEL("CIptvServiceManager:: db is version %d and sw is version %d -> doing db conversion!", dbVersion, KIptvSmDbVersion);
+            ConvertDatabaseL( dbVersion );
+            }
+        else
+            {
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: Both databases and sw are version %d", dbVersion);
+            }
+        }
+    else 
+        {
+        IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: db is version 0 (= unknown format), sw is version %d, deleting old databases.", KIptvSmDbVersion);
+        iFsSession.Delete(iServicesFile);
+        iFsSession.Delete(iPasswordsFile);
+        }
+        
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CheckSmDbVersionL() exit");
+    }        
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::SaveSmDbVersion
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::SaveSmDbVersion(void)
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::SaveSmDbVersion() start");
+
+    TFileName smDbVersionFileName;
+    
+    smDbVersionFileName = KIptvSmCDiskPrefix;			
+    smDbVersionFileName.Append(iPrivatePath);
+    smDbVersionFileName.Append(KSmDbVersionFileName);
+
+    RFile versionFile;
+    TInt err = versionFile.Replace(iFsSession, smDbVersionFileName, EFileWrite);
+    if (err == KErrNone)
+        {
+        TBuf8<4> versionDes;
+        versionDes.Append( static_cast<TUint8>( ( KIptvSmDbVersion >> 24 ) & 0x000000ff ) );
+        versionDes.Append( static_cast<TUint8>( ( KIptvSmDbVersion >> 16 ) & 0x000000ff ) );
+        versionDes.Append( static_cast<TUint8>( ( KIptvSmDbVersion >> 8 ) & 0x000000ff ) );
+        versionDes.Append( static_cast<TUint8>( KIptvSmDbVersion & 0x000000ff ) );
+        err = versionFile.Write(versionDes);
+        versionFile.Close();
+        if ( err == KErrNone )
+            {
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: version saved");    
+            }
+        else
+            {
+            IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: version file write FAILED: %d", err );
+            }
+        
+        }
+    else
+        {
+        IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: couldn't create %S file!", &KSmDbVersionFileName );
+        }
+        
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::SaveSmDbVersion() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::ConvertDatabaseL
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::ConvertDatabaseL( TInt aOldVersion )
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::ConvertDatabaseL() start");
+
+    //read old services
+    CIptvServices* oldDbServices = GetServicesL(
+        0 /* 0 = all services */,
+        CIptvServiceManagementClient::EDateAscending,
+        aOldVersion );
+    CleanupStack::PushL( oldDbServices ); // 1->
+
+    //delete old db
+    iFsSession.Delete( iServicesFile );
+    iFsSession.Delete( iPasswordsFile );
+
+    //create empty db files   
+    CreateFilesL( EFalse /* dont do provisioning */);
+    
+    //open db, does not execute provisioning since files are already created
+    OpenL();
+    CleanupClosePushL( *this ); // 2->
+
+    //write to new db
+    IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: %d services found for conversion", oldDbServices->Count());
+
+    for ( TInt i( 0 ); i < oldDbServices->Count(); i++ )
+        {
+        IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager:: converting %S", &(oldDbServices->GetServiceRefL(i).GetName()));
+        AddServiceL(oldDbServices->GetServiceRefL(i), EFalse /* dont do open/close */);
+        }
+    
+    ExecuteProvisioningL();
+    
+    CleanupStack::PopAndDestroy( this ); // <-2
+    CleanupStack::PopAndDestroy( oldDbServices ); // <-1
+         
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::ConvertDatabaseL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::AddService
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::AddServiceL( 
+    CIptvService& aService,
+    TBool aDoOpenClose )
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::AddServiceL() start");
+
+    if ( aDoOpenClose )
+        {
+        OpenL();
+        CleanupClosePushL( *this ); // 1->
+        }
+        
+    //find out mode (update or add)
+    TUint32 mode = 0;
+    if ( aService.GetProviderId() != KIptvEmptyDes )
+        {
+        CIptvServices* servicesAlready = GetServicesL(aService.GetProviderId(), EFalse /* Dont do open & close */);
+        CleanupStack::PushL(servicesAlready); // 2->
+        if ( servicesAlready->Count() > 0 )
+            {
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: found service with same provider id, using update mode");
+            mode = 0; //0 = update
+            aService.SetId(servicesAlready->GetServiceRefL(0).GetId()); //set id to correct value
+            }
+        else
+            {
+            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: provider id was unique, using add mode");
+            mode = EAddService;
+            }
+        CleanupStack::PopAndDestroy( servicesAlready ); // <-2
+        }
+    else
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: provider id was empty, using add mode");
+        mode = EAddService;
+        }
+                
+    mode |= EDontOpen;
+    
+    AddOrUpdateServiceL( aService, mode );
+
+#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+    // Provision Video Store service to Active Space.
+    if ( ( aService.GetName().CompareF( KQtnIptvVideoStoreList ) == 0 ) &&
+         ( aService.GetType() == CIptvService::EBrowser ) )
+        {
+        // Note; missing Active Space helper or leave in Active Space must
+        // not interrupt finishing of for example factory provisioning.
+        TRAP_IGNORE( UpdateVideoStoreSpaceDbL( aService ) );
+        }
+#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+
+    if ( aDoOpenClose )
+        {
+        CleanupStack::PopAndDestroy( this ); // <-1
+        }
+        
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::AddServiceL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::UpdateService
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::UpdateServiceL( CIptvService& aService )
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::UpdateServiceL() start");
+
+    AddOrUpdateServiceL( aService, 0 /* 0 = update */ );
+
+#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+    // Provision Video Store service to Active Space.
+    if ( ( aService.GetName().CompareF( KQtnIptvVideoStoreList ) == 0 ) &&
+         ( aService.GetType() == CIptvService::EBrowser ) )
+        {
+        TRAP_IGNORE( UpdateVideoStoreSpaceDbL( aService ) );
+        }
+#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)
+
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::UpdateServiceL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::CompactDatabases
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceManager::CompactDatabases()
+    {
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CompactDatabases() start");
+
+    if ( iCompactCounter == 0 )
+        {
+        IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager:: running compact for databases");
+        iServicesDb.Compact();
+        iPasswordsDb.Compact();
+        }
+
+    iCompactCounter++;
+
+    if ( iCompactCounter > KIptvSmServiceDbCompactingFrequency )
+        {
+        iCompactCounter = 0;
+        }
+
+    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManager::CompactDatabases() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceManager::MaxDisplayOrderL
+// ---------------------------------------------------------------------------
+//
+TUint32 CIptvServiceManager::MaxDisplayOrderL()
+    {
+    TUint32 maxDisplayOrder( 0 );
+
+    // Query "SELECT DisplayOrder FROM Services ORDER BY DisplayOrder DESC" to
+    // find highest DisplayOrder for moving updated service to top of list
+    _LIT( KMaxDisplayOrderQueryFormat, "SELECT %S FROM %S ORDER BY %S DESC" );
+    HBufC* maxDisplayOrderQueryBuf = HBufC::NewLC(
+            KMaxDisplayOrderQueryFormat().Length()
+            + KIptvSmServicesDbDisplayOrderCol().Length()
+            + KIptvSmServicesTable().Length()
+            + KIptvSmServicesDbDisplayOrderCol().Length() );
+    maxDisplayOrderQueryBuf->Des().Format(
+            KMaxDisplayOrderQueryFormat,
+            &KIptvSmServicesDbDisplayOrderCol,
+            &KIptvSmServicesTable,
+            &KIptvSmServicesDbDisplayOrderCol );
+
+    IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager::MaxDisplayOrder() query: %S", maxDisplayOrderQueryBuf);
+    
+    RDbView servicesView;
+    User::LeaveIfError( servicesView.Prepare(
+            iServicesDb,
+            TDbQuery( *maxDisplayOrderQueryBuf ) ) );
+    CleanupClosePushL( servicesView );
+    User::LeaveIfError( servicesView.EvaluateAll() );
+    
+    // First result has the highest DisplayOrder value
+    if ( servicesView.FirstL() )
+        {
+        servicesView.GetL();
+        maxDisplayOrder = servicesView.ColUint32( 1 );
+        IPTVLOGSTRING2_HIGH_LEVEL("CIptvServiceManager::MaxDisplayOrder() maxDisplayOrder: %d", maxDisplayOrder);
+        }
+
+    CleanupStack::PopAndDestroy( &servicesView );
+    CleanupStack::PopAndDestroy( maxDisplayOrderQueryBuf );
+
+    return maxDisplayOrder;
+    }