// Copyright (c) 2009 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:
// @file atclcc.cpp
// This contains CATClcc which query incoming or waitting call information.
//
//system include
//user include
#include "mslogger.h"
#include "atmanager.h"
#include "activecommandstore.h"
#include "atclcc.h"
#include "callinformationquerycompletenotify.h"
#include "ltsycommondefine.h"
#include "ltsycallinformationmanager.h"
//const define
const TInt KLtsyClccReadTimeout = 2;
//List current call information
_LIT8(KLtsyCLCCCommand, "AT+CLCC\r");
_LIT8(KLtsyCLCCMatchString, "+CLCC:*");
// ---------------------------------------------------------------------------
// CATClcc::NewL
// other items were commented in a header
// ---------------------------------------------------------------------------
CATClcc* CATClcc::NewL(CGlobalPhonemanager& aGloblePhone,
CCtsyDispatcherCallback& aCtsyDispatcherCallback)
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::NewL()"));
CATClcc* self = CATClcc::NewLC(aGloblePhone, aCtsyDispatcherCallback);
CleanupStack::Pop(self);
return self;
}
// ---------------------------------------------------------------------------
// CATClcc::NewLC
// other items were commented in a header
// ---------------------------------------------------------------------------
CATClcc* CATClcc::NewLC(CGlobalPhonemanager& aGloblePhone,
CCtsyDispatcherCallback& aCtsyDispatcherCallback)
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::NewLC()"));
CATClcc* self = new (ELeave) CATClcc(aGloblePhone, aCtsyDispatcherCallback);
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
// ---------------------------------------------------------------------------
// CATClcc::~CATClcc
// other items were commented in a header
// ---------------------------------------------------------------------------
CATClcc::~CATClcc()
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::~CATClcc()"));
}
// ---------------------------------------------------------------------------
// CATClcc::CATClcc
// other items were commented in a header
// ---------------------------------------------------------------------------
CATClcc::CATClcc(CGlobalPhonemanager& aGloblePhone,
CCtsyDispatcherCallback& aCtsyDispatcherCallback)
:CAtCommandBase(aGloblePhone, aCtsyDispatcherCallback)
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::CATClcc()"));
iAtType = ELtsyAT_General_CLCC;
iQueryCallInfoNotify = NULL;
InitVariable();
}
// ---------------------------------------------------------------------------
// CATClcc::ConstructL
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::ConstructL()
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::ConstructL()"));
//Invoke base class function
CAtCommandBase::ConstructL();
//Set read and write timeout
SetTimeOut(KLtsyDefaultWriteTimeOut, KLtsyClccReadTimeout);
//Add expecting string
AddExpectStringL(KLtsyCLCCMatchString);
}
// ---------------------------------------------------------------------------
// CATClcc::ExecuteCommand
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::ExecuteCommand()
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::ExecuteCommand()"));
iOKFounded = EFalse;
iTxBuffer.Copy(KLtsyCLCCCommand);
Write();
iATStep = EATWaitForWriteComplete;
iProcessStates = EProcessInProgress;
}
// ---------------------------------------------------------------------------
// CATClcc::InitVariable
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::InitVariable()
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::InitVariable()"));
iOKFounded = EFalse;
iIOStatus = KErrNone;
iATResult = KErrNone;
iATStep = EATNotInProgress;
iProcessStates = EProcessNotInProgress;
}
// ---------------------------------------------------------------------------
// CATClcc::AddQueryCallInformationCompleteNotify
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::AddQueryCallInformationCompleteNotify(MCallInformationQueryCompleteNotify* aQueryCallInfoNotify)
{
iQueryCallInfoNotify = aQueryCallInfoNotify;
}
// ---------------------------------------------------------------------------
// CATClcc::GetProcessStates
// other items were commented in a header
// ---------------------------------------------------------------------------
CATClcc::TATProcessStates CATClcc::GetProcessStates() const
{
return iProcessStates;
}
// ---------------------------------------------------------------------------
// CATClcc::SetProcessStates
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::SetProcessStates(CATClcc::TATProcessStates aProcessState)
{
iProcessStates = aProcessState;
}
// ---------------------------------------------------------------------------
// CATClcc::StartRequest
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::StartRequest()
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::StartRequest()"));
ExecuteCommand();
}
// ---------------------------------------------------------------------------
// CATClcc::ParseCLCCResponseL
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::ParseCLCCResponseL(const TDesC8& aResponseBuf)
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::ParseCLCCResponseL()"));
RArray<TPtrC8> array;
CleanupClosePushL(array);
iParser->ParseRespondedBuffer(array, aResponseBuf);
TInt nCount = array.Count();
// 1 2 3 4 5 6
//+CLCC : <id1>, <dir>, <stat>, <mode>, <mpty>
//Its count must >= 6
if (nCount < 6)
{
CleanupStack::PopAndDestroy(1);
return;
}
//Parse +CLCC :* buffer
//Only care Waiting call and incoming call
TInt nVal(0);
TLex8 tLex(array[3]);
if (tLex.Val(nVal) == KErrNone)
{
if (nVal == TLtsyCallInformation::EActiveCall ||
nVal == TLtsyCallInformation::EHeldCall ||
nVal == TLtsyCallInformation::EDialingCall ||
nVal == TLtsyCallInformation::EAlertingCall )
{
CleanupStack::PopAndDestroy(1);
LOGTEXT(_L8("[Ltsy CallControl] First Parse state of the call not find incoming call and waiting call"));
return;
}
}
else
{
CleanupStack::PopAndDestroy(1);
LOGTEXT(_L8("[Ltsy CallControl] First Parse state of the call Failing"));
return;
}
//Parse incoming call or waiting call
//Call id
tLex.Assign(array[1]);
if ((tLex.Val(nVal) != KErrNone)||
(nVal < KLtsyMinCallId) ||
(nVal > KLtsyMaxCallId))
{
CleanupStack::PopAndDestroy(1);
LOGTEXT(_L8("[Ltsy CallControl] Parse call id of the call Failing"));
return;
}
//Parse call id success
TLtsyCallInformation& callinfo(iPhoneGlobals.GetCallInfoManager().GetCallInformationByCallId(nVal));
callinfo.SetCallIdIsUsedInfo(TLtsyCallInformation::EUsed);
callinfo.SetCallId(nVal);
TBool bSuccess(ETrue);
for (TInt n = 2; bSuccess && n < nCount; n++)
{
//Direction Call
if (n == 2)
{
tLex.Assign(array[n]);
if (tLex.Val(nVal) == KErrNone)
{
if (TLtsyCallInformation::EMoCall == nVal)
{
callinfo.SetCallDirection(TLtsyCallInformation::EMoCall);
}
else
{
callinfo.SetCallDirection(TLtsyCallInformation::EMtCall);
}
}
else
{
bSuccess = EFalse;
LOGTEXT(_L8("[Ltsy CallControl] Parse direction call Failing"));
}
}
//State of the Call
if (n == 3)
{
tLex.Assign(array[n]);
if (tLex.Val(nVal) == KErrNone)
{
if (TLtsyCallInformation::EInComingCall == nVal)
{
callinfo.SetCallState(TLtsyCallInformation::EInComingCall);
}
else
{
callinfo.SetCallState(TLtsyCallInformation::EWaitingCall);
}
}
else
{
bSuccess = EFalse;
LOGTEXT(_L8("[Ltsy CallControl] Parse state of the call Failing"));
}
}
//Teleservice
if (n == 4)
{
tLex.Assign(array[n]);
if (tLex.Val(nVal) == KErrNone)
{
if (TLtsyCallInformation::EVoiceCall == nVal)
{
callinfo.SetCallMode(TLtsyCallInformation::EVoiceCall);
}
else if (TLtsyCallInformation::EDataCall == nVal)
{
callinfo.SetCallMode(TLtsyCallInformation::EDataCall);
}
else if (TLtsyCallInformation::EFaxCall == nVal)
{
callinfo.SetCallMode(TLtsyCallInformation::EFaxCall);
}
else
{
callinfo.SetCallMode(TLtsyCallInformation::EUnKnowCall);
}
}
else
{
bSuccess = EFalse;
LOGTEXT(_L8("[Ltsy CallControl] Parse teleservice Failing"));
}
}
//multiparty
if (n == 5)
{
tLex.Assign(array[n]);
if (tLex.Val(nVal) == KErrNone)
{
if (TLtsyCallInformation::ENotConference == nVal)
{
callinfo.SetConferenceCall(TLtsyCallInformation::ENotConference);
}
else
{
callinfo.SetConferenceCall(TLtsyCallInformation::EIsConference);
}
}
else
{
bSuccess = EFalse;
LOGTEXT(_L8("[Ltsy CallControl] Parse multiparty Failing"));
}
}
//telenum
if (n == 6)
{
callinfo.SetMobileTelNum(array[n]);
}
//type of address
if (n == 7)
{
tLex.Assign(array[n]);
if (tLex.Val(nVal) == KErrNone)
{
callinfo.SetAddressType(nVal);
}
else
{
bSuccess = EFalse;
LOGTEXT(_L8("[Ltsy CallControl] Parse type of address Failing"));
}
}
//alpah
if (n == 8)
{
callinfo.SetMobileName(array[n]);
}
}
//Parse failer
if (!bSuccess)
{
iPhoneGlobals.GetCallInfoManager().ResetCallInformationByCallId(callinfo.GetCallId());
}
CleanupStack::PopAndDestroy(1);
}
// ---------------------------------------------------------------------------
// CATClcc::ParseResponseL
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::ParseResponseL(const TDesC8& aResponseBuf)
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::ParseResponseL()"));
//Process expecting string +CLCC : *
if (aResponseBuf.Match(KLtsyCLCCMatchString) == 0)
{
ParseCLCCResponseL(aResponseBuf);
}
else if (aResponseBuf.Match(KLtsyOkString) == 0) //Process expecting string OK
{
iATResult = KErrNone;
iProcessStates = EProcessOK;
iOKFounded = ETrue;
}
else if (aResponseBuf.Match(KLtsyErrorString) == 0) //Process expecting string ERROR
{
iATResult = KErrArgument;
iProcessStates = EProcessError;
iOKFounded = EFalse;
}
}
// ---------------------------------------------------------------------------
// CATClcc::HandleIOError
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::HandleIOError()
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::HandleIOError()"));
iProcessStates = EProcessError;
if (iQueryCallInfoNotify != NULL)
{
iQueryCallInfoNotify->QueryCallInformationComplete(iIOStatus);
}
}
// ---------------------------------------------------------------------------
// CATClcc::HandleResponseError
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::HandleResponseError()
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::HandleResponseError()"));
if (iQueryCallInfoNotify != NULL)
{
iQueryCallInfoNotify->QueryCallInformationComplete(iATResult);
}
}
// ---------------------------------------------------------------------------
// CATClcc::HandleCLCCComplete
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::HandleCLCCComplete()
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::HandleCLCCComplete()"));
if (iQueryCallInfoNotify != NULL)
{
iQueryCallInfoNotify->QueryCallInformationComplete(KErrNone);
}
}
// ---------------------------------------------------------------------------
// CATClcc::Complete
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::Complete()
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::Complete()"));
LOGTEXT2(_L8("[Ltsy CallControl] iIOStatus = %d"), iIOStatus);
LOGTEXT2(_L8("[Ltsy CallControl] iATResult = %d"), iATResult);
//Remove Ative Command and stop timer
CAtCommandBase::Complete();
//Let other command can use I/O port
iPhoneGlobals.iEventSignalActive = EFalse;
}
// ---------------------------------------------------------------------------
// CATClcc::EventSignal
// other items were commented in a header
// ---------------------------------------------------------------------------
void CATClcc::EventSignal(TAtEventSource /*aEventSource*/, TInt aStatus)
{
LOGTEXT(_L8("[Ltsy CallControl] Starting CATClcc::EventSignal()"));
LOGTEXT2(_L8("[Ltsy CallControl] aEventSource = %d\taStatus = %d"),aStatus);
iIOStatus = aStatus;
if (iIOStatus != KErrNone)
{
HandleIOError();
Complete();
return;
}
switch (iATStep)
{
case EATWaitForWriteComplete:
iATStep = EATReadComplete;
break;
case EATReadComplete:
ClearCurrentLine();
if (iATResult == KErrNone)
{
if (iOKFounded)
{
HandleCLCCComplete();
Complete();
}
}
else
{
HandleResponseError();
Complete();
}
break;
default:
break;
}
}
//End of file