/*

* Copyright (c) 2005 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:  This class contains utility method implementation 

*               related to usage of Calendar Interim API.

*

*/

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

// INCLUDE FILES

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

//

#include "CalenInterimUtils2Impl.h"

//debug

#include "calendarengines_debug.h"

#include <calentry.h>

#include <caluser.h>

#include <calentryview.h>

#include <etelmm.h>

#include <e32math.h>

#include <calrrule.h>

#include <featmgr.h>

#include <ecom/ecom.h>

#include <utf.h>

#include <openssl/md5.h>

#include <string.h>

#include "CleanupResetAndDestroy.h"

#include "RImplInfoPtrArrayOwn.inl"

#include "CalenEcomWatcher.h"       // Watches for ECOM registry changes

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

#ifdef __WINSCW__

    _LIT( KEmulatorImei, "123456789012345" );

#endif

    const TInt KImeiLength = 15; // 15 chars from left of imei

    const TInt KAsciiFirstLowercaseLetter = 97;    // ASCII character 97 = 'a'.

}  // namespace

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

// MEMBER FUNCTIONS

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

//

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

// CCalenInterimUtils2Impl::NewL()

// Creates and returns a new CCalenInterimUtils2Impl object.

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

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

CCalenInterimUtils2Impl* CCalenInterimUtils2Impl::NewL()

    {

    TRACE_ENTRY_POINT;

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenInterimUtils2Impl::CCalenInterimUtils2Impl()

// Default constructor

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

CCalenInterimUtils2Impl::CCalenInterimUtils2Impl()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenInterimUtils2Impl::ConstructL()

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

void CCalenInterimUtils2Impl::ConstructL()

    {

    TRACE_ENTRY_POINT;

    FeatureManager::InitializeLibL();

    // Only start the ecom watcher if the feature flags are on.

    if ((FeatureManager::FeatureSupported(KFeatureIdMeetingRequestEnabler)) || 

        (FeatureManager::FeatureSupported(KFeatureIdMeetingRequestSupport)) )

        {

        iEcomWatcher  = CCalenEComWatcher::NewL(*this);

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenInterimUtils2Impl::~CCalenInterimUtils2Impl()

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

CCalenInterimUtils2Impl::~CCalenInterimUtils2Impl()

    {

    TRACE_ENTRY_POINT;

    delete iEcomWatcher;

	FeatureManager::UnInitializeLib();

	TRACE_EXIT_POINT;

    }

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

// CCalenInterimUtils2Impl::PopulateChildFromParentL

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

void CCalenInterimUtils2Impl::PopulateChildFromParentL(CCalEntry& aChild, const CCalEntry& aParent)

    {

    TRACE_ENTRY_POINT;

    if ( aChild.DescriptionL() == KNullDesC )

        {

        aChild.SetDescriptionL( aParent.DescriptionL() );

        }

    if ( aChild.LocationL() == KNullDesC )

        {

        aChild.SetLocationL( aParent.LocationL() );

        }

    if ( aChild.PriorityL() == 0 )

        { // zero is undefined priority according to iCal spec.

        aChild.SetPriorityL( aParent.PriorityL() );

        }

    if ( aChild.SummaryL() == KNullDesC )

        {

        aChild.SetSummaryL( aParent.SummaryL() );

        }

    if ( aChild.StatusL() == CCalEntry::ENullStatus )

        {

        aChild.SetStatusL( aParent.StatusL() );

        }

    CCalAlarm* childAlarm = aChild.AlarmL();

    CCalAlarm* parentAlarm = aParent.AlarmL();

    CleanupStack::PushL(childAlarm);

    CleanupStack::PushL(parentAlarm);

    if( !childAlarm && parentAlarm )

        {

        aChild.SetAlarmL( parentAlarm);

        }

    CleanupStack::PopAndDestroy(childAlarm);

    CleanupStack::PopAndDestroy(parentAlarm);

    if (aChild.ReplicationStatusL() != aParent.ReplicationStatusL())

        {

        aChild.SetReplicationStatusL(aParent.ReplicationStatusL());

        }

    if (aChild.MethodL() == CCalEntry::EMethodNone)

        {

        aChild.SetMethodL(aParent.MethodL());

        }

    if ( !aChild.OrganizerL() && aParent.OrganizerL() )

        {

        CCalUser* owner = CopyUserLC( *( aParent.OrganizerL() ) );

        aChild.SetOrganizerL( owner );

        CleanupStack::Pop(owner); // ownership transferred

        }

    PopulateAttendeeListL( aChild, aParent );

    TRACE_EXIT_POINT;

    // "Categories" property is omitted

    }

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

// CCalenInterimUtils2Impl::PopulateAttendeeListL

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

//

void CCalenInterimUtils2Impl::PopulateAttendeeListL(

    CCalEntry& aChild,

    const CCalEntry& aParent )

    {

    TRACE_ENTRY_POINT;

    RPointerArray<CCalAttendee>& childAtt = aChild.AttendeesL();

    RPointerArray<CCalAttendee>& parentAtt = aParent.AttendeesL();

    CCalUser *po = NULL;

    if ( !aChild.PhoneOwnerL() )

        { // Phone owner is internal data, not part of ical protocol, it's

          // benefit is to avoid heavy "who am I?" resolving operation

        po = aParent.PhoneOwnerL();

        }

    TInt parentAttCount( parentAtt.Count() );

    if ( childAtt.Count() == 0 && parentAttCount > 0 )

        {

        for ( TInt i( 0 ); i < parentAttCount; ++i )

            {

            CCalAttendee* copy = CopyAttendeeLC( *( parentAtt[i] ) );

            aChild.AddAttendeeL( copy );

            CleanupStack::Pop(copy); // ownership transferred

            if(po == parentAtt[i])

                {

                aChild.SetPhoneOwnerL(copy);

                }

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenInterimUtils2Impl::CopyAttendeeLC

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

//

CCalAttendee* CCalenInterimUtils2Impl::CopyAttendeeLC(

    const CCalAttendee& aSource )

    {

    TRACE_ENTRY_POINT;

    CCalAttendee* copy = CCalAttendee::NewL( aSource.Address(),

                                             aSource.SentBy() );

    CleanupStack::PushL( copy );

    copy->SetCommonNameL( aSource.CommonName() );

    copy->SetRoleL( aSource.RoleL() );

    copy->SetStatusL( aSource.StatusL() );

    copy->SetResponseRequested( aSource.ResponseRequested() );

    TRACE_EXIT_POINT;

    return copy;

    }

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

// CCalenInterimUtils2Impl::CopyUserLC

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

//

CCalUser* CCalenInterimUtils2Impl::CopyUserLC( const CCalUser& aSource )

    {

    TRACE_ENTRY_POINT;

    CCalUser* copy = CCalUser::NewL( aSource.Address(),

                                     aSource.SentBy() );

    CleanupStack::PushL( copy );

    copy->SetCommonNameL( aSource.CommonName() );

    TRACE_EXIT_POINT;

    return copy;

    }

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

// CCalenInterimUtils2Impl::GlobalUidL

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

//

HBufC8* CCalenInterimUtils2Impl::GlobalUidL()

    {

    TRACE_ENTRY_POINT;

    // Loosely using UID generation algorithm from

    // http://www.webdav.org/specs/draft-leach-uuids-guids-01.txt

    // Number of 100ns ticks since Oct 15 1582.

    // This differs slightly from the spec in that the clock sequence is just a pseudo-random number.

    HBufC8* resultBuf = DoCreateUidLC(clockSeq, timeStamp, iImeiNode);

    CleanupStack::Pop(resultBuf);

    TRACE_EXIT_POINT;

    return resultBuf;

    }

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

// CCalenInterimUtils2Impl::GetTicksFromGregorianCalendarStartL()

// This function returns the number of 100ns ticks since 0:00 15th October 1582.

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

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

//

TInt64 CCalenInterimUtils2Impl::GetTicksFromGregorianCalendarStartL()

    {

    TRACE_ENTRY_POINT;

    TTime timeNow;

    timeNow.HomeTime();

    TDateTime gregorianStartDT(1582, EOctober, 15, 0, 0, 0, 0);

    TTime gregorianStart(gregorianStartDT);

    TTimeIntervalMicroSeconds msDifference = timeNow.MicroSecondsFrom(gregorianStart);

    TRACE_EXIT_POINT;

    }

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

// CCalenInterimUtils2Impl::GetImeiAsNodeValueL()

// Formats the IMEI returned from GetImeiL() into a 64-bit integer.

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

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

//

TInt64 CCalenInterimUtils2Impl::GetImeiAsNodeValueL()

    {

    TRACE_ENTRY_POINT;

    TBuf<RMobilePhone::KPhoneSerialNumberSize> serialNumber;

    GetImeiL( serialNumber );

    // Trim off all but the first KImeiLength digits.

    TLex lex( serialNumber.Left(KImeiLength) );

    TInt64 val;

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

    TRACE_EXIT_POINT;

    return val;

    }

inline TUint8 LastFourBits(TUint8& aNum)

    {

    TRACE_ENTRY_POINT;

    // 00001111 b

    TRACE_EXIT_POINT;

    return aNum & 0x0F;

    }

inline TUint8 FirstFourBits(TUint8& aNum)

    {

    TRACE_ENTRY_POINT;

    // 11110000 b

    TRACE_EXIT_POINT;

    return (aNum & 0xF0) >> 4;

    }

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

// CCalenInterimUtils2Impl::DoCreateUidLC()

// Performs the work in creating a GUID.

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

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

//

HBufC8* CCalenInterimUtils2Impl::DoCreateUidLC( const TUint32& aClockSeq,

                                               const TUint64& aTimeStamp,

                                               const TUint64& aNodeValue )

    {

    TRACE_ENTRY_POINT;

    // The roast beef of the algorithm. Does all the shifting about as described in the web draft.

    TUint64 mask = 0xFF0000000000;

    for(TInt i=0; i<=6; ++i)

        {

        TInt64 temp = aNodeValue & mask;

        temp >>= ((5-i)*8);

        mask = mask >> 8;

        }

    //initialize the context

    //Append a string to the message

    //Finish the message and return the digest.

    // Add the version field in the msb 4 bits. The value of version is 3.

    //Add the variant field in the msb 2 bits. The value of variant is 2.

    TBuf8<36> output;

    TInt i;

    for(i=0; i<16; ++i)

    TRACE_EXIT_POINT;

    }

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

// CCalenInterimUtils2Impl::ConvertToCharacterL()

// Converts from a number between 0-15 to a hexadecimal character representation.

// 0-9, a-f

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

//

TChar CCalenInterimUtils2Impl::ConvertToCharacterL(TUint8 aChar)

    {

    TRACE_ENTRY_POINT;

    if(aChar < 10)

        {

        // Convert to a digit.

        TRACE_EXIT_POINT;

        return TChar(aChar + KAsciiFirstNumber);

        }

    else if(aChar < 16)

        {

        // Convert to lower case character.

        TRACE_EXIT_POINT;

        return TChar(aChar - 10 + KAsciiFirstLowercaseLetter);

        }

    // This function should only be passed numbers between 0-15.

    User::Leave(KErrArgument);

    TRACE_EXIT_POINT;

    return TChar(KAsciiFirstLowercaseLetter); // Stops compiler warning.

    }

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

// CCalenInterimUtils2Impl::GetImeiL

// Gets the IMEI of the device. On the emulator, this will return a fake IMEI.

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

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

//

void CCalenInterimUtils2Impl::GetImeiL( TDes& aImei )

    {

    TRACE_ENTRY_POINT;

    #ifndef __WINSCW__

    RTelServer telServer;

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

    CleanupClosePushL(telServer);

    TInt numPhones = 0;

    User::LeaveIfError( telServer.EnumeratePhones(numPhones) );

    if(numPhones < 1)

        {

        User::Leave(KErrNotFound);

        }

    RTelServer::TPhoneInfo info;