/*

* Copyright (c) 2004 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:   Provides class methods for creating Db , boot and missed alarm manager

*                implements CServer2 methods as part of IPC message interaction with client.

*

*/

#include <centralrepository.h>

#include <CalendarInternalCRKeys.h>

#include <calsession.h>

#include <calcalendarinfo.h>

#include <calenmulticalutil.h>

#include <CalenInterimUtils2.h>

#include <calensvrmissedalarmmanagerresource.rsg>

#include <data_caging_path_literals.hrh>

#include <bautils.h>

#include <pathinfo.h>

//debug

#include "calendarui_debug.h"

// INCLUDES

#include "CalenServer.h"

#include "CalSvrSession.h"

#include "CalSvrDef.h"

//#include "CalenSvrAlarmManager.h"

#include "CalenSvrBootManager.h"

#include "CalenSvrDBManager.h"

#include "calensvrmissedalarmmanager.h"

#include "calenmissedalarmconstants.h"

// LOCAL CONSTANTS AND MACROS

const TInt KCalenServerPriority(CActive::EPriorityStandard);

_LIT( KCalendarDatabaseFilePath, "c:calendar" );

const TInt KBufferStartingSize( 128 ); 

const TInt KBufferSizeIncrement( 64 );

const TInt KBuffLength = 128;

const TInt KComma( ',' );

_LIT(KPhoneCalendarName,"PhoneCalendar");

// ================= MEMBER FUNCTIONS =======================

//

// Construction and destruction 

//

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

// ?classname::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

CCalenServer* CCalenServer::NewL()

    {

    TRACE_ENTRY_POINT;

    CCalenServer* server = new( ELeave )CCalenServer( KCalenServerPriority );

    CleanupStack::PushL(server);

    server->ConstructL();

    CleanupStack::Pop();

    TRACE_EXIT_POINT;

    return server;

    }

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

// ?classname::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

CCalenServer::CCalenServer(TInt aPriority)

    : CServer2(aPriority, ESharableSessions)

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// ?classname::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

CCalenServer::~CCalenServer()

    {

    TRACE_ENTRY_POINT;

    //delete iAlarmManager;

    delete iDBManager;

    delete iBootManager;

    delete iMissedAlarmHandler;

    TRACE_EXIT_POINT;

    }

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

// ?classname::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

void CCalenServer::ConstructL()

    {

    TRACE_ENTRY_POINT;

    TBool firstStartUp(EFalse);

    CheckForFirstStartUpL(firstStartUp);

    if(!firstStartUp)

        {

        TRAPD(error,CreateCalendarFilesL());

        if(error==KErrNone)

            {

            SetFirstStartUpL(ETrue);

            }

        }

    iBootManager = CCalenSvrBootManager::NewL( *this );

    iDBManager = CCalenSvrDBManager::NewL();

    //iAlarmManager = CCalenSvrAlarmManager::NewL();

    iMissedAlarmHandler = CCalenSvrMissedAlarmManager::NewL();

    StartL( KCalendarServerName );

    TRACE_EXIT_POINT;

    }

//

// CServer mandatory functions, e.g. session creation and error handling

//

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

// ?classname::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

CSession2* CCalenServer::NewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const

    {

    TRACE_ENTRY_POINT;

    CCalSvrSession* session = new( ELeave )CCalSvrSession();

    CleanupStack::PushL( session );

    session->ConstructL( *const_cast<CCalenServer*>( this ) );

    CleanupStack::Pop( session );

    TRACE_EXIT_POINT;

    return session;

    }

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

// ?classname::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CCalenServer::RunError(TInt aErr)

    /**

     * Handle leaves from ServiceL.

     * Any leave from a ServiceL() will land up here.

     **/

    {

    TRACE_ENTRY_POINT;

    // if it's a bad descriptor, panic the client

    if (aErr==KErrBadDescriptor)    // client had a bad descriptor

        {

        PanicClient(Message(), EBadDescriptor);

        // If client message is panicked, it is also completed.

        }

    else

        {

        // otherwise, complete the outstanding message with error

        Message().Complete(aErr);

        }

    ReStart(); // really means just continue reading client requests

    TRACE_EXIT_POINT;

    return KErrNone;

    }

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

// ?classname::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

void CCalenServer::PanicClient(const RMessage2& aMessage, TInt aPanic) const

    {

    TRACE_ENTRY_POINT;

    // FIXME: should we Panic Client, if client is running in 

    // phone thread ?

    // ok, go for it

    _LIT(KCalenSvrClientPanic, "CalenServer");

    aMessage.Panic(KCalenSvrClientPanic, aPanic);

    TRACE_EXIT_POINT;

    }

//

// Calendar server specific functionality

//

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

// ?classname::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

void CCalenServer::BootReadyL()

    {

    TRACE_ENTRY_POINT;

    iDBManager->BootReadyL();

    TRACE_EXIT_POINT;

    }

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

// ?classname::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

void CCalenServer::RegisterUserL(CCalenSvrDBManager::MCalenDBUser& aUser)

    {

    TRACE_ENTRY_POINT;

    iDBManager->RegisterUserL(aUser);

    TRACE_EXIT_POINT;

    }

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

// ?classname::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

void CCalenServer::UnregisterUserL(CCalenSvrDBManager::MCalenDBUser& aUser)

    {

    TRACE_ENTRY_POINT;

    iDBManager->UnregisterUserL(aUser);

    TRACE_EXIT_POINT;

    }

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

// CCalenServer::ServerMessage

// Returns the current IPC message.

// (other items were commented in a header).

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

// 

const RMessage2 CCalenServer::ServerMessage() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return Message();

    }

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

// CCalenServer::CheckForFirstStartUpL

// checks for first start up by reading the information from cenrep key 

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

//

void CCalenServer::CheckForFirstStartUpL(TBool& aFirstStartUp)

    {

    TRACE_ENTRY_POINT;

    CRepository* cenRep = CRepository::NewLC(KCRUidCalendar);

    User::LeaveIfError(cenRep->Get(KCalendarStartupStatus, aFirstStartUp));

    CleanupStack::PopAndDestroy(cenRep);

    TRACE_EXIT_POINT;

    }

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

// CCalenServer::SetFirstStartUpL

// Sets first start up value to ETrue

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

//

void CCalenServer::SetFirstStartUpL(TBool aFirstStartUp)

    {

    TRACE_ENTRY_POINT;

    CRepository* cenRep = CRepository::NewLC(KCRUidCalendar);

    User::LeaveIfError(cenRep->Set(KCalendarStartupStatus, aFirstStartUp));

    CleanupStack::PopAndDestroy(cenRep);

    TRACE_EXIT_POINT;

    }

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

// CCalenServer::CreateCalendarFilesL

// Create default calendar files

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

//

TInt CCalenServer::CreateCalendarFilesL()

    {

    TRACE_ENTRY_POINT;

    CDesC16ArrayFlat* calendarNamesList = new (ELeave) CDesC16ArrayFlat(2);

    CleanupStack::PushL(calendarNamesList);

    // read calendar names from central repository

    ReadCalendarNamesFromResourceL(*calendarNamesList);

    RArray<TInt> calendarColors;

    // read calendar colors from central repository

    ReadCalendarColorsFromCenrepL(calendarColors);

    TInt calendarsCount = calendarNamesList->Count();

    TInt error(KErrNone);

    for (TInt index = 0; index < calendarsCount; index++)

        {

        // create cal session

        CCalSession* session = CCalSession::NewL();

        CleanupStack::PushL(session);

        // create and set metadata information from central repository

        CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();

        CleanupStack::PushL(calendarInfo);

        SetCalendarAddPropertiesL(*calendarInfo);

		calendarInfo->SetNameL(calendarNamesList->MdcaPoint(index));

        calendarInfo->SetColor(TRgb(calendarColors[index]));

        calendarInfo->SetEnabled(ETrue);

        if(!index)

            {

            TBuf<KMaxFileName> calendarFileName;

            calendarFileName.Append(KCalendarDatabaseFilePath);

            calendarInfo->SetEnabled(EFalse);

            TRAPD(error,session->CreateCalFileL(calendarFileName,*calendarInfo));

			User::LeaveIfError(error);

            }

        else

            {

            HBufC* calFileName = 

                    CCalenMultiCalUtil::GetNextAvailableCalFileL();

            CleanupStack::PushL(calFileName);

            TRAPD(error,session->CreateCalFileL( calFileName->Des(),

                                        *calendarInfo));

			User::LeaveIfError(error);

            CleanupStack::PopAndDestroy(calFileName);

            }

        CleanupStack::PopAndDestroy(calendarInfo);

        CleanupStack::PopAndDestroy(session);

        }

    calendarColors.Close();

    CleanupStack::PopAndDestroy(calendarNamesList);

    TRACE_EXIT_POINT;

    return error;

    }

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

// CCalenServer::ReadCalendarNamesFromCenrepL

// Read calendar names from central repository

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

//

void CCalenServer::ReadCalendarNamesFromResourceL(CDesC16ArrayFlat& aCalendarNames)

    {

    TRACE_ENTRY_POINT;

    RFs fsSession;

    CleanupClosePushL( fsSession );

    RResourceFile resourceFile;

    CleanupClosePushL( resourceFile );

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

    TFileName resourceFileName( KMissedAlarmResourceFile );

    BaflUtils::NearestLanguageFile( fsSession, resourceFileName );

    resourceFile.OpenL(fsSession, resourceFileName );

    resourceFile.ConfirmSignatureL( 0 );

    //Phone calendar 

       HBufC* phoneCalendarBuffer = KPhoneCalendarName().AllocLC();

       aCalendarNames.AppendL(phoneCalendarBuffer->Des());

       CleanupStack::PopAndDestroy( phoneCalendarBuffer );

    // personal

        HBufC8* personalBuffer = resourceFile.AllocReadLC( R_CALE_DB_PERSONAL );    

       const TPtrC16 ptrPBuffer(( TText16*) personalBuffer->Ptr(),

                                         ( personalBuffer->Length()+1 )>>1 );    

       HBufC *personalCalendar = ptrPBuffer.AllocL();    

       aCalendarNames.AppendL( personalCalendar->Des() );    

       CleanupStack::PopAndDestroy( personalBuffer );

    // famliy

       HBufC8* familyBuffer=resourceFile.AllocReadLC( R_CALE_DB_FAMILY );

       const TPtrC16 ptrFBuffer(( TText16*) familyBuffer->Ptr(),

               ( familyBuffer->Length()+1 )>>1 );

       HBufC *familyCalendar = ptrFBuffer.AllocL();

       aCalendarNames.AppendL( familyCalendar->Des() );

       CleanupStack::PopAndDestroy( familyBuffer );

    //friends

       HBufC8* friendsBuffer = resourceFile.AllocReadLC( R_CALE_DB_FRIENDS );

       const TPtrC16 ptrFrBuffer(( TText16*) friendsBuffer->Ptr(),

               ( friendsBuffer->Length()+1 )>>1 );

       HBufC *friendsCalendar = ptrFrBuffer.AllocL();

       aCalendarNames.AppendL( friendsCalendar->Des() );

       CleanupStack::PopAndDestroy( friendsBuffer );

    CleanupStack::PopAndDestroy(&resourceFile);

    CleanupStack::PopAndDestroy(&fsSession);

    TRACE_EXIT_POINT;

    }

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

// CCalenServer::ReadCalendarColorsFromCenrepL

// Read calendar colors from central repository

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

//

void CCalenServer::ReadCalendarColorsFromCenrepL(RArray<TInt>& aCalendarColors)

    {

    TRACE_ENTRY_POINT;

    CRepository* repository = CRepository::NewL(KCRUidCalendar);

    CleanupStack::PushL(repository);

    TInt bufSize(KBufferStartingSize);

    TBool wasRead(EFalse);

    do

        {

        RBuf buf;

        CleanupClosePushL(buf);

        buf.CreateL(bufSize);

        // read calendar colors from cenrep

        TInt err = repository->Get(KCalendarDefaultColors, buf);

        if (err == KErrNone)

            {

            wasRead = ETrue;

            PopulateCalendarColorListL(buf, aCalendarColors);

            }

        else if (err == KErrOverflow)

            {

            bufSize += KBufferSizeIncrement;

            }

        else

            {

            User::Leave(err);

            }

        CleanupStack::PopAndDestroy(&buf);

        }

    while (!wasRead);

    CleanupStack::PopAndDestroy(repository);

    TRACE_EXIT_POINT;

    }

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

// CCalenServer::PopulateCalendarColorListL

// Populate calendar colors list from central repository buffer

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

//

void CCalenServer::PopulateCalendarColorListL( const TDesC& aRepositoryBuffer,

                        RArray<TInt>& aCalendarColors )

    {

    TRACE_ENTRY_POINT;

    TPtrC marker = aRepositoryBuffer;

    TInt calendarColorOffset;

    //For phone calendar 

    aCalendarColors.Append(KRgbRed.Value());

    while ((calendarColorOffset = marker.Locate(TChar(KComma)))

            != KErrNotFound)

        {

        TLex lex(marker.Left(calendarColorOffset));

        TInt colorValue;

        User::LeaveIfError(lex.Val(colorValue));

        // append calendar color value to list

        aCalendarColors.Append(colorValue);

        // Set marker to one char after the comma.

        marker.Set(marker.Mid(calendarColorOffset + 1));

        if (marker.Locate(TChar(KComma)) == KErrNotFound)

            {

            lex = marker.Left(marker.Length());

            User::LeaveIfError(lex.Val(colorValue));

            aCalendarColors.Append(colorValue);

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenServer::SetCalendarAddPropertiesL

// (other items were commented in a header).

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

//

void CCalenServer::SetCalendarAddPropertiesL(CCalCalendarInfo& aCalendarInfo)

    {

    TRACE_ENTRY_POINT

    // EFolderLUID

    TBuf8<KBuffLength> keyBuff;

    keyBuff.AppendNum(EFolderLUID);

    TRAPD(err,aCalendarInfo.PropertyValueL(keyBuff));

    if (KErrNotFound == err)

        {

        TUint calValue = 0;

        //Get the available offset value and set as property value.

        calValue = CCalenMultiCalUtil::GetNextAvailableOffsetL();

        TPckgC<TUint> calValuePckg(calValue);

        aCalendarInfo.SetPropertyL(keyBuff, calValuePckg);

        }

    // ECreationTime

    TTime currentTime;

    currentTime.HomeTime();