// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @internalTechnology

*/

#include <e32base.h>

#include <bautils.h>

#include "cmediasyncserver.h"

#include "cmediasyncserversession.h"

#include "cmediasyncobserver.h"

#include "cmediasyncserverdef.h"

__FLOG_STMT(_LIT8(KComponent, "MediaSyncServer");)

const TInt KMediaSyncFunctionCodeRanges[] = 

    {    

    EMediaSyncClientGetGSHHandle,

    EMediaSyncClientShutdown,

    EMediaSyncClientNotSupported,

    };

const TUint KMediaSyncFunctionCodeRangeCount = (sizeof(KMediaSyncFunctionCodeRanges) 

                                            / sizeof(KMediaSyncFunctionCodeRanges[0]));

const TUint8 KMediaSyncPolicyElementNetworkAndLocal = 0;

const TUint8 KMediaSyncPolicyElementPowerMgmt = 1;

const TUint8 KMediaSyncElementsIndex[KMediaSyncFunctionCodeRangeCount] =

    {

    KMediaSyncPolicyElementNetworkAndLocal,

    KMediaSyncPolicyElementPowerMgmt,

    CPolicyServer::ENotSupported,

    };

const CPolicyServer::TPolicyElement KMediaSyncPolicyElements[] = 

    { 

    {_INIT_SECURITY_POLICY_C2(ECapabilityNetworkServices, ECapabilityLocalServices), CPolicyServer::EFailClient},

    {_INIT_SECURITY_POLICY_C1(ECapabilityPowerMgmt), CPolicyServer::EFailClient},

    };

const CPolicyServer::TPolicy KMediaSyncServerPolicy =

    {

    CPolicyServer::EAlwaysPass, //specifies all connect attempts should pass

    KMediaSyncFunctionCodeRangeCount,

    KMediaSyncFunctionCodeRanges,

    KMediaSyncElementsIndex,     // what each range is compared to 

    KMediaSyncPolicyElements     // what policies range is compared to

    };

/**

Creates and executes a new CMTPServer instance.

@leave One of the system wide error codes, if a processing failure occurs.

*/

void CMediaSyncServer::RunServerL()

    {           

    RFs fs;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    TFileName lockFileName;

    fs.PrivatePath(lockFileName);

    TDriveUnit driveNum = RFs::GetSystemDrive();

    lockFileName.Insert(0, driveNum.Name());

    lockFileName.Append(KMssLockName);

    RFile lockFile;

    CleanupClosePushL(lockFile);

    TInt ret = KErrNone;

    if (!BaflUtils::FileExists(fs, lockFileName))

        {        

        BaflUtils::EnsurePathExistsL(fs, lockFileName);

        ret = lockFile.Create(fs, lockFileName, EFileShareExclusive|EFileWrite);

        }

    else

        {

        ret = lockFile.Open(fs, lockFileName, EFileShareExclusive|EFileWrite);

        }

    if (ret == KErrNone)

        {

        // Naming the server thread after the server helps to debug panics

        User::LeaveIfError(User::RenameProcess(KMediaSyncServerName));

        // Create and install the active scheduler.

        CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

        CleanupStack::PushL(scheduler);

        CActiveScheduler::Install(scheduler);

        // Create the server and leave it on the cleanup stack.

        CMediaSyncServer* server = CMediaSyncServer::NewLC(fs);

        // Initialisation complete, signal the client

        RProcess::Rendezvous(KErrNone);

        // Execute the server.

        CActiveScheduler::Start();

        // Server shutting down. 

        CleanupStack::PopAndDestroy(server);

        CleanupStack::PopAndDestroy(scheduler); // scheduler        

        }

    else

        {

        RProcess::Rendezvous(KErrNone);

        }

    CleanupStack::PopAndDestroy(&lockFile);

    CleanupStack::PopAndDestroy(&fs);    

    }

CMediaSyncServer* CMediaSyncServer::NewLC(RFs& aFs)

    {

    CMediaSyncServer* self = new (ELeave) CMediaSyncServer;

    CleanupStack::PushL(self);

    self->ConstructL(aFs);

    return self;

    }

CMediaSyncServer::CMediaSyncServer() : 

    CPolicyServer(CActive::EPriorityStandard, KMediaSyncServerPolicy)

    {   

    }

CMediaSyncServer::~CMediaSyncServer()

    {

    __FLOG(_L8("CMediaSyncServer::~CMediaSyncServer - Entry")); 

    delete iDb;

    delete iObserver;    

    __FLOG(_L8("CMediaSyncServer::~CMediaSyncServer - Exit"));

    __FLOG_CLOSE;

    }

void CMediaSyncServer::ConstructL(RFs& aFs)

    {  

    __FLOG_OPEN(KMSSSubsystem, KComponent);

    __FLOG(_L8("CMediaSyncServer::ConstructL - Entry"));

    iDb = CMediaSyncDatabase::NewL(aFs);

    iObserver = CMediaSyncObserver::NewL(iDb);

    iNeedFullSync = iDb->IsMssDbCorrupt();

    StartL(KMediaSyncServerName);

    __FLOG(_L8("CMediaSyncObserver::ConstructL - Exit"));    

    }

CSession2* CMediaSyncServer::NewSessionL(const TVersion&,const RMessage2&) const

    {

    __FLOG(_L8("CMediaSyncServer::NewSessionL - Entry"));

    CMediaSyncServer* ncThis = const_cast<CMediaSyncServer*>(this);

    __FLOG(_L8("CMediaSyncObserver::NewSessionL - Exit"));    

    return new(ELeave) CMediaSyncServerSession(ncThis);

    }

CMediaSyncObserver* CMediaSyncServer::MediaSyncObserver() const

    {

    return iObserver;

    }

CMediaSyncDatabase* CMediaSyncServer::MediaSyncDatabase() const

    {

    return iDb;

    }

TBool CMediaSyncServer::NeedFullSync()

    {

    return iNeedFullSync;

    }

void CMediaSyncServer::ClearFullSyncFlag()

    {

    __FLOG(_L8("CMediaSyncServer::ClearFullSyncFlag - Entry"));

    iNeedFullSync = EFalse;

    iDb->ClearMssDbCorrupt();

    __FLOG(_L8("CMediaSyncObserver::ClearFullSyncFlag - Exit"));    

    }