/*

* Copyright (c) 2004 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:  Synchronous client group notify mediator.

*

*/

// INCLUDE FILES

#include <E32std.h>

#include "CCnUiClientGroupUiNotifyMediator.h"

#include "CnUiCommon.hrh"

#include "CnUiPanics.h"

#include "IMPSCommonUiDebugPrint.h"

const TInt KClientGroupQueryTimeout = 30000000;    //30 seconds, defined in UI specification

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

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

// CCnUiClientGroupUiNotifyMediator::NewLC

// Two-phased constructor.

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

//

CCnUiClientGroupUiNotifyMediator* CCnUiClientGroupUiNotifyMediator::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CCnUiClientGroupUiNotifyMediator::~CCnUiClientGroupUiNotifyMediator()

    {

    //cancel the self

    Cancel();

    CancelActiveChannels();

    }

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

// might leave.

//

CCnUiClientGroupUiNotifyMediator::CCnUiClientGroupUiNotifyMediator()

        : CTimer( CActive::EPriorityUserInput )

    {

    }

// EPOC default constructor can leave.

void CCnUiClientGroupUiNotifyMediator::ConstructL()

    {

    CTimer::ConstructL();

    CActiveScheduler::Add( this );

    }

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

// CCnUiClientGroupUiNotifyMediator::CGQActiveConnectionScheduledCloseL()

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

//

TBool CCnUiClientGroupUiNotifyMediator::CGQActiveConnectionSuppressForScheduledConnectionL(

    const TDesC& aServerName,

    const TArray<TIMPSConnectionClient>& aClientsToShow )

    {

    return IssueTheQueryL( ECGQActiveConnectionSuppressForScheduledConnection, //RQ id from hrh

                           aServerName,

                           KClientGroupQueryTimeout,

                           EFalse,       //default result for timeout & deletion cases

                           aClientsToShow );

    }

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

// CCnUiClientGroupUiNotifyMediator::CGQActiveConnectionScheduledCloseL()

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

//

TBool CCnUiClientGroupUiNotifyMediator::CGQActiveConnectionScheduledCloseL(

    const TArray<TIMPSConnectionClient>& aClientsToShow )

    {

    return IssueTheQueryL( ECGQActiveConnectionScheduledClose, //RQ id from hrh

                           KNullDesC,

                           KClientGroupQueryTimeout,

                           ETrue,       //default result for timeout & deletion cases

                           aClientsToShow );

    }

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

// CCnUiClientGroupUiNotifyMediator::IssueTheQueryL()

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

//

TBool CCnUiClientGroupUiNotifyMediator::IssueTheQueryL(

    TInt aQueryMessageId,

    const TDesC& aDynamicInsertText,

    TTimeIntervalMicroSeconds32 aQueryTimeout,

    TBool aDefaultResult,

    const TArray<TIMPSConnectionClient>& aClientsToShow )

    {

    __ASSERT_ALWAYS( !IsActive(), User::Leave( KErrInUse ) );

    CancelActiveChannels();

    //issue client messages & time out notification

    IssueMessageToGroupsL( aQueryMessageId,

                           aDynamicInsertText,

                           aClientsToShow );

    After( aQueryTimeout );

    //wait the query to complete

    WaitCompletion();

    //get the completion result

    TBool queryResult = aDefaultResult;

    if ( iStatus == KErrNone )

        {

        queryResult = iQueryResult;

        }

    //and cancel all activity

    Cancel();               //cancel the time out timer

    CancelActiveChannels(); //cancel still active channels

    return queryResult;

    }

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

// CCnUiClientGroupUiNotifyMediator::HandleChannelMsg()

// MCnUiGroupChannelListener

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

//

void CCnUiClientGroupUiNotifyMediator::HandleChannelMsg( TInt aGroupId,

                                                         TGCChannelID aChannelId,

                                                         TInt aChannelMsg )

    {

    IMPSCUI_DP_TXT( "CCnUiClientGroupUiNotifyMediator::HandleChannelMsg()" );

    //there might come other messages from note cancellations etc.

    //those are ignored and only accept/declines are handled

    //==>query will timeout if no accept / decline is received

    if ( aChannelMsg == ERemoteQueryAccepted )

        {

        RemoveFromActiveChannels( aGroupId, aChannelId );

        iQueryResult = ETrue;

        iStatus = KErrNone;

        Completed();

        }

    else if ( aChannelMsg == ERemoteQueryDeclined )

        {

        RemoveFromActiveChannels( aGroupId, aChannelId );

        iQueryResult = EFalse;

        iStatus = KErrNone;

        Completed();

        }

    }

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

// CCnUiClientGroupUiNotifyMediator::RunL

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

//

void CCnUiClientGroupUiNotifyMediator::RunL()

    {

    IMPSCUI_DP_TXT( "CCnUiClientGroupUiNotifyMediator::RunL() Timed out" );

    iStatus = KErrTimedOut;

    Completed();

    }

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

// CCnUiClientGroupUiNotifyMediator::DoCancel

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

//

void CCnUiClientGroupUiNotifyMediator::DoCancel()

    {

    IMPSCUI_DP_TXT( "CCnUiClientGroupUiNotifyMediator::DoCancel()" );

    CTimer::DoCancel();

    iStatus = KErrCancel;

    Completed();

    }

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

// CCnUiClientGroupUiNotifyMediator::RunError

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

//

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

    {

    iStatus = KErrGeneral;

    Completed();

    return KErrNone;

    }

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

// CCnUiClientGroupUiNotifyMediator::WaitCompletion()

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

//

void CCnUiClientGroupUiNotifyMediator::WaitCompletion()

    {

    //wait with the scheduler loop

    IMPSCUI_DP_TXT( "CCnUiClientGroupUiNotifyMediator::WaitCompletion() - starting wait" );

    if ( !iWait.IsStarted() )

        {

        // Code scanner warning "active object called without checking

        // whether it is active or cancelling it first" ignored because

        // CActiveSchedulerWait is not an active object

        iWait.Start(); // CSI: 10 # See above

        }

    IMPSCUI_DP_TXT( "CCnUiClientGroupUiNotifyMediator::WaitCompletion() - wait done" );

    }

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

// CCnUiClientGroupUiNotifyMediator::Completed()

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

//

void CCnUiClientGroupUiNotifyMediator::Completed()

    {

    //break away from the waiting scheduler loop

    if ( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    }

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

// CCnUiClientGroupUiNotifyMediator::IssueMessageToGroupsL()

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

//

void CCnUiClientGroupUiNotifyMediator::IssueMessageToGroupsL(

    TInt aRemoteMessage,

    const TDesC& aExtraData,

    const TArray<TIMPSConnectionClient>& aClientGroups )

    {

    const TInt groupCount = aClientGroups.Count();

    for ( TInt ii( 0 ); ii < groupCount; ++ii  )

        {

        //issue the message to channel and listen further events from that channel

        TIMPSConnectionClient clientId = aClientGroups[ ii ];

        CCnUiGroupChannel* gc = CCnUiGroupChannel::NewLC( clientId,

                                                          ECnUiRemoteUiNotificationsChannel );

        gc->WriteL( aRemoteMessage, aExtraData );

        gc->ListenL( this );

        User::LeaveIfError( iGroupChannels.Append( gc ) );

        CleanupStack::Pop( gc ); //gc

        }

    }

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

// CCnUiClientGroupUiNotifyMediator::CancelActiveChannels()

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

//

void CCnUiClientGroupUiNotifyMediator::CancelActiveChannels()

    {

    //issue the cancel to all channels

    const TInt channelCount = iGroupChannels.Count();

    for ( TInt ii( 0 ); ii < channelCount; ++ii  )

        {

        TInt ignore;

        TRAP( ignore, iGroupChannels[ ii ]->WriteL( ERemoteCancelAllActivity ) );

        }

    //and destroy those

    iGroupChannels.ResetAndDestroy();

    }

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

// CCnUiClientGroupUiNotifyMediator::RemoveFromActiveChannels()

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

//

void CCnUiClientGroupUiNotifyMediator::RemoveFromActiveChannels( TInt aGroupId,

                                                                 TGCChannelID aChannelId )

    {

    //given channel is tried to remove from group of active channels

    //==> go downwards from the last index and remove all matching ones

    TInt ii = ( iGroupChannels.Count() - 1 ); //last index is 1 smaller than total count

    for ( ; ii >= 0; ii-- )

        {

        CCnUiGroupChannel* gc = iGroupChannels[ ii ];

        if ( ( gc->GroupID() == aGroupId ) && ( gc->ChannelId() == aChannelId ) )

            {

            iGroupChannels.Remove( ii );

            delete gc;

            }

        }

    }

// end of file