blob: 42014fbad5a4d77e2e68e503b4b77bb28a624817 [file] [log] [blame]
// Copyright 2017 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <stdlib.h>
#include <algorithm>
#include <string>
#include <vector>
#include "starboard/common/device_type.h"
#include "starboard/common/log.h"
#include "starboard/common/string.h"
#include "starboard/configuration_constants.h"
#include "starboard/memory.h"
#include "starboard/shared/uwp/application_uwp.h"
#include "starboard/shared/uwp/keys.h"
#include "starboard/shared/win32/wchar_utils.h"
#include "starboard/system.h"
#include "starboard/xb1/shared/internal_shims.h"
#include "starboard/xb1/system_properties.h"
using starboard::shared::win32::platformStringToString;
using Windows::Security::ExchangeActiveSyncProvisioning::
EasClientDeviceInformation;
using Windows::System::Profile::AnalyticsInfo;
using Windows::System::Profile::AnalyticsVersionInfo;
using Windows::System::UserProfile::AdvertisingManager;
namespace {
#define arraysize(array) (sizeof(array) / sizeof(*array))
struct UwpDevice {
const char* deviceForm;
const char* chipsetModel;
const char* model;
const char* year;
} UwpDevices;
// Array of model name and year for known UWP devices.
struct UwpDevice kDevices[] = {
{"Xbox One", "XboxOne", "XboxOne", "2013"},
{"Xbox One S", "XboxOne", "XboxOne S", "2016"},
{"Xbox One X", "XboxOne", "XboxOne X", "2017"},
{"Xbox One X DevKit", "XboxOne", "XboxOne X", "2017"},
{"Xbox Series X", "XboxScarlett", "XboxScarlett Series X", "2020"},
{"Xbox Series X Devkit", "XboxScarlett", "XboxScarlett Series X", "2020"},
{"Xbox Series S", "XboxScarlett", "XboxScarlett Series S", "2020"},
};
const char kSystemIntegrator[] = "YouTube";
const char kXboxDeviceFormField[] = "Xbox";
// Year for unknown Uwp devices. This assumes that they will be as
// capable as the most recent known device.
const char kUnknownModelYear[] = "2020";
// Chipset for unidentified device forms.
const char kUnknownChipset[] = "UwpUnknown";
bool CopyStringAndTestIfSuccess(char* out_value,
int value_length,
const char* from_value) {
if (strlen(from_value) + 1 > value_length)
return false;
starboard::strlcpy(out_value, from_value, value_length);
return true;
}
bool CopyStringAndTestIfSuccess(char* out_value,
int value_length,
const wchar_t* from_value) {
char* from_value_str = new char[value_length];
int len = wcstombs(from_value_str, from_value, value_length);
bool result = len < 0 ? false
: CopyStringAndTestIfSuccess(out_value, value_length,
from_value_str);
delete from_value_str;
return result;
}
const std::size_t kOsVersionSize = 128;
struct WindowsVersion {
uint16_t major_version;
uint16_t minor_version;
uint16_t build_version;
uint16_t revision;
};
bool GetWindowsVersion(WindowsVersion* version) {
SB_DCHECK(version);
AnalyticsVersionInfo ^ version_info = AnalyticsInfo::VersionInfo;
std::string device_family_version =
platformStringToString(version_info->DeviceFamilyVersion);
if (device_family_version.empty()) {
return false;
}
uint64_t version_info_all =
strtoull(device_family_version.c_str(), nullptr, 10);
if (version_info_all == 0) {
return false;
}
version->major_version = (version_info_all >> 48) & 0xFFFF;
version->minor_version = (version_info_all >> 32) & 0xFFFF;
version->build_version = (version_info_all >> 16) & 0xFFFF;
version->revision = version_info_all & 0xFFFF;
return true;
}
std::string GetDeviceForm() {
Platform::String ^ device_form = AnalyticsInfo::DeviceForm;
return platformStringToString(device_form);
}
bool GetBrandName(char* out_value, int value_length) {
EasClientDeviceInformation ^ current_device_info =
ref new EasClientDeviceInformation();
std::string brand_name =
platformStringToString(current_device_info->SystemManufacturer);
if (brand_name.empty()) {
return false;
}
return CopyStringAndTestIfSuccess(out_value, value_length,
brand_name.c_str());
}
bool GetChipsetModelNumber(char* out_value, int value_length) {
std::string deviceForm = GetDeviceForm();
// If the device form is a known device, return the chipset model from the
// table.
for (size_t i = 0; i < arraysize(kDevices); i++) {
const UwpDevice* device = kDevices + i;
if (deviceForm == device->deviceForm) {
return CopyStringAndTestIfSuccess(out_value, value_length,
device->chipsetModel);
}
}
// The device form is not a known value, return unknown chipset.
return CopyStringAndTestIfSuccess(out_value, value_length, kUnknownChipset);
}
bool GetFirmwareVersion(char* out_value, int value_length) {
WindowsVersion version = {0};
if (!GetWindowsVersion(&version)) {
return false;
}
// The caller expects that the the output string will only be written if
// when true is returned. Therefore we have to buffer the string in case
// there is a false condition, such as small memory input size to hold
// the output parameter.
std::vector<char> out_path_copy(kSbFileMaxPath + 1, 0);
int len = std::min<int>(kSbFileMaxPath, value_length);
int return_value = SbStringFormatF(
out_path_copy.data(), len, "%u.%u.%u.%u", version.major_version,
version.minor_version, version.build_version, version.revision);
const bool ok = ((return_value > 0) && (return_value < value_length));
if (ok) {
starboard::strlcpy(out_value, out_path_copy.data(), len);
}
return ok;
}
bool GetFriendlyName(char* out_value, int value_length) {
EasClientDeviceInformation ^ current_device_info =
ref new EasClientDeviceInformation();
std::string friendly_name =
platformStringToString(current_device_info->FriendlyName);
if (friendly_name.empty()) {
return false;
}
return CopyStringAndTestIfSuccess(out_value, value_length,
friendly_name.c_str());
}
bool GetModelYear(char* out_value, int value_length) {
std::string deviceForm = GetDeviceForm();
for (size_t i = 0; i < arraysize(kDevices); i++) {
const UwpDevice* device = kDevices + i;
if (deviceForm == device->deviceForm) {
return CopyStringAndTestIfSuccess(out_value, value_length, device->year);
}
}
return CopyStringAndTestIfSuccess(out_value, value_length, kUnknownModelYear);
}
bool GetModelName(char* out_value, int value_length) {
std::string deviceForm = GetDeviceForm();
for (size_t i = 0; i < arraysize(kDevices); i++) {
const UwpDevice* device = kDevices + i;
if (deviceForm == device->deviceForm) {
return CopyStringAndTestIfSuccess(out_value, value_length, device->model);
}
}
// The device form is not a known value, return the device form verbatim.
return CopyStringAndTestIfSuccess(out_value, value_length,
deviceForm.c_str());
}
bool GetPlatformName(char* out_value, int value_length) {
EasClientDeviceInformation ^ current_device_info =
ref new EasClientDeviceInformation();
std::string operating_system =
platformStringToString(current_device_info->OperatingSystem);
AnalyticsVersionInfo ^ version_info = AnalyticsInfo::VersionInfo;
std::string os_name_and_version =
platformStringToString(current_device_info->OperatingSystem);
if (os_name_and_version.empty()) {
return false;
}
WindowsVersion os_version;
if (!GetWindowsVersion(&os_version)) {
return false;
}
os_name_and_version += " ";
char os_version_buffer[kOsVersionSize];
os_version_buffer[0] = '\0';
int return_value =
SbStringFormatF(os_version_buffer, value_length, "%u.%u",
os_version.major_version, os_version.minor_version);
if ((return_value < 0) || (return_value >= value_length)) {
return false;
}
os_name_and_version.append(os_version_buffer);
return CopyStringAndTestIfSuccess(out_value, value_length,
os_name_and_version.c_str());
}
bool GetAppXVersion(char* out_value, int value_length) {
Windows::ApplicationModel::PackageVersion version =
Windows::ApplicationModel::Package::Current->Id->Version;
std::stringstream version_string;
version_string << version.Major << '.' << version.Minor << '.'
<< version.Build << '.' << version.Revision;
return CopyStringAndTestIfSuccess(out_value, value_length,
version_string.str().c_str());
}
std::string GetAdvertisingId() {
Platform::String ^ advertising_id = AdvertisingManager::AdvertisingId;
return platformStringToString(advertising_id);
}
bool GetDeviceType(char* out_value, int value_length) {
AnalyticsVersionInfo ^ version_info = AnalyticsInfo::VersionInfo;
std::string family = starboard::shared::win32::platformStringToString(
version_info->DeviceFamily);
std::string device_type;
if (family.compare("Windows.Desktop") == 0) {
return CopyStringAndTestIfSuccess(out_value, value_length,
starboard::kSystemDeviceTypeDesktopPC);
}
if (family.compare("Windows.Xbox") == 0) {
return CopyStringAndTestIfSuccess(out_value, value_length,
starboard::kSystemDeviceTypeGameConsole);
}
SB_NOTREACHED();
return CopyStringAndTestIfSuccess(out_value, value_length,
starboard::kSystemDeviceTypeUnknown);
}
} // namespace
bool SbSystemGetProperty(SbSystemPropertyId property_id,
char* out_value,
int value_length) {
if (!out_value || !value_length) {
return false;
}
using starboard::shared::uwp::SpeechApiKey;
switch (property_id) {
case kSbSystemPropertyCertificationScope: {
Platform::String ^ scope = starboard::xb1::shared::GetCertScope();
if (scope->IsEmpty()) {
if (kCertificationScope[0] == '\0')
return false;
return CopyStringAndTestIfSuccess(out_value, value_length,
kCertificationScope);
}
bool result =
CopyStringAndTestIfSuccess(out_value, value_length, scope->Data());
return result;
}
case kSbSystemPropertyChipsetModelNumber:
return GetChipsetModelNumber(out_value, value_length);
case kSbSystemPropertyFirmwareVersion:
return GetFirmwareVersion(out_value, value_length);
case kSbSystemPropertyFriendlyName:
return GetFriendlyName(out_value, value_length);
case kSbSystemPropertyBrandName:
return GetBrandName(out_value, value_length);
case kSbSystemPropertyModelName:
return GetModelName(out_value, value_length);
case kSbSystemPropertyModelYear:
return GetModelYear(out_value, value_length);
case kSbSystemPropertySystemIntegratorName:
return CopyStringAndTestIfSuccess(out_value, value_length,
kSystemIntegrator);
case kSbSystemPropertyPlatformName:
return GetPlatformName(out_value, value_length);
case kSbSystemPropertySpeechApiKey:
CopyStringAndTestIfSuccess(out_value, value_length, SpeechApiKey());
return true;
case kSbSystemPropertyUserAgentAuxField:
return GetAppXVersion(out_value, value_length);
#if SB_API_VERSION >= 14
case kSbSystemPropertyAdvertisingId: {
std::string advertising_id = GetAdvertisingId();
return CopyStringAndTestIfSuccess(out_value, value_length,
advertising_id.c_str());
}
case kSbSystemPropertyLimitAdTracking: {
std::string advertising_id = GetAdvertisingId();
// If we get an empty ID, that means the user disabled it.
return CopyStringAndTestIfSuccess(out_value, value_length,
advertising_id.empty() ? "1" : "0");
}
#endif // SB_API_VERSION >= 14
#if SB_API_VERSION >= 15
case kSbSystemPropertyDeviceType:
return GetDeviceType(out_value, value_length);
#endif
default:
SB_DLOG(WARNING) << __FUNCTION__
<< ": Unrecognized property: " << property_id;
break;
}
return false;
}