/*
* 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: Reactive authorization handling utilities
*
*/
//INCLUDES
#include "CCAReactiveAuthorization.h"
#include "CCAAppUi.h"
#include "IMDialogUtils.h"
#include "StringLoader.h"
#include "IMUtils.h"
#include "CCAContactEditor.h"
#include "CAUtils.h"
#include "CCABlockingUI.h"
#include "ChatDebugAssert.h"
#include "MCAReactiveAuthPC.h"
#include "MCASettingsPC.h"
#include "MCAProcessManager.h"
#include "MCABlockingPC.h"
#include <chatNG.rsg>
#include <chatNG.mbg>
#include "CCAUINGUtils.h"
#include "CCAPCUtils.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 ===============================
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::CCAReactiveAuthorization
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CCAReactiveAuthorization::CCAReactiveAuthorization( CCAAppUi& aAppUi,
MCAReactiveAuthPC* aReactiveAuthPC )
: iAppUi( aAppUi ),
iReactiveAuthPC( aReactiveAuthPC )
{
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCAReactiveAuthorization* CCAReactiveAuthorization::NewLC( CCAAppUi& aAppUi,
MCAReactiveAuthPC* aReactiveAuthPC )
{
CCAReactiveAuthorization* temp =
new( ELeave )CCAReactiveAuthorization( aAppUi, aReactiveAuthPC );
CleanupStack::PushL( temp );
temp->ConstructL();
return temp;
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCAReactiveAuthorization* CCAReactiveAuthorization::NewL( CCAAppUi& aAppUi,
MCAReactiveAuthPC* aReactiveAuthPC )
{
CCAReactiveAuthorization* temp = CCAReactiveAuthorization::NewLC( aAppUi, aReactiveAuthPC );
CleanupStack::Pop( temp );
return temp;
}
// Destructor
CCAReactiveAuthorization::~CCAReactiveAuthorization()
{
delete iIdle;
delete iBlockingUI;
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCAReactiveAuthorization::ConstructL()
{
iIdle = CIdle::NewL( CActive::EPriorityIdle );
// iBlockingUI is constructed when it's needed,
// because of the login speedup
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::HandleRAPendingReqL
// New pending request
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCAReactiveAuthorization::HandleRAPendingReqL()
{
if ( ! IMUtils::IntResourceValueL(
RSC_CHAT_VARIATION_REACTIVE_PRESENCE_AUTH ) )
{
// no RA active
return;
}
// launch consumer method via CIdle
if ( !iIdle->IsActive() && !iRequestPending )
{
// not active, launch it again
iIdle->Start( TCallBack( ConsumerCallback, this ) );
iRequestPending = ETrue;
}
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::HandleRAStatusL
// New RA status message
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCAReactiveAuthorization::HandleRAStatusL()
{
if ( ! IMUtils::IntResourceValueL(
RSC_CHAT_VARIATION_REACTIVE_PRESENCE_AUTH ) )
{
// no RA active
return;
}
// launch consumer via CIdle
if ( ! iIdle->IsActive() && !iRequestPending )
{
// not active, launch it again
iIdle->Start( TCallBack( ConsumerCallback, this ) );
iRequestPending = ETrue;
}
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::HandleRAError
// Error case, some of the RA observer methods left.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCAReactiveAuthorization::HandleRAError( TInt aError )
{
if ( aError )
{
CActiveScheduler::Current()->Error( aError );
}
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::ConsumerCallback
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CCAReactiveAuthorization::ConsumerCallback( TAny* aInstance )
{
return static_cast<CCAReactiveAuthorization*>( aInstance )->Consumer();
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::Consumer
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CCAReactiveAuthorization::Consumer()
{
TRAPD( err, iRequestPending = DoConsumerL() );
if ( err )
{
CActiveScheduler::Current()->Error( err );
iRequestPending = EFalse;
}
return iRequestPending;
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::DoConsumerL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CCAReactiveAuthorization::DoConsumerL()
{
// 1. get pending messages from IM Presence
// - handle queue
// 2. Get pending statuses from IM Presence
// - handle queue
// 3. If both queues are empty, get out
HBufC* userId = HBufC::NewLC( KMaxWVIDLength );
// since this method got called, there has to be at least one (1) in either
// array
TPtr userIdPtr( userId->Des() );
TInt id = 0;
TInt lastPendingPos = 0;
// eat up the request queue
// can get the whole list at once on pc side( like have been done for
// status queue) n then handle here
// can do later if it is a performance issue
while ( iReactiveAuthPC->GetNextPendingRARequestL( id, userIdPtr,
lastPendingPos ) )
{
// keep on emptying the queue
TBool response = DoHandleRAPendingReqL( *userId );
iReactiveAuthPC->SendReactiveAuthResponseL( id, response );
}
// eat up the status queue
CDesCArray* userIdsArray = new ( ELeave ) CDesCArrayFlat( 1 );
CleanupStack::PushL( userIdsArray );
iReactiveAuthPC->GetListOfRAStatusL( userIdPtr, *userIdsArray );
TInt count = userIdsArray->Count();
for ( TInt i( 0 ); i < count; i++ )
{
// the user rejected us
DoHandleRAStatusL( userIdsArray->MdcaPoint( i ) );
}
CleanupStack::PopAndDestroy( userIdsArray );
CleanupStack::PopAndDestroy( userId );
return EFalse;
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::DoHandleRAPendingReqL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CCAReactiveAuthorization::DoHandleRAPendingReqL( const TDesC& aId )
{
// reactive authorization pending request
TBool accepted = EFalse;
TInt authorizePresence = iAppUi.GetProcessManager().GetSettingsInterface()
->GetIntValuePC( TEnumsPC::EAuthorizeIMPresence, NULL );
if ( !IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_HAVEPRESENCEAUTH ) )
{
// if VARIATION_HAVEPRESENCEAUTH is disabled, we always show RA query
authorizePresence = TEnumsPC::EFriends;
}
switch ( authorizePresence )
{
case TEnumsPC::EAllValue:
{
accepted = ETrue;
break;
}
case TEnumsPC::ENobody:
{
accepted = EFalse;
break;
}
case TEnumsPC::EFriends:
{
// check if we have that contact
TBool isContactFound( iReactiveAuthPC->FindAnyContactL( aId ) );
MCABlockingPC* blockingPC = iAppUi.GetProcessManager().GetBlockingInterface();
TBool isContactBlocked = blockingPC->IsContactBlocked( aId );
if ( isContactFound && !isContactBlocked )
{
// we have the user in our contactlist
accepted = ETrue;
}
else if ( isContactBlocked )
{
// we have the user in our blocked list
accepted = EFalse;
}
else
{
TInt aliasErr( 0 );
HBufC* aliasTxt = NULL;
HBufC* queryTxt = NULL;
// Get alias
TRAP( aliasErr, aliasTxt = iReactiveAuthPC->GetAliasL( aId ) );
CleanupStack::PushL( aliasTxt );
TBool validAlias( EFalse );
if ( aliasTxt )
{
validAlias = TBool( aliasTxt->Length() );
}
if ( aliasErr == KErrNotFound || !validAlias )
{
// no alias, use wvid
queryTxt = StringLoader::LoadLC(
R_QTN_CHAT_REACTIVE_AUTHORIZE_QUERY,
CCAPCUtils::DisplayId( aId ) );
}
else
{
if ( aliasErr == KErrNone )
{
// alias found
queryTxt = StringLoader::LoadLC( R_QTN_CHAT_REACTIVE_AUTHORIZE_QUERY,
*aliasTxt );
}
else
{
// all other errors
User::Leave( aliasErr );
}
}
// Ask from user to accept authorization
TInt result = IMDialogUtils::DisplayQueryDialogL(
R_GENERIC_YES_NO_CONFIRMATION_QUERY,
*queryTxt );
CleanupStack::PopAndDestroy( queryTxt );
CleanupStack::PopAndDestroy( aliasTxt );
if ( ( result == EAknSoftkeyOk ) || ( result == EAknSoftkeyYes ) )
{
// recipient has accepted authorization
accepted = ETrue;
// we don't have the contact,
// so ask if the user wants to add it
queryTxt = StringLoader::LoadLC( R_QTN_CHAT_REACTIVE_ADD_LIST,
CCAPCUtils::DisplayId( aId ) );
result = IMDialogUtils::DisplayQueryDialogL(
R_GENERIC_YES_NO_CONFIRMATION_QUERY,
*queryTxt );
CleanupStack::PopAndDestroy( queryTxt );
if ( ( result == EAknSoftkeyOk ) || ( result == EAknSoftkeyYes ) )
{
// verify that we have a contact list
if ( CCAUINGUtils::VerifyContactlistL() ==
CCAUINGUtils::EChatNoContactList )
{
// Could not create contact list
break;
}
// add the contact to friends list
TBool contactSaved = EFalse;
CCAContactEditor* contactEditor =
CCAContactEditor::NewL( -1, contactSaved );
TInt err;
TRAP( err, contactEditor->EditContactLD(
TEnumsPC::EAddToContact, KNullDesC(), aId ) );
}
}
else
{
// user did not auth, ask whether to block
queryTxt = StringLoader::LoadLC( R_QTN_CHAT_REACTIVE_BLOCK,
CCAPCUtils::DisplayId( aId ) );
result = IMDialogUtils::DisplayQueryDialogL(
R_GENERIC_YES_NO_CONFIRMATION_QUERY, *queryTxt );
CleanupStack::PopAndDestroy( queryTxt );
if ( ( result == EAknSoftkeyOk ) ||
( result == EAknSoftkeyYes ) )
{
// make sure that blocking interface exists
iAppUi.FinalizeChatConstructionL();
// block the contact
if ( !iBlockingUI )
{
iBlockingUI = CCABlockingUI::NewL( blockingPC );
}
iBlockingUI->BlockUserL( aId );
}
accepted = EFalse;
}
}
break;
}
default:
{
// We should not get here... some strange value
__CHAT_ASSERT_DEBUG( EFalse );
break;
}
}
return accepted;
}
// -----------------------------------------------------------------------------
// CCAReactiveAuthorization::DoHandleRAStatusL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCAReactiveAuthorization::DoHandleRAStatusL( const TDesC& aId )
{
// reactive authorization status
HBufC* text = StringLoader::LoadLC(
R_QTN_CHAT_REACTIVE_NOT_AUTHORIZED, CCAPCUtils::DisplayId( aId ) );
IMDialogUtils::DisplayNoteDialogL( *text, R_AVKON_SOFTKEYS_OK_EMPTY__OK,
CAknNoteDialog::ENoTimeout );
CleanupStack::PopAndDestroy( text );
}
// End of file