void LogInfoReporter::CreateReportMsg(int iLogType, const char* szTypeName, const char* szLogContent, int64_t date, bool pd) { JSON* joMsg = JSON::CreateObject(); joMsg->AddNumberItem("date", date); joMsg->AddNumberItem("eid", iLogType); joMsg->AddStringItem("tname", szTypeName); joMsg->AddStringItem("content", szLogContent); joMsg->AddBoolItem("pd", pd); char *pJsonValue = joMsg->PrintValue(0, false); SetReportMsg(pJsonValue); MJ_FREE(pJsonValue); SetReportType(5); }
JSON* ManufacturerInfo::ToJson(unsigned short wLanguageCode) { JSON* pRet = ToJson(); if (m_Display.find(wLanguageCode) != m_Display.end()) { pRet->AddStringItem("Display", m_Display[wLanguageCode].ToCStr()); } return pRet; }
// Writes the current calibration for a particular device to a device profile file // sensor - the sensor that was calibrated // cal_name - an optional name for the calibration or default if cal_name == NULL bool SensorFusion::SaveMagCalibration(const char* calibrationName) const { if (CachedSensorInfo.SerialNumber[0] == 0 || !HasMagCalibration()) return false; // A named calibration may be specified for calibration in different // environments, otherwise the default calibration is used if (calibrationName == NULL) calibrationName = "default"; // Generate a mag calibration event JSON* calibration = JSON::CreateObject(); // (hardcoded for now) the measurement and representation method calibration->AddStringItem("Version", "2.0"); calibration->AddStringItem("Name", "default"); // time stamp the calibration char time_str[64]; #if defined(OVR_OS_WIN32) and !defined(__MINGW32__) struct tm caltime; localtime_s(&caltime, &MagCalibrationTime); strftime(time_str, 64, "%Y-%m-%d %H:%M:%S", &caltime); #else struct tm* caltime; caltime = localtime(&MagCalibrationTime); strftime(time_str, 64, "%Y-%m-%d %H:%M:%S", caltime); #endif calibration->AddStringItem("Time", time_str); // write the full calibration matrix char matrix[256]; Matrix4f calmat = GetMagCalibration(); calmat.ToString(matrix, 256); calibration->AddStringItem("CalibrationMatrix", matrix); // save just the offset, for backwards compatibility // this can be removed when we don't want to support 0.2.4 anymore Vector3f center(calmat.M[0][3], calmat.M[1][3], calmat.M[2][3]); Matrix4f tmp = calmat; tmp.M[0][3] = tmp.M[1][3] = tmp.M[2][3] = 0; tmp.M[3][3] = 1; center = tmp.Inverted().Transform(center); Matrix4f oldcalmat; oldcalmat.M[0][3] = center.x; oldcalmat.M[1][3] = center.y; oldcalmat.M[2][3] = center.z; oldcalmat.ToString(matrix, 256); calibration->AddStringItem("Calibration", matrix); String path = GetBaseOVRPath(true); path += "/Devices.json"; // Look for a prexisting device file to edit Ptr<JSON> root = *JSON::Load(path); if (root) { // Quick sanity check of the file type and format before we parse it JSON* version = root->GetFirstItem(); if (version && version->Name == "Oculus Device Profile Version") { int major = atoi(version->Value.ToCStr()); if (major > MAX_DEVICE_PROFILE_MAJOR_VERSION) { // don't use the file on unsupported major version number root->Release(); root = NULL; } } else { root->Release(); root = NULL; } } JSON* device = NULL; if (root) { device = root->GetFirstItem(); // skip the header device = root->GetNextItem(device); while (device) { // Search for a previous calibration with the same name for this device // and remove it before adding the new one if (device->Name == "Device") { JSON* item = device->GetItemByName("Serial"); if (item && item->Value == CachedSensorInfo.SerialNumber) { // found an entry for this device item = device->GetNextItem(item); while (item) { if (item->Name == "MagCalibration") { JSON* name = item->GetItemByName("Name"); if (name && name->Value == calibrationName) { // found a calibration of the same name item->RemoveNode(); item->Release(); break; } } item = device->GetNextItem(item); } // update the auto-mag flag item = device->GetItemByName("EnableYawCorrection"); if (item) item->dValue = (double)EnableYawCorrection; else device->AddBoolItem("EnableYawCorrection", EnableYawCorrection); break; } } device = root->GetNextItem(device); } } else { // Create a new device root root = *JSON::CreateObject(); root->AddStringItem("Oculus Device Profile Version", "1.0"); } if (device == NULL) { device = JSON::CreateObject(); device->AddStringItem("Product", CachedSensorInfo.ProductName); device->AddNumberItem("ProductID", CachedSensorInfo.ProductId); device->AddStringItem("Serial", CachedSensorInfo.SerialNumber); device->AddBoolItem("EnableYawCorrection", EnableYawCorrection); root->AddItem("Device", device); } // Create and the add the new calibration event to the device device->AddItem("MagCalibration", calibration); return root->Save(path); }
//----------------------------------------------------------------------------- bool ProfileManager::SetTaggedProfile(const char** tag_names, const char** tags, int num_tags, Profile* profile) { Lock::Locker lockScope(&ProfileLock); if (ProfileCache == NULL) { // Load the cache LoadCache(true); if (ProfileCache == NULL) return false; // TODO: Generate a new profile DB } JSON* tagged_data = ProfileCache->GetItemByName("TaggedData"); OVR_ASSERT(tagged_data); if (tagged_data == NULL) return false; // Get the cached tagged data section JSON* vals = FindTaggedData(tagged_data, tag_names, tags, num_tags); if (vals == NULL) { JSON* tagged_item = JSON::CreateObject(); JSON* taglist = JSON::CreateArray(); for (int i=0; i<num_tags; i++) { JSON* k = JSON::CreateObject(); k->AddStringItem(tag_names[i], tags[i]); taglist->AddArrayElement(k); } vals = JSON::CreateObject(); tagged_item->AddItem("tags", taglist); tagged_item->AddItem("vals", vals); tagged_data->AddArrayElement(tagged_item); } // Now add or update each profile setting in cache for (unsigned int i=0; i<profile->Values.GetSize(); i++) { JSON* value = profile->Values[i]; bool found = false; JSON* item = vals->GetFirstItem(); while (item) { if (value->Name == item->Name) { // Don't allow a pre-existing type to be overridden OVR_ASSERT(value->Type == item->Type); if (value->Type == item->Type) { // Check for the same value if (value->Type == JSON_Array) { // Update each array item if (item->GetArraySize() == value->GetArraySize()) { // Update each value (assumed to be basic types and not array of objects) JSON* value_element = value->GetFirstItem(); JSON* item_element = item->GetFirstItem(); while (item_element && value_element) { if (value_element->Type == JSON_String) { if (item_element->Value != value_element->Value) { // Overwrite the changed value and mark for file update item_element->Value = value_element->Value; Changed = true; } } else { if (item_element->dValue != value_element->dValue) { // Overwrite the changed value and mark for file update item_element->dValue = value_element->dValue; Changed = true; } } value_element = value->GetNextItem(value_element); item_element = item->GetNextItem(item_element); } } else { // if the array size changed, simply create a new one // TODO: Create the new array } } else if (value->Type == JSON_String) { if (item->Value != value->Value) { // Overwrite the changed value and mark for file update item->Value = value->Value; Changed = true; } } else { if (item->dValue != value->dValue) { // Overwrite the changed value and mark for file update item->dValue = value->dValue; Changed = true; } } } else { return false; } found = true; break; } item = vals->GetNextItem(item); } if (!found) { // Add the new value Changed = true; if (value->Type == JSON_String) vals->AddStringItem(value->Name, value->Value); else if (value->Type == JSON_Bool) vals->AddBoolItem(value->Name, ((int)value->dValue != 0)); else if (value->Type == JSON_Number) vals->AddNumberItem(value->Name, value->dValue); else if (value->Type == JSON_Array) vals->AddItem(value->Name, value->Copy()); else { OVR_ASSERT(false); Changed = false; } } } return true; }
JSON* GetSystemSpecs() { JSON* specs = JSON::CreateObject(); HRESULT hres; IWbemLocator* pLoc = NULL; hres = CoCreateInstance( CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID*)&pLoc); if (FAILED(hres)) { return specs; // Program has failed. } IWbemServices* pSvc = NULL; // Connect to the root\cimv2 namespace with // the current user and obtain pointer pSvc // to make IWbemServices calls. hres = pLoc->ConnectServer( _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace NULL, // User name. NULL = current user NULL, // User password. NULL = current 0, // Locale. NULL indicates current NULL, // Security flags. 0, // Authority (for example, Kerberos) 0, // Context object &pSvc // pointer to IWbemServices proxy ); if (FAILED(hres)) { pLoc->Release(); return specs; // Program has failed. } hres = CoSetProxyBlanket( pSvc, // Indicates the proxy to set RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx NULL, // Server principal name RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx NULL, // client identity EOAC_NONE // proxy capabilities ); if (FAILED(hres)) { pSvc->Release(); pLoc->Release(); return specs; // Program has failed. } IEnumWbemClassObject* pEnumerator = NULL; hres = pSvc->ExecQuery( bstr_t("WQL"), bstr_t("SELECT Caption FROM Win32_OperatingSystem"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if (FAILED(hres)) { pSvc->Release(); pLoc->Release(); return specs; // Program has failed. } IWbemClassObject* pclsObj; ULONG uReturn = 0; while (pEnumerator) { HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if (0 == uReturn) { break; } VARIANT vtProp; // Get the value of the Name property hr = pclsObj->Get(L"Caption", 0, &vtProp, 0, 0); specs->AddStringItem("Operating System", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); VariantClear(&vtProp); pclsObj->Release(); } pEnumerator = NULL; hres = pSvc->ExecQuery( bstr_t("WQL"), bstr_t("SELECT Name FROM Win32_processor"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if (FAILED(hres)) { pSvc->Release(); pLoc->Release(); return specs; // Program has failed. } uReturn = 0; while (pEnumerator) { HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if (0 == uReturn) { break; } VARIANT vtProp; // Get the value of the Name property hr = pclsObj->Get(L"Name", 0, &vtProp, 0, 0); specs->AddStringItem("Processor", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); VariantClear(&vtProp); pclsObj->Release(); } pEnumerator = NULL; hres = pSvc->ExecQuery( bstr_t("WQL"), bstr_t( "SELECT Name , AdapterRam, DriverVersion, VideoModeDescription FROM Win32_VideoController"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if (FAILED(hres)) { pSvc->Release(); pLoc->Release(); return specs; // Program has failed. } JSON* graphicsadapters = JSON::CreateArray(); uReturn = 0; while (pEnumerator) { JSON* graphicscard = JSON::CreateObject(); HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if (0 == uReturn) { break; } VARIANT vtProp; // Get the value of the Name property hr = pclsObj->Get(L"Name", 0, &vtProp, 0, 0); graphicscard->AddStringItem("Name", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); VariantClear(&vtProp); // Get the value of the Name property hr = pclsObj->Get(L"AdapterRam", 0, &vtProp, 0, 0); uint32_t capacity = vtProp.uintVal; graphicscard->AddNumberItem("Video Controller RAM (MB)", capacity / 1048576); VariantClear(&vtProp); // get driver version hr = pclsObj->Get(L"DriverVersion", 0, &vtProp, 0, 0); graphicscard->AddStringItem("Driver Version", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); // get resolution hr = pclsObj->Get(L"VideoModeDescription", 0, &vtProp, 0, 0); graphicscard->AddStringItem("Video Mode", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); VariantClear(&vtProp); pclsObj->Release(); graphicsadapters->AddArrayElement(graphicscard); } specs->AddItem("Graphics Adapters", graphicsadapters); pEnumerator = NULL; hres = pSvc->ExecQuery( bstr_t("WQL"), bstr_t("SELECT Capacity FROM Win32_PhysicalMemory"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if (FAILED(hres)) { pSvc->Release(); pLoc->Release(); return specs; // Program has failed. } uint64_t totalram = 0; uReturn = 0; while (pEnumerator) { HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if (0 == uReturn) { break; } VARIANT vtProp; // Get the value of the Name property hr = pclsObj->Get(L"Capacity", 0, &vtProp, 0, 0); uint64_t capacity = QString::fromWCharArray(vtProp.bstrVal).toLongLong(); totalram += capacity; VariantClear(&vtProp); pclsObj->Release(); } specs->AddNumberItem("Total RAM (GB)", totalram / 1073741824.0); JSON* usbtree = JSON::CreateArray(); QMap<QString, QStringList> antecedents; pEnumerator = NULL; hres = pSvc->ExecQuery( bstr_t("WQL"), bstr_t("SELECT Antecedent,Dependent FROM Win32_USBControllerDevice"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if (FAILED(hres)) { pSvc->Release(); pLoc->Release(); return specs; // Program has failed. } VARIANT vtProp; while (pEnumerator) { HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if (0 == uReturn) { break; } // Get the reference value of the Antecedent property. There is not a function to dereference // the value. hr = pclsObj->Get(L"Antecedent", 0, &vtProp, 0, 0); BSTR name = vtProp.bstrVal; // sanitize the string input to just the output QString antecedent = QString::fromWCharArray(name).split("=")[1].replace("\"", ""); VariantClear(&vtProp); // Get the reference value of the Dependent property. There is not a function to dereference // the value. hr = pclsObj->Get(L"Dependent", 0, &vtProp, 0, 0); name = vtProp.bstrVal; // sanitize the string input to just the output QString dependent = QString::fromWCharArray(name).split("=")[1].replace("\"", ""); antecedents[antecedent].append(dependent); VariantClear(&vtProp); } for (int ant = 0; ant < antecedents.size(); ant++) { QString antecedent_name = antecedents.keys()[ant]; // get antecedent object in a new enumerator IEnumWbemClassObject* pEnumerator2 = NULL; IWbemClassObject* pclsObj2; hres = pSvc->ExecQuery( bstr_t("WQL"), bstr_t( "SELECT Manufacturer, Name, DeviceID, Caption FROM WIN32_USBController where deviceid = '") + bstr_t(antecedent_name.toUtf8()) + bstr_t("'"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator2); if (FAILED(hres)) { pSvc->Release(); pLoc->Release(); return specs; // Program has failed. } JSON* USBAntecedent = JSON::CreateObject(); while (pEnumerator2) { HRESULT hr = pEnumerator2->Next(WBEM_INFINITE, 1, &pclsObj2, &uReturn); if (0 == uReturn) { break; } VARIANT vtProp; // Get the value of the Name property hr = pclsObj2->Get(L"Name", 0, &vtProp, 0, 0); USBAntecedent->AddStringItem("name", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); VariantClear(&vtProp); // Get the value of the DeviceID property hr = pclsObj2->Get(L"DeviceID", 0, &vtProp, 0, 0); USBAntecedent->AddStringItem("deviceid", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); VariantClear(&vtProp); // Get the value of the caption property hr = pclsObj2->Get(L"Caption", 0, &vtProp, 0, 0); USBAntecedent->AddStringItem("caption", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); VariantClear(&vtProp); // Get the value of the manufacturer property hr = pclsObj2->Get(L"Manufacturer", 0, &vtProp, 0, 0); USBAntecedent->AddStringItem("manufacturer", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); VariantClear(&vtProp); pclsObj2->Release(); } JSON* devices = JSON::CreateArray(); for (int dev = 0; dev < antecedents[antecedent_name].size(); ++dev) { // get antecedent object in a new enumerator pEnumerator2 = NULL; if (!pclsObj2) pclsObj2->Release(); hres = pSvc->ExecQuery( bstr_t("WQL"), bstr_t("SELECT Manufacturer,Name FROM Win32_PnPEntity where DeviceID = '") + bstr_t(antecedents[antecedent_name][dev].toUtf8()) + bstr_t("'"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator2); if (FAILED(hres)) { pSvc->Release(); pLoc->Release(); return specs; // Program has failed. } while (pEnumerator2) { HRESULT hr = pEnumerator2->Next(WBEM_INFINITE, 1, &pclsObj2, &uReturn); if (0 == uReturn) { break; } VARIANT vtProp; JSON* properties = JSON::CreateObject(); // Get the value of the Manufacturer property hr = pclsObj2->Get(L"Manufacturer", 0, &vtProp, 0, 0); properties->AddStringItem("manufacturer", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); VariantClear(&vtProp); // Get the value of the Manufacturer property hr = pclsObj2->Get(L"Name", 0, &vtProp, 0, 0); properties->AddStringItem("name", WCHAR_TO_OVR_STRING(vtProp.bstrVal)); VariantClear(&vtProp); pclsObj2->Release(); devices->AddArrayElement(properties); } } USBAntecedent->AddItem("Devices", devices); usbtree->AddArrayElement(USBAntecedent); } specs->AddItem("USB Tree", usbtree); // Cleanup // ======== pSvc->Release(); pLoc->Release(); pEnumerator->Release(); if (!pclsObj) pclsObj->Release(); return specs; }