xbmc/platform/posix/XTimeUtils.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "utils/XTimeUtils.h"
  10
  11 #include <errno.h>
  12 #include <mutex>
  13 #include <time.h>
  14
  15 #include <sys/times.h>
  16
  17 #if defined(TARGET_ANDROID) && !defined(__LP64__)
  18 #include <time64.h>
  19 #endif
  20
  21 #define WIN32_TIME_OFFSET ((unsigned long long)(369 * 365 + 89) * 24 * 3600 * 10000000)
  22
  23 namespace KODI
  24 {
  25 namespace TIME
  26 {
  27
  28 /*
  29  * A Leap year is any year that is divisible by four, but not by 100 unless also
  30  * divisible by 400
  31  */
  32 #define IsLeapYear(y) ((!(y % 4)) ? (((!(y % 400)) && (y % 100)) ? 1 : 0) : 0)
  33
  34 uint32_t GetTimeZoneInformation(TimeZoneInformation* timeZoneInformation)
  35 {
  36   if (!timeZoneInformation)
  37     return KODI_TIME_ZONE_ID_INVALID;
  38
  39   struct tm t;
  40   time_t tt = time(NULL);
  41   if (localtime_r(&tt, &t))
  42     timeZoneInformation->bias = -t.tm_gmtoff / 60;
  43
  44   timeZoneInformation->standardName = tzname[0];
  45   timeZoneInformation->daylightName = tzname[1];
  46
  47   return KODI_TIME_ZONE_ID_UNKNOWN;
  48 }
  49
  50 void GetLocalTime(SystemTime* systemTime)
  51 {
  52   const time_t t = time(NULL);
  53   struct tm now;
  54
  55   localtime_r(&t, &now);
  56   systemTime->year = now.tm_year + 1900;
  57   systemTime->month = now.tm_mon + 1;
  58   systemTime->dayOfWeek = now.tm_wday;
  59   systemTime->day = now.tm_mday;
  60   systemTime->hour = now.tm_hour;
  61   systemTime->minute = now.tm_min;
  62   systemTime->second = now.tm_sec;
  63   systemTime->milliseconds = 0;
  64 }
  65
  66 int FileTimeToLocalFileTime(const FileTime* fileTime, FileTime* localFileTime)
  67 {
  68   ULARGE_INTEGER l;
  69   l.u.LowPart = fileTime->lowDateTime;
  70   l.u.HighPart = fileTime->highDateTime;
  71
  72   time_t ft;
  73   struct tm tm_ft;
  74   FileTimeToTimeT(fileTime, &ft);
  75   localtime_r(&ft, &tm_ft);
  76
  77   l.QuadPart += static_cast<unsigned long long>(tm_ft.tm_gmtoff) * 10000000;
  78
  79   localFileTime->lowDateTime = l.u.LowPart;
  80   localFileTime->highDateTime = l.u.HighPart;
  81   return 1;
  82 }
  83
  84 int SystemTimeToFileTime(const SystemTime* systemTime, FileTime* fileTime)
  85 {
  86   static const int dayoffset[12] = {0, 31, 59, 90, 120, 151, 182, 212, 243, 273, 304, 334};
  87 #if defined(TARGET_DARWIN)
  88   static std::mutex timegm_lock;
  89 #endif
  90
  91   struct tm sysTime = {};
  92   sysTime.tm_year = systemTime->year - 1900;
  93   sysTime.tm_mon = systemTime->month - 1;
  94   sysTime.tm_wday = systemTime->dayOfWeek;
  95   sysTime.tm_mday = systemTime->day;
  96   sysTime.tm_hour = systemTime->hour;
  97   sysTime.tm_min = systemTime->minute;
  98   sysTime.tm_sec = systemTime->second;
  99   sysTime.tm_yday = dayoffset[sysTime.tm_mon] + (sysTime.tm_mday - 1);
 100
 101   // If this is a leap year, and we're past the 28th of Feb, increment tm_yday.
 102   if (IsLeapYear(systemTime->year) && (sysTime.tm_yday > 58))
 103     sysTime.tm_yday++;
 104
 105 #if defined(TARGET_DARWIN)
 106   std::lock_guard<std::mutex> lock(timegm_lock);
 107 #endif
 108
 109 #if defined(TARGET_ANDROID) && !defined(__LP64__)
 110   time64_t t = timegm64(&sysTime);
 111 #else
 112   time_t t = timegm(&sysTime);
 113 #endif
 114
 115   LARGE_INTEGER result;
 116   result.QuadPart = (long long)t * 10000000 + (long long)systemTime->milliseconds * 10000;
 117   result.QuadPart += WIN32_TIME_OFFSET;
 118
 119   fileTime->lowDateTime = result.u.LowPart;
 120   fileTime->highDateTime = result.u.HighPart;
 121
 122   return 1;
 123 }
 124
 125 long CompareFileTime(const FileTime* fileTime1, const FileTime* fileTime2)
 126 {
 127   ULARGE_INTEGER t1;
 128   t1.u.LowPart = fileTime1->lowDateTime;
 129   t1.u.HighPart = fileTime1->highDateTime;
 130
 131   ULARGE_INTEGER t2;
 132   t2.u.LowPart = fileTime2->lowDateTime;
 133   t2.u.HighPart = fileTime2->highDateTime;
 134
 135   if (t1.QuadPart == t2.QuadPart)
 136      return 0;
 137   else if (t1.QuadPart < t2.QuadPart)
 138      return -1;
 139   else
 140      return 1;
 141 }
 142
 143 int FileTimeToSystemTime(const FileTime* fileTime, SystemTime* systemTime)
 144 {
 145   LARGE_INTEGER file;
 146   file.u.LowPart = fileTime->lowDateTime;
 147   file.u.HighPart = fileTime->highDateTime;
 148
 149   file.QuadPart -= WIN32_TIME_OFFSET;
 150   file.QuadPart /= 10000; /* to milliseconds */
 151   systemTime->milliseconds = file.QuadPart % 1000;
 152   file.QuadPart /= 1000; /* to seconds */
 153
 154   time_t ft = file.QuadPart;
 155
 156   struct tm tm_ft;
 157   gmtime_r(&ft, &tm_ft);
 158
 159   systemTime->year = tm_ft.tm_year + 1900;
 160   systemTime->month = tm_ft.tm_mon + 1;
 161   systemTime->dayOfWeek = tm_ft.tm_wday;
 162   systemTime->day = tm_ft.tm_mday;
 163   systemTime->hour = tm_ft.tm_hour;
 164   systemTime->minute = tm_ft.tm_min;
 165   systemTime->second = tm_ft.tm_sec;
 166
 167   return 1;
 168 }
 169
 170 int LocalFileTimeToFileTime(const FileTime* localFileTime, FileTime* fileTime)
 171 {
 172   ULARGE_INTEGER l;
 173   l.u.LowPart = localFileTime->lowDateTime;
 174   l.u.HighPart = localFileTime->highDateTime;
 175
 176   l.QuadPart += (unsigned long long) timezone * 10000000;
 177
 178   fileTime->lowDateTime = l.u.LowPart;
 179   fileTime->highDateTime = l.u.HighPart;
 180
 181   return 1;
 182 }
 183
 184
 185 int FileTimeToTimeT(const FileTime* localFileTime, time_t* pTimeT)
 186 {
 187   if (!localFileTime || !pTimeT)
 188     return false;
 189
 190   ULARGE_INTEGER fileTime;
 191   fileTime.u.LowPart = localFileTime->lowDateTime;
 192   fileTime.u.HighPart = localFileTime->highDateTime;
 193
 194   fileTime.QuadPart -= WIN32_TIME_OFFSET;
 195   fileTime.QuadPart /= 10000; /* to milliseconds */
 196   fileTime.QuadPart /= 1000; /* to seconds */
 197
 198   time_t ft = fileTime.QuadPart;
 199
 200   struct tm tm_ft;
 201   localtime_r(&ft, &tm_ft);
 202
 203   *pTimeT = mktime(&tm_ft);
 204   return 1;
 205 }
 206
 207 int TimeTToFileTime(time_t timeT, FileTime* localFileTime)
 208 {
 209   if (!localFileTime)
 210     return false;
 211
 212   ULARGE_INTEGER result;
 213   result.QuadPart = (unsigned long long) timeT * 10000000;
 214   result.QuadPart += WIN32_TIME_OFFSET;
 215
 216   localFileTime->lowDateTime = result.u.LowPart;
 217   localFileTime->highDateTime = result.u.HighPart;
 218
 219   return 1;
 220 }
 221
 222 } // namespace TIME
 223 } // namespace KODI