/*

* Copyright (c) 2005-2006 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:  The firmware update result notifier.

*

*/

// INCLUDE FILES

#include <eikenv.h>          // Eikon environment

#include <uikon/eiksrvui.h>

#include <AknQueryDialog.h>

#include <aknmessagequerydialog.h>

#include <aknstaticnotedialog.h>

#include <centralrepository.h>  

#include <StringLoader.h>    // Localisation stringloader

#include <SyncMLClient.h>

#include <SyncMLClientDS.h>

#include <SyncMLClientDM.h>

#include <centralrepository.h>

#include <DevManInternalCRKeys.h>   

#include <SyncMLNotifierDomainCRKeys.h> 

#include <SyncMLNotifier.rsg>           // Own resources

#include <aknnotewrappers.h>

#include <e32property.h>

#include "SyncMLFwUpdNotifier.h"  // Class declaration

#include "SyncMLNotifDebug.h"

#include "SyncMLQueryDialog.h"

#include "SyncMLMessageQueryDialog.h"

#include "SyncMLNotifPrivateCRKeys.h"

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

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

// CSyncMLFwUpdNotifier::CSyncMLFwUpdNotifier

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSyncMLFwUpdNotifier::CSyncMLFwUpdNotifier()

    {

    iRunLhang = EFalse;

    iDlg = NULL;

    iFotaEncryptReq = EFalse;

    }

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

// CSyncMLDSNotifier::NewL

// Two-phased constructor.

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

//

CSyncMLFwUpdNotifier* CSyncMLFwUpdNotifier::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

//

CSyncMLFwUpdNotifier::~CSyncMLFwUpdNotifier()

    {

    Cancel();   // Free own resources

    }

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

// CSyncMLFwUpdNotifier::RegisterL

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

//

CSyncMLFwUpdNotifier::TNotifierInfo CSyncMLFwUpdNotifier::RegisterL()

    {

    FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::RegisterL()"));

    iInfo.iUid = KSyncMLFwUpdNotifierUid;

    iInfo.iChannel = KSmlFwUpdChannel;

    iInfo.iPriority = ENotifierPriorityHigh;

    FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::RegisterL() completed"));

    return iInfo;

    }

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

// CSyncMLFwUpdNotifier::GetParamsL

// Initialize parameters and check if device is already

// in registry. Jump to RunL as soon as possible.

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

//

void CSyncMLFwUpdNotifier::GetParamsL( const TDesC8& aBuffer,

                                             TInt aReplySlot,

                                       const RMessagePtr2& aMessage )

    {

    FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::GetParamsL()"));

    if( iReplySlot != NULL || iNeedToCompleteMessage )

        {

        User::Leave( KErrInUse );

        }

    iMessage = aMessage;

    iNeedToCompleteMessage = ETrue;

    iReplySlot = aReplySlot;

	TSyncMLFwUpdNotifParams param;

 	TPckgC<TSyncMLFwUpdNotifParams> pckg( param );

 	pckg.Set( aBuffer );

    iNoteType = pckg().iNoteType;

    iNoteInfo = pckg().iIntParam;

    iFotaMemoryNeeded = pckg().iMemoryNeeded;

    iFotaEncryptReq = pckg().iEncryptReq;

	iUserPostponeCount = pckg().iFotaUserPostponeCount;

    iMaxPostponeCount = pckg().iFotaMaxPostponeCount;

    iIntervalType = pckg().iIntervalType;

    iInterval = pckg().iInterval;

    if(pckg().iSelectedReminder.Length() > 0)

        iSelectedReminder.Copy(pckg().iSelectedReminder);

    // Call SetActive() so RunL() will be called by the active scheduler

    //

    SetActive();

    iStatus = KRequestPending;

    TRequestStatus* stat = &iStatus;

    User::RequestComplete( stat, KErrNone );

    FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::GetParamsL() completed"));

    }

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

// CSyncMLFwUpdNotifier::RunL

// Ask user response and return it to caller.

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

//

void CSyncMLFwUpdNotifier::RunL()

    {

    FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::RunL()"));

    TInt result( KErrNone );

    const TInt KNormal = 1;

		const TInt KForce = 0;

    // Turn lights on and deactivate apps -key

    //

    TurnLightsOn();

    SuppressAppSwitching( ETrue );

    switch( iNoteType )

        {

        case ESyncMLFwUpdErrorNote:

            {

            result = ShowUpdateErrorNoteL();

            break;

            }

        case ESyncMLFwUpdResultNote:

            {

            if (iFotaEncryptReq)

                {

                result = ShowUpdateResultWithEncryptionNoteL();

                }

            else

                {

                result = ShowUpdateResultNoteL();

                }

            break;

            }

		case ESyncMLFwUpdPostponeLimitQuery:

            {

            result = ShowPostLimitUpdateStartQueryL(KNormal);

       			break;

     				}

        case ESyncMLFwUpdForceQuery:

            {

            result = ShowPostLimitUpdateStartQueryL(KForce);

            break;

            }

        case ESyncMLFwUpdStartQuery:

            {

            result = ShowUpdateStartQueryL();

            break;

            }

        case ESyncMLFwUpdRebootNote:

            {

            CAknStaticNoteDialog* dlg = new ( ELeave ) CAknStaticNoteDialog;

            dlg->PrepareLC( R_SML_FOTA_RESTART_NOTE );

            HBufC* stringHolder = StringLoader::LoadLC( R_FOTA_REBOOT_NOTE );

            dlg->SetTextL( *stringHolder );

            CleanupStack::PopAndDestroy( stringHolder );

            result = dlg->RunLD();

            if ( result == KErrNone )

                {

                result = EAknSoftkeyOk;

                };

            break;

            }

     	case ESyncMLFwUpdNoReminder:

     		{

     		 result =  ShowNoReminderQueryL();

			 break;

            }

        case ESyncMLFwUpdLargeNotEnoughMemory:

        	{

        	 result = ShowNotEnoughMemoryL( iFotaMemoryNeeded , EFalse );

			 break;

        	}

        case ESyncMLFwUpdOmaDLNotEnoughMemory:

        	{

        	 result = ShowNotEnoughMemoryL( iFotaMemoryNeeded , ETrue );

			 break;

        	}	

        case ESyncMLFwUpdOmaDLUserCancel:

        	{

        	 result = ShowDownloadUserCancelL();

        	 break;	

        	}

        case ESyncMLFwUpdOmaDLPostponed:

        	{

        	 result = ShowDownloadPostponedL();

        	 break;	

        	}

        case ESyncMLFwUpdOmaDLCancelled:

        	{

        	 result = ShowDownloadCancelledL();

        	 break;	

        	}

        case ESyncMLFwUpdOmaDLResume:

        	{

        	 result = ShowDownloadResumeL();

        	 break;	

        	}

        case ESyncMLFwUpdStartQueryEnc:

            {

            result = ShowUpdateStartQueryEncryptionL();

            break;

            }

		case ESyncMLFwUpdPostponeNote:

            {

            result = ShowPostponeLimitNoteL();

            break; 

            }

        default: // Unhandled note type

            {

            FLOG(_L("[SMLNOTIF]\t CSyncMLDlgNotifier::RunL() Note type not handled"));

            User::Leave( KErrArgument );

            break;

            }

        }

    // Activate apps -key again

    //

    SuppressAppSwitching( EFalse );

		if ( iNeedToCompleteMessage )

			{

			// Translate the user key presses to message completion response

			FTRACE( FPrint( _L("[SmlNotif]\t User Key-Press for dialog = %d" ), result ) );

			switch( result ) 

				{

					case ESyncMLDlgRespKeyOk://all LSK press will fall here.

						iMessage.Complete( KErrNone );

						break;

					case ESyncMLDlgRespKeyCancel://all RSK press will fall here.

						iMessage.Complete (KErrCancel);

						break;

					case ESyncMLDlgRespKeyOthers: //all call-termination key press fall here.

						iMessage.Complete (KErrNotFound);

						break;

					default://rest of the cases and errors

						iMessage.Complete (KErrNone);

						break;

				}		

			}

    // Complete message and free resources

    //

    iNeedToCompleteMessage = EFalse;

    iReplySlot = NULL;

    iNoteType = ESyncMLFwUpdUnknown;

    FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::RunL() completed"));

    }

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

// CSyncMLFwUpdNotifier::Cancel

// Release all own resources (member variables)

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

//

void CSyncMLFwUpdNotifier::Cancel()

    {

    FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::Cancel()"));

    if(iRunLhang)

    	{

    	 FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::Cancel() inside Runlhang"));

    	if(iDlg)

    		{

    		FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::Cancel()before exit"));

    		TRAP_IGNORE(iDlg->ExitL());

    		if(iDlg)

    			{

        		FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::Cancel()before delete"));

    			delete iDlg;

    			iDlg = NULL;

        		FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::Cancel()after delete"));

    			}

    		}

    	}

    CSyncMLNotifierBase::Cancel();

    FLOG(_L("[SmlNotif]\t CSyncMLFwUpdNotifier::Cancel() completed"));

    }

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

// CSyncMLFwUpdNotifier::ShowUpdateErrorNoteL

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

//

TInt CSyncMLFwUpdNotifier::ShowUpdateErrorNoteL()

    {

    FTRACE( FPrint( _L(

        "[SmlNotif]\t CSyncMLFwUpdNotifier::ShowUpdateErrorNoteL() error = %d" ),

        iNoteInfo ) );

    HBufC* stringHolder( NULL );

    switch ( iNoteInfo )

        {

        case KErrDiskFull:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_NOT_PERMITTED );

            break;

            }

        case KErrCommsLineFail:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_LOST_CONNECTION );

            break;

            }

        case KErrCouldNotConnect:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_SERVER_ERROR );

            break;

            }

        case KErrBadPower:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_BATTERY_LOW );

            break;

            }

        case KErrBadUsbPower:

             {

             	stringHolder = StringLoader::LoadLC( R_FOTA_USB_BATTERY_LOW ); 

             	break;

            }

        case KErrCommsLineFail2:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_CONNECTION_FAIL2 );

            break;

            }

        case KErrGeneralResume:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_DOWNLOAD_GENERAL_RESUME );

            break;

            }

        case KErrGeneralNoResume:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_DOWNLOAD_NO_RESUME );

            break;

            }

        case KErrBadPowerForEnc:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_UPDATE_ENC_BATTERY_LOW );

            break;

            }

        case KErrDeviceMemoryBusy:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_DEVICE_MEMORY_BUSY );

            break;

            }

        default:

            {

            return KErrArgument; // Will be converted to KErrNone when completing

                                 // message, since this is not actually an error.

            }

        }

    TBool keypress(EFalse);

	CSyncMLMessageQueryDialog* msgDlg = CSyncMLMessageQueryDialog::NewL(keypress);

    msgDlg->SetMessageTextL(*stringHolder);

    CleanupStack::PopAndDestroy( stringHolder );

    msgDlg->PrepareLC( R_SML_MESSAGE_QUERY );  // Pushed dialog is popped inside RunLD

    stringHolder = StringLoader::LoadLC( R_FOTA_TITLE_PHONE_UPDATES );

    msgDlg->SetHeaderTextL( stringHolder->Des() );

    CleanupStack::PopAndDestroy( stringHolder );

    stringHolder = NULL;

   	msgDlg->ButtonGroupContainer().SetCommandSetL( 

    	                                  R_AVKON_SOFTKEYS_OK_EMPTY__OK );

    TInt retval (ESyncMLDlgRespKeyNone);

    iRunLhang = ETrue;

    iDlg = msgDlg; 

	retval = msgDlg->RunLD();

	iRunLhang = EFalse;

    msgDlg = NULL;

	iDlg = NULL;

	//call-termination key press is handled here.

	if (keypress)

    	retval = ESyncMLDlgRespKeyOthers;

    FTRACE( FPrint( _L(

        "[SmlNotif]\t CSyncMLFwUpdNotifier::ShowUpdateErrorNoteL() completed: retval = %d" ),

        retval ) );

    return retval;

    }

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

// CSyncMLFwUpdNotifier::ShowUpdateResultNoteL

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

//

TInt CSyncMLFwUpdNotifier::ShowUpdateResultNoteL()

    {

    FTRACE( FPrint( _L(

        "[SmlNotif]\t CSyncMLFwUpdNotifier::ShowUpdateResultNoteL() result = %d" ),

        iNoteInfo ) );

    HBufC* stringHolder( NULL );

    switch ( iNoteInfo )  // It is easier to add cases to switch structure

        {

        case KErrNone:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_NOTIF_COMPLETE );

            break;

            }

        default:

            {

            stringHolder = StringLoader::LoadLC( R_FOTA_MSG_QUERY_NOT_UPDATED );

            break;

            }

        }

    TBool keypress(EFalse);

	CSyncMLMessageQueryDialog* msgDlg = CSyncMLMessageQueryDialog::NewL(keypress);

    msgDlg->SetMessageTextL(*stringHolder);

    CleanupStack::PopAndDestroy( stringHolder );

    msgDlg->PrepareLC( R_SML_MESSAGE_QUERY );  // Pushed dialog is popped inside RunLD

    stringHolder = StringLoader::LoadLC( R_FOTA_TITLE_PHONE_UPDATES );

    msgDlg->SetHeaderTextL( stringHolder->Des() );

    CleanupStack::PopAndDestroy( stringHolder );

    stringHolder = NULL;

   	msgDlg->ButtonGroupContainer().SetCommandSetL( 

        									R_AVKON_SOFTKEYS_OK_EMPTY__OK );

    TInt retval(ESyncMLDlgRespKeyNone);

    iRunLhang = ETrue;

    iDlg = msgDlg; 

    retval = msgDlg->RunLD();

    iRunLhang = EFalse;

    msgDlg = NULL;

    iDlg = NULL;

	//call-termination key press has to be suppressed here. so keypress has no significance here!    

	/*if (keypress)

    	retval = EKeyOthers;*/

    FTRACE( FPrint( _L(

        "[SmlNotif]\t CSyncMLFwUpdNotifier::ShowUpdateResultNoteL() completed: retval = %d" ),

        retval ) );

    return retval;

    }

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

// CSyncMLFwUpdNotifier::ShowPostLimitUpdateStartQueryL

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

//

TInt CSyncMLFwUpdNotifier::ShowPostLimitUpdateStartQueryL(TInt aQueryType)

{	    

	    FTRACE( FPrint( _L(

	        "[SmlNotif]\t CSyncMLFwUpdNotifier::ShowUpdateStartQueryL() profileId = %d" ),

	        aQueryType ) );

      HBufC* headerText = StringLoader::LoadLC( R_FOTA_TITLE_PHONE_UPDATES );

      TInt retval (ESyncMLDlgRespKeyNone);  

      TBool keypress(EFalse);

//      CSyncMLQueryDialog* dlg = CSyncMLQueryDialog::NewL(keypress);

      CSyncMLMessageQueryDialog* msgDlg = CSyncMLMessageQueryDialog::NewL(keypress);

      // Implementation of notes for postpone limit requirement.

        TBuf< KSyncMLMaxProfileNameLength > operatorName;

        RetrieveProfileNameL( operatorName );