/*

* Copyright (c) 2008 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 is the source file for the CAdtUpdaterContainer class.

*

*/

// System includes

#include <AknsBasicBackgroundControlContext.h>

#include <AknsSkinInstance.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <AknGlobalNote.h>

#include <StringLoader.h>

#include <adtupdater.rsg>

#include <avkon.rsg>

#include <tzlocalizer.h>

#include <aknmessagequerydialog.h>

#include <tz.h>

#include <AknGlobalMsgQuery.h>

#include <badesca.h>

#include <aknlists.h>

#include <centralrepository.h>

#include <starterdomaincrkeys.h>

#include <startupdomainpskeys.h> 

#include <startupdomaincrkeys.h>

#include <starterclient.h>

// User includes

#include "adtupdatercontainer.h"

#include "adtupdaterappui.h"

#include "adtupdaterlistener.h"

#include "adtupdaterpopuplist.h"

#include "adtupdaterquerydialog.h"

#include "clocktimezoneresolver.h"

#include "clock_debug.h"

#include <uikon/eiksrvui.h>

// Constants

const TInt KNitzPlugin( 0x200159A5 );

const TInt KTimeout( 90000000 );				// 90 seconds

const TInt KInterval( 5000000 );				// 5 seconds

const TInt KMaximumTwoDigitValue( 99 );

const TInt KNitzYearOffset( 2000 );

const TInt KMaxCityLength( 120 );

const TInt KMaxCountryLength( 120 );

const TInt KSingleCity( 1 );

const TInt KZero( 0 );

const TInt KFirstBootDone( 1 );

const TInt KTimeFormatLength( 16 );				 // "20070000:090000."

const TInt KMaxMobileCountryCode( 4 );

const TInt KAppBackgroundInterval( 2000000 );   // 2 seconds

// Literals

_LIT( KOneSpace, " " );

_LIT( KMobileCountryCode, "%d" );

_LIT( KDefaultDateTimeValue, "20070000:090000." ); // YYYYMMDD:HHMMSS.

_LIT( KDefault, "default" );

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

// CAdtUpdaterContainer::NewL

// rest of the details are commented in the header

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

//

CAdtUpdaterContainer* CAdtUpdaterContainer::NewL( const TRect& aRect )

    {

    __PRINTS( "CAdtUpdaterContainer::NewL - Entry" );

    CAdtUpdaterContainer* self = new ( ELeave ) CAdtUpdaterContainer;

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    CleanupStack::Pop( self );

    __PRINTS( "CAdtUpdaterContainer::NewL - Exit" );

    return self;

    }

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

// CAdtUpdaterContainer::~CAdtUpdaterContainer

// rest of the details are commented in the header

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

//

CAdtUpdaterContainer::~CAdtUpdaterContainer()

    {

    __PRINTS( "CAdtUpdaterContainer::~CAdtUpdaterContainer - Entry" );

    if(iPSObserver)

        {

        delete iPSObserver;

        iPSObserver = NULL;

        }

	if( iBgContext )

		{

		delete iBgContext;

		iBgContext = NULL;

		}

	if( iPeriodic )

		{

		delete iPeriodic;

		iPeriodic = NULL;

		}

	if( iListener )

		{

		delete iListener;

		iListener = NULL;

		}

	if( iGMTString )

		{

		delete iGMTString;

		iGMTString = NULL;

		}

	if( iGMTText )

		{

		delete iGMTText;

		iGMTText = NULL;

		}

	__PRINTS( "CAdtUpdaterContainer::~CAdtUpdaterContainer - Exit" );

    }

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

// CAdtUpdaterContainer::CAdtUpdaterContainer

// rest of the details are commented in the header

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

//    

CAdtUpdaterContainer::CAdtUpdaterContainer() : iDataAvailability( EDataNone ), iQueryDialogsInDisplay( EFalse )

    {

    __PRINTS( "CAdtUpdaterContainer::CAdtUpdaterContainer - Entry" );

    //No Implementation yet

    __PRINTS( "CAdtUpdaterContainer::CAdtUpdaterContainer - Exit" );

    }

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

// CAdtUpdaterContainer::ConstructL

// rest of the details are commented in the header

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

//    

void CAdtUpdaterContainer::ConstructL( const TRect& aRect )

    {

    __PRINTS( "CAdtUpdaterContainer::ConstructL - Entry" );

	CreateWindowL();

	iAdtUpdaterAppUi =  static_cast < CAdtUpdaterAppUi* > ( CCoeEnv::Static()->AppUi() );

	// Construct the background control context.

    iBgContext = CAknsBasicBackgroundControlContext::NewL( KAknsIIDQsnBgScreen,

    													   aRect.Size(),

    													   EFalse );

    SetRect( aRect );

    // set the flag for showing startup queries

    iDisplayStartupQueries = DisplayStartupQueriesL();

    iPSObserver = CPsKeyObserver::NewL(KPSUidStartup, KPSStartupUiPhase, EStartupUiPhaseAllDone, this);

	iIsRTCInvalidAndHiddenReset = EFalse;

	iPeriodic = CPeriodic::NewL( EPriorityAbsoluteHigh );

	iNitzTimerActive = EFalse;

    __PRINTS( "CAdtUpdaterContainer::ConstructL - Exit" );

    }     

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

// CAdtUpdaterContainer::OfferKeyEventL

// rest of the details are commented in the header

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

//    

TKeyResponse CAdtUpdaterContainer::OfferKeyEventL( const TKeyEvent& /*aKeyEvent*/, 

												   TEventCode /*aType*/ )

    {

    __PRINTS( "CAdtUpdaterContainer::OfferKeyEventL - Entry" );

    TKeyResponse ret( EKeyWasConsumed );

    __PRINTS( "CAdtUpdaterContainer::OfferKeyEventL - Exit" );

    return ret;

    }

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

// CAdtUpdaterContainer::CountComponentControls

// rest of the details are commented in the header

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

//

TInt CAdtUpdaterContainer::CountComponentControls() const

	{

	__PRINTS( "CAdtUpdaterContainer::CountComponentControls - Entry" );

	__PRINTS( "CAdtUpdaterContainer::CountComponentControls - Exit" );

	return 0;

	}

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

// CAdtUpdaterContainer::ComponentControl

// rest of the details are commented in the header

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

//	

CCoeControl* CAdtUpdaterContainer::ComponentControl( TInt /*aIndex*/ ) const

	{

	__PRINTS( "CAdtUpdaterContainer::ComponentControl - Entry" );

	__PRINTS( "CAdtUpdaterContainer::ComponentControl - Exit" );

	return NULL;

	}

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

// CAdtUpdaterContainer::Draw

// rest of the details are commented in the header

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

//

void CAdtUpdaterContainer::Draw( const TRect& aRect ) const

	{

	__PRINTS( "CAdtUpdaterContainer::Draw - Entry" );

	CWindowGc& gc = SystemGc();

	gc.Clear( aRect );

	if( iBgContext )

		{

		MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

		AknsDrawUtils::Background( skinInstance, iBgContext, this, gc, aRect );

		}

	__PRINTS( "CAdtUpdaterContainer::Draw - Exit" );

    }

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

// CAdtUpdaterContainer::SizeChanged

// rest of the details are commented in the header

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

//

void CAdtUpdaterContainer::SizeChanged()

	{

	__PRINTS( "CAdtUpdaterContainer::SizeChanged - Entry" );

	if( iBgContext )

	    {

	    iBgContext->SetRect( Rect() );

	    }

	__PRINTS( "CAdtUpdaterContainer::SizeChanged - Exit" );

	}

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

// CAdtUpdaterContainer::MopSupplyObject

// rest of the details are commented in the header

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

//

TTypeUid::Ptr CAdtUpdaterContainer::MopSupplyObject( TTypeUid aId )

    {

    __PRINTS( "CAdtUpdaterContainer::MopSupplyObject - Entry" );

    if( MAknsControlContext::ETypeId == aId.iUid )

        {

        return MAknsControlContext::SupplyMopObject( aId, iBgContext );

        }

    __PRINTS( "CAdtUpdaterContainer::MopSupplyObject - Exit" );

    return CCoeControl::MopSupplyObject( aId );

    }

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

// CAdtUpdaterContainer::HandleResourceChange

// rest of the details are commented in the header

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

//    

void CAdtUpdaterContainer::HandleResourceChange( TInt aType )

	{

	__PRINTS( "CAdtUpdaterContainer::HandleResourceChange - Entry" );

	// Forward the control to CCoeControl.

	CCoeControl::HandleResourceChange( aType );

	if( KAknsMessageSkinChange == aType || KEikDynamicLayoutVariantSwitch == aType )

	    {

        TRect mainPane;

	    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow, mainPane );

	    SetRect(mainPane);	    

	    }

	__PRINTS( "CAdtUpdaterContainer::HandleResourceChange - Exit" );

	}

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

// CAdtUpdaterContainer::InformAboutNwUpdateL

// rest of the details are commented in the header

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

//	

void CAdtUpdaterContainer::InformAboutNwUpdateL()

	{

	__PRINTS( "CAdtUpdaterContainer::InformAboutNwUpdate - Entry" );

	if( IsFirstBoot() &&  IsSimPresent() && IsNitzPluginActive() && PredictiveTimeEnabled())

		{

		__PRINTS( "First boot, sim is present and auto time update is ON" );

		// First bring the application to the foreground.

		iAdtUpdaterAppUi->ToggleAppViewL( EFalse );

		// Hide in FSW.

		iAdtUpdaterAppUi->HideApplicationFromFSW( ETrue );

		// Hide the status pane.

		iAdtUpdaterAppUi->HideStatusPane( ETrue );

		// Listener object which listens for a Nitz packet

		iListener = CAdtUpdaterListener::NewL( this );

		iListener->WaitForNitzInfoL();

		// A 90 seconds call back timer.

		TCallBack timerCallBack( CallBackL, this );

		// Start the Nitz timer.

		iPeriodic->Start( KTimeout, KInterval, timerCallBack );

		iNitzTimerActive =ETrue;

		}

	else if( IsFirstBoot()&& PredictiveTimeEnabled())

		{		

		__PRINTS( "First boot, normal boot sequence" );

		WaitToShowQueriesL();

		__PRINTS( "CAdtUpdaterContainer::InformAboutNwUpdate : 2nd condition - Exit" );

		}

	else if( !RTCStatus() && !HiddenReset() && PredictiveTimeEnabled())

		{

		__PRINTS( "RTC invalid or Hidden Reset" );

		iIsRTCInvalidAndHiddenReset = ETrue;

		WaitToShowQueriesL();

		__PRINTS( "CAdtUpdaterContainer::InformAboutNwUpdate : 3rd condition - Exit" );

		}		

	else

		{

		__PRINTS( "Not the first boot, simply exit" );

		// No need ot execute further as it's not the first boot. Exit the application.

		User::Exit( KErrNone );

		}

	__PRINTS( "CAdtUpdaterContainer::InformAboutNwUpdate - Exit" );

	}

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

// CAdtUpdaterContainer::InformAboutNwUpdate

// rest of the details are commented in the header

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

//

TInt CAdtUpdaterContainer::CallBackL( TAny* aPtr )

	{

	__PRINTS( "CAdtUpdaterContainer::CallBackL - Entry" );

	CAdtUpdaterContainer* selfObject = static_cast< CAdtUpdaterContainer* >( aPtr );

	if(selfObject->iNitzTimerActive)

	    {

        CAdtUpdaterListener* listenerObject = selfObject->Listener();

        // Callback after 90 seconds. If control reaches here, it means Nitz packet has

        // not yet arrived and we can continue with normal bootup sequence.

        // Buf before we do that, we can do a final check with the server, just to ensure

        // there weren't any missed notifications.

        TBool dataAvailable = listenerObject->ConfirmDataAvailabilityL();

        if( dataAvailable )

            {

            __PRINTS( "NITZ info is available" );

            // Update the status to EDataAvailable

            selfObject->iDataAvailability = EDataAvailable;

            // We have data from server.

            listenerObject->NitzInfoAvailableL();

            }

        else

            {

            __PRINTS( "NITZ info unavailable" );

            // Update the status to EDataNotAvailable

            selfObject->iDataAvailability = EDataNotAvailable;

            // We don't have any data for sure.

            selfObject->NitzInfoNotAvailableL();

            }

        }

	else//CDT Query timer is active. 

	    {

            {

            selfObject->iAdtUpdaterAppUi->ToggleAppViewL(ETrue);

            }

	__PRINTS( "CAdtUpdaterContainer::CallBackL - Exit" );

	return KZero;

	}

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

// CAdtUpdaterContainer::NitzInfoNotAvailableL

// rest of the details are commented in the header

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

//

void CAdtUpdaterContainer::NitzInfoNotAvailableL()

	{

	__PRINTS( "CAdtUpdaterContainer::NitzInfoNotAvailableL - Entry" );

	iTimeOut = ETrue;

	// First cancel all requests.

	CancelAllRequests();

	// The normal bootup sequence.

	WaitToShowQueriesL();

	__PRINTS( "CAdtUpdaterContainer::NitzInfoNotAvailableL - Exit" );

	// We're done. Exit the application.

	//iAdtUpdaterAppUi->Exit();

	}

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

// CAdtUpdaterContainer::NitzInfoAvailableL

// rest of the details are commented in the header

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

//

void CAdtUpdaterContainer::NitzInfoAvailableL( STimeAttributes aTimeAttributes, TInt aTimeZoneId )

	{

	__PRINTS( "CAdtUpdaterContainer::NitzInfoAvailableL - Entry" );

	__PRINTS( "!iTimeOut" );

	// Check if the Nitz packet has arrived before timeout. 

	// This is just a sanity check. Since this will function will be called by a different thread.

	if( !iTimeOut )	

		{

		__PRINT( "Received timezoneid: %d", aTimeZoneId );

		// First store the values.

		iTimeAttributes = aTimeAttributes;

		iTimeZoneId = aTimeZoneId;

		// Cancel all requests and timers.

		CancelAllRequests();

		// We're done. Exit the application.

		iAdtUpdaterAppUi->Exit();

		}

	__PRINTS( "CAdtUpdaterContainer::NitzInfoAvailableL - Exit" );

	}

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

// CAdtUpdaterContainer::CancelAllRequests

// rest of the details are commented in the header

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

//

void CAdtUpdaterContainer::CancelAllRequests()

	{

	__PRINTS( "CAdtUpdaterContainer::CancelAllRequests - Entry" );

	// Cancel the timer.

	if( iPeriodic )

		{

		iPeriodic->Cancel();

		}

	iNitzTimerActive = EFalse;

	// Cancel the listener

	if( iListener )

		{

		iListener->Cancel();

		}

	__PRINTS( "CAdtUpdaterContainer::CancelAllRequests - Exit" );

	}

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

// CAdtUpdaterContainer::DisplayNitzInfoL

// rest of the details are commented in the header

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

//

void CAdtUpdaterContainer::DisplayNitzInfoL()

	{

	__PRINTS( "CAdtUpdaterContainer::DisplayNitzInfoL - Entry" );

	// Construct CTzLocalizer object to get the name of the zone.

	CTzLocalizer* tzLocalizer = CTzLocalizer::NewL();

	CTzLocalizedCity* localizedCity( NULL );

	CTzLocalizedTimeZone* localizedTimeZone( NULL );

	TRAPD( errorVal, localizedTimeZone = tzLocalizer->GetLocalizedTimeZoneL( iTimeZoneId ) );

	__PRINT( "Received timezoneid: %d errorVal: %d ", iTimeZoneId, errorVal );

	if( KErrNone == errorVal )

		{

		if( localizedTimeZone )