/*
* Copyright (c) 2002-2007 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: Handles CloseChannel command
*
*/
#include "MSatApi.h"
#include "MSatUtils.h"
#include "MSatBIPUtils.h"
#include "MSatUiSession.h"
#include "SatSOpcodes.h"
#include "MSatSUiClientHandler.h"
#include "CCloseChannelHandler.h"
#include "SatLog.h"
// ======== MEMBER FUNCTIONS ========
// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCloseChannelHandler* CCloseChannelHandler::NewL( MSatUtils* aUtils )
{
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::NewL calling" )
CCloseChannelHandler* self = new( ELeave ) CCloseChannelHandler;
CleanupStack::PushL( self );
self->BaseConstructL( aUtils );
// ConstructL not needed.
CleanupStack::Pop( self );
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::NewL exiting" )
return self;
}
// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CCloseChannelHandler::~CCloseChannelHandler()
{
LOG( NORMAL,
"CLOSECHANNEL: CCloseChannelHandler::~CCloseChannelHandler calling" )
Cancel();
LOG( NORMAL,
"CLOSECHANNEL: CCloseChannelHandler::~CCloseChannelHandler exiting" )
}
// -----------------------------------------------------------------------------
// From class MSatCommand.
// Response from client
// -----------------------------------------------------------------------------
//
void CCloseChannelHandler::ClientResponse()
{
LOG( NORMAL,
"CLOSECHANNEL: CCloseChannelHandler::ClientResponse calling" )
// Send terminal response if closing channel doesn't have to be waited and
// it was necessary to wait UI response due to icon response
if ( !iWaitHandleCloseCommand && iWaitClientIconResponse )
{
// requested icon not shown
if ( !iCloseChannelUiRsp.iRequestedIconDisplayed )
{
LOG( NORMAL, "CCloseChannelHandler::ClientResponse requested icon\
not shown" )
// Icons are not yet supported
iCloseChannelRspData.iGeneralResult =
RSat::KSuccessRequestedIconNotDisplayed;
}
else
{
LOG( NORMAL, "CCloseChannelHandler::ClientResponse success" )
iCloseChannelRspData.iGeneralResult = RSat::KSuccess;
}
iCloseChannelRspData.iInfoType = RSat::KNoAdditionalInfo;
iCloseChannelRspData.iAdditionalInfo.Zero();
TerminalRsp( RSat::ECloseChannel, iCloseChannelRspPckg );
}
iWaitClientIconResponse = EFalse;
LOG( NORMAL,
"CLOSECHANNEL: CCloseChannelHandler::ClientResponse calling" )
}
// -----------------------------------------------------------------------------
// From class CActive.
// Cancels the sat request.
// -----------------------------------------------------------------------------
//
void CCloseChannelHandler::DoCancel()
{
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::DoCancel calling" )
iUtils->USatAPI().NotifyCloseChannelCancel();
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::DoCancel exiting" )
}
// -----------------------------------------------------------------------------
// From class CSatCommandHandler.
// Requests the command notification.
// -----------------------------------------------------------------------------
//
void CCloseChannelHandler::IssueUSATRequest( TRequestStatus& aStatus )
{
LOG( NORMAL,
"CLOSECHANNEL: CCloseChannelHandler::IssueUSATRequest calling" )
// Reset command data.
new (&iCloseChannelData) RSat::TCloseChannelV2();
iUtils->USatAPI().NotifyCloseChannel( aStatus, iCloseChannelPckg );
LOG( NORMAL,
"CLOSECHANNEL: CCloseChannelHandler::IssueUSATRequest exiting" )
}
// -----------------------------------------------------------------------------
// From class CSatCommandHandler.
// Precheck before executing the command.
// -----------------------------------------------------------------------------
//
TBool CCloseChannelHandler::CommandAllowed()
{
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::CommandAllowed calling" )
TBool commandAllowed( ETrue );
LOG2( NORMAL,
"CLOSECHANNEL: CCloseChannelHandler::CommandAllowed \
iCloseChannelData.iAlphaId.iStatus: %d",
iCloseChannelData.iAlphaId.iStatus )
LOG2( NORMAL,
"CLOSECHANNEL: CCloseChannelHandler::CommandAllowed \
iCloseChannelData.iIconId.iQualifier: %d",
iCloseChannelData.iIconId.iQualifier )
// If icon data without alpha id
if ( ( RSat::EAlphaIdProvided != iCloseChannelData.iAlphaId.iStatus ) &&
( ( RSat::ESelfExplanatory ==
iCloseChannelData.iIconId.iQualifier ) ||
( RSat::ENotSelfExplanatory ==
iCloseChannelData.iIconId.iQualifier ) ) )
{
commandAllowed = EFalse;
iCloseChannelRspData.iGeneralResult = RSat::KCmdDataNotUnderstood;
iCloseChannelRspData.iInfoType = RSat::KNoAdditionalInfo;
iCloseChannelRspData.iAdditionalInfo.Zero();
iCloseChannelRspData.SetPCmdNumber( iCloseChannelData.PCmdNumber() );
TerminalRsp( RSat::ECloseChannel, iCloseChannelRspPckg );
LOG( SIMPLE,
"CLOSECHANNEL: CCloseChannelHandler::CommandAllowed \
data not understood" )
}
// Set icon command flag whether icon data was received and set qualifier
// to no icon id
// To be removed when icons are allowed in this command
else if ( ( RSat::ESelfExplanatory ==
iCloseChannelData.iIconId.iQualifier ) ||
( RSat::ENotSelfExplanatory ==
iCloseChannelData.iIconId.iQualifier ) )
{
LOG( NORMAL, "CCloseChannelHandler::CommandAllowed set no icon id" )
iIconCommand = ETrue;
iCloseChannelData.iIconId.iQualifier = RSat::ENoIconId;
}
else
{
LOG( NORMAL, "CCloseChannelHandler::CommandAllowed others" )
iIconCommand = EFalse;
}
LOG2( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::CommandAllowed \
exiting,commandAllowed: %d", commandAllowed )
return commandAllowed;
}
// -----------------------------------------------------------------------------
// From class CSatCommandHandler.
// Need for ui session.
// -----------------------------------------------------------------------------
//
TBool CCloseChannelHandler::NeedUiSession()
{
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::NeedUiSession calling" )
// UI is NOT needed in case where AlphaID is provided and it is a NULL
const TBool retVal( !( RSat::EAlphaIdNull ==
iCloseChannelData.iAlphaId.iStatus ) );
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::NeedUiSession calling" )
// Send notification to Mediator client if Cover UI is supported
if ( retVal && iUtils->CoverUiSupported() )
{
LOG( NORMAL, "CCloseChannelHandler::NeedUiSession CoverUiSupported" )
TSatCommandData medEventData;
medEventData.iPCmdNumber = RSat::ECloseChannel;
medEventData.iAlphaId = iCloseChannelData.iAlphaId;
medEventData.iDuration.iNumOfUnits = KSatDefaultDuration;
medEventData.iIconID = iCloseChannelData.iIconId;
TSatCommandPckg tPckg( medEventData );
iUtils->RaiseSatEvent( tPckg );
}
LOG2( NORMAL,
"CLOSECHANNEL: CCloseChannelHandler::NeedUiSession exiting,retVal: %d",
retVal )
return retVal;
}
// -----------------------------------------------------------------------------
// From class CSatCommandHandler.
// Called when USAT API notifies that command.
// -----------------------------------------------------------------------------
//
void CCloseChannelHandler::HandleCommand()
{
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::HandleCommand calling" )
// Notify other's about this command execution.
iUtils->NotifyEvent( MSatUtils::ECloseChannelExecuting );
TInt uiError( KErrNone );
// Reset flags
iWaitHandleCloseCommand = EFalse;
iWaitClientIconResponse = EFalse;
// If information indication to the user is needed, show it now.
if ( !( RSat::EAlphaIdNull == iCloseChannelData.iAlphaId.iStatus ) )
{
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::HandleCommand \
Sending UI Notification" )
iWaitHandleCloseCommand = ETrue;
uiError = SendUiNotification();
}
LOG2( NORMAL, "CCloseChannelHandler::HandleCommand uiError: %i",
uiError )
// Check UI error status
if ( KErrNone == uiError )
{
// Proceed with the command
const TInt channelId( iCloseChannelData.iDestination );
LOG2( NORMAL,
"CLOSECHANNEL: CCloseChannelHandler::HandleCommand channelId: %d",
channelId )
if ( RSat::KChannel1 > channelId || RSat::KChannel7 < channelId )
{
// Create the response IPC package
iCloseChannelRspData.SetPCmdNumber(
iCloseChannelData.PCmdNumber() );
iCloseChannelRspData.iGeneralResult = RSat::KCmdDataNotUnderstood;
iCloseChannelRspData.iInfoType = RSat::KNoAdditionalInfo;
iCloseChannelRspData.iAdditionalInfo.Zero();
iWaitClientIconResponse = EFalse;
}
else
{
// Close the channel
const TInt err( iUtils->BipUtils().CloseChannel( channelId ) );
// Create the response IPC package
iCloseChannelRspData.SetPCmdNumber(
iCloseChannelData.PCmdNumber() );
// Check were the channel close-up success.
if ( MSatBIPUtils::ESatBIPSuccess != err )
{
LOG2( NORMAL,
"CLOSECHANNEL: CCloseChannel::HandleCommand Error %i", err )
iCloseChannelRspData.iGeneralResult =
RSat::KBearerIndepProtocolError;
iCloseChannelRspData.iInfoType = RSat::KMeProblem;
iCloseChannelRspData.iAdditionalInfo.SetLength( 1 );
iCloseChannelRspData.iAdditionalInfo[0] =
static_cast<TUint8> ( err );
iWaitClientIconResponse = EFalse;
}
else
{
LOG( NORMAL,
"CLOSECHANNEL: CCloseChannel::HandleCommand success")
LOG2( NORMAL,
"CLOSECHANNEL: CCloseChannel::HandleCommand \
iCloseChannelUiRsp.iRequestedIconDisplayed: %i",
iCloseChannelUiRsp.iRequestedIconDisplayed )
LOG2( NORMAL,
"CLOSECHANNEL: CCloseChannel::HandleCommand \
iCloseChannelData.iIconId.iQualifier: %i",
iCloseChannelData.iIconId.iQualifier )
// requested icon not shown
if ( !iCloseChannelUiRsp.iRequestedIconDisplayed &&
( ( RSat::ENotSelfExplanatory ==
iCloseChannelData.iIconId.iQualifier ) ||
( RSat::ESelfExplanatory ==
iCloseChannelData.iIconId.iQualifier ) ) )
{
// Icons could not be shown
iCloseChannelRspData.iGeneralResult =
RSat::KSuccessRequestedIconNotDisplayed;
}
else
{
iCloseChannelRspData.iGeneralResult = RSat::KSuccess;
}
// No additional info for CloseChannel
iCloseChannelRspData.iInfoType = RSat::KNoAdditionalInfo;
iCloseChannelRspData.iAdditionalInfo.Zero();
}
}
iWaitHandleCloseCommand = EFalse;
// If command had icon data and was done succesfully, report that icon
// was not shown
// To be removed when icons are allowed in this command
if ( ( RSat::KSuccess == iCloseChannelRspData.iGeneralResult ) &&
iIconCommand )
{
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::\
HandleCommand requested icon not shown" )
iCloseChannelRspData.iGeneralResult =
RSat::KSuccessRequestedIconNotDisplayed;
}
// Send terminal response if UI response doesn't have to be waited
if ( !iWaitClientIconResponse )
{
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::\
HandleCommand send terminal response" )
TerminalRsp( RSat::ECloseChannel, iCloseChannelRspPckg );
}
}
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::HandleCommand exiting" )
}
// -----------------------------------------------------------------------------
// From class CSatCommandHandler.
// Indicates the failure of launching ui client.
// -----------------------------------------------------------------------------
//
void CCloseChannelHandler::UiLaunchFailed()
{
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::UiLaunchFailed calling" )
iCloseChannelRspData.iGeneralResult = RSat::KMeUnableToProcessCmd;
iCloseChannelRspData.iInfoType = RSat::KMeProblem;
iCloseChannelRspData.iAdditionalInfo.SetLength( 1 );
iCloseChannelRspData.iAdditionalInfo[0] = RSat::KNoSpecificMeProblem;
iCloseChannelRspData.SetPCmdNumber( iCloseChannelData.PCmdNumber() );
TerminalRsp( RSat::ECloseChannel, iCloseChannelRspPckg );
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::UiLaunchFailed exiting" )
}
// -----------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
//lint -e{1403, 1769} Can not be initialized.
CCloseChannelHandler::CCloseChannelHandler() :
CSatCommandHandler(),
iCloseChannelData(),
iCloseChannelPckg( iCloseChannelData ),
iCloseChannelRspData(),
iCloseChannelRspPckg( iCloseChannelRspData ),
iCloseChannelUiData(),
iCloseChannelUiPckg( iCloseChannelUiData ),
iCloseChannelUiRsp(),
iCloseChannelUiRspPckg( iCloseChannelUiRsp ),
iWaitHandleCloseCommand( EFalse ),
iWaitClientIconResponse( EFalse ),
// To be removed when icons are allowed in this command
iIconCommand( EFalse )
{
LOG( NORMAL, "CLOSECHANNEL: CCloseChannelHandler::CCloseChannelHandler \
calling - exiting" )
}
// -----------------------------------------------------------------------------
// Sends notification to UI.
// -----------------------------------------------------------------------------
//
TInt CCloseChannelHandler::SendUiNotification()
{
LOG( NORMAL,
"CloseChannel: CCloseChannelHandler::SendUiNotification calling" )
// Register to ui service request
TRAPD( uiError, iUtils->RegisterServiceRequestL(
ESatSProactiveNotification,
ESatSProactiveNotificationResponse,
this ) );
LOG2( NORMAL, "CCloseChannelHandler::SendUiNotification uiError: %i",
uiError )
if ( KErrNone != uiError )
{
// Send error terminal response
UiLaunchFailed();
}
else
{
// Create IPC data to UI
iCloseChannelUiData.iCommand = ESatSCloseChannelNotify;
iCloseChannelUiData.iText = iCloseChannelData.iAlphaId.iAlphaId;
iCloseChannelUiData.iIconId.iIdentifier
= iCloseChannelData.iIconId.iIdentifier;
// Define icon qualifier
if ( RSat::ENotSelfExplanatory ==
iCloseChannelData.iIconId.iQualifier )
{
LOG( NORMAL, "CloseChannel: CCloseChannelHandler::\
SendUiNotification ENotSelfExplanatory" )
iCloseChannelUiData.iIconId.iIconQualifier =
ESatNotSelfExplanatory;
// Terminal response may be only when UI has resposed
iWaitClientIconResponse = ETrue;
}
else if ( RSat::ESelfExplanatory ==
iCloseChannelData.iIconId.iQualifier )
{
LOG( NORMAL, "CloseChannel: CCloseChannelHandler::\
SendUiNotification ESelfExplanatory" )
iCloseChannelUiData.iIconId.iIconQualifier = ESatSelfExplanatory;
// Terminal response may be only when UI has resposed
iWaitClientIconResponse = ETrue;
}
else // Icon qualifier not present
{
LOG( NORMAL, "CloseChannel: CCloseChannelHandler::\
SendUiNotification others" )
iCloseChannelUiData.iIconId.iIconQualifier = ESatENoIconId;
}
LOG2( NORMAL, "CCloseChannelHandler::SendUiNotification \
iCloseChannelData.iAlphaId.iStatus: %i",
iCloseChannelData.iAlphaId.iStatus )
// Define AlphaID status
switch ( iCloseChannelData.iAlphaId.iStatus )
{
case RSat::EAlphaIdNotPresent:
{
iCloseChannelUiData.iAlphaIdStatus = ESatAlphaIdNotProvided;
break;
}
case RSat::EAlphaIdProvided:
{
iCloseChannelUiData.iAlphaIdStatus = ESatAlphaIdNotNull;
break;
}
default:
{
iCloseChannelUiData.iAlphaIdStatus = ESatAlphaIdNull;
break;
}
}
// Send notification to UI
MSatUiSession* session = iUtils->SatUiHandler().UiSession();
session->SendCommand( &iCloseChannelUiPckg,
&iCloseChannelUiRspPckg,
ESatSProactiveNotification );
}
LOG( NORMAL,
"CloseChannel: CCloseChannelHandler::SendUiNotification exiting" )
return uiError;
}