changes to win32, added some functions for linux

Author: dorin-ga

source/gameanalytics/Platform/GADeviceOSX.mm

@@ -70,25 +70,25 @@ SCNetworkReachabilityRef createReachabilityRef()
 
     if ((flags & kSCNetworkReachabilityFlagsReachable) == 0) {
         // The target host is not reachable.
-        return "offline";
+        return gameanalytics::CONNECTION_OFFLINE;
     }
 
     if ((flags & kSCNetworkReachabilityFlagsConnectionRequired) == 0) 
     {
-        // If the target host is reachable and no connection is required then we'll assume (for now) that you're on Wi-Fi...
-        return "wifi";
+        // If the target host is reachable and no connection is required then we'll assume (for now) that you're on lan...
+        return gameanalytics::CONNECTION_LAN;
     }
 
     if ((((flags & kSCNetworkReachabilityFlagsConnectionOnDemand ) != 0) ||
          (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) != 0)) {
         // ... and the connection is on-demand (or on-traffic) if the calling application is using the CFSocketStream or higher APIs...
         if ((flags & kSCNetworkReachabilityFlagsInterventionRequired) == 0) {
             // ... and no [user] intervention is needed...
-            return "wifi";
+            return gameanalytics::CONNECTION_WIFI;
         }
     }
 
-    return "";
+    return gameanalytics::CONNECTION_LAN;
 }
 
 int getNumCpuCores()

source/gameanalytics/Platform/GALinux.cpp

@@ -165,4 +165,62 @@ void gameanalytics::GAPlatformLinux::signalHandler(int sig, siginfo_t* info, voi
 }
 
 
+int64_t gameanalytics::GAPlatformLinux::getAppMemoryUsage() const
+{
+    struct task_basic_info info;
+    
+    mach_msg_type_number_t infoSize = TASK_BASIC_INFO_COUNT;
+    kern_return_t result = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &infoSize);
+    
+    if(result == KERN_SUCCESS) 
+    {
+        return utilities::convertBytesToMB(info.resident_size);
+    }
+
+    return 0;
+}
+
+int64_t gameanalytics::GAPlatformLinux::getSysMemoryUsage() const
+{
+    mach_port_t port = mach_host_self();
+    mach_msg_type_number_t hostSize = sizeof(vm_statistics_data_t) / sizeof(integer_t);
+    
+    vm_size_t pageSize;
+    host_page_size(port, &pageSize);
+    
+    vm_statistics_data_t stats;
+    
+    if(host_statistics(port, HOST_VM_INFO, (host_info_t)&stats, &hostSize) == KERN_SUCCESS)
+    {
+        const int64_t freeMemory = (stats.free_count + stats.inactive_count) * pageSize;
+        return getTotalDeviceMemory() - utilities::convertBytesToMB(freeMemory);
+    }
+
+    return 0;
+}
+
+int64_t gameanalytics::GAPlatformLinux::getBootTime() const
+{
+    const size_t len = 4;
+    int mib[len] = {0,0,0,0};
+    struct kinfo_proc kp = {};
+
+    const size_t pidId = 3;
+    
+    size_t num = len;
+    sysctlnametomib("kern.proc.pid", mib, &num);
+    mib[pidId] = getpid();
+    
+    num = sizeof(kp);
+    sysctl(mib, len, &kp, &num, NULL, 0);
+
+    struct timeval startTime = kp.kp_proc.p_un.__p_starttime;
+    struct timeval currentTime = {};
+    
+    gettimeofday(&currentTime, NULL);
+    
+    return currentTime.tv_sec - startTime.tv_sec;
+}
+
+
 #endif

source/gameanalytics/Platform/GAUwp.cpp

@@ -64,20 +64,20 @@ std::string gameanalytics::GAPlatformUWP::getConnectionType()
     {
         if (connectionProfile->IsWlanConnectionProfile)
         {
-            return "wifi";
+            return CONNECTION_WIFI;
         }
         else if (connectionProfile->IsWwanConnectionProfile)
         {
-            return "wwan";
+            return CONNECTION_WWAN;
         }
         else
         {
-            return "lan";
+            return CONNECTION_LAN;
         }
     }
     else
     {
-        return "offline";
+        return CONNECTION_OFFLINE;
     }
 }
 

source/gameanalytics/Platform/GAWin32.cpp

@@ -83,104 +83,6 @@ std::string GAPlatformWin32::getConnectionType()
     return "";
 }
 
-std::string GAPlatformWin32::getDeviceManufacturer()
-{
-#if !GA_SHARED_LIB && defined(GA_USE_WBEM_SERVICES)
-    __try
-    {
-        IWbemLocator*  locator  = nullptr;
-        IWbemServices* services = nullptr;
-
-        auto hResult = CoInitializeEx(0, COINIT_MULTITHREADED);
-        if (FAILED(hResult))
-        {
-            return UNKNOWN_VALUE;
-        }
-        hResult = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID*)&locator);
-
-
-        auto hasFailed = [&hResult]() {
-            if (FAILED(hResult))
-            {
-                return true;
-            }
-            return false;
-            };
-
-        auto getValue = [&hResult, &hasFailed](IWbemClassObject* classObject, LPCWSTR property) {
-            BSTR propertyValueText = L"unknown";
-            VARIANT propertyValue;
-            hResult = classObject->Get(property, 0, &propertyValue, 0, 0);
-            if (!hasFailed()) {
-                if ((propertyValue.vt == VT_NULL) || (propertyValue.vt == VT_EMPTY)) {
-                }
-                else if (propertyValue.vt & VT_ARRAY) {
-                    propertyValueText = L"unknown"; //Array types not supported
-                }
-                else {
-                    propertyValueText = propertyValue.bstrVal;
-                }
-            }
-            VariantClear(&propertyValue);
-            return propertyValueText;
-            };
-
-        BSTR manufacturer = L"unknown";
-        if (!hasFailed()) 
-        {
-            // Connect to the root\cimv2 namespace with the current user and obtain pointer pSvc to make IWbemServices calls.
-            hResult = locator->ConnectServer(L"ROOT\\CIMV2", nullptr, nullptr, 0, NULL, 0, 0, &services);
-
-            if (!hasFailed()) {
-                // Set the IWbemServices proxy so that impersonation of the user (client) occurs.
-                hResult = CoSetProxyBlanket(services, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, nullptr, RPC_C_AUTHN_LEVEL_CALL,
-                    RPC_C_IMP_LEVEL_IMPERSONATE, nullptr, EOAC_NONE);
-
-                if (!hasFailed()) {
-                    IEnumWbemClassObject* classObjectEnumerator = nullptr;
-                    hResult = services->ExecQuery(L"WQL", L"SELECT * FROM Win32_ComputerSystem", WBEM_FLAG_FORWARD_ONLY |
-                        WBEM_FLAG_RETURN_IMMEDIATELY, nullptr, &classObjectEnumerator);
-                    if (!hasFailed()) 
-                    {
-                        IWbemClassObject* classObject;
-                        ULONG uReturn = 0;
-                        hResult = classObjectEnumerator->Next(WBEM_INFINITE, 1, &classObject, &uReturn);
-                        if (uReturn != 0) {
-                            manufacturer = getValue(classObject, (LPCWSTR)L"Manufacturer");
-                        }
-
-                        if(classObject)
-                            classObject->Release();
-                    }
-
-                    if(classObjectEnumerator)
-                        classObjectEnumerator->Release();
-                }
-            }
-        }
-
-        if (locator) {
-            locator->Release();
-        }
-        if (services) {
-            services->Release();
-        }
-        CoUninitialize();
-
-        std::string manufacturer = _com_util::ConvertBSTRToString(manufacturer);
-        return manufacturer;
-    }
-    __except(EXCEPTION_EXECUTE_HANDLER)
-    {
-        logging::GALogger::e("Failed to get device's model");
-        return UNKNOWN_VALUE;
-    }
-
-#else
-    return UNKNOWN_VALUE;
-#endif
-}
-
 std::string GAPlatformWin32::getBuildPlatform()
 {
     return "windows";
@@ -204,33 +106,30 @@ std::string GAPlatformWin32::getPersistentPath()
     return path;
 }
 
-std::string GAPlatformWin32::getDeviceModel()
+std::string getRegistryKey(HKEY key, const TCHAR* subkey, const TCHAR* value)
 {
     __try
     {
-        constexpr const TCHAR* subkey = _T("SYSTEM\\CurrentControlSet\\Control\\SystemInformation");
-        constexpr const TCHAR* value  = _T("SystemProductName");
-
         constexpr DWORD maxBufSize = 128;
 
         DWORD size = 0;
         TCHAR buffer[maxBufSize] = _T("");
-        RegGetValue(HKEY_LOCAL_MACHINE, subkey, value, RRF_RT_REG_SZ, NULL, buffer, &size);
+        RegGetValue(key, subkey, value, RRF_RT_REG_SZ, NULL, buffer, &size);
 
         size = std::min(size, maxBufSize);
 
         if (!GetLastError() && size > 0)
         {
-            std::string modelName;
+            std::string val;
 
 #ifdef UNICODE
             std::wstring wstr(buffer, buffer + size);
-            modelName = utilities::GAUtilities::ws2s(wstr);
+            val = utilities::GAUtilities::ws2s(wstr);
 #else
-            modelName = std::string(buffer, buffer + size);
+            val = std::string(buffer, buffer + size);
 #endif
 
-            return modelName;
+            return val;
         }
     }
     __except(EXCEPTION_EXECUTE_HANDLER)
@@ -241,6 +140,30 @@ std::string GAPlatformWin32::getDeviceModel()
     return UNKNOWN_VALUE;
 }
 
+std::string GAPlatformWin32::getDeviceModel()
+{
+    constexpr const TCHAR* subkey = _T("SYSTEM\\CurrentControlSet\\Control\\SystemInformation");
+    constexpr const TCHAR* value  = _T("SystemProductName");
+
+    return getRegistryKey(HKEY_LOCAL_MACHINE, subkey, value);
+}
+
+std::string GAPlatformWin32::getDeviceManufacturer()
+{
+    constexpr const TCHAR* subkey = _T("SYSTEM\\CurrentControlSet\\Control\\SystemInformation");
+    constexpr const TCHAR* value  = _T("SystemManufacturer");
+
+    return getRegistryKey(HKEY_LOCAL_MACHINE, subkey, value);
+}
+
+std::string GAPlatformWin32::getCpuModel() const
+{
+    constexpr const TCHAR* subkey = _T("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0");
+    constexpr const TCHAR* value  = _T("ProcessorName");
+
+    return getRegistryKey(HKEY_LOCAL_MACHINE, subkey, value);
+}
+
 void GAPlatformWin32::setupUncaughtExceptionHandler()
 {
     signal(SIGILL,  signalHandler);
@@ -293,12 +216,6 @@ void GAPlatformWin32::signalHandler(int sig)
     }
 }
 
-std::string GAPlatformWin32::getCpuModel() const
-{
-    // todo
-    return "";
-}
-
 std::string GAPlatformWin32::getGpuModel() const
 {
     //todo 
@@ -307,7 +224,31 @@ std::string GAPlatformWin32::getGpuModel() const
 
 int GAPlatformWin32::getNumCpuCores() const
 {
-    //todo
+    DWORD len = 0;
+    GetLogicalProcessorInformation(nullptr, &len);
+
+    if(len && (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
+    {
+        const int size = len / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
+        auto buffer = std::make_unique<SYSTEM_LOGICAL_PROCESSOR_INFORMATION[]>(size);
+        if(buffer)
+        {
+            if(GetLogicalProcessorInformation(buffer.get(), &len))
+            {
+                int numProcessors = 0;
+                for(int i = 0; i < size; ++i)
+                {
+                    if(buffer[i].Relationship == RelationProcessorCore)
+                    {
+                        ++numProcessors;
+                    }
+                }
+
+                return numProcessors;
+            }
+        }
+    }
+
     return 0;
 }
 
@@ -374,6 +315,22 @@ int64_t GAPlatformWin32::getBootTime() const
     return 0ll;
 }
 
+std::string GAPlatformWin32::getConnectionType()
+{
+    DWORD flags = 0;
+    if(InternetGetConnectedState(&flags, 0))
+    {
+        if(flags & INTERNET_CONNECTION_OFFLINE)
+            return CONNECTION_OFFLINE;
+
+        if(flags & INTERNET_CONNECTION_LAN)
+            return CONNECTION_LAN;
+
+        return CONNECTION_WIFI;
+    }
+
+    return CONNECTION_OFFLINE;
+}
 
 }
 #endif