/*
* Copyright (c) 2004-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:
* This class is a BTSapServer's state for setting up connection with BTSap client
*
*/
// INCLUDE FILES
#include <e32property.h>
#include <ctsydomainpskeys.h>
#include <PSVariables.h>
#include "BTSapServerState.h"
#include "BTSapSocketHandler.h"
#include "BTSapSimCardStatusNotifier.h"
#include "debug.h"
CBTSapServerState::TStateConnect::TStateConnect(CBTSapServerState& aServerState)
: TStateIdle(aServerState), iConnectRequestOK(EFalse), iCardStatus(ECardStatusReserved), iSendRespMessageDone(EFalse), iMessageSizeNegotiationDone(EFalse)
{
}
// ---------------------------------------------------------
// Enter
// ---------------------------------------------------------
void CBTSapServerState::TStateConnect:: Enter(TRequestStatus& aStatus)
{
BTSAP_TRACE_OPT(KBTSAP_TRACE_STM, BTSapPrintTrace(_L("[BTSap] SM: TStateConnect: Enter")));
iStatus = &aStatus;
TConnectionStatus connectionStatus = EConnectionErrReject;
if (!iMessageSizeNegotiationDone)
{
CheckMaxMsgSize(connectionStatus);
}
if (connectionStatus == EConnectionOK || iMessageSizeNegotiationDone)
{
iMessageSizeNegotiationDone = ETrue;
if(IsCallOngoing())
{ // SAP cannot be accepted if a call is ongoing or if no SIM is present
connectionStatus = EConnectionOKOngoingCall;
}
else
{
connectionStatus = EConnectionOK;
}
}
else
{
iMessageSizeNegotiationDone = EFalse;
}
if (connectionStatus == EConnectionOK)
{
iConnectRequestOK = ETrue;
// init value which is impossible to be received.
// by checking the value, BTSap knows if status_ind is received
iCardStatus = ECardStatusReserved;
// listen to status_ind (card_reset is expected)
iServerState.BTSapSimCardStatusNotifier().Start();
NotifySapState(ESapConnecting);
// Waiting for Accept/RejectSapConnection()
aStatus = KRequestPending;
if(!IsSimPresent())
{
// If there is no SIM present, we bypass the accept/reject for the connection.
// Instead this will be signalled in the connection reply, followed by disconnection.
iCardStatus = ECardStatusRemoved;
User::RequestComplete(iStatus, EUserAccepted);
}
#ifdef __WINS__
//Doesn't wait for any confirmation (used in WINS)
BTSAP_TRACE_OPT(KBTSAP_TRACE_STM, BTSapPrintTrace(_L("[BTSap] SM: TStateConnect: Enter Accept")));
User::RequestComplete(iStatus, EUserAccepted);
#endif //__WINS__
}
else if (connectionStatus == EConnectionOKOngoingCall)
{
iConnectRequestOK = EFalse;
aStatus = KRequestPending;
if (iSendRespMessageDone)
{
//start subscribe to CallStatusChange
iServerState.SubscribeCallStatusL();
}
else
{
User::RequestComplete(iStatus, EConnectionWithActiveCall);
}
}
else
{
iConnectRequestOK = EFalse;
iResponseMessage.SetMsgID(EConnectResponse);
iResponseMessage.AddParameter(EParaConnectionStatus, connectionStatus);
if (connectionStatus == EConnectionErrNotSupported)
{
iResponseMessage.AddParameter(EParaMaxMsgSize, KMaxMsgSize, 2);
}
iServerState.BTSapSocketHandler().Send(iResponseMessage.Data());
if (connectionStatus == EConnectionErrNotSupported)
{
// waiting for the client to send another conn_req with my KMaxMsgSize
aStatus = KRequestPending;
}
else
{
// too small or a phone call ongoing
User::RequestComplete(iStatus, EConnectionError);
}
}
}
// --------------------------------------------------------------------------------------------
// Complete
// set next state
// --------------------------------------------------------------------------------------------
//
TBTSapServerState CBTSapServerState::TStateConnect::Complete(TInt aReason)
{
BTSAP_TRACE_OPT(KBTSAP_TRACE_STM, BTSapPrintTrace(_L("[BTSap] SM: TStateConnect: Complete")));
TBTSapServerState nextState = EStateNotConnected;
if (aReason == EConnectionWithActiveCall)
{
if (!iSendRespMessageDone)
{
TInt connectionStatus = EConnectionOKOngoingCall;
iResponseMessage.SetMsgID(EConnectResponse);
iResponseMessage.AddParameter(EParaConnectionStatus, connectionStatus);
iServerState.BTSapSocketHandler().Send(iResponseMessage.Data());
iSendRespMessageDone = ETrue;
}
//wait in TStateConnect state, until call is released
nextState = EStateConnect;
}
else if (aReason == EConnectionWithoutActiveCall)
{
//Enter TStateConnect state one last time, make a SAP connection
nextState = EStateConnect;
}
else if (aReason == EUserAccepted || aReason == EUserRejected)
{
TInt connectionStatus = (aReason == EUserAccepted) ? EConnectionOK : EConnectionErrReject;
iResponseMessage.SetMsgID(EConnectResponse);
iResponseMessage.AddParameter(EParaConnectionStatus, connectionStatus);
iServerState.BTSapSocketHandler().Send(iResponseMessage.Data());
if (connectionStatus == EConnectionOK)
{
BTSAP_TRACE_OPT(KBTSAP_TRACE_INFO, BTSapPrintTrace(_L("[BTSap] SM: TStateConnect: Complete: iCardStatus: %d"), iCardStatus));
if (iCardStatus != ECardStatusReserved)
{
// send status_ind
TStateIdle::SimCardStatusChanged(iCardStatus);
}
if(iCardStatus != ECardStatusRemoved)
{
// There is no SIM, so the connection will be disconnected by the client.
// We therefore do not signal a connection complete.
NotifySapState(ESapConnected);
}
nextState = EStateIdle;
iSendRespMessageDone = EFalse;
iMessageSizeNegotiationDone = EFalse;
}
}
return nextState;
}
void CBTSapServerState::TStateConnect::Cancel()
{
NotifySapState(ESapNotConnected);
iSendRespMessageDone = EFalse;
iMessageSizeNegotiationDone = EFalse;
iServerState.CancelSubscribeCallStatusL();
User::RequestComplete(iStatus, KErrCancel);
}
TBool CBTSapServerState::TStateConnect::IsCallOngoing()
{
#ifdef __WINS__
BTSAP_TRACE_OPT(KBTSAP_TRACE_FUNCTIONS, BTSapPrintTrace(_L("[BTSap] CBTSapServerState::TStateConnect::IsCallOngoing ON THE WINS SIDE")));
return EFalse;
#else
TBool retVal = EFalse;
BTSAP_TRACE_OPT(KBTSAP_TRACE_FUNCTIONS, BTSapPrintTrace(_L("[BTSap] CBTSapServerState::TStateConnect::IsCallOngoing")));
TInt callState;
// Try to get the call state property
TInt err = RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, callState);
// Check if retrieving the property value succeeded
if(err == KErrNone)
{
BTSAP_TRACE_OPT(KBTSAP_TRACE_INFO, BTSapPrintTrace(_L("[BTSap] TStateConnect: callState: %d"), callState));
// If callState is EPSTelephonyCallStateNone or EPSTelephonyCallStateUninitialized, there's no ongoing call
// should EPSCTsyCallStateDisconnecting be treated as non active call status ???
// added it here for testing with SAP 1.0 supported carkit. Since there is delay for call status changes from EPSCTsyCallStateDisconnecting
// to EPSCTsyCallStateNone or EPSCTsyCallStateUninitialized. If we do not treat EPSCTsyCallStateDisconnecting as
// Call Inactive status, SAP connection will be dropped and client connects to HFP profile instead.
// could be removed and try if it works with SAP 1.1 clients.
retVal = (callState != EPSCTsyCallStateNone) && (callState != EPSCTsyCallStateUninitialized) && (callState != EPSCTsyCallStateDisconnecting);
}
else
{
// Couldn't retrieve call state property
BTSAP_TRACE_OPT(KBTSAP_TRACE_ERROR, BTSapPrintTrace(_L("[BTSap] TStateConnect: Couldn't get callState!!! (err = %d)"), err));
retVal = ETrue; // Assume there was an ongoing call to abort the SAP connection
}
return retVal;
#endif // __WINS__
}
void CBTSapServerState::TStateConnect::CheckMaxMsgSize(TConnectionStatus& aMsgSizeStatus)
{
TInt msgSize;
iServerState.BTSapRequestMessage().GetParameter(EParaMaxMsgSize, msgSize);
BTSAP_TRACE_OPT(KBTSAP_TRACE_FUNCTIONS, BTSapPrintTrace(_L("[BTSap] TStateConnect: msg size: %d"), msgSize));
if (msgSize < KMinMsgSize)
{
BTSAP_TRACE_OPT(KBTSAP_TRACE_INFO, BTSapPrintTrace(_L("[BTSap] SM: TStateConnect: msg size too small ***")));
aMsgSizeStatus = EConnectionErrTooSmall;
}
else if (msgSize > KMaxMsgSize)
{
BTSAP_TRACE_OPT(KBTSAP_TRACE_INFO, BTSapPrintTrace(_L("[BTSap] SM: TStateConnect: msg size too big ***")));
aMsgSizeStatus = EConnectionErrNotSupported;
}
else
{
aMsgSizeStatus = EConnectionOK;
}
}
TInt CBTSapServerState::TStateConnect::AcceptSapConnection()
{
BTSAP_TRACE_OPT(KBTSAP_TRACE_FUNCTIONS, BTSapPrintTrace(_L("[BTSap] SM: TStateConnect: AcceptSapConnection")));
if (*iStatus == KRequestPending)
{
User::RequestComplete(iStatus, EUserAccepted);
}
return KErrNone;
}
TInt CBTSapServerState::TStateConnect::RejectSapConnection(TBTSapRejectReason /*aReason*/)
{
BTSAP_TRACE_OPT(KBTSAP_TRACE_FUNCTIONS, BTSapPrintTrace(_L("[BTSap] SM: TStateConnect: RejectSapConnection")));
if (*iStatus == KRequestPending)
{
User::RequestComplete(iStatus, EUserRejected);
}
return KErrNone;
}
TInt CBTSapServerState::TStateConnect::ChangeState(TBTSapServerState& aNextState)
{
TInt retVal = KErrNotSupported;
TBTSapServerState nextState = EStateNotConnected;
if ((aNextState == EStateConnect &&
*iStatus == KRequestPending &&
!iConnectRequestOK) ||
aNextState == EStateDisconnect)
{
retVal = KErrNone;
nextState = aNextState;
}
aNextState = nextState;
return retVal;
}
void CBTSapServerState::TStateConnect::SimCardStatusChanged(TCardStatus aCardStatus)
{
iCardStatus = aCardStatus;
}
TInt CBTSapServerState::TStateConnect::CallInactive()
{
BTSAP_TRACE_OPT(KBTSAP_TRACE_FUNCTIONS, BTSapPrintTrace(_L("[BTSap] SM: TStateConnect: CallInactive")));
if (*iStatus == KRequestPending)
{
User::RequestComplete(iStatus, EConnectionWithoutActiveCall);
}
return KErrNone;
}
// End of File