/*

* 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()