/*

* 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:  Process Component for Login,Logout

*

*/

// INCLUDE FILES

#include 	"CCAEngine.h"

#include 	"PublicEngineDefinitions.h"

#include 	"ImpsCSPAllErrors.h"

#include    "MCABlocking.h"

#include    "MCAStoredContact.h"

#include    "MCAStoredContacts.h"

#include    "CCAStorageManagerFactory.h"

#include	"MCABackgroundInterface.h"

#include    "MCAContactListModel.h"

#include    "MCAContactList.h"

#include    "MCAContactLists.h"

#include    "CAPresenceManager.h"

#include 	"MCABackgroundObserver.h"

#include 	"MCABlockingPC.h"

#include 	"MCAServerContactsArrayPC.h"

#include 	"CCAServerContactsArrayPC.h"

#include    "CAArrayUtils.h"

#include 	"CCABlockingPC.h"

#include 	"MCABlockingBackgroundObserverPC.h"

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

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

// CCABlockingPC::NewL

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

//

CCABlockingPC* CCABlockingPC::NewL( CCAEngine& aEngine )

    {

    CCABlockingPC* self = new ( ELeave ) CCABlockingPC( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CCABlockingPC::~CCABlockingPC()

    {

    delete iBlockingArray;

    }

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

// CCABlockingPC::CCABlockingPC

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

// might leave.

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

//

CCABlockingPC::CCABlockingPC( CCAEngine& aEngine )

        : iEngine( aEngine ),

        iBlockingInterface( *iEngine.GetBlockingInterface() ),

        iBackgroundInterface( *iEngine.BackgroundInterface() )

    {

    }

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

// CCABlockingPC::ConstructL

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

//

void CCABlockingPC::ConstructL()

    {

    // codescanner warning can be ignored

    }

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

// CCABlockingPC::GetBackgroundStatus

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

//

TInt CCABlockingPC::GetBackgroundStatus()

    {

    return ( iBackgroundInterface.BackgroundTaskStatus(

                 MCABackgroundInterface::EBlockGrantListFetch ) );

    }

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

// CCABlockingPC::GetBlockedListFromServerL

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

//

TInt CCABlockingPC::GetBlockedListFromServerL()

    {

    return iBlockingInterface.GetBlockedListFromServerL();

    }

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

// CCABlockingPC::GetBlockedList

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

//

const CDesCArray*	CCABlockingPC::GetBlockedList()

    {

    const CDesCArray* blockedList = iBlockingInterface.BlockedList();

    return blockedList;

    }

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

// CCABlockingPC::RemoveL

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

//

TInt CCABlockingPC::RemoveL( const CDesCArray* aUnBlockList,

                             const CDesCArray* aGrantList  )

    {

    if ( aUnBlockList )

        {

        return iBlockingInterface.RemoveL( aUnBlockList, aGrantList );

        }

    return KErrNotFound;

    }

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

// CCABlockingPC::InsertL

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

//

TInt CCABlockingPC::InsertL( const CDesCArray* aUnBlockList,

                             const CDesCArray* /*aGrantList =NULL*/ )

    {

    if ( aUnBlockList )

        {

        return iBlockingInterface.InsertL( aUnBlockList, NULL );

        }

    return KErrNotFound;

    }

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

// CCABlockingPC::GetBlockedMembersL

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

//

void CCABlockingPC::GetBlockedMembersL( const TDesC& aIcon )

    {

    const CDesCArray* blockedMembers = iBlockingInterface.BlockedList();

    CDesCArray* blockedWVIDs = CAArrayUtils::CloneArrayLC( *blockedMembers );

    //Temporary array for the popup list

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

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

    CleanupStack::PushL( identifications );

    CleanupStack::PushL( nicknames );

    MCAStoredContacts* contacts =

        CCAStorageManagerFactory::ContactListInterfaceL();

    //Populating temporary array

    TInt blockedMembersCount( blockedWVIDs->MdcaCount() );

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

        {

        identifications->AppendL( contacts->Identification(

                                      blockedWVIDs->MdcaPoint( count ) ) );

        MCAStoredContact* contact = contacts->FindAnyContact(

                                        blockedWVIDs->MdcaPoint( count ) );

        if ( contact )

            {

            nicknames->AppendL( contact->Nickname() );

            }

        else

            {

            nicknames->AppendL( KNullDesC );

            }

        }

    if ( iBlockingArray )

        {

        iBlockingArray->ReplaceL( nicknames, blockedWVIDs, aIcon,

                                  identifications );

        }

    else

        {

        // servercontactsarray takes the ownership

        iBlockingArray = CCAServerContactsArrayPC::NewL( nicknames,

                                                         blockedWVIDs,

                                                         aIcon,

                                                         identifications );

        }

    CleanupStack::Pop( 3, blockedWVIDs );

    // identifications, nicknames, blockedWVIDs

    }

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

// CCABlockingUI::GetBlockedMembersLC

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

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

//

MCAServerContactsArrayPC* CCABlockingPC::GetBlockedMembersLC(

    const TDesC& aIcon )

    {

    const CDesCArray* blockedMembers = iBlockingInterface.BlockedList();

    CDesCArray* blockedWVIDs = CAArrayUtils::CloneArrayLC( *blockedMembers );

    //Temporary array for the popup list

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

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

    CleanupStack::PushL( identifications );

    CleanupStack::PushL( nicknames );

    MCAStoredContacts* contacts =

        CCAStorageManagerFactory::ContactListInterfaceL();

    //Populating temporary array

    TInt blockedMembersCount( blockedWVIDs->MdcaCount() );

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

        {

        identifications->AppendL( contacts->Identification(

                                      blockedWVIDs->MdcaPoint( count ) ) );

        MCAStoredContact* contact = contacts->FindAnyContact(

                                        blockedWVIDs->MdcaPoint( count ) );

        if ( contact )

            {

            nicknames->AppendL( contact->Nickname() );

            }

        else

            {

            nicknames->AppendL( KNullDesC );

            }

        }

    // servercontactsarray takes the ownership

    CCAServerContactsArrayPC* pairsArray =

        CCAServerContactsArrayPC::NewL( nicknames,

                                        blockedWVIDs,

                                        aIcon, identifications );

    CleanupStack::Pop( 3, blockedWVIDs ); // identifications, nicknames, blockedWVIDs

    CleanupStack::PushL( pairsArray );

    return pairsArray;

    }

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

// CCABlockingPC::GetBlockedMembersL

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

//

MCAServerContactsArrayPC& CCABlockingPC::GetServerContactsArray()

    {

    return *iBlockingArray;

    }

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

// CCABlockingPC::GetUnBlockListL

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

//

CDesCArrayFlat* CCABlockingPC::GetUnBlockListL( TInt aSelectedItem,

                                                const TDesC& aFindTxt )

    {

    // Simulate the findPane functionality when getting the iSelectedItem

    // from the blockingArray structure

    CDesCArrayFlat* unBlockList =  new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

    // unBlockList is those persons who are going to be unblocked

    const TCAServerContact* unblocked = iBlockingArray->WVIdL( aSelectedItem, aFindTxt );

    if ( unblocked ) //can be NULL

        {

        unBlockList->AppendL( unblocked->iWVID );

        }

    return unBlockList;

    }

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

// CCABlockingPC::GetWvId

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

//

TPtrC CCABlockingPC::GetWvIdL( const TDesC& aIcon, TInt aDeletedIndex )

    {

    CCAServerContactsArrayPC* blockedMembers = static_cast

                                               < CCAServerContactsArrayPC* >

                                               ( GetBlockedMembersLC(  aIcon ) );

    if ( ( *blockedMembers ).MdcaCount() < 0 ||

         ( aDeletedIndex < 0 || aDeletedIndex >= ( *blockedMembers ).MdcaCount() ) )

        {

        return KNullDesC();

        }

    TPtrC wvId = ( ( *blockedMembers )[ aDeletedIndex ].iWVID );

    CleanupStack::Pop( blockedMembers );

    return wvId;

    }

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

// CCABlockingPC::RegisterBackgroundObserver

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

//

void CCABlockingPC::RegisterBackgroundObserver(

    MCABlockingBackgroundObserverPC* aBackgroundObserver )

    {

    ASSERT( aBackgroundObserver );

    iBackgroundObserver = aBackgroundObserver;

    iBackgroundInterface.RegisterBackgroundObserver( this,

                                                     MCABackgroundInterface::EBlockGrantListFetch,

                                                     MCABackgroundInterface::EFailed |

                                                     MCABackgroundInterface::EUnknown |

                                                     MCABackgroundInterface::ECancelled |

                                                     MCABackgroundInterface::ECompleted );

    }

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

// CCABlockingPC::RegisterBackgroundObserver

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

//

void CCABlockingPC::UnRegisterBackgroundObserver(  )

    {

    iBackgroundObserver = NULL;

    iBackgroundInterface.UnRegisterBackgroundObserver( this );

    }

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

// CCABlockingPC::HandleBackgroundEvent

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

//

void CCABlockingPC::HandleBackgroundEvent(

    MCABackgroundInterface::TCABackgroundTasks aEventSource,

    MCABackgroundInterface::TCABackgroundStatus aStatus,

    TInt aSubTaskNumber,

    TInt aLeaveCode

)

    {

    TEnumsPC::TCABackgroundTasks eventSource;

    TEnumsPC::TCABackgroundStatus status;

    switch ( aEventSource )

        {

        case MCABackgroundInterface::EGroupFetch:

            {

            eventSource = TEnumsPC::EGroupFetch;

            break;

            }

        case MCABackgroundInterface::EPresence:

            {

            eventSource = TEnumsPC::EPresenceTask;

            break;

            }

        case MCABackgroundInterface::EWhisperSync:

            {

            eventSource = TEnumsPC::EWhisperSync;

            break;

            }

        default:

            {

            eventSource = TEnumsPC::EBlockGrantListFetch;

            break;

            }

        }

    switch ( aStatus )

        {

        case MCABackgroundInterface::EUnknown:

            {

            status = TEnumsPC::EUnknownStatus;

            break;

            }

        case MCABackgroundInterface::EIdleStarted:

            {

            status = TEnumsPC::EIdleStarted;

            break;

            }

        case MCABackgroundInterface::EStarting:

            {

            status = TEnumsPC::EStarting;

            break;

            }

        case MCABackgroundInterface::EWaiting:

            {

            status = TEnumsPC::EWaiting;

            break;

            }

        case MCABackgroundInterface::ECompleted:

            {

            status = TEnumsPC::ECompleted;

            break;

            }

        case MCABackgroundInterface::ECancelled:

            {

            status = TEnumsPC::ECancelled;

            break;

            }

        default:

            {

            status = TEnumsPC::EFailedStatus;

            break;

            }

        }

    iBackgroundObserver->HandleBackgroundEventPC(

        eventSource,

        status,

        aSubTaskNumber,

        aLeaveCode

    );

    }

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

// CCABlockingPC::RegisterBackgroundObserver

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

//

TInt CCABlockingPC::DeleteContactL( TInt aSelectedItem, const TDesC& aFindTxt )

    {

    TInt errorCode( KErrNone );

    // Simulate the findPane functionality when getting the iSelectedItem

    // from the blockingArray structure

    const TCAServerContact* unblocked = iBlockingArray->WVIdL( aSelectedItem, aFindTxt );

    // if block is in hide mode. We have to delete those items from contact lists.

    MCAStoredContacts* contacts = CCAStorageManagerFactory::ContactListInterfaceL();

    TInt countOfLists( contacts->ListCount() );

    for ( TInt listCount( 0 ); listCount < countOfLists && errorCode == KErrNone; ++listCount )

        {

        MCAContactList& list = contacts->ListAt( listCount );

        MCAStoredContact* contact = NULL;

        if ( unblocked ) //can be NULL

            {

            contact = contacts->FindContact( list.ListId(), unblocked->iWVID );

            }

        if ( contact )

            {

            MCAPresence* presence = CAPresenceManager::InstanceL();

            MCAContactLists* listInterface = presence->ContactLists();

            // don't update to network directly

            TRAP( errorCode, listInterface->DeleteServerContactL( list.ListId(),

                                                                  contact->UserId(), EFalse ) );

            }

        }

    // Update all changes with one operation

    MCAPresence* presence = CAPresenceManager::InstanceL();

    MCAContactLists* listInterface = presence->ContactLists();

    listInterface->CommitDeleteServerContactL();

    return errorCode;

    }

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

// CCABlockingPC::RemoveIDsL

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

//

void CCABlockingPC::RemoveIDsL( const CDesCArray* aUserIds )

    {

    TInt userIdCount( aUserIds->MdcaCount() );

    MCAStoredContacts* contacts =

        CCAStorageManagerFactory::ContactListInterfaceL();

    TInt listCount( contacts->ListCount() );

    MCAPresence* presence = CAPresenceManager::InstanceL();

    MCAContactLists* listInterface = presence->ContactLists();

    for ( TInt listindex( 0 ); listindex < listCount; listindex++ )

        {//list iteration

        MCAContactList& myList( contacts->ListAt( listindex ) );

        for ( TInt useridindex( 0 ); useridindex < userIdCount; useridindex++ )

            {

            listInterface->DeleteServerContactL( myList.ListId(),

                                                 aUserIds->MdcaPoint( useridindex ) );

            }

        }

    }

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

// CCABlockingPC::IsContactBlocked

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

//

TBool CCABlockingPC::IsContactBlocked( const TDesC& aContact,

                                       TBool aUseGrant /* EFalse*/ ) const

    {

    return iBlockingInterface.IsContactBlocked( aContact, aUseGrant );

    }

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

// CCABlockingPC::SetTemporaryGrantL

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

//

TInt CCABlockingPC::SetTemporaryGrantL( const TDesC& aContact, TBool aOn )

    {

    return iBlockingInterface.SetTemporaryGrantL( aContact, aOn );

    }