void CTcpSymbianEngine::Read()
{
__ASSERT_ALWAYS(EngineState() == EConnected,
User::Panic(KEchoEngine, EReadNotConnected));
///if we are already active, that's not a problem.
if ((EngineState() == EConnected) && (!iEchoRead->IsActive())) {
iEchoRead->IssueRead();
} else {
ERR("Read issued while not connected ot echoread is active");
}
}
void CTcpSymbianEngine::Query()
{
DBG("Query");
//TODO: keep the disconnect reasons somewhere, we can give better
//indication that way.
enum isab::Module::ConnectionNotify state = isab::Module::CLEAR;
enum isab::Module::ConnectionNotifyReason reason = isab::Module::REQUESTED;
switch(EngineState()){
case EComplete: break;
case EConnecting: state = isab::Module::CONNECTING; break;
case EConnected: state = isab::Module::CONNECTED; break;
case ETimedOut: state = isab::Module::DISCONNECTING;
reason = isab::Module::UNSPECIFIED; break;
case ELinking: state = isab::Module::CONNECTING; break;
case ELinkFailed: state = isab::Module::DISCONNECTING;
reason = isab::Module::TRANSPORT_FAILED; break;
case ELookingUp: state = isab::Module::CONNECTING; break;
case ELookUpFailed: state = isab::Module::DISCONNECTING;
reason = isab::Module::LOOKUP_FAILED; break;
case EConnectFailed: state = isab::Module::DISCONNECTING;
reason = isab::Module::NO_RESPONSE; break;
case EClosing: state = isab::Module::DISCONNECTING;
reason = isab::Module::REQUESTED; break;
case EBroken: state = isab::Module::DISCONNECTING;
reason = isab::Module::CHANNEL_FAILED; break;
case ESwitching: state = isab::Module::CONNECTING;
reason = isab::Module::REQUESTED; break;
case EClosed: state = isab::Module::DISCONNECTING;
reason = isab::Module::BY_PEER; break;
}
iConsole.ConnectionNotify(state, reason);
}
void CTcpSymbianEngine::DoCancel()
// Cancel asychronous requests
{
DBG("DoCancel");
iTimer->Cancel();
// Cancel appropriate request to socket
//XXX handle bad opens!
switch (EngineState()){
case EConnecting:
DBG("While EConnecting");
iEchoSocket.CancelConnect();
break;
case ELookingUp:
DBG("While ELookingUp");
// Cancel look up attempt
iResolver.Cancel();
iResolver.Close();
break;
case ELinking:
DBG("While ELinking");
CloseLinkLayer();
break;
case EClosing:
DBG("While EClosing");
break;
default:
ERR("PANIC KEchoEngine, EBadCancelStatus (%d)", TInt(EBadCancelStatus));
User::Panic(KEchoEngine, EBadCancelStatus);
break;
}
DBG("DoCancel comnplete");
}
void CTcpSymbianEngine::Write(HBufC8* aData)
{
if(EngineState() != EConnected || iEchoWrite->IsActive()){
ERR("EngineState: %d, Echowrite is %sactive", EngineState(), iEchoWrite->IsActive() ? "": "not");
}
__ASSERT_ALWAYS(EngineState() == EConnected,
User::Panic(KEchoEngine, EWriteNotConnected));
__ASSERT_ALWAYS(!iEchoWrite->IsActive(),
User::Panic(KEchoEngine, EWriteActive));
//we should never get here unless CTcpSymbianEngine is ready for
//another write. See assertations above.
if ((EngineState() == EConnected) && !iEchoWrite->IsActive()){
iEchoWrite->IssueWrite(aData);
} else {
ERR("Write issued while not connected or echowrite is active");
}
}
void Rocket::update(float deltaSec) {
Projectile::update(deltaSec);
if (m_aiTask) {
m_aiTask->update(deltaSec);
m_boardComputer.update(deltaSec);
} else {
components().setEngineState(EngineState(
glm::vec3(0, 0, -1),
glm::vec3(0, 0, 0)
));
}
}
void CTcpSymbianEngine::ConnectL()
{
DBG("ConnectL()");
if(EngineState() == EComplete){
iConsole.ConnectionNotify( isab::Module::CONNECTING,
isab::Module::REQUESTED );
OpenLinkLayerL(); //setactive here
} else {
DBG("Do nothing, but handle the next request.");
if(!IsActive()){ //don't think this is needed
DBG("Signal OperationComplete");
iConsole.OperationComplete();
} else {
WARN("This was unexpected!");
}
}
}
void CTcpSymbianEngine::Stop(enum TEchoEngineState aState)
{
enum TEchoEngineState state = EngineState();
DBG("Stop, Enginestate: %d, aState: %d", state, aState);
if(state != EComplete){
iConsole.BlockEvents();
}
switch (state){
case EConnected:
// Stop live connection
iEchoRead->Cancel();
iEchoWrite->Cancel();
SetEngineState(aState);
iEchoSocket.Shutdown(RSocket::EImmediate, iStatus);
SetActive();
iTimer->After(iTimeOut);
break;
case EConnecting:
case ELookingUp:
case ELinking:
// if request to CTcpSymbianEngine, then stop it
Cancel();
break;
case ESwitching:
SetEngineState(EClosing);
break;
case EClosing:
///already closing.
break;
case EComplete:
//all set.
if(!IsActive()){
DBG("Signal OperationComplete");
iConsole.OperationComplete();
DBG("Signaled OperationComplete");
}
break;
default:
ERR("PANIC KEchoEngine EBadEngineStopState (%d)", EBadEngineStopState);
User::Panic(KEchoEngine, EBadEngineStopState);
break;
}
}
void CTcpSymbianEngine::ConnectL(const TDesC& aServerName, TUint aPort,
TInt aIAP, TBool aConsiderWLAN)
{
DBG("ConnectL(HOST, %u, %d)", aPort, aIAP);
//see if state is EComplete. used several times below
const TBool stateComplete = (EngineState() == EComplete);
//The changeServer variable indicates that we must close the
//current connection and open a new one.
const TBool changeServer = !stateComplete && iHostName &&
(*iHostName != aServerName || iPort != aPort);
DBG("stateComplete: %d, changeServer: %d", stateComplete, changeServer);
if(changeServer){
WARN("Switching server, danger will robinson");
Stop(ESwitching);
SetConnectionParamsL(aServerName, aPort, aIAP, aConsiderWLAN);
} else {
DBG("No need to change server");
if(stateComplete){
DBG("update params");
SetConnectionParamsL(aServerName, aPort, aIAP, aConsiderWLAN);
}
ConnectL();
}
}
void CTcpSymbianEngine::RunL()
{
DBG("RunL, EngineState: %d, iStatus: %d", EngineState(), iStatus.Int());
iTimer->Cancel(); // Cancel TimeOut timer before handling completion
switch(EngineState()){
case EConnecting:
// IP connection request
if (iStatus == KErrNone){
DBG("Connection completed Ok");
// Connection completed sucessfully
iConsole.ConnectionNotify(isab::Module::CONNECTED,
isab::Module::REQUESTED);
SetEngineState(EConnected);
Read(); //Start CTcpSymbianRead Active object
} else {
WARN("Unable to connect, removing host from cache.");
iDNSCache.Remove(*iHostName);
if (iStatus == KErrCouldNotConnect){
ResetL(EConnectFailed, isab::Module::NO_RESPONSE);
} else if (iStatus == KErrTimedOut) {
ResetL(ETimedOut, isab::Module::NO_RESPONSE);
} else{
WARN("EConnectFailed, INTERNAL_ERROR");
ResetL(EConnectFailed, isab::Module::INTERNAL_ERROR);
//XXX handle the different cases
}
}
break;
case ELookingUp:
iResolver.Close();
if (iStatus == KErrNone) {
DBG("Name lookup ok");
// DNS look up successful
// Extract domain name and IP address from name record
class TInetAddr addr = TInetAddr::Cast(iNameEntry().iAddr);
//cache the ip for later.
TInt cacheStat = iDNSCache.CacheHost(*iHostName, addr.Address());
DBG("Host cached with result %d", cacheStat);
cacheStat = cacheStat;
// And connect to the IP address
Connect(addr.Address(), iPort); //setactive here
} else { //includes KErrTimedOut
WARN("Lookup failed");
ResetL(ELookUpFailed, isab::Module::LOOKUP_FAILED);
}
break;
case ELinking:
if(iStatus == KErrNone){
DBG("Link layer setup ok");
OpenSocketL(); //cannot open socket until here. We need RConnection.
StartLookupL(); //setactive here
} else { //includes KErrCanceled and KErrTimedOut
WARN("Link layer setup failed");
ResetL(ELinkFailed, isab::Module::TRANSPORT_FAILED);
}
break;
case EBroken:
DBG("Broken");
ResetL( EngineState(), isab::Module::CHANNEL_FAILED );
break;
case EClosing:
if(iStatus == KErrNone){
DBG("Closing ok");
ResetL(EComplete, isab::Module::REQUESTED);
} else if(iStatus == KErrTimedOut){
ResetL(ETimedOut);
} else {
ResetL(EngineState());
//XXX ???
}
break;
case ESwitching:
if(iStatus == KErrNone){
//the connection has been closed, start a new connection
//using the values in iHostName, iPort, and iIAP.
SetEngineState(EComplete);
ConnectL();
} else if(iStatus == KErrTimedOut){
ResetL(ETimedOut);
} else {
ResetL(EngineState());
}
break;
case EClosed:
DBG("Closed");
ResetL( EngineState(), isab::Module::BY_PEER );
break;
default:
ERR("PANIC KEchoEngine EBadEngineState (%d)", TInt(EBadEngineState));
User::Panic(KEchoEngine, EBadEngineState);
break;
};
if(!IsActive()){
DBG("Signal OperationComplete");
iConsole.OperationComplete();
DBG("Signaled OperationComplete");
}
}
TBool CTcpSymbianEngine::IsConnected()
{
return EngineState() == EConnected;
}
