/*
* Copyright (c) 2008 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: Info Note implementation
*
*/
// System Includes
#include <eikenv.h>
#include <e32std.h>
#include <aknmessagequerydialog.h>
#include <bautils.h>
#include <StringLoader.h>
#include <data_caging_path_literals.hrh>
#include <AknNotiferAppServerApplication.h>
#include <aknPopupHeadingPane.h>
#include <evtinfonote.rsg>
#include <s32mem.h>
#include <eikbtgpc.h>
#include <gulicon.h>
#include <AknsUtils.h>
#include <eikimage.h>
#include <aknnotedialog.h>
// User Includes
#include "evtinfonoteparams.h"
#include "evtinfonote.h"
#include "evtinfonoteinterface.h"
#include "evtinfonoteconsts.hrh"
#include "evtinfonoteimpl.h"
#include "evtdebug.h"
// Constant Definitions
_LIT(KResourceFileName, "evtinfonote.rsc");
static const TInt KLengthOfNum = 64;
//
// ------------------------- Member Function definition ----------------------
// ---------------------------------------------------------------------------
// CEvtInfoNote::CEvtInfoNote()
// ---------------------------------------------------------------------------
//
CEvtInfoNote::CEvtInfoNote()
: CActive( EPriorityStandard )
{
}
// ---------------------------------------------------------------------------
// CEvtInfoNote::~CEvtInfoNote()
// ---------------------------------------------------------------------------
//
CEvtInfoNote::~CEvtInfoNote()
{
// If there is an existing message outstanding then
// terminate the message
CompleteMessage( KErrServerTerminated );
Cancel();
delete iInputBuffer;
// Free the resources
iEikEnv->DeleteResourceFile( iResourceFileFlag );
if ( iAppSwitchSupress && iAppUi )
{
iAppUi->SuppressAppSwitching( EFalse );
iAppSwitchSupress = EFalse;
}
}
// ---------------------------------------------------------------------------
// void CEvtInfoNote::ConstructL()
// ---------------------------------------------------------------------------
//
void CEvtInfoNote::ConstructL()
{
EVTUIDEBUG( "+ CEvtInfoNote::ConstructL" );
// Store a Local pointer for Eikon Env
iEikEnv = CEikonEnv::Static();
iAppUi = static_cast< CAknNotifierAppServerAppUi* >( iEikEnv->EikAppUi());
// Open the localized resource file
TFileName dllDrive;;
Dll::FileName( dllDrive );
// File name without the drive letter.
TFileName filename;
filename += KDC_RESOURCE_FILES_DIR;
filename += KResourceFileName;
// Append the drive letter to the file name.
TParse parse;
User::LeaveIfError( parse.Set( dllDrive, NULL, NULL ) );
User::LeaveIfError( parse.Set( parse.Drive(), &filename, NULL ) );
filename = parse.FullName();
BaflUtils::NearestLanguageFile(iEikEnv->FsSession(),filename);
EVTUIDEBUG( "Before Resource File" );
iResourceFileFlag=iEikEnv->AddResourceFileL(filename);
EVTUIDEBUG( "After Resource File" );
// Add the object to the Active scheduler
CActiveScheduler::Add( this );
EVTUIDEBUG( "- CEvtInfoNote::ConstructL" );
}
// ---------------------------------------------------------------------------
// CEvtInfoNote* CEvtInfoNote::NewL()
// ---------------------------------------------------------------------------
//
CEvtInfoNote* CEvtInfoNote::NewL()
{
CEvtInfoNote* self = new ( ELeave ) CEvtInfoNote;
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// void CEvtInfoNote::Release()
// ---------------------------------------------------------------------------
//
void CEvtInfoNote::Release()
{
EVTUIDEBUG( "+ CEvtInfoNote::Release" );
// This method is called to free all the resources
// associated with the Notifier. Here it would mean deleting
// the notifier handle
delete this;
EVTUIDEBUG( "- CEvtInfoNote::Release" );
}
// ---------------------------------------------------------------------------
// MEikSrvNotifierBase2::TNotifierInfo CEvtInfoNote::Info() const
// ---------------------------------------------------------------------------
//
MEikSrvNotifierBase2::TNotifierInfo CEvtInfoNote::Info() const
{
EVTUIDEBUG( "+ CEvtInfoNote::Info" );
// Return the notifier information
return iInfo;
}
// ---------------------------------------------------------------------------
// TPtrC8 CEvtInfoNote::StartL
// ---------------------------------------------------------------------------
//
TPtrC8 CEvtInfoNote::StartL( const TDesC8& /* aBuffer */ )
{
TPtrC8 ret( KNullDesC8 );
return ( ret );
}
// ---------------------------------------------------------------------------
// void CEvtInfoNote::StartL
// ---------------------------------------------------------------------------
//
void CEvtInfoNote::StartL( const TDesC8& aBuffer,
TInt aReplySlot,
const RMessagePtr2& aMessage )
{
EVTUIDEBUG( "+ CEvtInfoNote::StartL" );
// The notifier will handle only one request at a time.
if ( IsActive())
{
User::Leave ( KErrInUse );
}
iTriggerEvent = EDisplayNotifier;
iMessage = aMessage;
// Delete the old buffer and copy the contents of the argument into this
// buffer
// This buffer needs to be stored because, the user is going to handle
// the request asynchrnously.
delete iInputBuffer;
iInputBuffer = NULL;
iInputBuffer = aBuffer.AllocL();
// Copy the reply Slot
iReplySlot = aReplySlot;
TRequestStatus* status = &iStatus;
SetActive();
User::RequestComplete( status, KErrNone );
EVTUIDEBUG( "- CEvtInfoNote::StartL" );
}
// ---------------------------------------------------------------------------
// void CEvtInfoNote::Cancel
// ---------------------------------------------------------------------------
//
void CEvtInfoNote::Cancel()
{
EVTUIDEBUG( "+ CEvtInfoNote::Cancel" );
// Delete the running Information note
delete iInfoNote;
iInfoNote = NULL;
CompleteMessage( KErrCancel );
delete iInputBuffer;
iInputBuffer = NULL;
iTriggerEvent = ENone;
CActive::Cancel();
EVTUIDEBUG( "- CEvtInfoNote::Cancel" );
}
// ---------------------------------------------------------------------------
// TPtrC8 CEvtInfoNote::UpdateL
// ---------------------------------------------------------------------------
//
TPtrC8 CEvtInfoNote::UpdateL( const TDesC8& /* aBuffer */ )
{
TPtrC8 ret( KNullDesC8 );
return ( ret );
}
// ---------------------------------------------------------------------------
// TPtrC8 CEvtInfoNote::UpdateL
// ---------------------------------------------------------------------------
//
void CEvtInfoNote::UpdateL( const TDesC8& /* aBuffer */,
TInt /* aReplySlot */,
const RMessagePtr2& aMessage)
{
aMessage.Complete( KErrNotSupported );
}
// ---------------------------------------------------------------------------
// CEvtInfoNote::TNotifierInfo CEvtInfoNote::RegisterL()
// ---------------------------------------------------------------------------
//
CEvtInfoNote::TNotifierInfo CEvtInfoNote::RegisterL()
{
iInfo.iUid = KEvtInfoNote;
iInfo.iChannel = KEvtInfoNoteChannel;
iInfo.iPriority = ENotifierPriorityHigh;
return iInfo;
}
// ---------------------------------------------------------------------------
// void CEvtInfoNote::CompleteMessage()
// ---------------------------------------------------------------------------
//
void CEvtInfoNote::CompleteMessage( TInt aError,
TInt aKeyPressEvent )
{
EVTUIDEBUG( "+ CEvtInfoNote::CompleteMessage" );
// Check if the message is not NULL
if ( !iMessage.IsNull() )
{
// Obtain the Reply slot and communicate the response
// to the user
TInt desLength = iMessage.GetDesLength( iReplySlot );
if ( desLength >= KLengthOfNum )
{
TBuf8< KLengthOfNum > returnBuf;
returnBuf.AppendNum( aKeyPressEvent );
TInt length = returnBuf.Length();
length = length + 1;
TInt error = iMessage.Write( iReplySlot, returnBuf );
if ( !error )
{
EVTUIDEBUG1( "CEvtInfoNote::CompleteMessage - Write Error : %d", error );
}
}
iMessage.Complete( aError );
}
if ( iAppSwitchSupress && iAppUi )
{
iAppUi->SuppressAppSwitching( EFalse );
iAppSwitchSupress = EFalse;
}
iTriggerEvent = ENone;
EVTUIDEBUG( "- CEvtInfoNote::CompleteMessage" );
}
// ---------------------------------------------------------------------------
// void CEvtInfoNote::RunL()
// ---------------------------------------------------------------------------
//
void CEvtInfoNote::RunL()
{
EVTUIDEBUG( "+ CEvtInfoNote::RunL" );
// Do this only on KErrNone
if ( !iStatus.Int())
{
switch( iTriggerEvent )
{
case EDisplayNotifier:
{
// Fetch the input parameters
CEvtInfoNoteInputParam* param = GetInputParametersLC();
CleanupStack::Pop( param );
// Create a new dialog instance
CEvtInfoNoteImpl* queryDialog = CEvtInfoNoteImpl::NewLC( param );
// Display the dialog in cover UI
// queryDialog->PublishDialogL( SuplQueryId(), KCatUidSuplQuery );
// Store the value for the Query dialog. this would be useful
// for cancelling it.
iInfoNote = queryDialog;
// Supress the App switching
if ( !iAppSwitchSupress )
{
iAppUi->SuppressAppSwitching( ETrue );
iAppSwitchSupress = ETrue;
}
TEvtInfoNoteCmds flag;
TInt keypress = KErrNone;
keypress = queryDialog->RunLD( &flag );
iInfoNote = NULL;
EVTUIDEBUG1( "Key Press : %d", keypress );
EVTUIDEBUG1( "Return Code : %d", flag );
if ( keypress )
{
switch( flag )
{
case EEvtCmdOpenEvent:
{
CompleteMessage( KErrNone, EOpenTrigger );
break;
}
case EEvtCmdSnoozeEvent:
{
CompleteMessage( KErrNone, ESnoozeTrigger );
break;
}
case EEvtCmdShowDetails:
{
CompleteMessage( KErrNone, EShowDetails );
break;
}
case ECloseInfoNote:
{
CompleteMessage( KErrNone, ECloseInfoNote );
break;
}
default:
{
break;
}
}
}
else
{
CompleteMessage( KErrNone, ECloseInfoNote );
}
// Reset the trigger Event
iTriggerEvent = ENone;
break;
}
default:
{
User::Leave( KErrNotSupported );
break;
}
}
}
else
{
EVTUIDEBUG1( "- CEvtInfoNote::Error %d ", iStatus.Int() );
// Error Handling for non-KErrNone status
CompleteMessage( iStatus.Int());
}
EVTUIDEBUG( "- CEvtInfoNote::RunL" );
}
// ---------------------------------------------------------------------------
// void CEvtInfoNote::DoCancel()
// ---------------------------------------------------------------------------
//
void CEvtInfoNote::DoCancel()
{
// Reset the state machine
iTriggerEvent = ENone;
}
// ---------------------------------------------------------------------------
// TInt CEvtInfoNote::RunError()
// ---------------------------------------------------------------------------
//
TInt CEvtInfoNote::RunError( TInt aError )
{
EVTUIDEBUG( "+ CEvtInfoNote::RunError" );
// If the dialog value is set then the dialog must be
// set to NULL because the dialog would have been destroyed
// already since its present on the cleanup stack
iInfoNote= NULL;
// Complete the outstanding request with the error code
CompleteMessage( aError );
// Reset the state machine.
iTriggerEvent = ENone;
EVTUIDEBUG( "- CEvtInfoNote::RunError" );
return CActive::RunError( aError );
}
// ---------------------------------------------------------------------------
// TInt CEvtInfoNoteInputParam::GetInputParametersLC()
// ---------------------------------------------------------------------------
//
CEvtInfoNoteInputParam* CEvtInfoNote::GetInputParametersLC()
{
EVTUIDEBUG( "+ CEvtInfoNote::GetInputParametersLC" );
// Create a new input paramter object. The ownership of
// this object will be transferred back to the calling
// function.
CEvtInfoNoteInputParam* input = CEvtInfoNoteInputParam::NewL();
CleanupStack::PushL( input );
// Obtain the parameters from the Input Buffer
CBufFlat* inputParams =
CBufFlat::NewL( iInputBuffer->Des().Length() );
CleanupStack::PushL( inputParams );
inputParams->ResizeL( iInputBuffer->Des().Length());
inputParams->Ptr( 0 ).Copy( *iInputBuffer );
// Set the Read buffer to read the values from input buffer
RBufReadStream readStream( *inputParams, 0 );
CleanupClosePushL( readStream );
// Internalize the input buffer string to the current object.
input->InternalizeL( readStream );
CleanupStack::PopAndDestroy( 2, inputParams );
EVTUIDEBUG( "- CEvtInfoNote::GetInputParametersLC" );
return input;
}