/*

* Copyright (c) 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:  Editor for invites

*

*/

// INCLUDE FILES

#include	"CCAInviteEditor.h"		// header for this .cpp.

#include	"IMDialogUtils.h"

#include	"ChatDefinitions.h"

#include    "CCAApp.h"

#include    "CCAAppUi.h"

#include	"CCAVariantFactory.h"

#include    "ChatDebugPrint.h"

#include    "IMPSBuildDefinitions.h"

#include    "CCAContactSelectionDialog.h"

#include    "MCAInviteConflictResolver.h"

#include    "MCASettingsPC.h"

#include    "MCAMainViewArrayPC.h"

#include    "MCAProcessManager.h"

#include    "MCAInviteEditorPC.h"

#include    "MCAServerContactsArrayPC.h"

#include 	"ImpsCSPAllErrors.h"

#include 	"CCAPCUtils.h"

#include	<eikenv.h>

#include	<chatNG.rsg>

#include    <stringloader.h>

// The Settings have been moved to Cenrep (also retained in the Resource file),

// so the enums for keys and central repository header is added here

#include 	"VariantKeys.h"

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

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

// CCAInviteEditor::NewL

// Two-phased constructor.

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

//

CCAInviteEditor* CCAInviteEditor::NewL( const TDesC& aGroup )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aGroup );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCAInviteEditor::NewLC

// Two-phased constructor.

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

//

CCAInviteEditor* CCAInviteEditor::NewLC( const TDesC& aGroup )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aGroup );

    return self;

    }

// Destructor

CCAInviteEditor::~CCAInviteEditor()

    {

    delete iGroupID;

    delete iInviteEditorPC;

    }

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

// CCAInviteEditor::CreateAndSendInvitation

// (other items were commented in a header).

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

//

TBool CCAInviteEditor::CreateAndSendInvitation( MCAInviteConflictResolver& aResolver,

                                                const TDesC& aReceiver )

    {

    TRAPD( err, CreateAndSendInvitationL( aResolver, aReceiver ) );

    if ( err != KErrNone )

        {

        TRAPD( ign, ShowErrorNoteL() );

        if ( ign )

            {

            // propagate system errors to current active scheduler,

            CActiveScheduler::Current()->Error( ign );

            }

        }

    return ( err == KErrNone );

    }

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

// CCAInviteEditor::PopulateInviteListL

// (other items were commented in a header).

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

//

void CCAInviteEditor::PopulateInviteListL( CDesCArray& aInviteList,

                                           const MCAServerContactsArrayPC& aRawOnlineList,

                                           const CArrayFixFlat<TInt>& aSelectionArray )

    {

    iInviteEditorPC->PopulateInviteListL( aInviteList,

                                          aRawOnlineList,

                                          aSelectionArray );

    }

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

// CCAInviteEditor::QueryInviteMessageL

// (other items were commented in a header).

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

//

HBufC* CCAInviteEditor::QueryInviteMessageL()

    {

    HBufC* message = HBufC::NewLC( KInviteMessageMaxLength );

    TPtr messagePtr( message->Des() );

    if ( !IMDialogUtils::DisplayTextQueryDialogL( messagePtr,

                                                  R_CHAT_INVITE_MSG_DQ, R_CHAT_INVITE_MESSAGE_QUERY,

                                                  ETrue /* T9 */,

                                                  EFalse, // Show LSK only when needed

                                                  IMDialogUtils::ESend

                                                ) )

        {

        CleanupStack::PopAndDestroy( message );

        return NULL;

        }

    else

        {

        CleanupStack::Pop( message );

        return message;

        }

    }

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

// CCAInviteEditor::ShowErrorNoteL

// (other items were commented in a header).

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

//

void CCAInviteEditor::ShowErrorNoteL()

    {

    HBufC* prompt = CEikonEnv::Static()->AllocReadResourceLC(

                        R_CHAT_INVITE_SEND_ERROR );

    IMDialogUtils::DisplayErrorNoteL( *prompt );

    CleanupStack::PopAndDestroy( prompt );

    }

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

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

// might leave.

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

//

CCAInviteEditor::CCAInviteEditor(  )

    {

    }

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

// CCAInviteEditor::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCAInviteEditor::ConstructL( const TDesC& aGroup )

    {

    iGroupID = aGroup.AllocL();

    CCAAppUi* appUi = static_cast<CCAAppUi*>( CCoeEnv::Static()->AppUi() );

    iInviteEditorPC = appUi->GetProcessManager().CreateInviteEditorPCL();

    }

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

// CCAInviteEditor::CreateAndSendInvitationL

// (other items were commented in a header).

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

//

void CCAInviteEditor::CreateAndSendInvitationL( MCAInviteConflictResolver& aResolver,

                                                const TDesC& aReceiver

                                              )

    {

    CDesCArray* inviteList = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

    CleanupStack::PushL( inviteList );

    if ( aReceiver.Length() == 0 )

        {

        CCAAppUi* appUi = static_cast<CCAAppUi*>( CCoeEnv::Static()->AppUi() );

        CDesCArray* selectedContacts = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

        CleanupStack::PushL( selectedContacts );

        MCASkinVariant* skinVar = static_cast<CCAApp*>( appUi->Application() )

                                  ->VariantFactory()->SkinVariantL();

        MCASettingsPC* settingsPC = appUi->GetProcessManager().GetSettingsInterface();

        MCAMainViewArrayPC* mainViewArrayPC = appUi->GetProcessManager().GetArrayInterface();

        if ( ! CCAContactSelectionDialog::ShowDialogL( *selectedContacts,

                                                       *mainViewArrayPC,

                                                       *skinVar, *settingsPC,

                                                       appUi->MbmFullPath(),

                                                       TEnumsPC::EMultiSelect,

                                                       R_CONTACT_SELECTION_DIALOG,

                                                       *appUi->CAStatusPane(),

                                                       NULL ) )

            {

            // no contacts

            CleanupStack::PopAndDestroy( 2 ); // selectedContacts.Close(), inviteList

            return;

            }

        // handle selected contacts (if any)

        TInt count( selectedContacts->MdcaCount() );

        CHAT_DP( D_CHAT_LIT( "selection count %d" ), count );

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

            {

            TPtrC wvid( selectedContacts->MdcaPoint( i ) );

            CHAT_DP( D_CHAT_LIT( "..adding %S to invite list" ), &wvid );

            // Prevent duplicates and don't add if user canceled offline notification

            TInt pos( KErrNone );

            if ( inviteList->Find( wvid, pos ) != KErrNone )

                {

                inviteList->AppendL( wvid );

                }

            }

        CleanupStack::PopAndDestroy(); // selectedContacts.Close()

        }

    else

        {

        inviteList->AppendL( aReceiver );

        }

    // If user selected something, then proceed...

    if ( inviteList->MdcaCount() > 0 )

        {

        // Ask for invite message

        HBufC* message = QueryInviteMessageL();

        if ( message )

            {

            CleanupStack::PushL( message );

            // Resolve invite conflicts

            aResolver.ResolveInviteConflictL( *iGroupID, *inviteList );

            TInt inviteeCount = inviteList->MdcaCount();

            if ( inviteeCount > 0 )

                {

                // Create invitation

                // Show wait-note

                CCAAppUi* appUi =

                    static_cast< CCAAppUi* >( CCoeEnv::Static()->AppUi() );

                // Show wait-note. Error state dismisses it.

                appUi->ShowWaitDialogL( inviteList->MdcaCount() > 1 ?

                                        R_QTN_CHAT_INVITE_SENDING_MANY : R_QTN_CHAT_INVITE_SENDING,

                                        ETrue );

                // Send invitation

                TRAPD( retval, iInviteEditorPC->SendInvitationL( *inviteList,

                                                                 *iGroupID,

                                                                 *message ) );

                CleanupStack::PopAndDestroy( message );

                // Get rid of wait-note

                if ( retval == ECSPRecipientBlockedSender )

                    {

                    for ( TInt cnt = 0; cnt < inviteeCount; cnt++ )

                        {

                        appUi->DismissWaitDialogL( retval, EFalse,

                                                   CCAPCUtils::DisplayId( inviteList->MdcaPoint( cnt ) ) );

                        }

                    }

                else

                    {

                    appUi->DismissWaitDialogL( retval );

                    }

                }

            else

                {

                CleanupStack::PopAndDestroy( message );

                }

            }

        else

            {

            // User cancelled invite message query,

            // return to contact selection view

            CleanupStack::PopAndDestroy( inviteList );

            return;

            }

        }

    CleanupStack::PopAndDestroy( inviteList );

    }

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

// CCAInviteEditor::GetOnlineFriendsLC

// (other items were commented in a header).

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

//

MCAServerContactsArrayPC* CCAInviteEditor::GetOnlineFriendsLC()

    {

    MCAServerContactsArrayPC* pairsArray = iInviteEditorPC->GetOnlineFriendsLC( KIconTabulator );

    return pairsArray;

    }

//  End of File