xbmc/utils/SystemInfo.cpp

   1 /*
   2  *      Copyright (C) 2005-2008 Team XBMC
   3  *      http://www.xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, write to
  17  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *  http://www.gnu.org/copyleft/gpl.html
  19  *
  20  */
  21
  22 #include "system.h"
  23 #include "SystemInfo.h"
  24 #ifndef _LINUX
  25 #include <conio.h>
  26 #else
  27 #include <sys/utsname.h>
  28 #endif
  29 #include "utils/GUIInfoManager.h"
  30 #include "FileSystem/FileCurl.h"
  31 #include "Network.h"
  32 #include "Application.h"
  33 #include "GraphicContext.h"
  34 #include "WindowingFactory.h"
  35 #include "Settings.h"
  36 #include "LocalizeStrings.h"
  37 #include "CPUInfo.h"
  38 #include "utils/TimeUtils.h"
  39 #include "log.h"
  40 #ifdef _WIN32
  41 #include "dwmapi.h"
  42 #endif
  43 #ifdef __APPLE__
  44 #include "osx/CocoaInterface.h"
  45 #endif
  46
  47 CSysInfo g_sysinfo;
  48
  49 CSysInfoJob::CSysInfoJob()
  50 {
  51 }
  52
  53 bool CSysInfoJob::DoWork()
  54 {
  55   m_info.systemUptime      = GetSystemUpTime(false);
  56   m_info.systemTotalUptime = GetSystemUpTime(true);
  57   m_info.internetState     = GetInternetState();
  58   m_info.videoEncoder      = GetVideoEncoder();
  59   m_info.cpuFrequency      = GetCPUFreqInfo();
  60   m_info.kernelVersion     = CSysInfo::GetKernelVersion();
  61   m_info.macAddress        = GetMACAddress();
  62   return true;
  63 }
  64
  65 const CSysData &CSysInfoJob::GetData() const
  66 {
  67   return m_info;
  68 }
  69
  70 CStdString CSysInfoJob::GetCPUFreqInfo()
  71 {
  72   CStdString strCPUFreq;
  73   double CPUFreq = GetCPUFrequency();
  74   strCPUFreq.Format("%4.2fMHz", CPUFreq);
  75   return strCPUFreq;
  76 }
  77
  78 CSysData::INTERNET_STATE CSysInfoJob::GetInternetState()
  79 {
  80   // Internet connection state!
  81   XFILE::CFileCurl http;
  82   if (http.IsInternet())
  83     return CSysData::CONNECTED;
  84   if (http.IsInternet(false))
  85     return CSysData::NO_DNS;
  86   return CSysData::DISCONNECTED;
  87 }
  88
  89 CStdString CSysInfoJob::GetMACAddress()
  90 {
  91 #if defined(HAS_LINUX_NETWORK)
  92   CNetworkInterface* iface = g_application.getNetwork().GetFirstConnectedInterface();
  93   if (iface)
  94     return iface->GetMacAddress();
  95 #endif
  96   return "";
  97 }
  98
  99 CStdString CSysInfoJob::GetVideoEncoder()
 100 {
 101   return "GPU: " + g_Windowing.GetRenderRenderer();
 102 }
 103
 104 double CSysInfoJob::GetCPUFrequency()
 105 {
 106 #if defined (_LINUX) || defined(_WIN32)
 107   return double (g_cpuInfo.getCPUFrequency());
 108 #else
 109   return 0;
 110 #endif
 111 }
 112
 113 bool CSysInfoJob::SystemUpTime(int iInputMinutes, int &iMinutes, int &iHours, int &iDays)
 114 {
 115   iMinutes=0;iHours=0;iDays=0;
 116   iMinutes = iInputMinutes;
 117   if (iMinutes >= 60) // Hour's
 118   {
 119     iHours = iMinutes / 60;
 120     iMinutes = iMinutes - (iHours *60);
 121   }
 122   if (iHours >= 24) // Days
 123   {
 124     iDays = iHours / 24;
 125     iHours = iHours - (iDays * 24);
 126   }
 127   return true;
 128 }
 129
 130 CStdString CSysInfoJob::GetSystemUpTime(bool bTotalUptime)
 131 {
 132   CStdString strSystemUptime;
 133   int iInputMinutes, iMinutes,iHours,iDays;
 134
 135   if(bTotalUptime)
 136   {
 137     //Total Uptime
 138     iInputMinutes = g_settings.m_iSystemTimeTotalUp + ((int)(CTimeUtils::GetTimeMS() / 60000));
 139   }
 140   else
 141   {
 142     //Current UpTime
 143     iInputMinutes = (int)(CTimeUtils::GetTimeMS() / 60000);
 144   }
 145
 146   SystemUpTime(iInputMinutes,iMinutes, iHours, iDays);
 147   if (iDays > 0)
 148   {
 149     strSystemUptime.Format("%i %s, %i %s, %i %s",
 150       iDays,g_localizeStrings.Get(12393),
 151       iHours,g_localizeStrings.Get(12392),
 152       iMinutes, g_localizeStrings.Get(12391));
 153   }
 154   else if (iDays == 0 && iHours >= 1 )
 155   {
 156     strSystemUptime.Format("%i %s, %i %s",
 157       iHours,g_localizeStrings.Get(12392),
 158       iMinutes, g_localizeStrings.Get(12391));
 159   }
 160   else if (iDays == 0 && iHours == 0 &&  iMinutes >= 0)
 161   {
 162     strSystemUptime.Format("%i %s",
 163       iMinutes, g_localizeStrings.Get(12391));
 164   }
 165   return strSystemUptime;
 166 }
 167
 168 CStdString CSysInfo::TranslateInfo(int info) const
 169 {
 170   switch(info)
 171   {
 172   case SYSTEM_VIDEO_ENCODER_INFO:
 173     return m_info.videoEncoder;
 174   case NETWORK_MAC_ADDRESS:
 175     return m_info.macAddress;
 176   case SYSTEM_KERNEL_VERSION:
 177     return m_info.kernelVersion;
 178   case SYSTEM_CPUFREQUENCY:
 179     return m_info.cpuFrequency;
 180   case SYSTEM_UPTIME:
 181     return m_info.systemUptime;
 182   case SYSTEM_TOTALUPTIME:
 183     return m_info.systemTotalUptime;
 184   case SYSTEM_INTERNET_STATE:
 185     if (m_info.internetState == CSysData::CONNECTED)
 186       return g_localizeStrings.Get(13296);
 187     else if (m_info.internetState == CSysData::NO_DNS)
 188       return g_localizeStrings.Get(13274);
 189     else
 190       return g_localizeStrings.Get(13297);
 191   default:
 192     return "";
 193   }
 194 }
 195
 196 void CSysInfo::Reset()
 197 {
 198   m_info.Reset();
 199 }
 200
 201 CSysInfo::CSysInfo(void) : CInfoLoader(15 * 1000)
 202 {
 203 }
 204
 205 CSysInfo::~CSysInfo()
 206 {
 207 }
 208
 209 bool CSysInfo::GetDiskSpace(const CStdString drive,int& iTotal, int& iTotalFree, int& iTotalUsed, int& iPercentFree, int& iPercentUsed)
 210 {
 211   bool bRet= false;
 212   ULARGE_INTEGER ULTotal= { { 0 } };
 213   ULARGE_INTEGER ULTotalFree= { { 0 } };
 214
 215   if( !drive.IsEmpty() && !drive.Equals("*") )
 216   {
 217 #ifdef _WIN32
 218     UINT uidriveType = GetDriveType(( drive + ":\\" ));
 219     if(uidriveType != DRIVE_UNKNOWN && uidriveType != DRIVE_NO_ROOT_DIR)
 220 #endif
 221       bRet= ( 0 != GetDiskFreeSpaceEx( ( drive + ":\\" ), NULL, &ULTotal, &ULTotalFree) );
 222   }
 223   else
 224   {
 225     ULARGE_INTEGER ULTotalTmp= { { 0 } };
 226     ULARGE_INTEGER ULTotalFreeTmp= { { 0 } };
 227 #ifdef _WIN32
 228     char* pcBuffer= NULL;
 229     DWORD dwStrLength= GetLogicalDriveStrings( 0, pcBuffer );
 230     if( dwStrLength != 0 )
 231     {
 232       dwStrLength+= 1;
 233       pcBuffer= new char [dwStrLength];
 234       GetLogicalDriveStrings( dwStrLength, pcBuffer );
 235       int iPos= 0;
 236       do {
 237         if( DRIVE_FIXED == GetDriveType( pcBuffer + iPos  ) &&
 238             GetDiskFreeSpaceEx( ( pcBuffer + iPos ), NULL, &ULTotal, &ULTotalFree ) )
 239         {
 240           ULTotalTmp.QuadPart+= ULTotal.QuadPart;
 241           ULTotalFreeTmp.QuadPart+= ULTotalFree.QuadPart;
 242         }
 243         iPos += (strlen( pcBuffer + iPos) + 1 );
 244       }while( strlen( pcBuffer + iPos ) > 0 );
 245     }
 246     delete[] pcBuffer;
 247 #else // for linux and osx
 248     static const char *drv_letter[] = { "C:\\", "E:\\", "F:\\", "G:\\", "X:\\", "Y:\\", "Z:\\", NULL };
 249     for( int i = 0; drv_letter[i]; i++)
 250     {
 251       if( GetDiskFreeSpaceEx( drv_letter[i], NULL, &ULTotal, &ULTotalFree ) )
 252       {
 253         ULTotalTmp.QuadPart+= ULTotal.QuadPart;
 254         ULTotalFreeTmp.QuadPart+= ULTotalFree.QuadPart;
 255       }
 256     }
 257 #endif
 258     if( ULTotalTmp.QuadPart || ULTotalFreeTmp.QuadPart )
 259     {
 260       ULTotal.QuadPart= ULTotalTmp.QuadPart;
 261       ULTotalFree.QuadPart= ULTotalFreeTmp.QuadPart;
 262       bRet= true;
 263     }
 264   }
 265
 266   if( bRet )
 267   {
 268     iTotal = (int)( ULTotal.QuadPart / MB );
 269     iTotalFree = (int)( ULTotalFree.QuadPart / MB );
 270     iTotalUsed = iTotal - iTotalFree;
 271     iPercentUsed = (int)( 100.0f * ( ULTotal.QuadPart - ULTotalFree.QuadPart ) / ULTotal.QuadPart + 0.5f );
 272     iPercentFree = 100 - iPercentUsed;
 273   }
 274
 275   return bRet;
 276 }
 277
 278 CStdString CSysInfo::GetXBVerInfo()
 279 {
 280   return "CPU: " + g_cpuInfo.getCPUModel();
 281 }
 282
 283 bool CSysInfo::IsAeroDisabled()
 284 {
 285 #ifdef _WIN32
 286   OSVERSIONINFOEX osvi;
 287   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
 288   osvi.dwOSVersionInfoSize = sizeof(osvi);
 289
 290   if (GetVersionEx((OSVERSIONINFO *)&osvi))
 291   {
 292     if (osvi.dwMajorVersion == 5)
 293       return true; // windows XP -> no Aero
 294
 295     BOOL aeroEnabled = FALSE;
 296     HRESULT res = DwmIsCompositionEnabled(&aeroEnabled);
 297     if (SUCCEEDED(res))
 298       return !aeroEnabled;
 299   }
 300 #endif
 301   return false;
 302 }
 303
 304 bool CSysInfo::IsVistaOrHigher()
 305 {
 306 #ifdef _WIN32
 307   OSVERSIONINFOEX osvi;
 308   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
 309   osvi.dwOSVersionInfoSize = sizeof(osvi);
 310
 311   if (GetVersionEx((OSVERSIONINFO *)&osvi))
 312   {
 313     if (osvi.dwMajorVersion >= 6)
 314       return true;
 315   }
 316 #endif
 317   return false;
 318 }
 319
 320 CStdString CSysInfo::GetKernelVersion()
 321 {
 322 #if defined (_LINUX)
 323   struct utsname un;
 324   if (uname(&un)==0)
 325   {
 326     CStdString strKernel;
 327     strKernel.Format("%s %s %s %s", un.sysname, un.release, un.version, un.machine);
 328     return strKernel;
 329   }
 330
 331   return "";
 332 #else
 333   OSVERSIONINFOEX osvi;
 334   SYSTEM_INFO si;
 335
 336   ZeroMemory(&si, sizeof(SYSTEM_INFO));
 337   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
 338
 339   GetSystemInfo(&si);
 340
 341   osvi.dwOSVersionInfoSize = sizeof(osvi);
 342   CStdString strKernel = "Windows ";
 343
 344   if (GetVersionEx((OSVERSIONINFO *)&osvi))
 345   {
 346     if ( osvi.dwMajorVersion == 6 )
 347     {
 348       if (osvi.dwMinorVersion == 0)
 349       {
 350         if( osvi.wProductType == VER_NT_WORKSTATION )
 351           strKernel.append("Vista");
 352         else
 353           strKernel.append("Server 2008");
 354       } else if (osvi.dwMinorVersion == 1)
 355       {
 356         if( osvi.wProductType == VER_NT_WORKSTATION )
 357           strKernel.append("7");
 358         else
 359           strKernel.append("Server 2008 R2");
 360       }
 361
 362       if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64 || si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_IA64)
 363         strKernel.append(", 64-bit Native");
 364       else if (si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_INTEL )
 365       {
 366         BOOL bIsWow = FALSE;;
 367         if(IsWow64Process(GetCurrentProcess(), &bIsWow))
 368         {
 369           if (bIsWow)
 370           {
 371             GetNativeSystemInfo(&si);
 372             if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 || si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64)
 373              strKernel.append(", 64-bit (WoW)");
 374           }
 375           else
 376           {
 377             strKernel.append(", 32-bit");
 378           }
 379         }
 380         else
 381           strKernel.append(", 32-bit");
 382       }
 383     }
 384     else if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
 385     {
 386       if( osvi.wProductType == VER_NT_WORKSTATION && si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64)
 387       {
 388         strKernel.append("XP Professional x64 Edition");
 389       }
 390     }
 391     else if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
 392     {
 393       strKernel.append("XP ");
 394       if( osvi.wSuiteMask & VER_SUITE_PERSONAL )
 395         strKernel.append("Home Edition" );
 396       else
 397         strKernel.append("Professional" );
 398     }
 399     else if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
 400     {
 401       strKernel.append("2000");
 402     }
 403
 404     if( _tcslen(osvi.szCSDVersion) > 0 )
 405     {
 406       strKernel.append(" ");
 407       strKernel.append(osvi.szCSDVersion);
 408     }
 409     CStdString strBuild;
 410     strBuild.Format(" build %d",osvi.dwBuildNumber);
 411     strKernel += strBuild;
 412   }
 413   return strKernel;
 414 #endif
 415 }
 416
 417 bool CSysInfo::HasInternet()
 418 {
 419   if (m_info.internetState != CSysData::UNKNOWN)
 420     return m_info.internetState == CSysData::CONNECTED;
 421   return (m_info.internetState = CSysInfoJob::GetInternetState()) == CSysData::CONNECTED;
 422 }
 423
 424 CStdString CSysInfo::GetHddSpaceInfo(int drive, bool shortText)
 425 {
 426  int percent;
 427  return GetHddSpaceInfo( percent, drive, shortText);
 428 }
 429
 430 CStdString CSysInfo::GetHddSpaceInfo(int& percent, int drive, bool shortText)
 431 {
 432   int total, totalFree, totalUsed, percentFree, percentused;
 433   CStdString strDrive;
 434   bool bRet=false;
 435   percent = 0;
 436   CStdString strRet;
 437   switch (drive)
 438   {
 439     case SYSTEM_FREE_SPACE:
 440     case SYSTEM_USED_SPACE:
 441     case SYSTEM_TOTAL_SPACE:
 442     case SYSTEM_FREE_SPACE_PERCENT:
 443     case SYSTEM_USED_SPACE_PERCENT:
 444       bRet = g_sysinfo.GetDiskSpace("",total, totalFree, totalUsed, percentFree, percentused);
 445       break;
 446     case LCD_FREE_SPACE_C:
 447     case SYSTEM_FREE_SPACE_C:
 448     case SYSTEM_USED_SPACE_C:
 449     case SYSTEM_TOTAL_SPACE_C:
 450     case SYSTEM_FREE_SPACE_PERCENT_C:
 451     case SYSTEM_USED_SPACE_PERCENT_C:
 452       strDrive = "C";
 453       bRet = g_sysinfo.GetDiskSpace("C",total, totalFree, totalUsed, percentFree, percentused);
 454       break;
 455     case LCD_FREE_SPACE_E:
 456     case SYSTEM_FREE_SPACE_E:
 457     case SYSTEM_USED_SPACE_E:
 458     case SYSTEM_TOTAL_SPACE_E:
 459     case SYSTEM_FREE_SPACE_PERCENT_E:
 460     case SYSTEM_USED_SPACE_PERCENT_E:
 461       strDrive = "E";
 462       bRet = g_sysinfo.GetDiskSpace("E",total, totalFree, totalUsed, percentFree, percentused);
 463       break;
 464     case LCD_FREE_SPACE_F:
 465     case SYSTEM_FREE_SPACE_F:
 466     case SYSTEM_USED_SPACE_F:
 467     case SYSTEM_TOTAL_SPACE_F:
 468     case SYSTEM_FREE_SPACE_PERCENT_F:
 469     case SYSTEM_USED_SPACE_PERCENT_F:
 470       strDrive = "F";
 471       bRet = g_sysinfo.GetDiskSpace("F",total, totalFree, totalUsed, percentFree, percentused);
 472       break;
 473     case LCD_FREE_SPACE_G:
 474     case SYSTEM_FREE_SPACE_G:
 475     case SYSTEM_USED_SPACE_G:
 476     case SYSTEM_TOTAL_SPACE_G:
 477     case SYSTEM_FREE_SPACE_PERCENT_G:
 478     case SYSTEM_USED_SPACE_PERCENT_G:
 479       strDrive = "G";
 480       bRet = g_sysinfo.GetDiskSpace("G",total, totalFree, totalUsed, percentFree, percentused);
 481       break;
 482     case SYSTEM_USED_SPACE_X:
 483     case SYSTEM_FREE_SPACE_X:
 484     case SYSTEM_TOTAL_SPACE_X:
 485       strDrive = "X";
 486       bRet = g_sysinfo.GetDiskSpace("X",total, totalFree, totalUsed, percentFree, percentused);
 487       break;
 488     case SYSTEM_USED_SPACE_Y:
 489     case SYSTEM_FREE_SPACE_Y:
 490     case SYSTEM_TOTAL_SPACE_Y:
 491       strDrive = "Y";
 492       bRet = g_sysinfo.GetDiskSpace("Y",total, totalFree, totalUsed, percentFree, percentused);
 493       break;
 494     case SYSTEM_USED_SPACE_Z:
 495     case SYSTEM_FREE_SPACE_Z:
 496     case SYSTEM_TOTAL_SPACE_Z:
 497       strDrive = "Z";
 498       bRet = g_sysinfo.GetDiskSpace("Z",total, totalFree, totalUsed, percentFree, percentused);
 499       break;
 500   }
 501   if (bRet)
 502   {
 503     if (shortText)
 504     {
 505       switch(drive)
 506       {
 507         case LCD_FREE_SPACE_C:
 508         case LCD_FREE_SPACE_E:
 509         case LCD_FREE_SPACE_F:
 510         case LCD_FREE_SPACE_G:
 511           strRet.Format("%iMB", totalFree);
 512           break;
 513         case SYSTEM_FREE_SPACE:
 514         case SYSTEM_FREE_SPACE_C:
 515         case SYSTEM_FREE_SPACE_E:
 516         case SYSTEM_FREE_SPACE_F:
 517         case SYSTEM_FREE_SPACE_G:
 518         case SYSTEM_FREE_SPACE_X:
 519         case SYSTEM_FREE_SPACE_Y:
 520         case SYSTEM_FREE_SPACE_Z:
 521           percent = percentFree;
 522           break;
 523         case SYSTEM_USED_SPACE:
 524         case SYSTEM_USED_SPACE_C:
 525         case SYSTEM_USED_SPACE_E:
 526         case SYSTEM_USED_SPACE_F:
 527         case SYSTEM_USED_SPACE_G:
 528         case SYSTEM_USED_SPACE_X:
 529         case SYSTEM_USED_SPACE_Y:
 530         case SYSTEM_USED_SPACE_Z:
 531           percent = percentused;
 532           break;
 533       }
 534     }
 535     else
 536     {
 537       switch(drive)
 538       {
 539       case SYSTEM_FREE_SPACE:
 540       case SYSTEM_FREE_SPACE_C:
 541       case SYSTEM_FREE_SPACE_E:
 542       case SYSTEM_FREE_SPACE_F:
 543       case SYSTEM_FREE_SPACE_G:
 544       case SYSTEM_FREE_SPACE_X:
 545       case SYSTEM_FREE_SPACE_Y:
 546       case SYSTEM_FREE_SPACE_Z:
 547         if (strDrive.IsEmpty())
 548           strRet.Format("%i MB %s", totalFree, g_localizeStrings.Get(160));
 549         else
 550           strRet.Format("%s: %i MB %s", strDrive, totalFree, g_localizeStrings.Get(160));
 551         break;
 552       case SYSTEM_USED_SPACE:
 553       case SYSTEM_USED_SPACE_C:
 554       case SYSTEM_USED_SPACE_E:
 555       case SYSTEM_USED_SPACE_F:
 556       case SYSTEM_USED_SPACE_G:
 557       case SYSTEM_USED_SPACE_X:
 558       case SYSTEM_USED_SPACE_Y:
 559       case SYSTEM_USED_SPACE_Z:
 560         if (strDrive.IsEmpty())
 561           strRet.Format("%i MB %s", totalUsed, g_localizeStrings.Get(20162));
 562         else
 563           strRet.Format("%s: %i MB %s", strDrive, totalUsed, g_localizeStrings.Get(20162));
 564         break;
 565       case SYSTEM_TOTAL_SPACE:
 566       case SYSTEM_TOTAL_SPACE_C:
 567       case SYSTEM_TOTAL_SPACE_E:
 568       case SYSTEM_TOTAL_SPACE_F:
 569       case SYSTEM_TOTAL_SPACE_G:
 570         if (strDrive.IsEmpty())
 571           strRet.Format("%i MB %s", total, g_localizeStrings.Get(20161));
 572         else
 573           strRet.Format("%s: %i MB %s", strDrive, total, g_localizeStrings.Get(20161));
 574         break;
 575       case SYSTEM_FREE_SPACE_PERCENT:
 576       case SYSTEM_FREE_SPACE_PERCENT_C:
 577       case SYSTEM_FREE_SPACE_PERCENT_E:
 578       case SYSTEM_FREE_SPACE_PERCENT_F:
 579       case SYSTEM_FREE_SPACE_PERCENT_G:
 580         if (strDrive.IsEmpty())
 581           strRet.Format("%i %% %s", percentFree, g_localizeStrings.Get(160));
 582         else
 583           strRet.Format("%s: %i %% %s", strDrive, percentFree, g_localizeStrings.Get(160));
 584         break;
 585       case SYSTEM_USED_SPACE_PERCENT:
 586       case SYSTEM_USED_SPACE_PERCENT_C:
 587       case SYSTEM_USED_SPACE_PERCENT_E:
 588       case SYSTEM_USED_SPACE_PERCENT_F:
 589       case SYSTEM_USED_SPACE_PERCENT_G:
 590         if (strDrive.IsEmpty())
 591           strRet.Format("%i %% %s", percentused, g_localizeStrings.Get(20162));
 592         else
 593           strRet.Format("%s: %i %% %s", strDrive, percentused, g_localizeStrings.Get(20162));
 594         break;
 595       }
 596     }
 597   }
 598   else
 599   {
 600     if (shortText)
 601       strRet = "N/A";
 602     else if (strDrive.IsEmpty())
 603       strRet = g_localizeStrings.Get(161);
 604     else
 605       strRet.Format("%s: %s", strDrive, g_localizeStrings.Get(161));
 606   }
 607   return strRet;
 608 }
 609
 610 #if defined(_LINUX) && !defined(__APPLE__)
 611 CStdString CSysInfo::GetLinuxDistro()
 612 {
 613   static const char* release_file[] = { "/etc/debian_version",
 614                                         "/etc/SuSE-release",
 615                                         "/etc/mandrake-release",
 616                                         "/etc/fedora-release",
 617                                         "/etc/redhat-release",
 618                                         "/etc/gentoo-release",
 619                                         "/etc/slackware-version",
 620                                         "/etc/arch-release",
 621                                         NULL };
 622
 623   FILE* pipe = popen("unset PYTHONHOME; unset PYTHONPATH; lsb_release -d | cut -f2", "r");
 624
 625   for (int i = 0; !pipe && release_file[i]; i++)
 626   {
 627     CStdString cmd = "cat ";
 628     cmd += release_file[i];
 629
 630     pipe = popen(cmd.c_str(), "r");
 631   }
 632
 633   CStdString result = "Unknown";
 634   if (pipe)
 635   {
 636     char buffer[256] = {'\0'};
 637     if (fread(buffer, sizeof(char), sizeof(buffer), pipe) > 0 && !ferror(pipe))
 638       result = buffer;
 639     else
 640       CLog::Log(LOGWARNING, "Unable to determine Linux distribution");
 641     pclose(pipe);
 642   }
 643   return result.Trim();
 644 }
 645 #endif
 646
 647 #ifdef _LINUX
 648 CStdString CSysInfo::GetUnameVersion()
 649 {
 650   CStdString result = "";
 651
 652   FILE* pipe = popen("uname -rm", "r");
 653   if (pipe)
 654   {
 655     char buffer[256] = {'\0'};
 656     if (fread(buffer, sizeof(char), sizeof(buffer), pipe) > 0 && !ferror(pipe))
 657       result = buffer;
 658     else
 659       CLog::Log(LOGWARNING, "Unable to determine Uname version");
 660     pclose(pipe);
 661   }
 662
 663   return result.Trim();
 664 }
 665 #endif
 666
 667 CStdString CSysInfo::GetUserAgent()
 668 {
 669   CStdString result;
 670   result = "XBMC/" + g_infoManager.GetLabel(SYSTEM_BUILD_VERSION) + " (";
 671 #if defined(_WIN32)
 672   result += "Windows; ";
 673   result += GetKernelVersion();
 674 #elif defined(__APPLE__)
 675   result += "Mac OS X; ";
 676   result += GetUnameVersion();
 677 #elif defined(_LINUX)
 678   result += "Linux; ";
 679   result += GetLinuxDistro();
 680   result += "; ";
 681   result += GetUnameVersion();
 682 #endif
 683   result += "; http://www.xbmc.org)";
 684
 685   return result;
 686 }
 687
 688 bool CSysInfo::IsAppleTV()
 689 {
 690   bool        result = false;
 691 #if defined(__APPLE__)
 692   char        buffer[512];
 693   size_t      len = 512;
 694   std::string hw_model = "unknown";
 695
 696   if (sysctlbyname("hw.model", &buffer, &len, NULL, 0) == 0)
 697     hw_model = buffer;
 698
 699   if (hw_model.find("AppleTV") != std::string::npos)
 700     result = true;
 701 #endif
 702   return result;
 703 }
 704
 705 bool CSysInfo::HasVDADecoder()
 706 {
 707   bool        result = false;
 708
 709 #if defined(__APPLE__)
 710   result = Cocoa_HasVDADecoder();
 711 #endif
 712   return result;
 713 }
 714
 715 CJob *CSysInfo::GetJob() const
 716 {
 717   return new CSysInfoJob();
 718 }
 719
 720 void CSysInfo::OnJobComplete(unsigned int jobID, bool success, CJob *job)
 721 {
 722   m_info = ((CSysInfoJob *)job)->GetData();
 723   CInfoLoader::OnJobComplete(jobID, success, job);
 724 }