/*

* Copyright (c) 2009 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 creating notifications.

*

*/

// INCLUDE FILES

#include "HtiMessagesServicePlugin.h"

#include "HtiNotificationHandler.h"

#include <HtiDispatcherInterface.h>

#include <HtiLogging.h>

#include <aknSDData.h>          //CAknSDData

#include <avkon.rsg>            //R_AVKON_SOFTKEYS_LISTEN_EXIT

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

#define KSpeedDialViewId TVwsViewId( TUid::Uid( 0x1000590A ), TUid::Uid( 0x02 ) )

#define R_NCN_VOICE_MAIL_NOTE                     0x283d012

#define R_NCN_VOICE_MAILS_UNK_AMOUNT              0x283d01a

#define R_NCN_VOICE_MAIL_GROUPED                  0x283d017

#define R_NCN_VOICE_MAILS_UNK_AMOUNT_GROUPED      0x283d01b

// LOCAL CONSTANTS AND MACROS

_LIT8( KErrorInvalidParameters, "Invalid command parameters" );

_LIT8( KErrorCreateVoiceMessageNotificationFailed, "Creating voice message notification failed" );

_LIT8( KErrorClearNotificationFailed, "Clearing notification failed" );

_LIT8( KErrorUnrecognizedCommand, "Unrecognized command" );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CHtiNotificationHandler::NewL

// Two-phased constructor.

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

CHtiNotificationHandler* CHtiNotificationHandler::NewL()

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::NewL" );

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

    CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop();

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::NewL" );

    return self;

    }

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

// CHtiNotificationHandler::CHtiNotificationHandler

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

// might leave.

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

CHtiNotificationHandler::CHtiNotificationHandler()

    : CActive( CActive::EPriorityStandard ),

      iMsgWaiting(),

      iMsgWaitingPckg( iMsgWaiting ),

      iVoiceMailsInLine1(0)

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::CHtiNotificationHandler" );

    CActiveScheduler::Add( this );

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::CHtiNotificationHandler" );

    }

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

// CHtiNotificationHandler::~CHtiNotificationHandler

// Destructor.

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

CHtiNotificationHandler::~CHtiNotificationHandler()

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::~CHtiNotificationHandler" );

    Cancel();

    iMobilePhone.Close();

    iTelServer.Close();

    iReqQueue.Close();

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::~CHtiNotificationHandler" );

    }

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

// CHtiNotificationHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CHtiNotificationHandler::ConstructL()

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::ConstructL" );

    TInt err;       

    err = iTelServer.Connect();

    HTI_LOG_FORMAT("RTelServer::Connect() returns %d",err);

    User::LeaveIfError( err );

    err = iTelServer.GetPhoneInfo( 0, iPhoneInfo );

    HTI_LOG_FORMAT("RTelServer::GetPhoneInfo() returns %d",err);

    User::LeaveIfError( err ); 

    err = iMobilePhone.Open( iTelServer, iPhoneInfo.iName ); 

    HTI_LOG_FORMAT("RTelServer::Open() returns %d",err);

    User::LeaveIfError( err );

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::ConstructL" );

    }

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

// CHtiNotificationHandler::SetDispatcher

// Sets the dispatcher pointer.

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

void CHtiNotificationHandler::SetDispatcher( MHtiDispatcher* aDispatcher )

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::SetDispatcher" );

    iDispatcher = aDispatcher;

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::SetDispatcher" );

    }

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

// CHtiNotificationHandler::ProcessMessageL

// Parses the received message and calls handler functions.

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

void CHtiNotificationHandler::ProcessMessageL( const TDesC8& aMessage,

                                              THtiMessagePriority /*aPriority*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::ProcessMessageL" );

    // Zero length message and command code validity already checked

    // in HtiMessagesServicePlugin.

    if ( aMessage[0] == CHtiMessagesServicePlugin::ECreateVoiceMessageNotification )

        {

        TRAPD(err, HandleCreateVoiceMessageNotificationL(aMessage));

        if ( err != KErrNone )

            {

            SendErrorMessageL( err, KErrorCreateVoiceMessageNotificationFailed );

            }

        }

    else if ( aMessage[0] == CHtiMessagesServicePlugin::EClearAllNotifications)

        {

        TRAPD(err, HandleClearAllNotificationsL(aMessage));

        if( err!= KErrNone )

            {

            SendErrorMessageL( err, KErrorClearNotificationFailed );

            }

        }

    else

        {

        SendErrorMessageL( KErrArgument, KErrorUnrecognizedCommand );

        }

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::ProcessMessageL" );

    }

void CHtiNotificationHandler::RunL()

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::RunL" );

    if(iReqQueue.Count())

        {

        TNcnReqQueueElement elem = iReqQueue[0];

        iReqQueue.Remove(0);

        if(elem.iCmd == ENcnSetIndicator)

            {

            SetIndicator(elem.iIndicator, elem.iMsgCount, elem.iEnable);

            }

        else if(elem.iCmd == ENcnResetIndicator)

            {

            ResetIndicator();

            }

        }

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::RunL" );

    }

void CHtiNotificationHandler::DoCancel()

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::DoCancel" );

    if( IsActive() )

        {

        iMobilePhone.CancelAsyncRequest( EMobilePhoneSetIccMessageWaitingIndicators );

        }

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::DoCancel" );

    }

TInt CHtiNotificationHandler::RunError(TInt aError)

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::RunError" );

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::RunError" );

    return aError;

    }

CAknSoftNotificationParameters* CHtiNotificationHandler::CreateNotificationParametersLC(TBool aAmountKnown)

    {

        HTI_LOG_FUNC_IN( "CHtiNotificationHandler::CreateNotificationParametersLC" );

        const TUid KNcnDefaultMessageUid = { 1 };

        _LIT( KNcnResourceFile, "z:\\resource\\Ncnlist.rSC" );

        const TInt KNcnNotificationPriority = 2200;

        TInt noteId = aAmountKnown ? R_NCN_VOICE_MAIL_NOTE : R_NCN_VOICE_MAILS_UNK_AMOUNT;

        TInt groupId = aAmountKnown ? R_NCN_VOICE_MAIL_GROUPED : R_NCN_VOICE_MAILS_UNK_AMOUNT_GROUPED;

        TUid customMessageId = KNcnDefaultMessageUid; // default

        _LIT8( KNcnExternalLaunch, "outside" );

        CAknSoftNotificationParameters* ret = CAknSoftNotificationParameters::NewL(

                KNcnResourceFile,

                noteId,

                KNcnNotificationPriority,

                R_AVKON_SOFTKEYS_LISTEN_EXIT,

                CAknNoteDialog::ENoTone,

                KSpeedDialViewId,

                customMessageId,

                EAknSoftkeyListen,

                KNcnExternalLaunch );

        ret->SetGroupedTexts( groupId );

        CleanupStack::PushL( ret );

        HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::CreateNotificationParametersLC" );

        return ret;

    } 

void CHtiNotificationHandler::ShowNewItemsL( CAknSoftNotifier* aNotifier, 

        const TAknSoftNotificationType aNotificationType, const TInt aAmount )

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::ShowNewItemsL" );

    TInt KVMMaximumNumber = 0xfe;

    TBool amountKnown = ( aAmount <= KVMMaximumNumber );

    // fuzzy voicemail note and normal voice mail note should never exist at the same time. 

    // Always cancel the other before adding new note.

    if ( aNotificationType == EVoiceMailNotification

        || aNotificationType == ESeparateVoiceMailOnLine1Notification

        || aNotificationType == ESeparateVoiceMailOnLine2Notification )

        {

        CAknSoftNotificationParameters* params =

            CreateNotificationParametersLC(!amountKnown);

        aNotifier->CancelCustomSoftNotificationL( *params );

        CleanupStack::PopAndDestroy( params );

        }

    // create notification parameters

    CAknSoftNotificationParameters* params =

        CreateNotificationParametersLC(amountKnown);

    if( aAmount <= 0 )

        {

        aNotifier->CancelCustomSoftNotificationL( *params );

        }

    else

        {

        aNotifier->SetCustomNotificationCountL( *params, aAmount );

        }

    // destroy parameters

    CleanupStack::PopAndDestroy( params );

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::ShowNewItemsL" );

    }

void CHtiNotificationHandler::SetNotificationL(TUint aAmount)

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::SetNotificationL" );

    //Convert to avkon type

    TAknSoftNotificationType aknType = EVoiceMailNotification;

    //Get the secondary display id for this note

    TInt dialogID = 5; //SecondaryDisplay::ECmdVoiceMailNotification in NcnSecondaryDisplayAPI.h

    // The category UID for the messages in this header file.

    //

    const TUid KCatNcnList = {0x100058F1};

    const TUint KNcnExternalizedNumberMaxLength = 8;

    // Amount needs to be stored to "additional parameter"

    TBuf8<KNcnExternalizedNumberMaxLength> additionalData;

    additionalData.Num(aAmount);

    // Encapsulate the sent data

    CAknSDData* sdData = NULL;

    TRAPD( status, sdData = CAknSDData::NewL(

            KCatNcnList, 

            dialogID, 

            additionalData) );

    // Create notifier instance

    CAknSoftNotifier* notifier = CAknSoftNotifier::NewL();

    CleanupStack::PushL(notifier);

    // Send data to cover ui    

    if ( status == KErrNone && sdData != NULL)

        {

        notifier->SetSecondaryDisplayData( sdData ); //Takes ownership 

        }

    // If there are problems with notifier, just catch the error and 

    // try to finish the other processes.

    TRAP( status, ShowNewItemsL( notifier, aknType, aAmount ) );

    CleanupStack::PopAndDestroy(notifier);

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::SetNotificationL" );

    }

void CHtiNotificationHandler::SetIndicator(const TNcnIndicator aIndicator, TUint aMsgCount, TBool aEnable)

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::SetIndicator" );

    TInt aId = RMobilePhone::KDisplayVoicemailActive;

    if( aEnable )       

        {

        iMsgWaiting.iDisplayStatus |= aId;          

        }

    else

        {

        iMsgWaiting.iDisplayStatus &= ~ aId;                    

        } 

    iMsgWaiting.iVoiceMsgs = aMsgCount;

    if(IsActive())

        {

        TNcnReqQueueElement elem(ENcnSetIndicator, aIndicator, aMsgCount, aEnable );

        iReqQueue.Append( elem );

        }

    else

        {

        iStatus = KRequestPending;

        iMobilePhone.SetIccMessageWaitingIndicators( iStatus, iMsgWaitingPckg );

        HTI_LOG_FORMAT("iStatus: %d", iStatus.Int());

        SetActive();

        }

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::SetIndicator" );

    }

void CHtiNotificationHandler::ResetIndicator()

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::ResetIndicator" );

    if( IsActive() )

        {

        TNcnReqQueueElement elem(ENcnResetIndicator, ENcnIndicatorVMLine1, 0, EFalse );

        iReqQueue.Append( elem );

        return;

        }

    iMsgWaiting.iVoiceMsgs = 0;

    iMsgWaiting.iDisplayStatus = 0;

    iMobilePhone.SetIccMessageWaitingIndicators( iStatus, iMsgWaitingPckg );

    SetActive();

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::ResetIndicator" );

    }

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

// CHtiNotificationHandler::HandleCreateVoiceMessageNotificationL

// Creates new voice message notification.

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

void CHtiNotificationHandler::HandleCreateVoiceMessageNotificationL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::HandleCreateVoiceMessageNotificationL" );

    if ( aData.Length() == 1 )

        {

        HTI_LOG_TEXT( "no command parameter, using default value 1");

        iVoiceMailsInLine1 = 1;

        }    

    else if(aData.Length() == 2) //1-byte command parameter

        {

        iVoiceMailsInLine1 = aData[1];

        HTI_LOG_FORMAT("%d new voice messages", iVoiceMailsInLine1);

        }

    else

        {

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::HandleCreateVoiceMessageNotificationL" );

        return;

        }

    ResetIndicator();

    SetNotificationL(iVoiceMailsInLine1);    

    SetIndicator(ENcnIndicatorVMLine1, iVoiceMailsInLine1, iVoiceMailsInLine1 ? ETrue : EFalse);    

    SendOkMsgL( KNullDesC8 );    

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::HandleCreateVoiceMessageNotificationL" );

    }

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

// CHtiNotificationHandler::HandleClearAllNotificationsL

// Clears all message notifications.

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

void CHtiNotificationHandler::HandleClearAllNotificationsL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::HandleClearAllNotificationsL" );

    if ( aData.Length() != 1 )

        {

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::HandleClearAllNotificationsL" );

        return;

        }

    CAknSoftNotifier* notifier = CAknSoftNotifier::NewL();

    CleanupStack::PushL(notifier);

    CAknSoftNotificationParameters* params = CreateNotificationParametersLC( ETrue );  

    notifier->CancelCustomSoftNotificationL( *params ); 

    CleanupStack::PopAndDestroy(2);//param, notifier

    ResetIndicator();

    SendOkMsgL( KNullDesC8 ); 

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::HandleClearAllNotificationsL" );

    }

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

// CHtiNotificationHandler::SendOkMsgL

// Helper function for sending response messages.

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

void CHtiNotificationHandler::SendOkMsgL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::SendOkMsgL" );

    User::LeaveIfNull( iDispatcher );

    HBufC8* temp = HBufC8::NewL( aData.Length() + 1 );

    TPtr8 response = temp->Des();

    response.Append( ( TChar ) CHtiMessagesServicePlugin::EResultOk );

    response.Append( aData );

    User::LeaveIfError( iDispatcher->DispatchOutgoingMessage(

        temp, KHtiMessagesServiceUid ) );

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::SendOkMsgL" );

    }

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

// CHtiNotificationHandler::SendErrorMessageL

// Helper function for sending error response messages.

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

void CHtiNotificationHandler::SendErrorMessageL( TInt aError, const TDesC8& aDescription )

    {

    HTI_LOG_FUNC_IN( "CHtiNotificationHandler::SendErrorMessageL" );

    User::LeaveIfNull( iDispatcher );

    User::LeaveIfError( iDispatcher->DispatchOutgoingErrorMessage(

        aError, aDescription, KHtiMessagesServiceUid ) );

    HTI_LOG_FUNC_OUT( "CHtiNotificationHandler::SendErrorMessageL" );

    }

// End of file