/*

* 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:  Methods for the SyncML Appserver starter notifier

*

*/

// INCLUDE FILES

#include <eikenv.h>             // Eikon environment

#include <SyncMLClient.h>

#include <SyncMLClientDS.h>

#include <SyncMLClientDM.h>

#include <SyncService.h>

#include <aknnotewrappers.h>

#include <s32mem.h> 

#include <in_sock.h>

#include <StringLoader.h>    // Localisation stringloader

#include <aknlists.h>

#include <avkon.mbg>

#include <aknconsts.h>

#include <utf.h>

#include <SyncMLNotifier.rsg>   // Own resources

#include "SyncMLDlgNotifier.h"  // Class definition

#include "SyncMLTimedMessageQuery.h"

#include "SyncMLAppLaunchNotifier.h"

#include "SyncMLNotifDebug.h"

#include "SyncMLTimedInputTextQuery.h"

#include "SyncMLTimedDateQuery.h"

#include "SyncMLTimedNumberQueryDialog.h"

#include "SyncMLAknPopUplist.h"

// CONSTANTS

const TInt  KSyncMLuSecsInSec   = 1000000; // Microseconds in a second

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

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

// CSyncMLDlgNotifier::NewL

// Two-phased constructor.

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

//

CSyncMLDlgNotifier* CSyncMLDlgNotifier::NewL(

    CSyncMLAppLaunchNotifier* aAppLaunchNotif )

    {

    FLOG( _L("[SmlNotif]\t CSyncMLDlgNotifier::NewL()") );

    CSyncMLDlgNotifier* self = new (ELeave) CSyncMLDlgNotifier( aAppLaunchNotif );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    FLOG( _L("[SmlNotif]\t CSyncMLDlgNotifier::NewL() completed") );

    return self;

    }

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

// Destructor

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

//

CSyncMLDlgNotifier::~CSyncMLDlgNotifier()

    {

    Cancel();   // Free own resources

    if(iListItems)

        {

        delete iListItems;

        iListItems = NULL;

        }

    if(iChunk.Handle())

        {

        iChunk.Close();

        }

    }

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

// CSyncMLDlgNotifier::EnableSyncProgressNoteL

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

//

void CSyncMLDlgNotifier::EnableSyncProgressNoteL( TBool aEnable )

    {

    FTRACE( FPrint( _L(

        "[SmlNotif]\t CSyncMLDlgNotifier::EnableSyncProgressNoteL(), aEnable = %d" ),

        aEnable ) );

    TSmlJobId currentJobId( KErrNotFound );

    TSmlUsageType usageType;

    TUint serviceId = 0;

    RSyncMLSession syncSession;

    CleanupClosePushL( syncSession );

    syncSession.OpenL();

    syncSession.CurrentJobL( currentJobId, usageType );

    syncSession.Close();

    CleanupStack::Pop( &syncSession );

    if ( currentJobId != KErrNotFound )

        {

        switch( usageType )

            {

            case ESmlDataSync:

                serviceId = KDataSyncServiceStart;

                break;

            case ESmlDevMan:

                serviceId = KDevManServiceStart;

                break;

            default:

                User::Leave( KErrArgument );

                break;

            }

        // There should be a valid pointer to the application launcher

        // notifier, but we can survive without it. Therefore we'll just

        // check for it to prevent a crash.

        if ( iAppLaunchNotif )

            {

            CSyncService* syncService = iAppLaunchNotif->SyncServiceL( serviceId );

            if ( syncService )

                {

                syncService->EnableProgressNoteL( aEnable );

                }

            }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    FLOG( _L("[SmlNotif]\t CSyncMLDlgNotifier::EnableSyncProgressNoteL() completed") );

    }

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

// CSyncMLDlgNotifier::RegisterL

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

//

CSyncMLDlgNotifier::TNotifierInfo CSyncMLDlgNotifier::RegisterL()

    {

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

    iInfo.iUid = KSyncMLDlgNotifierUid;

    iInfo.iChannel = KSmlDlgChannel;

    iInfo.iPriority = ENotifierPriorityHigh;

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

    return iInfo;

    }

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

// CSyncMLDlgNotifier::GetParamsL

// Initialize parameters and check if device is already

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

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

//

void CSyncMLDlgNotifier::GetParamsL( const TDesC8& aBuffer,

                                           TInt    aReplySlot,

                                     const RMessagePtr2& aMessage )

    {

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

    const TChar KDRSeparator('-');

    const TChar KChoiceItemSeparator(',');

    if ( iReplySlot != NULL || iNeedToCompleteMessage )

        {

        User::Leave( KErrInUse );

        }

    if ( AutoLockOnL() )

        {

        // The phone is locked, access denied.

        // Write results back to caller and complete message.

        aMessage.Complete( KErrLocked );

        iNeedToCompleteMessage = EFalse;

        return;

        }

    iMessage = aMessage;

    iNeedToCompleteMessage = ETrue;

    iReplySlot = aReplySlot;

    TSyncMLDlgNotifParams param;

    TPckgC<TSyncMLDlgNotifParams> pckg( param );

    pckg.Set( aBuffer );

    iNoteType = pckg().iNoteType;

    iServerMsg.Copy( pckg().iServerMsg.Left( KSyncMLMaxServerMsgLength ) );

    iMaxTime = pckg().iMaxTime;

    iMaxlen = pckg().iMaxLength;

    //check for iDR is there are not

    iDR.Copy( pckg().iDR.Left( KSyncMLMaxDefaultResponseMsgLength ) );

    iIT = pckg().iIT;

    iET = pckg().iET;

    //verification of other params as like maxtime

    if ( iMaxlen <= 0 || iMaxlen >KSyncMLMaxDefaultResponseMsgLength )

        {

        iMaxlen = KSyncMLMaxDefaultResponseMsgLength;

        }

    if ( iIT < ESyncMLInputTypeAlphaNumeric || iIT > ESyncMLInputTypeIPAddress )

        {

        iIT = ESyncMLInputTypeAlphaNumeric;

        }

    if ( iET < ESyncMLEchoTypeText || iET > ESyncMLEchoTypePassword )

        {

        iET = ESyncMLEchoTypeText;

        }

    if( iServerMsg.Length() == 0 )

        {

        HBufC* stringholder = NULL;

        stringholder = StringLoader::LoadLC( R_DEFAULT_ALERT_HEADING );

        iServerMsg.Copy( stringholder->Des() );

        CleanupStack::PopAndDestroy( stringholder );

        }

    if ( iMaxTime < 0 )

        {

        iMaxTime = 0;

        }

    if (iNoteType == ESyncMLSingleChoiceQuery || iNoteType == ESyncMLMultiChoiceQuery )

        {

		iNumberOfItems = pckg().iNumberOfItems;  		

        if(iNumberOfItems > 0)

            {            

            iListItems = new (ELeave) CDesCArrayFlat( iNumberOfItems );

            }

		else

			{

		    aMessage.Complete( KErrCancel );

			iNeedToCompleteMessage = EFalse;

			return;

			}

        TPtrC8 listitemsptr;

        TBuf<KSyncMLChoiceItemsLengthBuffer> listlengtharray;                

        User::LeaveIfError(iChunk.OpenGlobal(pckg().iChunkName,EFalse));

        TInt size1 = iChunk.Size();

        listitemsptr.Set(iChunk.Base(),size1);        

        HBufC* databuf = NULL;

        TRAPD(errC, databuf = CnvUtfConverter::ConvertToUnicodeFromUtf8L(listitemsptr));

        iChunk.Close();

        if(errC)

            {

            aMessage.Complete( errC );

            iNeedToCompleteMessage = EFalse;

            return;

            }

        CleanupStack::PushL(databuf);

        TPtr listitems = databuf->Des();                       		

        listlengtharray=pckg().iItemLength;      

        TPtrC temp1,temp2,temp3,temp4;        

        TInt currlen=0,itemlength=0;

        TInt prevcommapos=0;

        TBuf<4> checkon(_L("0\t"));

        TBuf<4> checkoff(_L("1\t"));        

        for(TInt i=0;i<listlengtharray.Length();i++)

            {            

            if(listlengtharray[i]== KChoiceItemSeparator )

                {

                if(prevcommapos)

                    {

                    temp1.Set(listlengtharray.LeftTPtr(i));

                    temp2.Set(temp1.Right(i-(prevcommapos+1)));

                    prevcommapos=  i;

                    }

                else //firsttime finding comma

                    {

                    prevcommapos=  i;

                    temp1.Set(listlengtharray.LeftTPtr(i));

                    temp2.Set(temp1.Right(i));

                    }                

                TLex lexval;

                lexval.Assign(temp2);

                lexval.Val(itemlength);                

                temp3.Set(listitems.Left(currlen + itemlength));

                temp4.Set(temp3.Right(itemlength));

                currlen += itemlength;                

                HBufC* item1 = HBufC::NewLC(temp4.Length()+3);

                if(iNoteType == ESyncMLMultiChoiceQuery)

                    {

                    item1->Des().Append(checkoff);//by default dont show check on                                     

                    }                

                item1->Des().Append(temp4);

                iListItems->AppendL(item1->Des());

                CleanupStack::PopAndDestroy(1);//item,dataBuf16                

                }

            }

        CleanupStack::PopAndDestroy(1);

        }   

    SetActive();

    iStatus = KRequestPending;

    TRequestStatus* stat = &iStatus;

    User::RequestComplete( stat, KErrNone );

    FTRACE( FPrint( _L(

            "[SmlNotif]\t CSyncMLDlgNotifier::GetParamsL() completed, iNoteType = %d, iTimeout = %d, iServerMsg = " ),

            iNoteType, iMaxTime ) );

    FTRACE( FPrint( _L(

            "[SmlNotif]\t \"%S\"" ),

            &iServerMsg ) );

    }

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

// CSyncMLDlgNotifier::Cancel

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

//

void CSyncMLDlgNotifier::Cancel()

    {

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

    CSyncMLNotifierBase::Cancel();

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

    }

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

// CSyncMLDlgNotifier::RunL

// Ask user response and return it to caller.

// Store device into registry if user has accepted authorisation.

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

//

void CSyncMLDlgNotifier::RunL()

    {

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

    const TChar KDRSeparator('-');

    const TChar KChoiceItemSeparator(',');

    TInt result( KErrNone );

 		EndKeyPress = EFalse;

    // Turn lights on and deactivate apps -key

    //

    TurnLightsOn();  

    switch( iNoteType )

        {

        case ESyncMLInfoNote:

            {

            CAknInformationNote* infoNote = new (ELeave) CAknInformationNote;

            TInt maxtime = iMaxTime * KSyncMLuSecsInSec;

            if ( maxtime < 0  )

                {

                maxtime = 0;

                }

            infoNote->SetTimeout( (CAknNoteDialog::TTimeout) maxtime );

            result = infoNote->ExecuteLD( iServerMsg );

            if ( result == KErrNone )

                {

                result = EAknSoftkeyOk;

                }

            break;

            }

        case ESyncMLErrorNote:

            {

            CAknErrorNote* errNote = new (ELeave) CAknErrorNote;

            TInt maxtime = iMaxTime * KSyncMLuSecsInSec;

            if ( maxtime < 0  )

                {

                maxtime = 0;

                }

            errNote->SetTimeout( (CAknNoteDialog::TTimeout) maxtime );

            result = errNote->ExecuteLD( iServerMsg );

            if ( result == KErrNone )

                {

                result = EAknSoftkeyOk;

                };

            break;

            }

        case ESyncMLOkQuery:

            {

            FLOG( _L("[SmlNotif]\t CSyncMLDlgNotifier::RunL() Ok/Empty query shown") );

            CSyncMLTimedMessageQuery* dlg =

                CSyncMLTimedMessageQuery::NewL( iServerMsg, iMaxTime );

            // Pushed dialog is popped inside RunLD

            dlg->PrepareLC( R_SML_MESSAGE_QUERY );

            	dlg->ButtonGroupContainer().SetCommandSetL( 

                                        R_AVKON_SOFTKEYS_OK_EMPTY__OK );

            EnableSyncProgressNoteL( EFalse );

            result = dlg->RunLD();

            dlg = NULL;

            EnableSyncProgressNoteL( ETrue );

            break;

            }

        case ESyncMLQueryNote:  // This enumeration will be removed.

        case ESyncMLYesNoQuery:

            {

            FLOG( _L("[SmlNotif]\t CSyncMLDlgNotifier::RunL() Yes/No query shown") );

            CSyncMLTimedMessageQuery* dlg = 

            CSyncMLTimedMessageQuery::NewL( iServerMsg, iMaxTime );

            // Pushed dialog is popped inside RunLD

            dlg->PrepareLC( R_SML_MESSAGE_QUERY );

            dlg->ButtonGroupContainer().SetCommandSetL( 

                    R_AVKON_SOFTKEYS_YES_NO__YES );

            EnableSyncProgressNoteL( EFalse );

            result = dlg->RunLD();

            dlg = NULL;

            EnableSyncProgressNoteL( ETrue );

            break;

            }

        case ESyncMLSingleChoiceQuery:

            {

			FLOG( _L("[SmlNotif]\t CSyncMLDlgNotifier::RunL() single choice list query") );             

            if ( iNumberOfItems > 0 )

                {

                SuppressAppSwitching( ETrue );

                EnableSyncProgressNoteL( EFalse );

                CEikFormattedCellListBox* listBox = new ( ELeave )

                CAknSinglePopupMenuStyleListBox;

                CleanupStack::PushL( listBox );

                CSyncMLAknPopUpList* popupList = 

                CSyncMLAknPopUpList::NewL( (CAknSingleHeadingPopupMenuStyleListBox*)listBox, 

                            R_AVKON_SOFTKEYS_OK_CANCEL__OK,

                            AknPopupLayouts::EMenuWindow,iMaxTime );

                CleanupStack::PushL( popupList );

                listBox->ConstructL( popupList, ( EAknListBoxSelectionList | EAknListBoxLoopScrolling ) );

                listBox->Model()->SetItemTextArray( iListItems );

                listBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );

                listBox->ItemDrawer()->FormattedCellData()->EnableMarqueeL( ETrue );

                listBox->HandleItemAdditionL();

                listBox->CreateScrollBarFrameL( ETrue );

                listBox->ScrollBarFrame()->SetScrollBarVisibilityL(

                        CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

                TInt defaultindex = 0;

                TLex drval(iDR);                    

                drval.Val(defaultindex);

                if(defaultindex > 0)

                    defaultindex--;

                else

                    defaultindex = 0;

                listBox->SetCurrentItemIndex(defaultindex);                                   

                popupList->SetTitleL( iServerMsg );

                CleanupStack::Pop( popupList );

				FLOG( _L("[SmlNotif]\t CSyncMLDlgNotifier::RunL() single choice list query shown") ); 

                result = popupList->ExecuteLD();

				FLOG( _L("[SmlNotif]\t CSyncMLDlgNotifier::RunL() single choice list query dismissed") ); 

                popupList = NULL;

                if ( result )

                    {

                    reply.irettext.Num(listBox->CurrentItemIndex()+1);

                    }

                reply.iretval = result;                

                CleanupStack::PopAndDestroy( listBox );  // Destroys also the icon array

                EnableSyncProgressNoteL( ETrue );

                SuppressAppSwitching( EFalse );

                }

				else

				{

				reply.iretval = result;				

				}

				TSyncMLDlgNotifReturnParamsPckg pkg(reply);

                iMessage.WriteL(iReplySlot,pkg);

            break;

            }

        case ESyncMLMultiChoiceQuery:

            {           

            if ( iNumberOfItems > 0 )

                {

				SuppressAppSwitching( ETrue );

                EnableSyncProgressNoteL( EFalse );

                // create listbox

                // list item string format: "0\tLabel" where 0 is an index to icon array

                CEikFormattedCellListBox* listBox =

                new ( ELeave ) CAknSingleGraphicPopupMenuStyleListBox;

                CleanupStack::PushL( listBox );

                // create popup

                CSyncMLAknPopUpList* popup = 

                CSyncMLAknPopUpList::NewL((CAknSingleHeadingPopupMenuStyleListBox*) listBox,

                            R_AVKON_SOFTKEYS_OK_CANCEL__MARK ,

                            AknPopupLayouts::EMenuWindow,iMaxTime);

                CleanupStack::PushL( popup );

                popup->SetTitleL(iServerMsg );

#ifdef RD_SCALABLE_UI_V2

                if( AknLayoutUtils::PenEnabled() )

                    {

                    listBox->ConstructL( popup, EAknListBoxStylusMultiselectionList );

                    }

                else

                    {

                    listBox->ConstructL( popup, EAknListBoxMultiselectionList );

                    }

#else

                listBox->ConstructL( popup, EAknListBoxMultiselectionList );

#endif

                listBox->CreateScrollBarFrameL(ETrue);

                listBox->ScrollBarFrame()->

                SetScrollBarVisibilityL(

                        CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );                

                SetIconsL(listBox);

                listBox->Model()->SetItemTextArray( iListItems );

                listBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );

                listBox->SetCurrentItemIndex(iDefindex);  

                listBox->ItemDrawer()->FormattedCellData()->EnableMarqueeL( ETrue );                

                listBox->HandleItemAdditionL();

                // set all items as selected

                TInt count( listBox->Model()->NumberOfItems() );                

                TBuf<20> drcheck;

                for( TInt index( 0 ); index < count; index++ )

                    {

                    drcheck.Zero();

                    drcheck.Append(KDRSeparator);

                    drcheck.AppendNum(index+1);

                    drcheck.Append(KDRSeparator);

                    if(iDR.Find(drcheck) >= KErrNone)

                        {

                        listBox->View()->SelectItemL( index );

                        }                                                            

                    }              

                // launch popup

                result = popup->ExecuteLD();

                // No leaving functions allowed between executeLD and CleanupStack::Pop().

                CleanupStack::Pop( popup );                

                /// Own: ListBox selection array

                const CArrayFix<TInt>* iSelectionArray;                

                if( result )

                    {

                    iSelectionArray = listBox->View()->SelectionIndexes();

                    TBuf<20> temp;

                    TBuf<KSyncMLMaxAlertResultLength> temp1;

                    for(TInt i=iSelectionArray->Count()-1;i>=0;i--)

                        {

                        temp.Num(iSelectionArray->At(i)+1);

                        if((temp1.Length() + temp.Length()) < KSyncMLMaxAlertResultLength )

                            {

                            temp1.Append(temp);

                            temp1.Append(KDRSeparator);