// Private methods -----------------------------------------------
// Runs all the necessary functions to ensure connectivity
void Initialize(Controller controller){
int fd = open(JOYSTICK_DEVICE, O_RDONLY);
if(fd > 0){
char name[128];
int version;
js_fd = fd;
controller->active = true;
// store driver version, if it is less than
// version 1.0 there will be no support for it
ioctl(fd, JSIOCGVERSION, &version);
if (version < 0x010000){
return;
}
controller->version = version;
// store size of the name and makes sure its not null
// if its valid store the name into our struct.
int ret = ioctl(fd, JSIOCGNAME(sizeof(name)), name);
if (ret < 0){
return;
}
controller->name = strdup(name);
deviceInfo(controller);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_create(&controller->thread,&attr, Loop, (void*)controller);
}
}
V4L2WebcamInfo * Webcam::openAndGatherInfoFrom(const QString &fname)
{
setDevice(fname);
if( !open_device() )
return NULL;
return deviceInfo();
}
XlibTouchpad* XlibBackend::findTouchpad()
{
int nDevices = 0;
QScopedPointer<XDeviceInfo, DeviceListDeleter>
deviceInfo(XListInputDevices(m_display.data(), &nDevices));
for (XDeviceInfo *info = deviceInfo.data();
info < deviceInfo.data() + nDevices; info++)
{
// Make sure device is touchpad
if (info->type != m_touchpadAtom.atom()) {
continue;
}
int nProperties = 0;
QSharedPointer<Atom> properties(
XIListProperties(m_display.data(), info->id,
&nProperties), XDeleter);
Atom *atom = properties.data(), *atomEnd = properties.data() + nProperties;
for (; atom != atomEnd; atom++) {
if (*atom == m_libinputIdentifierAtom.atom()) {
return new LibinputTouchpad(m_display.data(), info->id);
} else if (*atom == m_synapticsIdentifierAtom.atom()) {
return new SynapticsTouchpad(m_display.data(), info->id);
}
}
}
return nullptr;
}
void tst_QBluetoothDeviceInfo::tst_cached()
{
QBluetoothDeviceInfo deviceInfo(QBluetoothAddress("AABBCCDDEEFF"),
QString("My Bluetooth Device"), quint32(0x002000));
QBluetoothDeviceInfo copyInfo = deviceInfo;
QVERIFY(!deviceInfo.isCached());
deviceInfo.setCached(true);
QVERIFY(deviceInfo.isCached());
QVERIFY(!(deviceInfo == copyInfo));
deviceInfo.setCached(false);
QVERIFY(!(deviceInfo.isCached()));
}
//--------------------------------------------------------------------------------
ChilliSource::SystemInfoCUPtr SystemInfoFactory::CreateSystemInfo() noexcept
{
// Create DeviceInfo.
ChilliSource::DeviceInfo deviceInfo(k_deviceModel, k_deviceModelType, k_deviceManufacturer, k_deviceUdid, GetLocale(), ParseLanguageFromLocale(GetLocale()), GetOSVersion(), GetNumberOfCPUCores());
// Create ScreenInfo.
ChilliSource::ScreenInfo screenInfo(GetScreenResolution(), 1.0f, 1.0f, GetSupportedFullscreenResolutions());
//Create RenderInfo
ChilliSource::RenderInfo renderInfo = OpenGL::RenderInfoFactory::CreateRenderInfo();
// Create SystemInfo.
ChilliSource::SystemInfoUPtr systemInfo(new ChilliSource::SystemInfo(deviceInfo, screenInfo, renderInfo, ""));
return std::move(systemInfo);
}
int main(void)
{
led1 = 1;
Ticker ticker;
ticker.attach(periodicCallback, 1); // blink LED every second
ble.init();
ble.gap().onDisconnection(disconnectionCallback);
/* Setup primary service. */
uint8_t hrmCounter = 100; // init HRM to 100bps
HeartRateService hrService(ble, hrmCounter, HeartRateService::LOCATION_FINGER);
/* Setup auxiliary service. */
DeviceInformationService deviceInfo(ble, "ARM", "Model1", "SN1", "hw-rev1", "fw-rev1", "soft-rev1");
/* Setup advertising. */
ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, sizeof(uuid16_list));
ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::GENERIC_HEART_RATE_SENSOR);
ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME));
ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
ble.gap().setAdvertisingInterval(1000); /* 1000ms */
ble.gap().startAdvertising();
// infinite loop
while (1) {
// check for trigger from periodicCallback()
if (triggerSensorPolling && ble.getGapState().connected) {
triggerSensorPolling = false;
// Do blocking calls or whatever is necessary for sensor polling.
// In our case, we simply update the HRM measurement.
hrmCounter++;
// 100 <= HRM bps <=175
if (hrmCounter == 175) {
hrmCounter = 100;
}
// update bps
hrService.updateHeartRate(hrmCounter);
} else {
ble.waitForEvent(); // low power wait for event
}
}
}
void initializeHOGP(BLE &ble)
{
static const uint16_t uuid16_list[] = {GattService::UUID_HUMAN_INTERFACE_DEVICE_SERVICE,
GattService::UUID_DEVICE_INFORMATION_SERVICE,
GattService::UUID_BATTERY_SERVICE};
DeviceInformationService deviceInfo(ble, "ARM", "m1", "abc", "def", "ghi", "jkl");
BatteryService batteryInfo(ble, 80);
ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED |
GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS,
(uint8_t *)uuid16_list, sizeof(uuid16_list));
// see 5.1.2: HID over GATT Specification (pg. 25)
ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
// 30ms to 50ms is recommended (5.1.2)
ble.gap().setAdvertisingInterval(50);
}
int
ZnsHelper::processDeviceInfoReply(QNetworkReply* reply, ChecksT& checks)
{
if (parseReply(reply) != 0){
return -1;
}
if (! checkRPCResultStatus()) {
return -1;
}
// check weird reponse
qint32 tid = m_replyJsonData.getProperty("tid").toInt32();
if (tid != DeviceInfo ) {
m_lastError = tr("Weird transaction type set for device info (%1)").arg(tid);
return -1;
}
// now treat successful result
CheckT check;
QScriptValue deviceInfo(m_replyJsonData.getProperty("result").property("data"));
QString dname = deviceInfo.property("name").toString();
check.host = dname.toStdString();
check.id = check.host; //FIXME: ??ID_PATTERN.arg(check.host.c_str(), "ping").toStdString();
check.host_groups = parseHostGroups(deviceInfo.property("groups"));
check.status = deviceInfo.property("status").toBool();
check.last_state_change = ngrt4n::convertToTimet(deviceInfo.property("lastChanged").toString(),
"yyyy/MM/dd hh:mm:ss");
if (check.status) {
check.status = ngrt4n::ZenossClear;
check.alarm_msg = tr("The host '%1' is Up").arg(dname).toStdString();
} else {
check.status = ngrt4n::ZenossCritical;
check.alarm_msg = tr("The host '%1' is Down").arg(dname).toStdString();
}
checks.insert(check.id, check);
return 0;
}
void tst_QBluetoothDeviceInfo::tst_construction()
{
{
QBluetoothDeviceInfo deviceInfo;
QVERIFY(!deviceInfo.isValid());
}
{
QFETCH(QBluetoothAddress, address);
QFETCH(QString, name);
QFETCH(quint32, classOfDevice);
QFETCH(QBluetoothDeviceInfo::ServiceClasses, serviceClasses);
QFETCH(QBluetoothDeviceInfo::MajorDeviceClass, majorDeviceClass);
QFETCH(quint8, minorDeviceClass);
QBluetoothDeviceInfo deviceInfo(address, name, classOfDevice);
QVERIFY(deviceInfo.isValid());
QCOMPARE(deviceInfo.address(), address);
QCOMPARE(deviceInfo.name(), name);
QCOMPARE(deviceInfo.serviceClasses(), serviceClasses);
QCOMPARE(deviceInfo.majorDeviceClass(), majorDeviceClass);
QCOMPARE(deviceInfo.minorDeviceClass(), minorDeviceClass);
QBluetoothDeviceInfo copyInfo(deviceInfo);
QVERIFY(copyInfo.isValid());
QCOMPARE(copyInfo.address(), address);
QCOMPARE(copyInfo.name(), name);
QCOMPARE(copyInfo.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo.minorDeviceClass(), minorDeviceClass);
}
}
void tst_QBluetoothDeviceInfo::tst_assignment()
{
QFETCH(QBluetoothAddress, address);
QFETCH(QString, name);
QFETCH(quint32, classOfDevice);
QFETCH(QBluetoothDeviceInfo::ServiceClasses, serviceClasses);
QFETCH(QBluetoothDeviceInfo::MajorDeviceClass, majorDeviceClass);
QFETCH(quint8, minorDeviceClass);
QBluetoothDeviceInfo deviceInfo(address, name, classOfDevice);
QVERIFY(deviceInfo.isValid());
{
QBluetoothDeviceInfo copyInfo = deviceInfo;
QVERIFY(copyInfo.isValid());
QCOMPARE(copyInfo.address(), address);
QCOMPARE(copyInfo.name(), name);
QCOMPARE(copyInfo.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo.minorDeviceClass(), minorDeviceClass);
}
{
QBluetoothDeviceInfo copyInfo;
QVERIFY(!copyInfo.isValid());
copyInfo = deviceInfo;
QVERIFY(copyInfo.isValid());
QCOMPARE(copyInfo.address(), address);
QCOMPARE(copyInfo.name(), name);
QCOMPARE(copyInfo.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo.minorDeviceClass(), minorDeviceClass);
}
{
QBluetoothDeviceInfo copyInfo1;
QBluetoothDeviceInfo copyInfo2;
QVERIFY(!copyInfo1.isValid());
QVERIFY(!copyInfo2.isValid());
copyInfo1 = copyInfo2 = deviceInfo;
QVERIFY(copyInfo1.isValid());
QVERIFY(copyInfo2.isValid());
QVERIFY(!(QBluetoothDeviceInfo() == copyInfo1));
QCOMPARE(copyInfo1.address(), address);
QCOMPARE(copyInfo2.address(), address);
QCOMPARE(copyInfo1.name(), name);
QCOMPARE(copyInfo2.name(), name);
QCOMPARE(copyInfo1.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo2.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo1.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo2.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo1.minorDeviceClass(), minorDeviceClass);
QCOMPARE(copyInfo2.minorDeviceClass(), minorDeviceClass);
}
{
QBluetoothDeviceInfo testDeviceInfo;
QVERIFY(testDeviceInfo == QBluetoothDeviceInfo());
}
}
void IosToolHandlerPrivate::processXml()
{
while (!outputParser.atEnd()) {
QXmlStreamReader::TokenType tt = outputParser.readNext();
//qCDebug(toolHandlerLog) << "processXml, tt=" << tt;
switch (tt) {
case QXmlStreamReader::NoToken:
// The reader has not yet read anything.
continue;
case QXmlStreamReader::Invalid:
// An error has occurred, reported in error() and errorString().
break;
case QXmlStreamReader::StartDocument:
// The reader reports the XML version number in documentVersion(), and the encoding
// as specified in the XML document in documentEncoding(). If the document is declared
// standalone, isStandaloneDocument() returns true; otherwise it returns false.
break;
case QXmlStreamReader::EndDocument:
// The reader reports the end of the document.
// state = XmlEndProcessed;
break;
case QXmlStreamReader::StartElement:
// The reader reports the start of an element with namespaceUri() and name(). Empty
// elements are also reported as StartElement, followed directly by EndElement.
// The convenience function readElementText() can be called to concatenate all content
// until the corresponding EndElement. Attributes are reported in attributes(),
// namespace declarations in namespaceDeclarations().
{
QStringRef elName = outputParser.name();
if (elName == QLatin1String("msg")) {
stack.append(ParserState(ParserState::Msg));
} else if (elName == QLatin1String("exit")) {
stack.append(ParserState(ParserState::Exit));
toolExited(outputParser.attributes().value(QLatin1String("code"))
.toString().toInt());
} else if (elName == QLatin1String("device_id")) {
stack.append(ParserState(ParserState::DeviceId));
} else if (elName == QLatin1String("key")) {
stack.append(ParserState(ParserState::Key));
} else if (elName == QLatin1String("value")) {
stack.append(ParserState(ParserState::Value));
} else if (elName == QLatin1String("query_result")) {
stack.append(ParserState(ParserState::QueryResult));
} else if (elName == QLatin1String("app_output")) {
stack.append(ParserState(ParserState::AppOutput));
} else if (elName == QLatin1String("control_char")) {
QXmlStreamAttributes attributes = outputParser.attributes();
QChar c[1] = { QChar::fromLatin1(static_cast<char>(attributes.value(QLatin1String("code")).toString().toInt())) };
if (stack.size() > 0 && stack.last().collectChars())
stack.last().chars.append(c[0]);
stack.append(ParserState(ParserState::ControlChar));
break;
} else if (elName == QLatin1String("item")) {
stack.append(ParserState(ParserState::Item));
} else if (elName == QLatin1String("status")) {
ParserState pState(ParserState::Status);
QXmlStreamAttributes attributes = outputParser.attributes();
pState.progress = attributes.value(QLatin1String("progress")).toString().toInt();
pState.maxProgress = attributes.value(QLatin1String("max_progress")).toString().toInt();
stack.append(pState);
} else if (elName == QLatin1String("app_started")) {
stack.append(ParserState(ParserState::AppStarted));
QXmlStreamAttributes attributes = outputParser.attributes();
QStringRef statusStr = attributes.value(QLatin1String("status"));
Ios::IosToolHandler::OpStatus status = Ios::IosToolHandler::Unknown;
if (statusStr.compare(QLatin1String("success"), Qt::CaseInsensitive) == 0)
status = Ios::IosToolHandler::Success;
else if (statusStr.compare(QLatin1String("failure"), Qt::CaseInsensitive) == 0)
status = Ios::IosToolHandler::Failure;
didStartApp(bundlePath, deviceId, status);
} else if (elName == QLatin1String("app_transfer")) {
stack.append(ParserState(ParserState::AppTransfer));
QXmlStreamAttributes attributes = outputParser.attributes();
QStringRef statusStr = attributes.value(QLatin1String("status"));
Ios::IosToolHandler::OpStatus status = Ios::IosToolHandler::Unknown;
if (statusStr.compare(QLatin1String("success"), Qt::CaseInsensitive) == 0)
status = Ios::IosToolHandler::Success;
else if (statusStr.compare(QLatin1String("failure"), Qt::CaseInsensitive) == 0)
status = Ios::IosToolHandler::Failure;
emit didTransferApp(bundlePath, deviceId, status);
} else if (elName == QLatin1String("device_info") || elName == QLatin1String("deviceinfo")) {
stack.append(ParserState(ParserState::DeviceInfo));
} else if (elName == QLatin1String("inferior_pid")) {
stack.append(ParserState(ParserState::InferiorPid));
} else if (elName == QLatin1String("server_ports")) {
stack.append(ParserState(ParserState::ServerPorts));
QXmlStreamAttributes attributes = outputParser.attributes();
Utils::Port gdbServerPort(
attributes.value(QLatin1String("gdb_server")).toString().toInt());
Utils::Port qmlServerPort(
attributes.value(QLatin1String("qml_server")).toString().toInt());
gotServerPorts(bundlePath, deviceId, gdbServerPort, qmlServerPort);
} else {
qCWarning(toolHandlerLog) << "unexpected element " << elName;
}
break;
}
case QXmlStreamReader::EndElement:
// The reader reports the end of an element with namespaceUri() and name().
{
ParserState p = stack.last();
stack.removeLast();
switch (p.kind) {
case ParserState::Msg:
errorMsg(p.chars);
break;
case ParserState::DeviceId:
if (deviceId.isEmpty())
deviceId = p.chars;
else
QTC_CHECK(deviceId.compare(p.chars, Qt::CaseInsensitive) == 0);
break;
case ParserState::Key:
stack.last().key = p.chars;
break;
case ParserState::Value:
stack.last().value = p.chars;
break;
case ParserState::Status:
isTransferringApp(bundlePath, deviceId, p.progress, p.maxProgress, p.chars);
break;
case ParserState::QueryResult:
state = XmlEndProcessed;
stop(0);
return;
case ParserState::AppOutput:
appOutput(p.chars);
break;
case ParserState::ControlChar:
break;
case ParserState::AppStarted:
break;
case ParserState::AppTransfer:
break;
case ParserState::Item:
stack.last().info.insert(p.key, p.value);
break;
case ParserState::DeviceInfo:
deviceInfo(deviceId, p.info);
break;
case ParserState::Exit:
break;
case ParserState::InferiorPid:
gotInferiorPid(bundlePath, deviceId, p.chars.toLongLong());
break;
case ParserState::ServerPorts:
break;
}
break;
}
case QXmlStreamReader::Characters:
// The reader reports characters in text(). If the characters are all white-space,
// isWhitespace() returns true. If the characters stem from a CDATA section,
// isCDATA() returns true.
if (stack.isEmpty())
break;
if (stack.last().collectChars())
stack.last().chars.append(outputParser.text());
break;
case QXmlStreamReader::Comment:
// The reader reports a comment in text().
break;
case QXmlStreamReader::DTD:
// The reader reports a DTD in text(), notation declarations in notationDeclarations(),
// and entity declarations in entityDeclarations(). Details of the DTD declaration are
// reported in in dtdName(), dtdPublicId(), and dtdSystemId().
break;
case QXmlStreamReader::EntityReference:
// The reader reports an entity reference that could not be resolved. The name of
// the reference is reported in name(), the replacement text in text().
break;
case QXmlStreamReader::ProcessingInstruction:
break;
}
}
if (outputParser.hasError()
&& outputParser.error() != QXmlStreamReader::PrematureEndOfDocumentError) {
qCWarning(toolHandlerLog) << "error parsing iosTool output:" << outputParser.errorString();
stop(-1);
}
}
std::string CSysInfo::GetUserAgent()
{
static std::string result;
if (!result.empty())
return result;
result = "XBMC/" + g_infoManager.GetLabel(SYSTEM_BUILD_VERSION_SHORT) + " (";
#if defined(TARGET_WINDOWS)
result += GetKernelName() + " " + GetKernelVersion();
BOOL bIsWow = FALSE;
if (IsWow64Process(GetCurrentProcess(), &bIsWow) && bIsWow)
result.append("; WOW64");
else
{
SYSTEM_INFO si = {};
GetSystemInfo(&si);
if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
result.append("; Win64; x64");
else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64)
result.append("; Win64; IA64");
else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM)
result.append("; ARM");
}
#elif defined(TARGET_DARWIN)
#if defined(TARGET_DARWIN_IOS)
std::string iDevStr(GetModelName()); // device model name with number of model version
size_t iDevStrDigit = iDevStr.find_first_of("0123456789");
std::string iDev(iDevStr, 0, iDevStrDigit); // device model name without number
if (iDevStrDigit == 0)
iDev = "unknown";
result += iDev + "; ";
std::string iOSVerison(GetOsVersion());
size_t lastDotPos = iOSVerison.rfind('.');
if (lastDotPos != std::string::npos && iOSVerison.find('.') != lastDotPos
&& iOSVerison.find_first_not_of('0', lastDotPos + 1) == std::string::npos)
iOSVerison.erase(lastDotPos);
StringUtils::Replace(iOSVerison, '.', '_');
if (iDev == "iPad" || iDev == "AppleTV")
result += "CPU OS ";
else
result += "CPU iPhone OS ";
result += iOSVerison + " like Mac OS X";
#else
result += "Macintosh; ";
std::string cpuFam(GetBuildTargetCpuFamily());
if (cpuFam == "x86")
result += "Intel ";
else if (cpuFam == "PowerPC")
result += "PPC ";
result += "Mac OS X ";
std::string OSXVersion(GetOsVersion());
StringUtils::Replace(OSXVersion, '.', '_');
result += OSXVersion;
#endif
#elif defined(TARGET_ANDROID)
result += "Linux; Android ";
std::string versionStr(GetOsVersion());
const size_t verLen = versionStr.length();
if (verLen >= 2 && versionStr.compare(verLen - 2, 2, ".0", 2) == 0)
versionStr.erase(verLen - 2); // remove last ".0" if any
result += versionStr;
std::string deviceInfo(GetModelName());
char buildId[PROP_VALUE_MAX];
int propLen = __system_property_get("ro.build.id", buildId);
if (propLen > 0 && propLen <= PROP_VALUE_MAX)
{
if (!deviceInfo.empty())
deviceInfo += " ";
deviceInfo += "Build/";
deviceInfo.append(buildId, propLen);
}
if (!deviceInfo.empty())
result += "; " + deviceInfo;
#elif defined(TARGET_POSIX)
result += "X11; ";
struct utsname un;
if (uname(&un) == 0)
{
std::string cpuStr(un.machine);
if (cpuStr == "x86_64" && GetXbmcBitness() == 32)
cpuStr = "i686 (x86_64)";
result += un.sysname;
result += " ";
result += cpuStr;
}
else
result += "Unknown";
#else
result += "Unknown";
#endif
result += ")";
// add fork ID here in form:
// result += " XBMC_FORK_" + "forkname" + "/" + "1.0"; // default fork number is '1.0'
#ifdef TARGET_RASPBERRY_PI
result += " XBMC_HW_RaspberryPi/1.0";
#elif defined (TARGET_DARWIN_IOS)
std::string iDevVer;
if (iDevStrDigit == std::string::npos)
iDevVer = "0.0";
else
iDevVer.assign(iDevStr, iDevStrDigit, std::string::npos);
StringUtils::Replace(iDevVer, ',', '.');
result += " XBMC_HW_" + iDev + "/" + iDevVer;
#endif
// add more device IDs here if needed.
// keep only one device ID in result! Form:
// result += " XBMC_HW_" + "deviceID" + "/" + "1.0"; // '1.0' if device has no version
#if defined(TARGET_ANDROID)
// Android has no CPU string by default, so add it as additional parameter
struct utsname un1;
if (uname(&un1) == 0)
{
std::string cpuStr(un1.machine);
StringUtils::Replace(cpuStr, ' ', '_');
result += " XBMC_CPU/" + cpuStr;
}
#endif
result += " XBMC_BITNESS/" + StringUtils::Format("%d", GetXbmcBitness());
std::string fullVer(g_infoManager.GetLabel(SYSTEM_BUILD_VERSION));
StringUtils::Replace(fullVer, ' ', '-');
result += " Version/" + fullVer;
return result;
}
void tst_QBluetoothDeviceInfo::tst_construction()
{
{
QBluetoothDeviceInfo deviceInfo;
QVERIFY(!deviceInfo.isValid());
QVERIFY(deviceInfo.coreConfigurations()
== QBluetoothDeviceInfo::UnknownCoreConfiguration);
}
{
QFETCH(QBluetoothAddress, address);
QFETCH(QString, name);
QFETCH(quint32, classOfDevice);
QFETCH(QBluetoothDeviceInfo::ServiceClasses, serviceClasses);
QFETCH(QBluetoothDeviceInfo::MajorDeviceClass, majorDeviceClass);
QFETCH(quint8, minorDeviceClass);
QFETCH(QBluetoothDeviceInfo::CoreConfiguration, coreConfiguration);
QFETCH(QBluetoothUuid, deviceUuid);
QBluetoothDeviceInfo deviceInfo(address, name, classOfDevice);
QVERIFY(deviceInfo.isValid());
QCOMPARE(deviceInfo.address(), address);
QCOMPARE(deviceInfo.name(), name);
QCOMPARE(deviceInfo.serviceClasses(), serviceClasses);
QCOMPARE(deviceInfo.majorDeviceClass(), majorDeviceClass);
QCOMPARE(deviceInfo.minorDeviceClass(), minorDeviceClass);
QCOMPARE(deviceInfo.coreConfigurations(), QBluetoothDeviceInfo::UnknownCoreConfiguration);
deviceInfo.setCoreConfigurations(coreConfiguration);
QCOMPARE(deviceInfo.coreConfigurations(), coreConfiguration);
deviceInfo.setDeviceUuid(deviceUuid);
QCOMPARE(deviceInfo.deviceUuid(), deviceUuid);
QBluetoothDeviceInfo copyInfo(deviceInfo);
QVERIFY(copyInfo.isValid());
QCOMPARE(copyInfo.address(), address);
QCOMPARE(copyInfo.name(), name);
QCOMPARE(copyInfo.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo.minorDeviceClass(), minorDeviceClass);
QCOMPARE(copyInfo.coreConfigurations(), coreConfiguration);
QCOMPARE(copyInfo.deviceUuid(), deviceUuid);
}
{
// Test construction from the device unique UUID, without an address.
QFETCH(QString, name);
QFETCH(quint32, classOfDevice);
QFETCH(QBluetoothDeviceInfo::ServiceClasses, serviceClasses);
QFETCH(QBluetoothDeviceInfo::MajorDeviceClass, majorDeviceClass);
QFETCH(quint8, minorDeviceClass);
QFETCH(QBluetoothDeviceInfo::CoreConfiguration, coreConfiguration);
QFETCH(QBluetoothUuid, deviceUuid);
QBluetoothDeviceInfo deviceInfo(deviceUuid, name, classOfDevice);
QVERIFY(deviceInfo.isValid());
QCOMPARE(deviceInfo.name(), name);
QCOMPARE(deviceInfo.serviceClasses(), serviceClasses);
QCOMPARE(deviceInfo.majorDeviceClass(), majorDeviceClass);
QCOMPARE(deviceInfo.minorDeviceClass(), minorDeviceClass);
QCOMPARE(deviceInfo.coreConfigurations(), QBluetoothDeviceInfo::UnknownCoreConfiguration);
deviceInfo.setCoreConfigurations(coreConfiguration);
QCOMPARE(deviceInfo.coreConfigurations(), coreConfiguration);
QBluetoothDeviceInfo copyInfo(deviceInfo);
QVERIFY(copyInfo.isValid());
QCOMPARE(copyInfo.name(), name);
QCOMPARE(copyInfo.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo.minorDeviceClass(), minorDeviceClass);
QCOMPARE(copyInfo.coreConfigurations(), coreConfiguration);
QCOMPARE(copyInfo.deviceUuid(), deviceUuid);
}
}
void deviceprop(char* d_name, char* d_platform, char *d_toolkit, char* d_compute)
{
deviceInfo(d_name, d_platform, d_toolkit, d_compute);
}
/*!
Transforms Symbian device name, address and service classes to QBluetootDeviceInfo.
*/
QBluetoothDeviceInfo BluetoothLinkManagerDeviceDiscoverer::currentDeviceDataToQBluetoothDeviceInfo() const
{
// extract device information from results and map them to QBluetoothDeviceInfo
#ifdef EIR_SUPPORTED
TBluetoothNameRecordWrapper eir(m_entry());
TInt bufferlength = 0;
TInt err = KErrNone;
QString deviceName;
bufferlength = eir.GetDeviceNameLength();
if (bufferlength > 0) {
TBool nameComplete;
HBufC *deviceNameBuffer = 0;
TRAP(err,deviceNameBuffer = HBufC::NewLC(bufferlength));
if(err)
deviceName = QString();
else
{
TPtr ptr = deviceNameBuffer->Des();
err = eir.GetDeviceName(ptr,nameComplete);
if (err == KErrNone /*&& nameComplete*/)
{
if(!nameComplete)
qWarning() << "device name incomplete";
// isn't it better to get an incomplete name than getting nothing?
deviceName = QString::fromUtf16(ptr.Ptr(), ptr.Length()).toUpper();
}
else
deviceName = QString();
CleanupStack::PopAndDestroy(deviceNameBuffer);
}
}
QList<QBluetoothUuid> serviceUidList;
RExtendedInquiryResponseUUIDContainer uuidContainer;
QBluetoothDeviceInfo::DataCompleteness completenes = QBluetoothDeviceInfo::DataUnavailable;
if (eir.GetServiceClassUuids(uuidContainer) == KErrNone) {
TInt uuidCount = uuidContainer.UUIDs().Count();
if (uuidCount > 0) {
for (int i = 0; i < uuidCount; ++i) {
TPtrC8 shortFormUUid(uuidContainer.UUIDs()[i].ShortestForm());
if (shortFormUUid.Size() == 2) {
QBluetoothUuid uuid(ntohs(*reinterpret_cast<const quint16 *>(shortFormUUid.Ptr())));
if (uuidContainer.GetCompleteness(RExtendedInquiryResponseUUIDContainer::EUUID16))
completenes = QBluetoothDeviceInfo::DataComplete;
else
completenes = QBluetoothDeviceInfo::DataIncomplete;
serviceUidList.append(uuid);
}else if (shortFormUUid.Size() == 4) {
QBluetoothUuid uuid(ntohl(*reinterpret_cast<const quint32 *>(shortFormUUid.Ptr())));
if (uuidContainer.GetCompleteness(RExtendedInquiryResponseUUIDContainer::EUUID32))
completenes = QBluetoothDeviceInfo::DataComplete;
else
completenes = QBluetoothDeviceInfo::DataIncomplete;
serviceUidList.append(uuid);
}else if (shortFormUUid.Size() == 16) {
QBluetoothUuid uuid(*reinterpret_cast<const quint128 *>(shortFormUUid.Ptr()));
if (uuidContainer.GetCompleteness(RExtendedInquiryResponseUUIDContainer::EUUID128))
completenes = QBluetoothDeviceInfo::DataComplete;
else
completenes = QBluetoothDeviceInfo::DataIncomplete;
serviceUidList.append(uuid);
}
}
}
}
uuidContainer.Close();
bufferlength = 0;
QByteArray manufacturerData;
bufferlength = eir.GetVendorSpecificDataLength();
if (bufferlength > 0) {
HBufC8 *msd = 0;
TRAP(err,HBufC8::NewLC(bufferlength));
if(err)
manufacturerData = QByteArray();
else
{
TPtr8 temp = msd->Des();
if (eir.GetVendorSpecificData(temp))
manufacturerData = s60Desc8ToQByteArray(temp);
else
manufacturerData = QByteArray();
CleanupStack::PopAndDestroy(msd);
}
}
// Get transmission power level
TInt8 transmissionPowerLevel = 0;
eir.GetTxPowerLevel(transmissionPowerLevel);
// unique address of the device
const TBTDevAddr symbianDeviceAddress = static_cast<TBTSockAddr> (m_entry().iAddr).BTAddr();
QBluetoothAddress bluetoothAddress = qTBTDevAddrToQBluetoothAddress(symbianDeviceAddress);
// format symbian major/minor numbers
quint32 deviceClass = qTPackSymbianDeviceClass(m_addr);
QBluetoothDeviceInfo deviceInfo(bluetoothAddress, deviceName, deviceClass);
deviceInfo.setRssi(transmissionPowerLevel);
deviceInfo.setServiceUuids(serviceUidList, completenes);
deviceInfo.setManufacturerSpecificData(manufacturerData);
#else
// device name
THostName symbianDeviceName = m_entry().iName;
QString deviceName = QString::fromUtf16(symbianDeviceName.Ptr(), symbianDeviceName.Length()).toUpper();
// unique address of the device
const TBTDevAddr symbianDeviceAddress = static_cast<TBTSockAddr> (m_entry().iAddr).BTAddr();
QBluetoothAddress bluetoothAddress = qTBTDevAddrToQBluetoothAddress(symbianDeviceAddress);
// format symbian major/minor numbers
quint32 deviceClass = qTPackSymbianDeviceClass(m_addr);
QBluetoothDeviceInfo deviceInfo(bluetoothAddress, deviceName, deviceClass);
if (m_addr.Rssi())
deviceInfo.setRssi(m_addr.Rssi());
#endif
if (!deviceInfo.rssi())
deviceInfo.setRssi(1);
deviceInfo.setCached(false); //TODO cache support missing from devicediscovery API
//qDebug()<< "Discovered device: name="<< deviceName <<", address=" << bluetoothAddress.toString() <<", class=" << deviceClass;
return deviceInfo;
}
std::string CSysInfo::GetUserAgent()
{
static std::string result;
if (!result.empty())
return result;
result = GetAppName() + "/" + CSysInfo::GetVersionShort() + " (";
#if defined(TARGET_DARWIN)
#if defined(TARGET_DARWIN_IOS)
std::string iDevStr(GetModelName()); // device model name with number of model version
size_t iDevStrDigit = iDevStr.find_first_of("0123456789");
std::string iDev(iDevStr, 0, iDevStrDigit); // device model name without number
if (iDevStrDigit == 0)
iDev = "unknown";
result += iDev + "; ";
std::string iOSVerison(GetOsVersion());
size_t lastDotPos = iOSVerison.rfind('.');
if (lastDotPos != std::string::npos && iOSVerison.find('.') != lastDotPos
&& iOSVerison.find_first_not_of('0', lastDotPos + 1) == std::string::npos)
iOSVerison.erase(lastDotPos);
StringUtils::Replace(iOSVerison, '.', '_');
if (iDev == "AppleTV4")
result += "CPU TVOS ";
else if (iDev == "iPad" || iDev == "AppleTV")
result += "CPU OS ";
else
result += "CPU iPhone OS ";
result += iOSVerison + " like Mac OS X";
#else
result += "Macintosh; ";
std::string cpuFam(GetBuildTargetCpuFamily());
if (cpuFam == "x86")
result += "Intel ";
else if (cpuFam == "PowerPC")
result += "PPC ";
result += "Mac OS X ";
std::string OSXVersion(GetOsVersion());
StringUtils::Replace(OSXVersion, '.', '_');
result += OSXVersion;
#endif
#elif defined(TARGET_ANDROID)
result += "Linux; Android ";
std::string versionStr(GetOsVersion());
const size_t verLen = versionStr.length();
if (verLen >= 2 && versionStr.compare(verLen - 2, 2, ".0", 2) == 0)
versionStr.erase(verLen - 2); // remove last ".0" if any
result += versionStr;
std::string deviceInfo(GetModelName());
char buildId[PROP_VALUE_MAX];
int propLen = __system_property_get("ro.build.id", buildId);
if (propLen > 0 && propLen <= PROP_VALUE_MAX)
{
if (!deviceInfo.empty())
deviceInfo += " ";
deviceInfo += "Build/";
deviceInfo.append(buildId, propLen);
}
if (!deviceInfo.empty())
result += "; " + deviceInfo;
#elif defined(TARGET_POSIX)
result += "X11; ";
struct utsname un;
if (uname(&un) == 0)
{
std::string cpuStr(un.machine);
if (cpuStr == "x86_64" && GetXbmcBitness() == 32)
cpuStr = "i686 (x86_64)";
result += un.sysname;
result += " ";
result += cpuStr;
}
else
result += "Unknown";
#else
result += "Unknown";
#endif
result += ")";
if (GetAppName() != "Kodi")
result += " Kodi_Fork_" + GetAppName() + "/1.0"; // default fork number is '1.0', replace it with actual number if necessary
#ifdef TARGET_LINUX
// Add distribution name
std::string linuxOSName(GetOsName(true));
if (!linuxOSName.empty())
result += " " + linuxOSName + "/" + GetOsVersion();
#endif
#ifdef TARGET_RASPBERRY_PI
result += " HW_RaspberryPi/1.0";
#elif defined (TARGET_DARWIN_IOS)
std::string iDevVer;
if (iDevStrDigit == std::string::npos)
iDevVer = "0.0";
else
iDevVer.assign(iDevStr, iDevStrDigit, std::string::npos);
StringUtils::Replace(iDevVer, ',', '.');
result += " HW_" + iDev + "/" + iDevVer;
#endif
// add more device IDs here if needed.
// keep only one device ID in result! Form:
// result += " HW_" + "deviceID" + "/" + "1.0"; // '1.0' if device has no version
#if defined(TARGET_ANDROID)
// Android has no CPU string by default, so add it as additional parameter
struct utsname un1;
if (uname(&un1) == 0)
{
std::string cpuStr(un1.machine);
StringUtils::Replace(cpuStr, ' ', '_');
result += " Sys_CPU/" + cpuStr;
}
#endif
result += " App_Bitness/" + StringUtils::Format("%d", GetXbmcBitness());
std::string fullVer(CSysInfo::GetVersion());
StringUtils::Replace(fullVer, ' ', '-');
result += " Version/" + fullVer;
return result;
}
void tst_QBluetoothDeviceInfo::tst_assignment()
{
QFETCH(QBluetoothAddress, address);
QFETCH(QString, name);
QFETCH(quint32, classOfDevice);
QFETCH(QBluetoothDeviceInfo::ServiceClasses, serviceClasses);
QFETCH(QBluetoothDeviceInfo::MajorDeviceClass, majorDeviceClass);
QFETCH(quint8, minorDeviceClass);
QFETCH(QBluetoothDeviceInfo::CoreConfiguration, coreConfiguration);
QFETCH(QBluetoothUuid, deviceUuid);
QBluetoothDeviceInfo deviceInfo(address, name, classOfDevice);
deviceInfo.setDeviceUuid(deviceUuid);
deviceInfo.setCoreConfigurations(coreConfiguration);
QVERIFY(deviceInfo.isValid());
{
QBluetoothDeviceInfo copyInfo = deviceInfo;
QVERIFY(copyInfo.isValid());
QCOMPARE(copyInfo.address(), address);
QCOMPARE(copyInfo.name(), name);
QCOMPARE(copyInfo.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo.minorDeviceClass(), minorDeviceClass);
QCOMPARE(copyInfo.coreConfigurations(), coreConfiguration);
QCOMPARE(copyInfo.deviceUuid(), deviceUuid);
}
{
QBluetoothDeviceInfo copyInfo;
QVERIFY(!copyInfo.isValid());
copyInfo = deviceInfo;
QVERIFY(copyInfo.isValid());
QCOMPARE(copyInfo.address(), address);
QCOMPARE(copyInfo.name(), name);
QCOMPARE(copyInfo.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo.minorDeviceClass(), minorDeviceClass);
QCOMPARE(copyInfo.coreConfigurations(), coreConfiguration);
QCOMPARE(copyInfo.deviceUuid(), deviceUuid);
}
{
QBluetoothDeviceInfo copyInfo1;
QBluetoothDeviceInfo copyInfo2;
QVERIFY(!copyInfo1.isValid());
QVERIFY(!copyInfo2.isValid());
copyInfo1 = copyInfo2 = deviceInfo;
QVERIFY(copyInfo1.isValid());
QVERIFY(copyInfo2.isValid());
QVERIFY(QBluetoothDeviceInfo() != copyInfo1);
QCOMPARE(copyInfo1.address(), address);
QCOMPARE(copyInfo2.address(), address);
QCOMPARE(copyInfo1.name(), name);
QCOMPARE(copyInfo2.name(), name);
QCOMPARE(copyInfo1.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo2.serviceClasses(), serviceClasses);
QCOMPARE(copyInfo1.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo2.majorDeviceClass(), majorDeviceClass);
QCOMPARE(copyInfo1.minorDeviceClass(), minorDeviceClass);
QCOMPARE(copyInfo2.minorDeviceClass(), minorDeviceClass);
QCOMPARE(copyInfo1.coreConfigurations(), coreConfiguration);
QCOMPARE(copyInfo2.coreConfigurations(), coreConfiguration);
QCOMPARE(copyInfo1.deviceUuid(), deviceUuid);
QCOMPARE(copyInfo2.deviceUuid(), deviceUuid);
}
{
QBluetoothDeviceInfo testDeviceInfo;
QVERIFY(testDeviceInfo == QBluetoothDeviceInfo());
}
}