/*

* Copyright (c) 2003 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:  Implementation of the DRM Nitz Observer

*

*/

// INCLUDE FILES

#include "DRMNitzObserver.h"

#include "DRMClock.h"

#include "drmlog.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KTimeZoneValidBit(0x3F);     // Time zone difference

const TInt KTimeZoneSignBit(0x80);      // Sign of time zone difference

const TInt KNitzYearOffset(2000);       // Adjusting the year value received

const TInt KMaximumTwoDigitValue(99);

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CDRMNitzObserver::CDRMNitzObserver

// Default Constructor

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

//

CDRMNitzObserver::CDRMNitzObserver( RMobilePhone& aMobilePhone, CDRMClock* aDRMClock) :

    CActive(EPriorityNormal) ,iDRMClock( aDRMClock ), iMobilePhone( &aMobilePhone ),

    iError( KErrNone )

    {

    }

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

// CDRMNitzObserver::~CDRMNitzObserver

// Destructor

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

//

CDRMNitzObserver::~CDRMNitzObserver()

    {

    Cancel();

    };

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

// CDRMNitzObserver::ConstructL

// Two-phase Constructor

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

//

void CDRMNitzObserver::ConstructL()

    {

    DRMLOG( _L("ConstructL "));

    // Get the NITZ info on the creation, might not be available yet

    iError = iMobilePhone->GetNITZInfo(iNitzInfo);

    DRMLOG2( _L("ConstructL: Error = %d"), iError );

    }

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

// CDRMNitzObserver::NewL

// Two-phase constructor

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

//

CDRMNitzObserver* CDRMNitzObserver::NewL( RMobilePhone& aMobilePhone,

                                         CDRMClock* aDRMClock)

    {

    CDRMNitzObserver* self = new(ELeave) CDRMNitzObserver(aMobilePhone,aDRMClock);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CDRMNitzObserver::Start

// Adds the active object into the ActiveScheduler

// and sets the object active, makes sure RunL is called

// atleast once

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

//

void CDRMNitzObserver::Start()

    {

    TRequestStatus* status = 0;

    DRMLOG2( _L("iError == %d "), iError );

    if( iError == KErrNotSupported )

        {

        // NITZ never supported, kill the observer

        if( IsAdded() )

            {

            Deque();

            return;

            }

        return;

        }

    if( !IsAdded() )

        {

        CActiveScheduler::Add(this);

        }

    if ( !IsActive() )

        {

        SetActive();

        }

    status = &iStatus;

    User::RequestComplete(status,KErrNone);

    }

// Ignore the error:

TInt CDRMNitzObserver::RunError( TInt /*aError*/ )

    {

    SetActive();

    return KErrNone;

    }

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

// CDRMNitzObserver::RunL

// Active object RunL

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

//

void CDRMNitzObserver::RunL()

    {

    TTime timeData;

    TInt timeZone( 0 );

    // Check if the nitz has changed and is available, if so call update

    // otherwise just wait

    DRMLOG( _L("ObserverRunL Called\n\r ") );

    iStatus = KRequestPending;

    iMobilePhone->NotifyNITZInfoChange(iStatus, iNitzInfo);

    DRMLOG( _L("NotifyNITZInfoChange:"));

    if( GetNitzTime( timeData, timeZone ) )

        {

        DRMLOG( _L("Resetting secure time from NITZ observer:"));

        TRAPD(error, iDRMClock->ResetSecureTimeL( timeData, timeZone ) );

        if( error )

            {

            DRMLOG( _L("Resetting secure time from NITZ observer returned an error."));

            }

        DRMLOG( _L("Resetting secure time from NITZ observer successful."));

        if( error != KErrArgument )

            {

            if( error )

                {

                DRMLOG( _L("ObserverRunL Called error \n\r ") );

                }

            User::LeaveIfError( error );

            }

        }

    SetActive();

    };

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

// CDRMNitzObserver::DoCancel

// Cancels the active object

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

//

void CDRMNitzObserver::DoCancel()

    {

    // cancel the notify change

    iMobilePhone->CancelAsyncRequest(EMobilePhoneNotifyNITZInfoChange);

    };

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

// CDRMNitzObserver::CheckDateTimeVal(const TDateTime& aDateTime)

// Check the date time value is valid.

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

//

TInt CDRMNitzObserver::CheckDateTimeVal(const TDateTime& aDateTime)

    {

    TDateTime tmp;

    return tmp.Set(aDateTime.Year(),

                   aDateTime.Month(),

                   aDateTime.Day(),

                   aDateTime.Hour(),

                   aDateTime.Minute(),

                   aDateTime.Second(),

                   aDateTime.MicroSecond());

    }

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

// CDRMNitzObserver::GetNitzTime(const TDateTime& aDateTime)

// Gets the nitz time from iNitzInfo

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

//

TBool CDRMNitzObserver::GetNitzTime(TTime& aNitzTime, TInt& aTimeZone)

    {

    TInt32 nitzCaps(iNitzInfo.iNitzFieldsUsed);

    if (nitzCaps & RMobilePhone::KCapsTimezoneAvailable)

        {

        TInt timezone(iNitzInfo.iTimeZone & KTimeZoneValidBit);

        if (iNitzInfo.iTimeZone & KTimeZoneSignBit)

            {

            // Changes sign

            timezone = - timezone;

            }

        // TimeZone info

        aTimeZone = timezone;

        }

    if (nitzCaps & RMobilePhone::KCapsTimeAvailable)

        {

        TDateTime dateTime;

        TInt fourDigitYear(iNitzInfo.Year());

        //Check if our TSY returns 2 digits in stead of 4 digits for the year value

        if (fourDigitYear <= KMaximumTwoDigitValue)        // The maximum year value in UI applications is 2060

            {

           //The year received from TSY is 2 digits we make it 4 digits

            fourDigitYear = fourDigitYear + KNitzYearOffset;  // 2000

            }

        dateTime.Set(fourDigitYear,

                    TMonth(iNitzInfo.Month()),

                    iNitzInfo.Day(),

                    iNitzInfo.Hour(),

                    iNitzInfo.Minute(),

                    iNitzInfo.Second(),

                    iNitzInfo.MicroSecond());

        DRMLOG2( _L( "CDRMNitzObserver::GetNitzTime: DateTime: %d" ), fourDigitYear );

        DRMLOG2( _L( ":%d" ), iNitzInfo.Month() );

        DRMLOG2( _L( ":%d" ), iNitzInfo.Day() );

        DRMLOG2( _L( ":%d" ), iNitzInfo.Hour() );

        DRMLOG2( _L( ":%d" ), iNitzInfo.Minute() );

        DRMLOG2( _L( ":%d" ), iNitzInfo.Second() );

        if (KErrNone != CheckDateTimeVal(dateTime))

            {

            return EFalse;

            }

        // Transfer the time into a TTime object, UTC

        aNitzTime = dateTime;

        return ETrue;

        }

    return EFalse;

    };