/*
* Copyright (c) 2010 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:  List query dialog suitable for verifier plug-in use.
*
*/


// INCLUDE FILES
#include "lpdglobalplugindialog.h"
#include "lpddlgobserver.h"
#include "lpdrequestorprocessor.h"
#include "locverifierdlgdebug.h"

#include <lbs/EPos_CPosContactRequestor.h>
#include <lbs/EPos_CPosServiceRequestor.h>
#include <lbs/EPos_CPosRequestor.h>
#include <hbsymbianvariant.h>
#include <hbtextresolversymbian.h>
#include <systemtoneservice.h>
#include <e32des16.h>

_LIT(KNotifReqSeperator,",");
_LIT(KHeadingKey, "heading");
_LIT(KQueryTextKey, "queryText");
_LIT(KQueryText2Key, "queryText2");
_LIT(KRequestorKey, "requestor");
_LIT(KVerificationDlgType, "hb.posverifiction.dialog/1.0");
_LIT(KLocTsFileName, "lilocationmw_");
_LIT(KLocTsFilePath, "z://resource/qt/translations/");
_LIT(KLocTsAFileAltPath, "c://resource/");
//Translation String Ids
//Verification Dialog
_LIT(KRequestHeading, "txt_loe_title_location_request");
_LIT(KSingleshotDecisionRejected, "txt_loe_info_your_location_will_not_be_shared_by_d");
_LIT(KSingleshotDecisionAccepted, "txt_loe_info_your_location_will_be_shared_by_defau");
_LIT(KSingleshotDecisionNotAvailable, "txt_loe_info_your_location_will_be_shared_with");
_LIT(KPeriodicDecisionRejected, "txt_loe_info_your_location_will_not_be_shared_peri");
_LIT(KPeriodicDecisionAccepted, "txt_loe_info_your_location_will_be_shared_periodic");
_LIT(KPeriodicDecisionNotAvailable, "txt_loe_info_you_location_will_be_shared_periodica");
_LIT(KRequestorText, "txt_loe_info_location_was_requested_by");
_LIT(KUnknownRequestor, "txt_loe_info_unknown_requestor");
//Notification
_LIT(KNotificationNotSent, "txt_loe_dpophead_your_location_not_sent_to");
_LIT(KNotificationSent, "txt_loe_dpophead_your_location_sent_to");

const TInt KNotificationTimeout = 15000;
const TInt KMaxSize = 1024;
const TInt KVariantMaxSize = 256;
// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CLpdGlobalPluginDialog::CLpdGlobalPluginDialog
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CLpdGlobalPluginDialog::CLpdGlobalPluginDialog(                    
    MLpdDlgObserver& aCallBack
    )
    : iCallBack( aCallBack ),
      iMsgBox(NULL),
      iNotification(NULL),
      iRequestInfo(NULL)
    {
    }

// -----------------------------------------------------------------------------
// CLpdGlobalPluginDialog::ConstructL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
void CLpdGlobalPluginDialog::ConstructL()
    {
    LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::ConstructL" );
    iMsgBox = CHbDeviceDialogSymbian::NewL();
    iNotification = CHbDeviceNotificationDialogSymbian::NewL(this);
    TBool result =
            HbTextResolverSymbian::Init(KLocTsFileName, KLocTsFilePath);
    if (!result)
        {
        HbTextResolverSymbian::Init(KLocTsFileName, KLocTsAFileAltPath);
        }
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::ConstructL" );
    }

// -----------------------------------------------------------------------------
// CLpdGlobalPluginDialog::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CLpdGlobalPluginDialog* CLpdGlobalPluginDialog::NewL(                    
    MLpdDlgObserver& aCallBack)
    {
    CLpdGlobalPluginDialog* self =
        new( ELeave ) CLpdGlobalPluginDialog( aCallBack);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);  
    return self;
    }

// Destructor
CLpdGlobalPluginDialog::~CLpdGlobalPluginDialog()
	{
   	 LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::~CLpdGlobalPluginDialog" );
   	delete iMsgBox;
	iMsgBox = NULL;
	
	delete iNotification;
	iNotification = NULL;
	
	 delete iRequestInfo;
	 iRequestInfo=NULL;
	 LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::~CLpdGlobalPluginDialog" );
	}


// -----------------------------------------------------------------------------
// CLpdGlobalPluginDialog::RunLD
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CLpdGlobalPluginDialog::RunVerificationQueryL()
    {
    LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::RunVerificationQueryL" );
    mSymbianVariantMap = CHbSymbianVariantMap::NewL();
    CleanupStack::PushL(mSymbianVariantMap);
    
    AddVerDlgHeadingParamL();
    AddQueryTextParamL();
    AddRequestorsParamL();
    CSystemToneService* sts = CSystemToneService::Create();
    iMsgBox->Show(KVerificationDlgType, *mSymbianVariantMap, this);
    if( sts )
        {
        sts->PlayTone(CSystemToneService::ELocationRequest);
        }
    CSystemToneService::Delete(sts);
    CleanupStack::Pop(mSymbianVariantMap);
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::RunVerificationQueryL" );
    }

void CLpdGlobalPluginDialog::RunNotificationL()
    {
    LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::RunNotificationL" );
    if( EPosDecisionByRequestSource == iRequestInfo->iNotifReason ||
        EPosVerificationTimeout == iRequestInfo->iNotifReason    )
        {
        if ( EPosDecisionAccepted == iRequestInfo->iRequestDecision )
            {
            HBufC* title = HbTextResolverSymbian::LoadL(KNotificationSent);
            CleanupStack::PushL(title);
            iNotification->SetTitleL(title->Des());
            CleanupStack::PopAndDestroy(title);
            }
        if( EPosDecisionRejected == iRequestInfo->iRequestDecision )
            {
            HBufC* title = HbTextResolverSymbian::LoadL(KNotificationNotSent);
            CleanupStack::PushL(title);
            iNotification->SetTitleL(title->Des());
            CleanupStack::PopAndDestroy(title);
            }
        }
    else
        {
        // Not supported   
        User::Leave(KErrNotSupported);
        }
    TBuf<KMaxSize> buf;
    
    TInt count= iRequestInfo->iRequestors.Count();
    if( count == 0 )
        {
        HBufC* requestor = HbTextResolverSymbian::LoadL(KUnknownRequestor);
        CleanupStack::PushL(requestor);
        buf.Append(requestor->Des());
        CleanupStack::PopAndDestroy(requestor);
        }
    else
        {
        for(TInt i=0;i< count;i++ )
            {
            if(i!=0)
                {
                buf.Append(KNotifReqSeperator);
                }
            buf.Append(iRequestInfo->iRequestors[i]->RequestorIdString());
            }
        }
    iNotification->SetTextL(buf);
    iNotification->SetTimeout(KNotificationTimeout);
    iNotification->EnableTouchActivation(ETrue);
    iNotification->ShowL();
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::RunNotificationL" );
    }

// -----------------------------------------------------------------------------
// CLpdGlobalPluginDialog::SetMessageTextL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CLpdGlobalPluginDialog::SetRequestInfoL( CLpdRequestorProcessor* aRequestInfo )
    {
    LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::SetRequestInfoL" );
    if(iRequestInfo)
        {
        // clear and create again if already has been set before
        delete iRequestInfo;
        iRequestInfo=NULL;
        }
    iRequestInfo=CLpdRequestorProcessor::NewL();
    
    iRequestInfo->iDialogType=aRequestInfo->iDialogType;
    iRequestInfo->iNotifReason=aRequestInfo->iNotifReason;
    iRequestInfo->iRequestDecision=aRequestInfo->iRequestDecision;
    iRequestInfo->iRequestType=aRequestInfo->iRequestType;
    
    const RPointerArray<CPosRequestor>& requestors = aRequestInfo->iRequestors;
    
    TInt count = requestors.Count();
    for(TInt i=0; i< count; i++ )
        {
        CPosRequestor::TRequestorIdFormat idFormat;
        TPtrC idString;
        idFormat=requestors[i]->RequestorIdFormat();
        idString.Set(requestors[i]->RequestorIdString());
        
        if( CPosRequestor::ERequestorService==requestors[i]->RequestType())
            {
            CPosServiceRequestor* service = CPosServiceRequestor::NewL(idFormat,idString);
            CleanupStack::PushL(service);
            // Ownership transferred
            iRequestInfo->iRequestors.Append(service);
            CleanupStack::Pop(service);
            }
        else
            {
            CPosContactRequestor* contact = CPosContactRequestor::NewL(idFormat,idString);
            CleanupStack::PushL(contact);
            // Ownership transferred
            iRequestInfo->iRequestors.Append(contact);
            CleanupStack::Pop(contact);
            }
        
        }
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::SetRequestInfoL" );
    }



void CLpdGlobalPluginDialog::Cancel()
    {
    // Close any running dialogs if any.Close() doesnt have any effect if dialog is not running
    LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::Cancel" );
    isCancelled = ETrue;
    iMsgBox->Cancel();
    iNotification->Close();
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::Cancel" );
    }

void CLpdGlobalPluginDialog::NotificationDialogActivated(
        const CHbDeviceNotificationDialogSymbian */*aDialog*/)        
    {
    LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::NotificationDialogActivated" );
    // Complete with KErrNone now 
    TRAP_IGNORE(iCallBack.HandleDlgDismissedL( KErrNone ));
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::NotificationDialogActivated" );
    }

void CLpdGlobalPluginDialog::NotificationDialogClosed(
        const CHbDeviceNotificationDialogSymbian */*aDialog*/,
        TInt aCompletionCode)
    {
    LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::NotificationDialogClosed" );
    TRAP_IGNORE(iCallBack.HandleDlgDismissedL( aCompletionCode ));
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::NotificationDialogClosed" );
    }

void CLpdGlobalPluginDialog::DataReceived(CHbSymbianVariantMap& /*aData*/)
    {
    LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::DataReceived" );
    mDissmissed = ETrue;
    TRAP_IGNORE(iCallBack.HandleDlgDismissedL( KErrAccessDenied ));
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::DataReceived" );
    }

void CLpdGlobalPluginDialog::DeviceDialogClosed(TInt /*aCompletionCode*/)
    {
     LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::DeviceDialogClosed" );
    if (!mDissmissed && !isCancelled)
        {
        TRAP_IGNORE(iCallBack.HandleDlgDismissedL( KErrNone ));
        }
     LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::DeviceDialogClosed" );
    }

void CLpdGlobalPluginDialog::AddVerDlgHeadingParamL()
    {
    LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::AddVerDlgHeadingParamL" );
    HBufC* headingText = HbTextResolverSymbian::LoadL(KRequestHeading);
    CleanupStack::PushL(headingText);
    CHbSymbianVariant* heading = CHbSymbianVariant::NewL(headingText,
            CHbSymbianVariant::EDes);
    CleanupStack::PushL(heading);
    mSymbianVariantMap->Add(KHeadingKey, heading );
    CleanupStack::Pop(heading);
    CleanupStack::PopAndDestroy(headingText);
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::AddVerDlgHeadingParamL" );
    }

void CLpdGlobalPluginDialog::AddQueryTextParamL()
    {
     LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::AddQueryTextParamL" );
    HBufC * value = HBufC::NewL(KVariantMaxSize);
    CleanupStack::PushL(value);
    HBufC * value2 = HBufC::NewL(KVariantMaxSize);
    CleanupStack::PushL(value2);
    HBufC* requestorText = HbTextResolverSymbian::LoadL(KRequestorText);
    CleanupStack::PushL(requestorText);

    if (CPosRequestor::ERequestSingleShot == iRequestInfo->iRequestType)
        {
        if (EPosDecisionNotAvailable == iRequestInfo->iRequestDecision)
            {
            HBufC* queryText = HbTextResolverSymbian::LoadL(
                    KSingleshotDecisionNotAvailable);
            CleanupStack::PushL(queryText);
            value->Des().Copy(queryText->Des());
            CleanupStack::PopAndDestroy(queryText);
            }
        else if (EPosDecisionAccepted == iRequestInfo->iRequestDecision)
            {
            HBufC* queryText = HbTextResolverSymbian::LoadL(
                    KSingleshotDecisionAccepted);
            CleanupStack::PushL(queryText);
            value->Des().Copy(queryText->Des());
            value2->Des().Copy(requestorText->Des());
            CleanupStack::PopAndDestroy(queryText);
            }
        else if (EPosDecisionRejected == iRequestInfo->iRequestDecision)
            {
            HBufC* queryText = HbTextResolverSymbian::LoadL(
                    KSingleshotDecisionRejected);
            CleanupStack::PushL(queryText);
            value->Des().Copy(queryText->Des());
            value2->Des().Copy(requestorText->Des());
            CleanupStack::PopAndDestroy(queryText);
            }
        }

    else if (CPosRequestor::ERequestPeriodic == iRequestInfo->iRequestType)
        {
        if (EPosDecisionNotAvailable == iRequestInfo->iRequestDecision)
            {
            HBufC* queryText = HbTextResolverSymbian::LoadL(
                    KPeriodicDecisionNotAvailable);
            CleanupStack::PushL(queryText);
            value->Des().Copy(queryText->Des());
            CleanupStack::PopAndDestroy(queryText);
            }
        else if (EPosDecisionAccepted == iRequestInfo->iRequestDecision)
            {
            HBufC* queryText = HbTextResolverSymbian::LoadL(
                    KPeriodicDecisionAccepted);
            CleanupStack::PushL(queryText);
            value->Des().Copy(queryText->Des());
            value2->Des().Copy(requestorText->Des());
            CleanupStack::PopAndDestroy(queryText);
            }
        else if (EPosDecisionRejected == iRequestInfo->iRequestDecision)
            {
            HBufC* queryText = HbTextResolverSymbian::LoadL(
                    KPeriodicDecisionRejected);
            CleanupStack::PushL(queryText);
            value->Des().Copy(queryText->Des());
            value2->Des().Copy(requestorText->Des());
            CleanupStack::PopAndDestroy(queryText);
            }
        }
    else
        {
        // Not supported   
        User::Leave(KErrNotSupported);
        }

    CHbSymbianVariant* queryText = CHbSymbianVariant::NewL(value,
            CHbSymbianVariant::EDes);
    CleanupStack::PushL(queryText);

    CHbSymbianVariant* queryText2 = CHbSymbianVariant::NewL(value2,
            CHbSymbianVariant::EDes);
    CleanupStack::PushL(queryText2);

    if (value2->Length()!= 0)
        {
        mSymbianVariantMap->Add(KQueryText2Key, queryText2);
        }
    mSymbianVariantMap->Add(KQueryTextKey, queryText);
    CleanupStack::Pop(queryText2);
    CleanupStack::Pop(queryText);
    CleanupStack::PopAndDestroy(3);
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::AddQueryTextParamL" );
    }

void CLpdGlobalPluginDialog::AddRequestorsParamL()
    {
    LOCVERIFIERDLGDEBUG( "+CLpdGlobalPluginDialog::AddRequestorsParamL" );
    CDesC16ArrayFlat* array = new CDesC16ArrayFlat(8);
    TInt reqCount = iRequestInfo->iRequestors.Count();
    if (!reqCount)
        {
        HBufC* requestor = HbTextResolverSymbian::LoadL(KUnknownRequestor);
        CleanupStack::PushL(requestor);
        array->AppendL(requestor->Des());
        CleanupStack::PopAndDestroy(requestor);
        }
    else
    	{
    	for (TInt i = 0; i < reqCount; ++i)
	        {
	        array->AppendL(iRequestInfo->iRequestors[i]->RequestorIdString());
	        }
	    }

    TInt count = array->MdcaCount();
    MDesCArray* marray = static_cast<MDesCArray*> (array);
    CHbSymbianVariant* requestors = CHbSymbianVariant::NewL(marray,
            CHbSymbianVariant::EDesArray);
    mSymbianVariantMap->Add(KRequestorKey, requestors);
    LOCVERIFIERDLGDEBUG( "-CLpdGlobalPluginDialog::AddRequestorsParamL" );
    }

// End of file