void CHCEmulator::InquiryCompleteEvent(TUint8 aError)
{
ClearPacket();
iConsole.Printf(_L("Sending InquiryComplete Event (error 0x%02x)...\n"), aError);
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCIInquiryCompleteEventCode);
PutBytes(KHCIInquiryCompleteEventLength);
PutBytes(aError);
WritePacket();
}
void CHCEmulator::ConnectionCompleteEvent(TUint8 aError, TLinkType /*aType*/)
{
ClearPacket();
iConsole.Printf(_L("Sending ConnectionComplete Event (error 0x%02x)...\n"), aError);
const TBTConnect& newConnection = iConnections[iConnections.Count()-1];
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCIConnectionCompleteEventCode);
PutBytes(KHCIConnectionCompleteEventLength);
// test for what happens if we createconnection while inquiry is active
if (iInquiryTimer->IsActive())
PutBytes(KHCICommandDisallowed);
else
PutBytes(aError);
PutBytes(newConnection.iConnH,2);
PutAddress(newConnection.iBdaddr); // <-- test signaller by changing this address
PutBytes(newConnection.iLinkType);
PutBytes(newConnection.iEncryptMode);
WritePacket();
}
void CHCEmulator::ConnectionRequestEvent(const TBTDevAddr& aAddr, TUint aCoD, TLinkType aType)
{
ClearPacket();
iConsole.Printf(_L("Sending Connection Request event...\n"));
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCIConnectionRequestEventCode);
PutBytes(KHCIConnectionRequestEventLength);
PutAddress(aAddr);
PutBytes(aCoD,3);
PutBytes(aType);
WritePacket();
}
void CHCEmulator::HardwareErrorEvent()
{
ClearPacket();
TUint8 error = KHCIOK;
iConsole.Printf(_L("Sending HardwareError Event (error 0x%02x)...\n"), error);
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCIHardwareErrorEventCode);
PutBytes(KHCIHardwareErrorEventLength);
PutBytes(error);
WritePacket();
}
void CHCEmulator::ReadRemoteNameCompleteEvent(TUint8 aError, const TBTDevAddr& aAddr, const TDesC8& aName)
{
ClearPacket();
iConsole.Printf(_L("Sending C.C.E (opcode ReadRemoteName, error 0x%02x)...\n"), aError);
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCIRemoteNameRequestCompleteEventCode);
PutBytes(KHCIRemoteNameReqCompleteEventPacketLength);
PutBytes(aError);
PutAddress(aAddr);
PutName(aName);
WritePacket();
}
void CHCEmulator::SpecificVendorDebugEvent()
{
TInputManager manager(iConsole);
iConsole.Printf(_L("Data length (0-99): "));
TBuf8<255> str;
manager.ReadString(str);
TUint count;
if (manager.String2Uint(str, count) != KErrNone)
{
iConsole.Printf(_L("Invalid data length\n"), count);
return;
}
iConsole.Printf(_L("Fill in %d bytes\n"), count);
TBuf8<255> data(count);
TUint value;
for(TUint index=0;index<count;index++)
{
iConsole.Printf(_L("byte %d: 0x"), index);
// TUint value = manager.ReadInt(ETrue);
manager.ReadString(str);
if (manager.String2Uint(str, value, ETrue) != KErrNone)
{
iConsole.Printf(_L("Invalid byte value (must be hex)\n"), count);
return;
}
data[index] = value;
}
ClearPacket();
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCISpecificVendorDebugEvent);
PutBytes(count);
for(TUint index=0;index<count;index++)
{
PutBytes(data[index]);
}
TRAPD(error,iWriter->WriteL(iPacket));
if (error)
iConsole.Printf(_L("ERROR - Write failed\n"));
}
HRESULT CBPersistMgr::Transfer(const char* Name, AnsiStringArray& Val)
{
size_t size;
if (m_Saving)
{
size = Val.size();
PutBytes((BYTE*)&size, sizeof(size_t));
for (AnsiStringArray::iterator it = Val.begin(); it != Val.end(); ++it)
{
PutString((*it).c_str());
}
}
else
{
Val.clear();
GetBytes((BYTE*)&size, sizeof(size_t));
for (size_t i = 0; i < size; i++)
{
char* str = GetString();
if (str) Val.push_back(str);
}
}
return S_OK;
}
void CHCEmulator::BuildAndWriteDataPacket(const TDesC8& aConnHandleBuf /* THCIConnHandle aConnH*/, const TDesC8& aRemainderBuf)
{
ClearPacket();
PutBytes(KHCIUARTACLDataHeader);
// PutBytes(aConnH,2);
iPacket.Append(aConnHandleBuf);
PutBytes(aRemainderBuf.Length(), 2);
iPacket.Append(aRemainderBuf);
TRAPD(error,iWriter->WriteL(iPacket));
if (error)
iConsole.Printf(_L("ERROR - Write failed\n"));
}
float BitConverter::ToSingle(byte value[], int startIndex)
{
sassert(value != null, String::Format("value; %s", FrameworkResources::ArgumentNull_Generic));
float ret;
PutBytes((byte*)&ret, value, startIndex, 4);
return ret;
}
void CBDynBuffer::PutString(const char* Val)
{
if(!Val) PutString("(null)");
else{
PutDWORD(strlen(Val)+1);
PutBytes((BYTE*)Val, strlen(Val)+1);
}
}
ulong BitConverter::ToUInt64(byte value[], int startIndex)
{
sassert(value != null, String::Format("value; %s", FrameworkResources::ArgumentNull_Generic));
ulong ret;
PutBytes((byte*)&ret, value, startIndex, 8);
return ret;
}
int8_t MessageIface::getBytes( void ) {
uint8_t byte;
int8_t status;
while ( _serial->readable() ) {
byte = _serial->getc();
//pc1.putc(byte);
status = PutBytes(&pf, &byte, 1);
}
return( status );
}
void CJpegEncoder::WriteDHT()
{
PutByte(0xff);
PutByte(0xc4);
WORD size = 0x01A2; // 2 + n*(17+mi);
PutByte(size>>8);
PutByte(size&0xff);
PutByte(0x00); // tbl class (DC) | tbl id
PutBytes(DCVLC_NumByLength[0], 16);
for(int i = 0; i < 12; i++) PutByte(i);
PutByte(0x01); // tbl class (DC) | tbl id
PutBytes(DCVLC_NumByLength[1], 16);
for(int i = 0; i < 12; i++) PutByte(i);
PutByte(0x10); // tbl class (AC) | tbl id
PutBytes(ACVLC_NumByLength[0], 16);
PutBytes(ACVLC_Data[0], sizeof(ACVLC_Data[0]));
PutByte(0x11); // tbl class (AC) | tbl id
PutBytes(ACVLC_NumByLength[1], 16);
PutBytes(ACVLC_Data[1], sizeof(ACVLC_Data[1]));
}
void CHCEmulator::InquiryResultEvent()
{
TInt resultsInPacket = Min(((iCurrentInquiryResponse % 5) + 1) , (KEmulatedInquiryNumberDevicesFound - iCurrentInquiryResponse));
ClearPacket();
TInt error = KHCIOK;
iConsole.Printf(_L("Sending InquiryResult Event (error 0x%02x)...\n"), error);
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCIInquiryResultEventCode);
PutBytes(1 + (14 * resultsInPacket));
PutBytes(resultsInPacket);
for (TInt i = 0; i < resultsInPacket; i++)
{
// stick them all in one event!
PutAddress(iInquiryAddresses[iCurrentInquiryResponse + i]);
PutBytes(KEmulatedInquiryPageScanRepetionMode);
PutBytes(KEmulatedInquiryPageScanPeriodMode);
PutBytes(KEmulatedInquiryPageScanMode);
PutBytes(KEmulatedInquiryClassOfDevice,3);
PutBytes(KEmulatedInquiryClockOffset,2);
}
WritePacket();
iCurrentInquiryResponse += resultsInPacket;
// Wait for another result if we've not done them all, else complete inquiry
if(iCurrentInquiryResponse < KEmulatedInquiryNumberDevicesFound)
{
iInquiryTimer->Start();
}
else
{
InquiryCompleteEvent(KHCIOK);
}
}
void CJpegEncoder::WriteDQT()
{
PutByte(0xff);
PutByte(0xdb);
WORD size = 2 + 2*(65 + 64*0);
PutByte(size>>8);
PutByte(size&0xff);
for(int c = 0; c < 2; c++)
{
PutByte(c);
PutBytes(quanttbl[c], 64);
}
}
void CHCEmulator::WriteLinkPolicySettingsCompleteEvent(TUint8 aError, THCIConnHandle aConnH)
{
ClearPacket();
iConsole.Printf(_L("Sending WriteLinkPolicySettingsComplete Event (error 0x%02x)...\n"), aError);
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCICommandCompleteEventCode);
PutBytes(KHCIWriteLinkPolicySettingsCompleteLength);
PutBytes(1); //1 command token
PutBytes(KWriteLinkPolicySettingsOpcode,2);
PutBytes(aError);
PutBytes(aConnH, 2);
WritePacket();
}
void CHCEmulator::ReadRemoteVersionInfoCompleteEvent(TUint8 aError, THCIConnHandle aConnH)
{
ClearPacket();
iConsole.Printf(_L("Sending ReadRemoteVersionInfoComplete Event (error 0x%02x)...\n"), aError);
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCIReadRemoteVersionInfoCode);
PutBytes(KHCIReadRemoteVersionInfoLength);
PutBytes(aError);
PutBytes(aConnH, 2);
PutBytes(KEmulatedRemoteVersionInfo1,4);
PutBytes(KEmulatedRemoteVersionInfo2,1);
WritePacket();
}
void CHCEmulator::DisconnectionCompleteEvent(TUint8 aError, THCIConnHandle aConnH, TUint8 aReason)
{
ClearPacket();
iConsole.Printf(_L("Sending DisconnectComplete Event (error 0x%02x)...\n"), aError);
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCIDisconnectionCompleteEventCode);
PutBytes(KHCIDisconnectionCompleteEventLength);
PutBytes(aError);
PutBytes(aConnH, 2);
PutBytes(aReason);
WritePacket();
}
void CHCEmulator::ReadClockOffsetCompleteEvent(TUint8 aError, THCIConnHandle aConnH)
{
ClearPacket();
iConsole.Printf(_L("Sending ReadClockOffsetComplete Event (error 0x%02x)...\n"), aError);
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCIReadClockOffsetCompleteEventCode);
PutBytes(KHCIReadClockOffsetCompleteLength);
PutBytes(aError);
PutBytes(aConnH, 2);
PutBytes(KEmulatedClockOffset,2);
WritePacket();
}
void CHCEmulator::ConnectionPacketTypeChangedEvent(TUint8 aError, THCIConnHandle aConnH)
{
ClearPacket();
iConsole.Printf(_L("Sending ConnectionPacketTypeChanged Event (error 0x%02x)...\n"), aError);
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCIConnectionPacketTypeChangedCode);
PutBytes(KHCIConnectionPacketTypeChangedLength);
PutBytes(aError);
PutBytes(aConnH, 2);
PutBytes(KEmulatedChangedPacketType,2);
WritePacket();
}
void CHCEmulator::NumberCompletedPacketsEvent(/*const TDesC8& aConnHandleFlagsBuf*/THCIConnHandle aConnH, TUint8 aNumPackets, TUint8 aError)
{
ClearPacket();
iConsole.Printf(_L("Sending NumPacketsComplete Event (error 0x%02x)...\n"), aError);
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCINumCompletedPacketsEventCode);
PutBytes(KHCINumCompletedPacketsEventLength);
PutBytes(0x01); // FIXME we'll do one at a time for the moment
PutBytes(aConnH,2);
// iPacket.Append(aConnHandleFlagsBuf);
PutBytes(aNumPackets,2); // FIXME we'll do one at a time for the moment
WritePacket();
}
void CHCEmulator::VendorSpecificDebugCompleteEvent(TUint16 aOpCode, const TDesC8& aRemainderBuf)
{
ClearPacket();
// Just send back the payload we got in Vendor Specific Command. This is used by
// the tproxy HCIProxy test program, to be found in HCIProxy's directory.
const TUint KFixedParamSize = 3;
const TUint KMaxUserParamSize = 255 - KFixedParamSize;
TUint userParamSize = (aRemainderBuf.Length() < KMaxUserParamSize) ?
aRemainderBuf.Length() : KMaxUserParamSize;
PutBytes(KHCIUARTEventHeader);
PutBytes(KHCICommandCompleteEventCode);
PutBytes(KFixedParamSize + userParamSize);
PutBytes(1); // numPackets
PutBytes(aOpCode, 2);
for (int i = 0; i < userParamSize; i++)
PutBytes(aRemainderBuf[i]);
iConsole.Printf(_L("Sending C.C.E (opcode VendorSpecificDebug), user param size %d...\n"),
userParamSize);
WritePacket();
}
void CBDynBuffer::PutTextForm(const char *format, va_list argptr)
{
char buff[32768];
vsprintf(buff, format, argptr);
PutBytes((BYTE*)buff, strlen(buff));
}
void CBDynBuffer::PutDWORD(DWORD Val)
{
PutBytes((BYTE*)&Val, sizeof(DWORD));
}
HRESULT CBPersistMgr::InitSave(char* Desc)
{
if(!Desc) return E_FAIL;
HRESULT res;
Cleanup();
m_Saving = true;
m_Buffer = (BYTE*)malloc(SAVE_BUFFER_INIT_SIZE);
if(m_Buffer)
{
m_BufferSize = SAVE_BUFFER_INIT_SIZE;
res = S_OK;
}
else res = E_FAIL;
if(SUCCEEDED(res))
{
// get thumbnails
if(!Game->m_CachedThumbnail)
{
Game->m_CachedThumbnail = new CBSaveThumbHelper(Game);
if(FAILED(Game->m_CachedThumbnail->StoreThumbnail(true)))
{
SAFE_DELETE(Game->m_CachedThumbnail);
}
}
// rich saved game stuff
if(Game->m_RichSavedGames) FillRichBuffer(Desc);
DWORD magic = DCGF_MAGIC;
PutDWORD(magic);
magic = SAVE_MAGIC_2;
PutDWORD(magic);
BYTE VerMajor, VerMinor, ExtMajor, ExtMinor;
Game->GetVersion(&VerMajor, &VerMinor, &ExtMajor, &ExtMinor);
DWORD Version = MAKELONG(MAKEWORD(VerMajor, VerMinor), MAKEWORD(ExtMajor, ExtMinor));
PutDWORD(Version);
// new in ver 2
PutDWORD((DWORD)DCGF_VER_BUILD);
PutString(Game->m_Name);
// thumbnail data size
bool ThumbnailOK = false;
if(Game->m_CachedThumbnail)
{
if(Game->m_CachedThumbnail->m_Thumbnail)
{
DWORD Size = 0;
BYTE* Buffer = Game->m_CachedThumbnail->m_Thumbnail->CreateBMPBuffer(&Size);
PutDWORD(Size);
if(Size>0) PutBytes(Buffer, Size);
delete [] Buffer;
ThumbnailOK = true;
}
}
if(!ThumbnailOK) PutDWORD(0);
// in any case, destroy the cached thumbnail once used
SAFE_DELETE(Game->m_CachedThumbnail);
DWORD DataOffset = m_Offset +
sizeof(DWORD) + // data offset
sizeof(DWORD) + strlen(Desc) + 1 + // description
sizeof(DWORD); // timestamp
PutDWORD(DataOffset);
PutString(Desc);
time_t Timestamp;
time(&Timestamp);
PutDWORD((DWORD)Timestamp);
}
return res;
}
bool CBPersistMgr::PutBuffer(unsigned char* Buffer, int Size)
{
return SUCCEEDED(PutBytes(Buffer, Size));
}
//////////////////////////////////////////////////////////////////////////
// D3DXMATRIX
HRESULT CBPersistMgr::Transfer(char* Name, D3DXMATRIX* Val)
{
if(m_Saving) return PutBytes((BYTE*)Val, sizeof(D3DXMATRIX));
else return GetBytes((BYTE*)Val, sizeof(D3DXMATRIX));
}
//////////////////////////////////////////////////////////////////////////
// POINT
HRESULT CBPersistMgr::Transfer(char* Name, POINT* Val)
{
if(m_Saving) return PutBytes((BYTE*)Val, sizeof(POINT));
else return GetBytes((BYTE*)Val, sizeof(POINT));
}
void CBPersistMgr::PutDWORD(DWORD Val)
{
PutBytes((BYTE*)&Val, sizeof(DWORD));
}
void GrowingBuffer::PutString(const char *t)
{
size_t len = strlen(t)+1;
PutBytes(reinterpret_cast<const uint8_t *>(t),len);
}
