void Com::updatePid() {
PidPacket pidPacket;
if(!readBytes((byte*)&pidPacket, sizeof(PidPacket))) {
sendErrorTimeout();
return;
}
uint8_t checksum = Serial.read();
uint8_t computedChecksum = computeChecksum((byte*)&pidPacket, sizeof(PidPacket));
if(computedChecksum != checksum) {
sendErrorInvalidChecksum(checksum, computedChecksum);
return;
}
Pid *pid = getPidFromPidType(pidPacket.PidType);
if(pid == NULL) {
sendErrorInvalidPid();
}
pid->P = pidPacket.P;
pid->I = pidPacket.I;
pid->D = pidPacket.D;
g_eeprom.updateValues();
sendOk();
}
/* Packets look like this:
quint32 key = 4 bytes
QByteArray data = n bytes
quint16 checksum = 2 bytes */
bool SerialServer::readPacket(QByteArray *packetData)
{
while(1){
QByteArray data;
quint32 key = 0;
quint16 checksum = 0xFFFF;
m_inStream >> key;
if (key == HEADER_KEY) {
m_inStream >> data;
m_inStream >> checksum;
qWarning("data.size()=%d", data.size());
qWarning("checksum=%x", checksum);
if(checksum == qChecksum(data, data.size())) {
*packetData = data;
sendOk();
return true;
}
}
m_inStream.skipRawData(512);
m_inStream.resetStatus();
qWarning("Retry...");
if(m_quit) return false;
}
static void ICQCALLBACK acceptButton(hWindow btn, hWindow hwnd)
{
ICQMSGDIALOG *cfg = icqskin_getWindowDataBlock(hwnd);
CHKPoint();
if(cfg->mgr && (cfg->mgr->flags & ICQMSGMF_REQUESTMESSAGE))
{
DBGTracex(cfg->sequenceNumber);
#ifdef EXTENDED_LOG
sprintf(cfg->buffer,"Request %08lx accepted",cfg->sequenceNumber);
icqWriteSysLog(cfg->fr.icq,PROJECT,cfg->buffer);
#endif
if(!icqAcceptRequest(cfg->fr.icq, cfg->sequenceNumber, ""))
icqskin_closeWindow(hwnd);
}
else
{
CHKPoint();
if(!icqSendMessage(cfg->fr.icq, cfg->uin, MSG_AUTHORIZED, ""))
{
sendOk(hwnd,cfg);
icqskin_setEnabled(btn,FALSE);
}
}
}
void Weibo::sendStatusWithPicture()
{
qDebug("update weibo with picture");
QString path(mFile);
//TODO: gif
if (!path.endsWith("jpg", Qt::CaseInsensitive)
&& !path.endsWith("jpeg", Qt::CaseInsensitive)
&& !path.endsWith("png", Qt::CaseInsensitive)
&& !path.endsWith("gif", Qt::CaseInsensitive)) {
QImage image(path);
path = QDir::tempPath() + "/weibotemp" + ".jpg";
if (!image.save(path)) {
qWarning("convert image failed! %s", qPrintable(path));
return;
}
}
QFile f(path);
if (!f.open(QIODevice::ReadOnly)) {
qDebug("open error: %s", qPrintable(f.errorString()));
return;
}
QByteArray data = f.readAll();
f.close();
connect(mPut, SIGNAL(ok(QString)), this, SIGNAL(sendOk()));
mPut->reset();
QUrl url(kApiHost + "statuses/upload.json");
mPut->setUrl(url);
mPut->addTextPart("access_token", mAccessToken);
mPut->addTextPart("status", QUrl::toPercentEncoding(mStatus));
mPut->addDataPart("image/jpg", "pic", data, path);
mPut->upload();
}
void WeiboDialog::sendWeiboWithPicture()
{
Q_D(WeiboDialog);
QSettings cfg(Config::configPath, QSettings::IniFormat);
cfg.setIniCodec("UTF-8");
if (d->userEdit->text().isEmpty() && d->passwdEdit->text().isEmpty())
Tools::showTip("<h2 style='color:red;text-align:center;'>" + tr("Error") + "</h2><p style='color:white;font-size:22px;'>"
+ tr("User name and password can't be empty") + "</p>", true, 3000);
//TODO: check whether the user changed. if yes, set empty token and login as new account
QString userNow = d->userEdit->text();
if (userNow != Config::weiboUser) {
access_token.clear();
}
QString passwdNow = d->passwdEdit->text();
d->api->setUSer(userNow);
d->api->setPassword(passwdNow);
d->api->setAccessToken(access_token);
Config::weiboUser = userNow;
Config::weiboPasswd = passwdNow;
qDebug("%s %s", qPrintable(Config::weiboUser), qPrintable(Config::weiboPasswd));
cfg.setValue("weiboUser", qCompress(Config::weiboUser.toLatin1()));
cfg.setValue("weiboPasswd", qCompress(Config::weiboPasswd.toLatin1()));
QString text = d->statusEdit->text();
qDebug("content: %s", qPrintable(text));
if (text.isEmpty()) {
Tools::showTip("<h2 style='color:red;text-align:center;'>" + tr("Error") + "</h2><p style='color:white;font-size:22px;'>"
+ tr("Weibo can't be empty") + "</p>", true, 3000);
return;
}
if (text.size() > 140) {
Tools::showTip("<h2 style='color:red;text-align:center;'>" + tr("Error") + "</h2><p style='color:white;font-size:22px;'>"
+ tr("Weibo caontent is limited to 140. now are %1").arg(text.size()) + "</p>", true, 3000);
return;
}
d->api->updateStatusWithPicture(text, d->image);
connect(d->api, SIGNAL(sendOk()), SLOT(sendOk()));
}
void Com::sendSettings() {
sendPacketStart(PACKET_SETTINGS);
sendFloat(g_rollPid.P);
sendFloat(g_rollPid.I);
sendFloat(g_rollPid.D);
sendFloat(g_pitchPid.P);
sendFloat(g_pitchPid.I);
sendFloat(g_pitchPid.D);
sendFloat(g_yawPid.P);
sendFloat(g_yawPid.I);
sendFloat(g_yawPid.D);
sendFloat(g_userControlGain);
sendFloat(g_pidWindupGuard);
sendOk();
}
void Com::updateFloat(float* f) {
float val;
if(!readBytes((byte*)&val, sizeof(float))) {
sendErrorTimeout();
return;
}
uint8_t checksum = Serial.read();
uint8_t computedChecksum = computeChecksum((byte*)&val, sizeof(float));
if(computedChecksum != checksum) {
sendErrorInvalidChecksum(checksum, computedChecksum);
return;
}
*f = val;
g_eeprom.updateValues();
sendOk();
}
void MailServer::handleSend(const SendMessage& msg)
{
try
{
try
{
DEBUG("PERSISTING SEND");
fileManager_->persistSendMessage(msg);
DEBUG("PERSISTED SEND");
sendOk(socket_id_);
}
catch(const FileManagerException& e)
{
DEBUG(e.what());
sendErr(socket_id_);
}
}
catch(const NetworkException& e)
{
DEBUG("Failed to send reply for sendMessage request, because " << e.what());
sendErr(socket_id_);
}
}
void Com::loop(int time) {
while(Serial.available()>0) {
char cmd = Serial.read();
switch(cmd) {
case 't':
temp = readLong();
sendOk();
Serial.print("temp = ");
Serial.println(temp);
break;
case 's': // read settings
sendSettings();
break;
case 'P': // write PID
updatePid();
break;
case 'G': // write Gain
updateFloat(&g_userControlGain);
break;
case 'W': // write Windup Guard
updateFloat(&g_pidWindupGuard);
break;
default:
sendError();
break;
}
}
{
Telem telem;
sendPacketStart(PACKET_TELEMETRY);
telem.Yaw = g_telemetryCom.Yaw;
telem.Pitch = g_telemetryCom.Pitch;
telem.Roll = g_telemetryCom.Roll;
telem.MotorL = g_motorLeft.get();
telem.MotorR = g_motorRight.get();
telem.MotorF = g_motorFront.get();
telem.MotorB = g_motorBack.get();
telem.BatteryLevel = g_batteryManager.getLastReading();
telem.UserElev = g_receiverCom.pos[RECEIVER_Throttle];
telem.UserPitch = g_receiverCom.pos[RECEIVER_Elevator];
telem.UserRoll = g_receiverCom.pos[RECEIVER_Aileron];
telem.UserYaw = g_receiverCom.pos[RECEIVER_Rudder];
telem.loopCount = g_loopCount;
Serial.write((byte*)&telem, sizeof(Telem));
}
if(time - _lastSlowTime > 1000) {
_lastSlowTime = time;
Serial.print("RECV: ");
Serial.print(g_receiverCom.hasSignal ? "HAS SIGNAL " : "NO SIGNAL ");
for(int i=0; i<SERVO_INPUT_CHANNELS; i++) {
if(i != 0) {
Serial.print(", ");
}
Serial.print(g_receiverCom.pos[i]);
}
Serial.print(" TELEM: ");
Serial.print(g_telemetryCom.Yaw);
Serial.print(", ");
Serial.print(g_telemetryCom.Pitch);
Serial.print(", ");
Serial.print(g_telemetryCom.Roll);
Serial.print(" MOTOR: ");
Serial.print(g_motorFront.get());
Serial.print(", ");
Serial.print(g_motorBack.get());
Serial.print(", ");
Serial.print(g_motorLeft.get());
Serial.print(", ");
Serial.print(g_motorRight.get());
Serial.print(" PID: ");
Serial.print(g_rollPid.getLastPosition());
Serial.print(", ");
Serial.print(g_pitchPid.getLastPosition());
Serial.print(", ");
Serial.print(g_yawPid.getLastPosition());
Serial.print(" BAT: ");
Serial.print(g_batteryManager.getLastReading());
Serial.println(g_batteryManager.getIsWarning() ? " warning" : " ");
}
}
int main(int argc, char *argv[])
{
/* server var */
unsigned short servPort; /* Server port */
struct sockaddr_in servAddr; /* Local address */
uint8_t bindMsgSize;
/* addr&port bind with */
unsigned long bindIP;
unsigned short bindPort;
/* client var */
unsigned int cliAddrLen; /* Length of incoming message */
int recvMsgSize; /* Size of received message */
/* packets var */
uint8_t msgType;
uint8_t code;
/*init the Queue used for receive history*/
mylog = (QUEUE *)malloc(sizeof(QUEUE));
initQueue(mylog);
//mylog->qBase = (struct logEntry **)malloc(sizeof(struct logEntry *)*MAXN);
//mylog->front = mylog->rear = 0;
/*init loss Record*/
lossRecord = (node_t *)malloc(sizeof(node_t));
/*init entry*/
entry = (struct logEntry *)malloc(sizeof(struct logEntry));
entry->packet = (struct data_t*)malloc(sizeof(struct data_t));
/* Check for correct number of parameters */
if (argc >= 2)
{
servPort = atoi(argv[1]); /* local port */
//printf("%s",argv[1] );
}
else
{
fprintf(stderr,"Usage: %s <TFRC SERVER PORT>\n", argv[0]);
exit(1);
}
/* bind SIGINT function */
signal(SIGINT, sigHandler);
signal(SIGALRM, handle_alarm);
/* Create socket for sending/receiving datagrams */
if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
{
printf("Failure on socket call, errno:%d\n", errno);
}
/* Construct local address structure */
memset(&servAddr, 0, sizeof(servAddr)); /* Zero out structure */
servAddr.sin_family = AF_INET; /* Internet address family */
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);/* Any incoming interface */
servAddr.sin_port = htons(servPort); /* Local port */
/* create buffer to store packets. 1600 maximum of packet size */
buffer = (struct control_t*)calloc((size_t)MAX_BUFFER, 1);
ok = (struct control_t*)calloc((size_t)MAX_BUFFER, 1);
dataAck = (struct ACK_t*)calloc((size_t)MAX_BUFFER, 1);
/* Bind to the local address */
if (bind(sock, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0)
{
printf("Failure on bind, errno:%d\n", errno);
}
/* Forever Loop */
for (;;)
{
cliAddrLen = sizeof(clntAddr);
//printf(" success!!\n");
/* Block until receive message from a client */
if ((recvMsgSize = recvfrom(sock, buffer, MAX_BUFFER, 0, (struct sockaddr *) &clntAddr, &cliAddrLen)) < 0)
{
printf("Failure on recvfrom, client: %s, errno:%d\n", inet_ntoa(clntAddr.sin_addr), errno);
continue;
}
buffer->msgLength = ntohs(buffer->msgLength);
buffer->CxID = ntohl(buffer->CxID);
buffer->seqNum = ntohl(buffer->seqNum);
if(buffer->seqNum > seqMax)
seqMax = buffer->seqNum;
/* Parsing the packet */
msgType = buffer -> msgType;
code = buffer -> code;
switch (msgType)
{
case CONTROL :
{
switch (code)
{
case START :
{
printf("\nreceived START!!\n\n");
if (bindFlag == 0)
{
bindFlag = 1;
//init the record var
countRecv = 0;
countRecvBytes = recvMsgSize;
seqMax = buffer->seqNum;
seqMin = buffer->seqNum;
bindPort = clntAddr.sin_port;
bindIP = clntAddr.sin_addr.s_addr;
CxID = buffer->CxID;
bindMsgSize = ntohs(buffer->msgSize);
printf("start packet:\n");
printf("length:%d\n", buffer->msgLength);
printf("type:%d\n", (int)buffer->msgType);
printf("code:%d\n", (int)buffer->code);
printf("Cxid:%d\n", buffer->CxID);
printf("Seq#:%d\n", buffer->seqNum);
printf("size:%d\n\n", buffer->msgSize);
sendOk(sock, &clntAddr,
buffer->seqNum,
buffer->msgSize
);
}
break;
}
case STOP :
{
if (bindFlag == 1
&& bindIP == clntAddr.sin_addr.s_addr
&& bindPort == clntAddr.sin_port)
{
printf("\nSTOP msg received!\n\n");
sendOk(sock, &clntAddr,
buffer->seqNum,
buffer->msgSize
);
printf("\nSTOP OK send!\n\n");
//display the output information
display();
ualarm(0,0);
mylog = (QUEUE *)malloc(sizeof(QUEUE));
initQueue(mylog);
lossRecord = (node_t *)malloc(sizeof(node_t));
bindFlag = 0;
}
break;
}
default : break;
}
break;
}
case DATA :
{
//printf("received DATA!!\n");
if (bindFlag == 1
&& bindIP == clntAddr.sin_addr.s_addr
&& bindPort == clntAddr.sin_port)
{
//printf("The total packet loss : %lf\n",countDroped);
countRecv++;
countRecvBytes += recvMsgSize;
data = (struct data_t *)buffer;
data->RTT = ntohl(data->RTT);
newestNum = data->seqNum;
// printf("timeStamp recv%" PRIu64 "\n",data->timeStamp);
//printf("timeStamp %lu, %d, %d, %d\n",data->timeStamp, data->seqNum, data->RTT, data->msgLength);
if (RTT == 0)
ualarm(data->RTT,0);
RTT = data->RTT;
//printf("data %" PRIu32 " received\n", data->seqNum);
//RTT = 1000000;//for test
preLossRate = lossRate;
enQueueAndCheck(data);
if(lossRate > preLossRate)
{
//printf("\nalarm now\n");
ualarm(0,0);
sendDataAck(sock, &clntAddr);
ualarm(RTT,0);
}
//send each receive
//else sendDataAck(sock, &clntAddr);
}
break;
}
default : break;
}
}
close(sock);
printf("\nServer terminates.\n\n");
return 0;
}
void* UserAgent::run(void* arg) {
common = (Common *)arg;
init(0);
while(common->go) {
memo = (Memo*)common->signalQ->waitForData(waitMSec);
if(memo) switch(memo->code) {
case VIVOCE_SIP_INVITE:
if(state==SIP_UA_DISCONNECTED) {
//printf("\n\tSending INVITE....");
name = strtok_r(memo->bytes,"@",&temp);
remoteId = (char*)malloc(strlen(name)+1);
sprintf(remoteId,"%s",name);
name = strtok_r(NULL,":",&temp);
if(name) {
remoteHost = (char*) malloc(strlen(name)+1);
sprintf(remoteHost,"%s",name);
name=name = strtok_r(NULL,":",&temp);
if(name)
remoteSipPort = atoi(name);
else
remoteSipPort = VIVOCE_SIP_PORT;
sendInvite();
common->reset();
}
else {
printf("\n\tSIP: Malformed URI");
common->sipRmg->releaseMemo(memo);
}
}
else
common->sipRmg->releaseMemo(memo);
break;
case VIVOCE_SIP_BYE:
if(common->isConnected) {
common->isConnected=0;
printf("\n\tDisconnecting....");
rptCount=0;
sendBye();
}
else
common->sipRmg->releaseMemo(memo);
break;
case VIVOCE_SIP_ACCEPT:
if(state == SIP_UA_RCVD_INV) {
//printf("\n\tSending OK....");
sendOk();
state = SIP_UA_ACCEPTED;
common->isRinging=0;
}
else
common->sipRmg->releaseMemo(memo);
break;
case VIVOCE_SIP_REJECT:
if(state == SIP_UA_RCVD_INV) {
//printf("\n\tSending DECLINE....");
sendDecline();
common->isRinging=0;
}
else
common->sipRmg->releaseMemo(memo);
break;
case VIVOCE_SIP_RCVD:
//incoming!!
if(common->verbose) {
printf("\n\tINFO: SIP Msg Recv=%d bytes:\n%s", memo->data1,memo->bytes);
}
sipPackRecv->reset();
ret = SIPHandler::read(memo->bytes,
memo->data1,
sipPackRecv);
if(ret<0) {
printf("\n\tSIP: Error in parsing SIP packet");
}
else {
if((!sipPackRecv->isRequest)
&& (sipPackRecv->responseCode!=SIP_RESPONSE_OK)) {
printf("\n\tSIP: Received response code %d.",
sipPackRecv->responseCode);
}
switch(state) {
case SIP_UA_DISCONNECTED:
if((sipPackRecv->isRequest)
&& (sipPackRecv->requestCode==SIP_METHOD_INV)) {
checkPacket();
if(discard) {
printf("\n\tSIP: Incorrect SDP content: discarding");
common->sipRmg->releaseMemo(memo);
checkSrc=false;
}
else {
callId = sipPackRecv->callId;
callIdHost = (char*)malloc(strlen(sipPackRecv->callIdHost)+1);
sprintf(callIdHost, "%s", sipPackRecv->callIdHost);
//memory leak in these mallocs, but fixing them with realloc causes segfaults! for now, waste these ~100 bytes...
remoteId = (char*)malloc(strlen(sipPackRecv->contactUri.id)+1);
sprintf(remoteId, "%s", sipPackRecv->contactUri.id);
remoteHost = (char*)malloc(strlen(sipPackRecv->contactUri.host)+1);
sprintf(remoteHost,"%s",
sipPackRecv->contactUri.host);
printf("\n\tSIP: Recvd invite from %s at %s!!!",
sipPackRecv->contactUri.id,
sipPackRecv->contactUri.host);
printf("\n\tRing!!!");
sendRinging();
waitMSec=2500;
state = SIP_UA_RCVD_INV;
defaultAction = SIP_SEND_RING;
}
}
else
common->sipRmg->releaseMemo(memo); //else discard
break;
case SIP_UA_SENT_INV:
if((!sipPackRecv->isRequest)
&& (sipPackRecv->callId == callId)
&& (!strcmp(callIdHost,sipPackRecv->callIdHost))) {
if(sipPackRecv->responseCode==SIP_RESPONSE_RING) {
printf("\n\tSIP: Ringing callee....");
common->isRinging=1;
waitMSec=5000;
defaultAction = SIP_CONN;
//display ringing for some time
common->sipRmg->releaseMemo(memo);
}
else if(sipPackRecv->responseCode==SIP_RESPONSE_BUSY) {
printf("\n\tSIP: Callee is Busy! Try again later");
waitMSec=500;
defaultAction = SIP_DISCONN;
common->sipRmg->releaseMemo(memo);
common->isRinging=0;
}
else if(sipPackRecv->responseCode==SIP_RESPONSE_DECLINE) {
printf("\n\tSIP: Callee has declined to accept your call");
waitMSec=500;
defaultAction = SIP_DISCONN;
common->sipRmg->releaseMemo(memo);
common->isRinging=0;
}
else if(sipPackRecv->responseCode==SIP_RESPONSE_OK) {
checkPacket();
if(discard) {
printf("\n\tSIP: Incorrect SDP content: discarding");
common->sipRmg->releaseMemo(memo);
checkSrc=false;
}
else {
if(common->verbose) {
printf("\n\tINFO: Listening for RTP/RTCP on ports %d/%d",
remoteRtpPort,
remoteRtcpPort);
}
UdpBase::initRemoteAddr(common,
remoteHost,
remoteRtpPort,
remoteRtcpPort,
0);
printf("\n\tSIP: Connected!!!");
sendAck();
common->isRinging=0;
}
}
else
checkSrc=true;
}
else
checkSrc=true;
break;
case SIP_UA_SENT_BYE:
if(!sipPackRecv->isRequest) {
if(sipPackRecv->responseCode==SIP_RESPONSE_OK) {
printf("\n\tSIP: Disconnect complete.");
state = SIP_UA_DISCONNECTED;
cleanup();
defaultAction = SIP_NONE;
}
common->sipRmg->releaseMemo(memo);
}
else
checkSrc=true;
break;
case SIP_UA_ACCEPTED:
if(sipPackRecv->isRequest
&& (sipPackRecv->requestCode== SIP_METHOD_ACK)
&& (sipPackRecv->callId == callId)
&& (!strcmp(callIdHost, sipPackRecv->callIdHost))) {
//printf("\n\tSIP: Acknowledged....");
common->isConnected = 1;
common->rtpMgr->init(RTP_PAYLOAD_TYPE_ADPCM, const_cast<char*>("stats"));
waitMSec=2500;
defaultAction = SIP_NONE;
state = SIP_UA_IN_CALL;
common->sipRmg->releaseMemo(memo);
common->isRinging=0;
}
else
checkSrc=true;
break;
case SIP_UA_REJECTED:
if(sipPackRecv->isRequest
&& (sipPackRecv->requestCode== SIP_METHOD_ACK)
&& (sipPackRecv->callId == callId)
&& (!strcmp(callIdHost,sipPackRecv->callIdHost))) {
//printf("\n\tSIP: Acknowledged....");
common->isConnected=0;
waitMSec=500;
defaultAction = SIP_DISCONN;
common->sipRmg->releaseMemo(memo);
common->isRinging=0;
}
else
checkSrc=true;
break;
case SIP_UA_IN_CALL:
if(sipPackRecv->isRequest
&& (sipPackRecv->requestCode==SIP_METHOD_BYE)
&& (sipPackRecv->callId == callId)) {
//printf("\n\tSending OK for BYE....");
printf("\n\tSIP: Disconnected by peer.");
sendOk();
common->isConnected=0;
waitMSec=2500;
defaultAction = SIP_DISCONN;
state = SIP_UA_DISCONNECTED;
}
else
checkSrc=true;
break;
default:
checkSrc=true;
break;
}
if(checkSrc) {
checkSrc=false;
if(sipPackRecv->callId != callId) {
//printf("\n\tSending BUSY");
UdpBase::initTempRemoteAddr(common,
sipPackRecv->contactUri.host,
remoteSipPort);
sendBusy();
}
else
common->sipRmg->releaseMemo(memo);
}
break;
}
break;
default:
printf("\n\tSIP: In invalid state! %d",state);
common->sipRmg->releaseMemo(memo);
break;
case VIVOCE_RESPOND:
printf("\n\tUser Agent active - %d",state);
common->sipRmg->releaseMemo(memo);
break;
}
else
doDefaultAction();
}
printf("UserAgent stopped. ");
return NULL;
}
TInt DISICLTransceiver::RouteISIMessage(
TDes8& aMessage,
TBool aDynamicSenderCheckNeeded
)
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage 0x%x 0x%x> len %d" ), &aMessage, aDynamicSenderCheckNeeded, aMessage.Length() ) );
const TUint8* msgPtr = aMessage.Ptr();
ISIMESSAGE_TRACE( aMessage );
TInt error( ValidateISIMessage( aMessage ) );
if( KErrNone != error )
{
TRACE_ASSERT_ALWAYS;
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage invalid message 0x%x" ), &aMessage ) );
MemApi::DeallocBlock( aMessage );
}
else
{
TBool sendOk( EFalse );
if ( aDynamicSenderCheckNeeded )// Save dynamic device ids from PN_DEV_OWN
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage from ISI Router" ) ) );
TUint8 txDeviceIdentifier = GET_SENDER_DEV( aMessage );
if ( DynamicDevice( txDeviceIdentifier ) )
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage from ISI Router Dynamic Dev" ) ) );
UpdateDynamicDeviceTable( txDeviceIdentifier, PN_DEV_OWN );
#ifndef USE_MEDIAAPI
ASSERT_RESET_ALWAYS( txDeviceIdentifier == PN_DEV_PC, 0xdeaddead );// only supported PN_DEV_PC with EIscNokiaUsbPhonetLink
#endif /* USE_MEDIAAPI */
}
}
TUint8 rxDeviceIdentifier = GET_RECEIVER_DEV( aMessage );
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage rxDeviceIdentifier 0x%x" ), rxDeviceIdentifier ) );
if ( DynamicDevice( rxDeviceIdentifier ) )
{
DynamicToStaticDevice( rxDeviceIdentifier );
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage rxDeviceIdentifier after 0x%x" ), rxDeviceIdentifier ) );
}
if( rxDeviceIdentifier == PN_DEV_OWN )
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage PN_DEV_OWN 0x%x" ), &aMessage ) );
TUint16 objId(0xffff);
#ifndef USE_MEDIAAPI
if ( GET_RECEIVER_DEV( aMessage ) == PN_DEV_PC )
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage to PN_DEV_PC in PN_DEV_OWN" )) );
objId = EIscNokiaUsbPhonetLink;
}
else
{
objId = GET_RECEIVER_OBJ( aMessage );
}
#endif /* USE_MEDIAAPI */
#ifdef USE_MEDIAAPI
objId = GET_RECEIVER_OBJ( aMessage );
#endif /* USE_MEDIAAPI */
sendOk = iShRouter.Receive( aMessage, objId );
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage PN_DEV_OWN 0x%x ok %d" ), &aMessage, sendOk ) );
}
else
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage Not PN_DEV_OWN 0x%x" ), &aMessage ) );
MISIRouterLinkIf* link = NULL;
const TInt count( iShDevices.Count() );
for( TInt index( 0 ); index < count; index++ )
{
DISIDevice* tmpDevice = iShDevices[ index ];
ASSERT_RESET_ALWAYS( tmpDevice, ( EISICLTransceiverNULLPtr4 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
tmpDevice->LockDeviceFM();
if( tmpDevice->GetDeviceIdentifier() == rxDeviceIdentifier )
{
link = tmpDevice->GetLink();
tmpDevice->FreeDeviceFM();
#ifndef USE_MEDIAAPI
sendOk = link->Send( aMessage );
break;
#endif /* USE_MEDIAAPI */
#ifdef USE_MEDIAAPI
if ( GET_RECEIVER_DEV( aMessage ) == PN_DEV_PC )
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage PN_DEV_PC %d, %d" ), link->GetTrxId(), iDevPcLastSendTrxId ) );
if(iDevPcLastSendTrxId < EAmountOfTrxs)
{
if ( link->GetTrxId() == iDevPcLastSendTrxId )
{
if (link->StateConnected())
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage PN_DEV_PC %d, Msg mediaid 0x%x" ), link->GetTrxId(), msgPtr[ ISI_HEADER_OFFSET_MEDIA ] ) );
sendOk = link->Send( aMessage );
break;
}
}
}
else
{
break;
}
}
else
{
sendOk = link->Send( aMessage );
break;
}
#endif /* USE_MEDIAAPI */
}
else
{
tmpDevice->FreeDeviceFM();
}
}
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage Not PN_DEV_OWN ok %d" ), &aMessage, sendOk ) );
}
if( !sendOk )
{
TRACE_ASSERT_ALWAYS;
error = SendCommIsaEntityNotReachableResp( aMessage );
}
}
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage 0x%x<" ), &aMessage ) );
return error;
}
