// 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 "rmediasyncserver.h"

const TInt KDefGlobalSharedHeapSize = 64 * 1024;//64K byte memory

//-----------------------------------------------------------------------------

//

//-----------------------------------------------------------------------------

//

EXPORT_C RMediaSyncServer::RMediaSyncServer() :

    iHasSharedHeap(EFalse)

    {

    }

EXPORT_C TInt RMediaSyncServer::Startup()

    {

    const TUidType serverUid(KNullUid, KNullUid, KMediaSyncServerUid3);

    // Create the server process.

    RProcess server;

    TInt err(server.Create(KMediaSyncServerName, KNullDesC, serverUid));

    // Loading failed.

    if ( err != KErrNone )

        {

        return err;

        }

    TRequestStatus status;

    server.Rendezvous(status);

    if (status != KRequestPending)

        {

        server.Kill(0);     // abort startup

        server.Close();

        return KErrGeneral;

        }

    else

        {

        server.Resume();    // Logon OK - start the server.

        }

    User::WaitForRequest(status);

    server.Close();

    return status.Int();    

    }

EXPORT_C void RMediaSyncServer::Shutdown()

    {

    SendReceive(EMediaSyncClientShutdown);

    }

EXPORT_C TInt RMediaSyncServer::Connect()

    {      

    TFindProcess findMdEServer(KFinderMSSName);

    TFullName name;

    TInt result = findMdEServer.Next(name);

    if(result == KErrNotFound)

        {

        // Server is not running

        result = Startup();

        }

    else if(KErrNone == result)

        {

        RProcess mss;

        result = mss.Open(findMdEServer, EOwnerProcess);

        if((result != KErrNone) && (mss.ExitReason() != KErrNone))

            {

            result = Startup();           

            }

        mss.Close();

        }    

    if(KErrNone == result)

        {

        TVersion version(KMediaSyncServerVersionMajor, KMediaSyncServerVersionMinor, 0);

        result = CreateSession( KMediaSyncServerName, version );

        }

	return result;

    }

EXPORT_C void RMediaSyncServer::Close()

    {

    RSessionBase::Close();

    if (iHasSharedHeap)

        {

        iGlobalSharedHeap.Close();

        iHasSharedHeap = EFalse;

        }    

    }

EXPORT_C TInt RMediaSyncServer::NeedFullSync(TBool& aNeedFullSync)

    {

    TPtr8 finishPtr((TUint8*)&aNeedFullSync, sizeof(TBool), sizeof(TBool));

    TIpcArgs args;    

    args.Set(0, &finishPtr);

    return SendReceive(EMediaSyncClientNeedFullSync, args);

    }

EXPORT_C TInt RMediaSyncServer::ClearFullSync()

    {

    return SendReceive(EMediaSyncClientClearFullSync);    

    }

EXPORT_C void RMediaSyncServer::GetChangesL(CMediaSyncDataReader*& aDataReader, TBool& aIsFinished, TRequestStatus& aStatus, TInt aMaxFetchCount)

    {

    if (!iHasSharedHeap)

        {

        User::LeaveIfError(GetGlobalSharedHeapHandle());

        iHasSharedHeap = ETrue;

        }

    TPtr8 finishPtr((TUint8*)&aIsFinished, sizeof(TBool), sizeof(TBool));

    TIpcArgs args;

    args.Set(0, aMaxFetchCount);       

    args.Set(1, &finishPtr);

    TInt ret = SendReceive(EMediaSyncClientGetChanges, args);    

    User::LeaveIfError(ret);

    aDataReader = CMediaSyncDataReader::NewL(iGlobalSharedHeap);

    TRequestStatus* pClient = &aStatus;

    User::RequestComplete(pClient, ret);   

    }

EXPORT_C void RMediaSyncServer::RemoveAllRecords()

    {

    SendReceive(EMediaSyncClientRemoveAllRecords);

    RelaseGlobalSharedHeap();

    return;

    }

EXPORT_C TInt RMediaSyncServer::EnableMonitor()

    {

    return SendReceive(EMediaSyncClientEnableMonitor);

    }

EXPORT_C TInt RMediaSyncServer::DisableMonitor()

    {

    return SendReceive(EMediaSyncClientDisableMonitor);

    }

TInt RMediaSyncServer::GetGlobalSharedHeapHandle()

    {

    TIpcArgs args;

    args.Set(0, KDefGlobalSharedHeapSize);    

    TInt ret = SendReceive(EMediaSyncClientGetGSHHandle, args);    

    ret = iGlobalSharedHeap.SetReturnedHandle(ret);

    return ret;    

    }

void RMediaSyncServer::RelaseGlobalSharedHeap()

    {

    iGlobalSharedHeap.Close();

    iHasSharedHeap = EFalse;

    }

CMediaSyncDataReader* CMediaSyncDataReader::NewL(const RChunk& aChunk)

    {

    CMediaSyncDataReader* self = new(ELeave) CMediaSyncDataReader();

    CleanupStack::PushL(self);    

    self->ConstructL(aChunk);  

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CMediaSyncDataReader::~CMediaSyncDataReader()

    {

    }

CMediaSyncDataReader::CMediaSyncDataReader() :

    iOffset(0),

    iCurrentIdx(0)

    {

    }

void CMediaSyncDataReader::ConstructL(const RChunk& aChunk)

    {

    TUint8* base = aChunk.Base();

    User::LeaveIfNull(base);

    iHeaderInfo = reinterpret_cast<TDataHeaderInfo*>(base);

    iReadBase   = base + sizeof(TDataHeaderInfo);

    }

EXPORT_C TInt CMediaSyncDataReader::Count()

    {

    return iHeaderInfo->iCount;

    }

EXPORT_C TBool CMediaSyncDataReader::HasNext()

    {

    return (iCurrentIdx < iHeaderInfo->iCount);

    }

EXPORT_C void CMediaSyncDataReader::GetNextL(TUint32& aObjectId, TUint8& aType, TPtr16& aUri)

    {

    if (iCurrentIdx < iHeaderInfo->iCount)

        {

        //read object id

        Mem::Copy(&aObjectId, (iReadBase + iOffset), sizeof(TUint32));

        iOffset += sizeof(TUint32);

        //read notification type

        Mem::Copy(&aType, (iReadBase + iOffset), sizeof(TUint8));

        iOffset += sizeof(TUint8);

        //read uri length

        TUint8 uriLen = 0;

        Mem::Copy(&uriLen, (iReadBase + iOffset), sizeof(TUint8));

        iOffset += sizeof(TUint8);

        if (uriLen > 0)

            {

            //read uri content

            TUint16* ptr = (TUint16*)(iReadBase + iOffset);

            aUri.Set(ptr, uriLen, uriLen);

            iOffset += (uriLen * sizeof(TUint16));

            }

        else

            {

            aUri.Set(NULL, 0, 0);

            }

        ++iCurrentIdx;        

        }

    else

        {

        User::Leave(KErrOverflow);

        }

    }