From e7e426ec1b8f22dfc0c24cdf7a8a4476920128e4 Mon Sep 17 00:00:00 2001 From: Lukas Rusak Date: Mon, 17 Feb 2020 22:41:25 -0800 Subject: [PATCH 01/17] [cmake] add support for date library and tzdata --- CMakeLists.txt | 2 + cmake/modules/FindDate.cmake | 92 ++++++++++++++++++++++++++++++++++++ 2 files changed, 94 insertions(+) create mode 100644 cmake/modules/FindDate.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index 572e99b481..e49e743fbd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -68,6 +68,7 @@ if(UNIX) option(ENABLE_INTERNAL_GTEST "Enable internal gtest?" OFF) option(ENABLE_INTERNAL_UDFREAD "Enable internal udfread?" OFF) option(ENABLE_INTERNAL_SPDLOG "Enable internal spdlog?" OFF) + option(ENABLE_INTERNAL_DATE "Enable internal date library?" ON) endif() # System options if(NOT WIN32) @@ -125,6 +126,7 @@ set(required_deps ASS Cdio CrossGUID Curl + Date FFMPEG FlatBuffers Fmt diff --git a/cmake/modules/FindDate.cmake b/cmake/modules/FindDate.cmake new file mode 100644 index 0000000000..bbaf99202a --- /dev/null +++ b/cmake/modules/FindDate.cmake @@ -0,0 +1,92 @@ +#.rst: +# FindDate +# ------- +# Finds the DATE library +# +# This will define the following variables:: +# +# DATE_FOUND - system has DATE +# DATE_INCLUDE_DIRS - the DATE include directory +# DATE_LIBRARIES - the DATE libraries + +set(DATE_VERSION "3.0.0") + +find_library(DATE_LIBRARY NAMES date-tz libdate-tz) +find_path(DATE_INCLUDE_DIR NAMES date/date.h) + +if(ENABLE_INTERNAL_DATE) + include(ExternalProject) + + # allow user to override the download URL with a local tarball + # needed for offline build envs + if(DATE_URL) + get_filename_component(DATE_URL "${DATE_URL}" ABSOLUTE) + else() + set(DATE_URL http://mirrors.kodi.tv/build-deps/sources/date-v${DATE_VERSION}.tar.gz) + endif() + + if(VERBOSE) + message(STATUS "DATE_URL: ${DATE_URL}") + endif() + + set(DATE_LIBRARY ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR}/lib/libdate-tz.a) + set(DATE_INCLUDE_DIR ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR}/include) + + externalproject_add(Date + URL ${DATE_URL} + DOWNLOAD_NAME date-${DATE_VERSION}.tar.gz + DOWNLOAD_DIR ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR}/download + PREFIX ${CORE_BUILD_DIR}/date + INSTALL_DIR ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR} + CMAKE_ARGS -DCMAKE_INSTALL_PREFIX= -DCMAKE_CXX_STANDARD=14 -DUSE_SYSTEM_TZ_DB=OFF -DMANUAL_TZ_DB=ON -DUSE_TZ_DB_IN_DOT=OFF -DBUILD_SHARED_LIBS=OFF -DDISABLE_STRING_VIEW=ON -DBUILD_TZ_LIB=ON -DCMAKE_INSTALL_LIBDIR=lib + BUILD_BYPRODUCTS ${DATE_LIBRARY}) + + externalproject_add_step(Date install_headers + COMMAND ${CMAKE_COMMAND} -E copy include/date/iso_week.h ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR}/include/date/iso_week.h + WORKING_DIRECTORY + DEPENDEES install) + + set_target_properties(Date PROPERTIES FOLDER "External Projects") + list(APPEND GLOBAL_TARGET_DEPS Date) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Date + REQUIRED_VARS DATE_LIBRARY DATE_INCLUDE_DIR + VERSION_VAR DATE_VERSION) + +if(DATE_FOUND) + set(DATE_INCLUDE_DIRS ${DATE_INCLUDE_DIR}) + set(DATE_LIBRARIES ${DATE_LIBRARY}) +endif() + +mark_as_advanced(DATE_INCLUDE_DIR DATE_LIBRARY) + +# not sure where this should go so it lives here for now + +set(TZDATA_VERSION "2020a") + +# allow user to override the download URL with a local tarball +# needed for offline build envs +if(TZDATA_URL) + get_filename_component(TZDATA_URL "${TZDATA_URL}" ABSOLUTE) +else() + set(TZDATA_URL http://mirrors.kodi.tv/build-deps/sources/tzdata${TZDATA_VERSION}.tar.gz) +endif() + +if(VERBOSE) + message(STATUS "TZDATA_URL: ${TZDATA_URL}") +endif() + +externalproject_add(tzdata + URL ${TZDATA_URL} + DOWNLOAD_NAME tzdata-${TZDATA_VERSION}.tar.gz + DOWNLOAD_DIR ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR}/download + PREFIX ${CORE_BUILD_DIR}/tzdata + INSTALL_DIR ${CMAKE_BINARY_DIR}/addons/resource.timezone/resources/tzdata + CONFIGURE_COMMAND "" + BUILD_COMMAND "" + INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_directory + BUILD_IN_SOURCE ON) + +list(APPEND GLOBAL_TARGET_DEPS tzdata) -- 2.31.1 From a15c159e4b19919775104f23eeed0c62b6368ff3 Mon Sep 17 00:00:00 2001 From: Lukas Rusak Date: Tue, 17 Mar 2020 13:12:04 -0700 Subject: [PATCH 02/17] add resource.timezone --- addons/kodi.resource/addon.xml | 1 + addons/kodi.resource/timezone.xsd | 16 ++++++++++++++ addons/resource.timezone/addon.xml | 12 +++++++++++ cmake/installdata/common/addons.txt | 1 + system/addon-manifest.xml | 1 + xbmc/Application.cpp | 17 +++++++++++++++ xbmc/addons/AddonBuilder.cpp | 3 +++ xbmc/addons/CMakeLists.txt | 2 ++ xbmc/addons/TimeZoneResource.cpp | 33 +++++++++++++++++++++++++++++ xbmc/addons/TimeZoneResource.h | 28 ++++++++++++++++++++++++ xbmc/addons/addoninfo/AddonInfo.cpp | 1 + xbmc/addons/addoninfo/AddonType.h | 1 + 12 files changed, 116 insertions(+) create mode 100644 addons/kodi.resource/timezone.xsd create mode 100644 addons/resource.timezone/addon.xml create mode 100644 xbmc/addons/TimeZoneResource.cpp create mode 100644 xbmc/addons/TimeZoneResource.h diff --git a/addons/kodi.resource/addon.xml b/addons/kodi.resource/addon.xml index 2bb3221b42..b615575744 100644 --- a/addons/kodi.resource/addon.xml +++ b/addons/kodi.resource/addon.xml @@ -7,4 +7,5 @@ + diff --git a/addons/kodi.resource/timezone.xsd b/addons/kodi.resource/timezone.xsd new file mode 100644 index 0000000000..990f8893ea --- /dev/null +++ b/addons/kodi.resource/timezone.xsd @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/addons/resource.timezone/addon.xml b/addons/resource.timezone/addon.xml new file mode 100644 index 0000000000..e57115d810 --- /dev/null +++ b/addons/resource.timezone/addon.xml @@ -0,0 +1,12 @@ + + + + + + + + Kodi Timezone Database + Kodi Timezone Database + all + + diff --git a/cmake/installdata/common/addons.txt b/cmake/installdata/common/addons.txt index 5a9aef2db0..b5e6aba364 100644 --- a/cmake/installdata/common/addons.txt +++ b/cmake/installdata/common/addons.txt @@ -26,6 +26,7 @@ addons/script.module.pil/* addons/script.module.pycryptodome/* addons/script.module.pysqlite/* addons/resource.language.en_gb/* +addons/resource.timezone/* addons/resource.uisounds.kodi/* addons/resource.images.weathericons.default/* addons/service.xbmc.versioncheck/* diff --git a/system/addon-manifest.xml b/system/addon-manifest.xml index e6de83fb02..33886951f9 100644 --- a/system/addon-manifest.xml +++ b/system/addon-manifest.xml @@ -40,6 +40,7 @@ repository.xbmc.org resource.images.weathericons.default resource.language.en_gb + resource.timezone resource.uisounds.kodi screensaver.xbmc.builtin.black screensaver.xbmc.builtin.dim diff --git a/xbmc/Application.cpp b/xbmc/Application.cpp index 5f25fcc9eb..e57a1d63d7 100644 --- a/xbmc/Application.cpp +++ b/xbmc/Application.cpp @@ -200,6 +200,10 @@ #include "addons/AddonSystemSettings.h" #include "FileItem.h" +#define USE_OS_TZDB 0 +#define HAS_REMOTE_API 0 +#include + using namespace ADDON; using namespace XFILE; #ifdef HAS_DVD_DRIVE @@ -525,6 +529,19 @@ bool CApplication::Create(const CAppParamParser ¶ms) return false; } + // must be done after stage two when addon manager is initialized + AddonPtr addon; + if (!CServiceBroker::GetAddonMgr().GetAddon("resource.timezone", addon, + ADDON::ADDON_RESOURCE_TIMEZONE, true)) + { + CLog::LogF(LOGDEBUG, "failed to find resource.timezone"); + return false; + } + + std::string tzdataPath = URIUtils::AddFileToFolder(addon->Path(), "resources", "tzdata"); + CLog::LogF(LOGDEBUG, "tzdata path: {}", tzdataPath); + date::set_install(tzdataPath); + m_pActiveAE.reset(new ActiveAE::CActiveAE()); m_pActiveAE->Start(); CServiceBroker::RegisterAE(m_pActiveAE.get()); diff --git a/xbmc/addons/AddonBuilder.cpp b/xbmc/addons/AddonBuilder.cpp index 39dd3c9eed..94f45ed11c 100644 --- a/xbmc/addons/AddonBuilder.cpp +++ b/xbmc/addons/AddonBuilder.cpp @@ -19,6 +19,7 @@ #include "addons/Scraper.h" #include "addons/Service.h" #include "addons/Skin.h" +#include "addons/TimeZoneResource.h" #include "addons/UISoundsResource.h" #include "addons/Webinterface.h" #include "games/addons/GameClient.h" @@ -104,6 +105,8 @@ AddonPtr CAddonBuilder::Generate(const AddonInfoPtr& info, TYPE type) return std::make_shared(info); case ADDON_RESOURCE_UISOUNDS: return std::make_shared(info); + case ADDON_RESOURCE_TIMEZONE: + return std::make_shared(info); case ADDON_REPOSITORY: return std::make_shared(info); case ADDON_CONTEXT_ITEM: diff --git a/xbmc/addons/CMakeLists.txt b/xbmc/addons/CMakeLists.txt index 404896399d..58579307ef 100644 --- a/xbmc/addons/CMakeLists.txt +++ b/xbmc/addons/CMakeLists.txt @@ -26,6 +26,7 @@ set(SOURCES Addon.cpp ScreenSaver.cpp Service.cpp Skin.cpp + TimeZoneResource.cpp UISoundsResource.cpp VFSEntry.cpp Visualization.cpp @@ -64,6 +65,7 @@ set(HEADERS Addon.h ScreenSaver.h Service.h Skin.h + TimeZoneResource.h UISoundsResource.h VFSEntry.h Visualization.h diff --git a/xbmc/addons/TimeZoneResource.cpp b/xbmc/addons/TimeZoneResource.cpp new file mode 100644 index 0000000000..e8cb31a46f --- /dev/null +++ b/xbmc/addons/TimeZoneResource.cpp @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2015-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ +#include "TimeZoneResource.h" + +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" + +#include + +namespace ADDON +{ + +bool CTimeZoneResource::IsAllowed(const std::string& file) const +{ + return true; +} + +bool CTimeZoneResource::IsInUse() const +{ + return true; +} + +void CTimeZoneResource::OnPostInstall(bool update, bool modal) +{ + date::reload_tzdb(); +} + +} // namespace ADDON diff --git a/xbmc/addons/TimeZoneResource.h b/xbmc/addons/TimeZoneResource.h new file mode 100644 index 0000000000..db471e0720 --- /dev/null +++ b/xbmc/addons/TimeZoneResource.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2015-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "addons/Resource.h" + +namespace ADDON +{ + +class CTimeZoneResource : public CResource +{ +public: + explicit CTimeZoneResource(const AddonInfoPtr& addonInfo) + : CResource(addonInfo, ADDON_RESOURCE_TIMEZONE) + { + } + bool IsAllowed(const std::string& file) const override; + bool IsInUse() const override; + void OnPostInstall(bool update, bool modal) override; +}; + +} // namespace ADDON diff --git a/xbmc/addons/addoninfo/AddonInfo.cpp b/xbmc/addons/addoninfo/AddonInfo.cpp index b0360d4166..c2378f5a09 100644 --- a/xbmc/addons/addoninfo/AddonInfo.cpp +++ b/xbmc/addons/addoninfo/AddonInfo.cpp @@ -64,6 +64,7 @@ static const TypeMapping types[] = {"xbmc.service", "", ADDON_SERVICE, 24018, "DefaultAddonService.png" }, {"kodi.resource.images", "", ADDON_RESOURCE_IMAGES, 24035, "DefaultAddonImages.png" }, {"kodi.resource.language", "", ADDON_RESOURCE_LANGUAGE, 24026, "DefaultAddonLanguage.png" }, + {"kodi.resource.timezone", "", ADDON_RESOURCE_TIMEZONE, 24026, "DefaultAddonTimeZone.png" }, {"kodi.resource.uisounds", "", ADDON_RESOURCE_UISOUNDS, 24006, "DefaultAddonUISounds.png" }, {"kodi.resource.games", "", ADDON_RESOURCE_GAMES, 35209, "DefaultAddonGame.png" }, {"kodi.resource.font", "", ADDON_RESOURCE_FONT, 13303, "DefaultAddonFont.png" }, diff --git a/xbmc/addons/addoninfo/AddonType.h b/xbmc/addons/addoninfo/AddonType.h index 08f79f9189..12d672d7cd 100644 --- a/xbmc/addons/addoninfo/AddonType.h +++ b/xbmc/addons/addoninfo/AddonType.h @@ -46,6 +46,7 @@ typedef enum ADDON_AUDIODECODER, ADDON_RESOURCE_IMAGES, ADDON_RESOURCE_LANGUAGE, + ADDON_RESOURCE_TIMEZONE, ADDON_RESOURCE_UISOUNDS, ADDON_RESOURCE_GAMES, ADDON_RESOURCE_FONT, -- 2.31.1 From 0f586aef328504fb81cabe9b1ea9b7cc77116aab Mon Sep 17 00:00:00 2001 From: Lukas Rusak Date: Mon, 10 Feb 2020 15:13:43 -0800 Subject: [PATCH 03/17] CDateTime: convert to use std::chrono --- xbmc/XBDateTime.cpp | 605 ++++++++++---------------- xbmc/XBDateTime.h | 31 +- xbmc/platform/posix/PosixTimezone.cpp | 3 - xbmc/pvr/guilib/PVRGUIActions.cpp | 5 +- 4 files changed, 248 insertions(+), 396 deletions(-) diff --git a/xbmc/XBDateTime.cpp b/xbmc/XBDateTime.cpp index c5bd507893..7e77f266ba 100644 --- a/xbmc/XBDateTime.cpp +++ b/xbmc/XBDateTime.cpp @@ -17,29 +17,17 @@ #include -#define SECONDS_PER_DAY 86400L -#define SECONDS_PER_HOUR 3600L -#define SECONDS_PER_MINUTE 60L -#define SECONDS_TO_FILETIME 10000000L +#define USE_OS_TZDB 0 +#define HAS_REMOTE_API 0 +#include +#include +#include -static const char *DAY_NAMES[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; static const char *MONTH_NAMES[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; -///////////////////////////////////////////////// -// -// CDateTimeSpan -// - -CDateTimeSpan::CDateTimeSpan() -{ - m_timeSpan.highDateTime = 0; - m_timeSpan.lowDateTime = 0; -} - CDateTimeSpan::CDateTimeSpan(const CDateTimeSpan& span) { - m_timeSpan.highDateTime = span.m_timeSpan.highDateTime; - m_timeSpan.lowDateTime = span.m_timeSpan.lowDateTime; + m_timeSpan = span.m_timeSpan; } CDateTimeSpan::CDateTimeSpan(int day, int hour, int minute, int second) @@ -49,7 +37,7 @@ CDateTimeSpan::CDateTimeSpan(int day, int hour, int minute, int second) bool CDateTimeSpan::operator >(const CDateTimeSpan& right) const { - return KODI::TIME::CompareFileTime(&m_timeSpan, &right.m_timeSpan) > 0; + return m_timeSpan > right.m_timeSpan; } bool CDateTimeSpan::operator >=(const CDateTimeSpan& right) const @@ -59,7 +47,7 @@ bool CDateTimeSpan::operator >=(const CDateTimeSpan& right) const bool CDateTimeSpan::operator <(const CDateTimeSpan& right) const { - return KODI::TIME::CompareFileTime(&m_timeSpan, &right.m_timeSpan) < 0; + return m_timeSpan < right.m_timeSpan; } bool CDateTimeSpan::operator <=(const CDateTimeSpan& right) const @@ -69,7 +57,7 @@ bool CDateTimeSpan::operator <=(const CDateTimeSpan& right) const bool CDateTimeSpan::operator ==(const CDateTimeSpan& right) const { - return KODI::TIME::CompareFileTime(&m_timeSpan, &right.m_timeSpan) == 0; + return m_timeSpan == right.m_timeSpan; } bool CDateTimeSpan::operator !=(const CDateTimeSpan& right) const @@ -81,15 +69,7 @@ CDateTimeSpan CDateTimeSpan::operator +(const CDateTimeSpan& right) const { CDateTimeSpan left(*this); - LARGE_INTEGER timeLeft; - left.ToLargeInt(timeLeft); - - LARGE_INTEGER timeRight; - right.ToLargeInt(timeRight); - - timeLeft.QuadPart+=timeRight.QuadPart; - - left.FromLargeInt(timeLeft); + left.m_timeSpan += right.m_timeSpan; return left; } @@ -98,122 +78,75 @@ CDateTimeSpan CDateTimeSpan::operator -(const CDateTimeSpan& right) const { CDateTimeSpan left(*this); - LARGE_INTEGER timeLeft; - left.ToLargeInt(timeLeft); - - LARGE_INTEGER timeRight; - right.ToLargeInt(timeRight); - - timeLeft.QuadPart-=timeRight.QuadPart; - - left.FromLargeInt(timeLeft); + left.m_timeSpan -= right.m_timeSpan; return left; } const CDateTimeSpan& CDateTimeSpan::operator +=(const CDateTimeSpan& right) { - LARGE_INTEGER timeThis; - ToLargeInt(timeThis); - - LARGE_INTEGER timeRight; - right.ToLargeInt(timeRight); - - timeThis.QuadPart+=timeRight.QuadPart; - - FromLargeInt(timeThis); + m_timeSpan += right.m_timeSpan; return *this; } const CDateTimeSpan& CDateTimeSpan::operator -=(const CDateTimeSpan& right) { - LARGE_INTEGER timeThis; - ToLargeInt(timeThis); - - LARGE_INTEGER timeRight; - right.ToLargeInt(timeRight); - - timeThis.QuadPart-=timeRight.QuadPart; - - FromLargeInt(timeThis); + m_timeSpan -= right.m_timeSpan; return *this; } -void CDateTimeSpan::ToLargeInt(LARGE_INTEGER& time) const -{ - time.u.HighPart = m_timeSpan.highDateTime; - time.u.LowPart = m_timeSpan.lowDateTime; -} - -void CDateTimeSpan::FromLargeInt(const LARGE_INTEGER& time) -{ - m_timeSpan.highDateTime = time.u.HighPart; - m_timeSpan.lowDateTime = time.u.LowPart; -} - void CDateTimeSpan::SetDateTimeSpan(int day, int hour, int minute, int second) { - LARGE_INTEGER time; - ToLargeInt(time); - - time.QuadPart= static_cast(day) *SECONDS_PER_DAY*SECONDS_TO_FILETIME; - time.QuadPart+= static_cast(hour) *SECONDS_PER_HOUR*SECONDS_TO_FILETIME; - time.QuadPart+= static_cast(minute) *SECONDS_PER_MINUTE*SECONDS_TO_FILETIME; - time.QuadPart+= static_cast(second) *SECONDS_TO_FILETIME; - - FromLargeInt(time); + m_timeSpan = std::chrono::duration_cast(date::days(day)) + + std::chrono::duration_cast(std::chrono::hours(hour)) + + std::chrono::duration_cast(std::chrono::minutes(minute)) + + std::chrono::duration_cast(std::chrono::seconds(second)); } void CDateTimeSpan::SetFromTimeString(const std::string& time) // hh:mm { if (time.size() >= 5 && time[2] == ':') { - int hour = atoi(time.substr(0, 2).c_str()); - int minutes = atoi(time.substr(3, 2).c_str()); - SetDateTimeSpan(0,hour,minutes,0); + int hour = std::stoi(time.substr(0, 2)); + int minutes = std::stoi(time.substr(3, 2)); + SetDateTimeSpan(0, hour, minutes, 0); } } int CDateTimeSpan::GetDays() const { - LARGE_INTEGER time; - ToLargeInt(time); - - return (int)(time.QuadPart/SECONDS_TO_FILETIME)/SECONDS_PER_DAY; + return date::floor(m_timeSpan).count(); } int CDateTimeSpan::GetHours() const { - LARGE_INTEGER time; - ToLargeInt(time); + auto time = date::floor(m_timeSpan); + auto dp = date::make_time(m_timeSpan - time); - return (int)((time.QuadPart/SECONDS_TO_FILETIME)%SECONDS_PER_DAY)/SECONDS_PER_HOUR; + return dp.hours().count(); } int CDateTimeSpan::GetMinutes() const { - LARGE_INTEGER time; - ToLargeInt(time); + auto time = date::floor(m_timeSpan); + auto dp = date::make_time(m_timeSpan - time); - return (int)((time.QuadPart/SECONDS_TO_FILETIME%SECONDS_PER_DAY)%SECONDS_PER_HOUR)/SECONDS_PER_MINUTE; + return dp.minutes().count(); } int CDateTimeSpan::GetSeconds() const { - LARGE_INTEGER time; - ToLargeInt(time); + auto time = date::floor(m_timeSpan); + auto dp = date::make_time(m_timeSpan - time); - return (int)(((time.QuadPart/SECONDS_TO_FILETIME%SECONDS_PER_DAY)%SECONDS_PER_HOUR)%SECONDS_PER_MINUTE)%SECONDS_PER_MINUTE; + return dp.seconds().count(); } int CDateTimeSpan::GetSecondsTotal() const { - LARGE_INTEGER time; - ToLargeInt(time); - - return (int)(time.QuadPart/SECONDS_TO_FILETIME); + return std::chrono::duration_cast(m_timeSpan).count(); } void CDateTimeSpan::SetFromPeriod(const std::string &period) @@ -233,42 +166,50 @@ void CDateTimeSpan::SetFromPeriod(const std::string &period) SetDateTimeSpan(days, 0, 0, 0); } -///////////////////////////////////////////////// -// -// CDateTime -// - CDateTime::CDateTime() { Reset(); } -CDateTime::CDateTime(const KODI::TIME::SystemTime& time) +CDateTime::CDateTime(const KODI::TIME::SystemTime& systemTime) { - // we store internally as a FileTime - m_state = ToFileTime(time, m_time) ? valid : invalid; + KODI::TIME::FileTime fileTime; + m_state = ToFileTime(systemTime, fileTime) ? valid : invalid; + + time_t time; + KODI::TIME::FileTimeToTimeT(&fileTime, &time); + m_time = std::chrono::system_clock::from_time_t(time); } -CDateTime::CDateTime(const KODI::TIME::FileTime& time) +CDateTime::CDateTime(const KODI::TIME::FileTime& fileTime) { - m_time=time; - SetValid(true); + time_t time; + KODI::TIME::FileTimeToTimeT(&fileTime, &time); + m_time = std::chrono::system_clock::from_time_t(time); } CDateTime::CDateTime(const CDateTime& time) { - m_time=time.m_time; - m_state=time.m_state; + m_time = time.m_time; + m_state = time.m_state; } CDateTime::CDateTime(const time_t& time) { - m_state = ToFileTime(time, m_time) ? valid : invalid; + m_time = std::chrono::system_clock::from_time_t(time); + SetValid(true); +} + +CDateTime::CDateTime(const std::chrono::system_clock::time_point& time) +{ + m_time = time; + SetValid(true); } CDateTime::CDateTime(const tm& time) { - m_state = ToFileTime(time, m_time) ? valid : invalid; + m_time = std::chrono::system_clock::from_time_t(std::mktime(const_cast(&time))); + SetValid(true); } CDateTime::CDateTime(int year, int month, int day, int hour, int minute, int second) @@ -278,52 +219,66 @@ CDateTime::CDateTime(int year, int month, int day, int hour, int minute, int sec CDateTime CDateTime::GetCurrentDateTime() { - // get the current time - KODI::TIME::SystemTime time; - KODI::TIME::GetLocalTime(&time); + auto zone = date::make_zoned(date::current_zone(), std::chrono::system_clock::now()); - return CDateTime(time); + return CDateTime( + std::chrono::duration_cast(zone.get_local_time().time_since_epoch()) + .count()); } CDateTime CDateTime::GetUTCDateTime() { - CDateTime time(GetCurrentDateTime()); - time += GetTimezoneBias(); - return time; + return CDateTime(std::chrono::system_clock::now()); } const CDateTime& CDateTime::operator=(const KODI::TIME::SystemTime& right) { - m_state = ToFileTime(right, m_time) ? valid : invalid; + KODI::TIME::FileTime fileTime; + m_state = ToFileTime(right, fileTime) ? valid : invalid; + + time_t time; + KODI::TIME::FileTimeToTimeT(&fileTime, &time); + m_time = std::chrono::system_clock::from_time_t(time); return *this; } const CDateTime& CDateTime::operator=(const KODI::TIME::FileTime& right) { - m_time=right; - SetValid(true); + time_t time; + KODI::TIME::FileTimeToTimeT(&right, &time); + m_time = std::chrono::system_clock::from_time_t(time); return *this; } const CDateTime& CDateTime::operator =(const time_t& right) { - m_state = ToFileTime(right, m_time) ? valid : invalid; + m_time = std::chrono::system_clock::from_time_t(right); + SetValid(true); return *this; } const CDateTime& CDateTime::operator =(const tm& right) { - m_state = ToFileTime(right, m_time) ? valid : invalid; + m_time = std::chrono::system_clock::from_time_t(std::mktime(const_cast(&right))); + SetValid(true); + + return *this; +} + +const CDateTime& CDateTime::operator=(const std::chrono::system_clock::time_point& right) +{ + m_time = right; + SetValid(true); return *this; } bool CDateTime::operator >(const CDateTime& right) const { - return operator >(right.m_time); + return m_time > right.m_time; } bool CDateTime::operator >=(const CDateTime& right) const @@ -333,7 +288,7 @@ bool CDateTime::operator >=(const CDateTime& right) const bool CDateTime::operator <(const CDateTime& right) const { - return operator <(right.m_time); + return m_time < right.m_time; } bool CDateTime::operator <=(const CDateTime& right) const @@ -343,7 +298,7 @@ bool CDateTime::operator <=(const CDateTime& right) const bool CDateTime::operator ==(const CDateTime& right) const { - return operator ==(right.m_time); + return m_time == right.m_time; } bool CDateTime::operator !=(const CDateTime& right) const @@ -353,7 +308,10 @@ bool CDateTime::operator !=(const CDateTime& right) const bool CDateTime::operator>(const KODI::TIME::FileTime& right) const { - return KODI::TIME::CompareFileTime(&m_time, &right) > 0; + time_t time; + KODI::TIME::FileTimeToTimeT(&right, &time); + + return m_time > std::chrono::system_clock::from_time_t(time); } bool CDateTime::operator>=(const KODI::TIME::FileTime& right) const @@ -363,7 +321,10 @@ bool CDateTime::operator>=(const KODI::TIME::FileTime& right) const bool CDateTime::operator<(const KODI::TIME::FileTime& right) const { - return KODI::TIME::CompareFileTime(&m_time, &right) < 0; + time_t time; + KODI::TIME::FileTimeToTimeT(&right, &time); + + return m_time < std::chrono::system_clock::from_time_t(time); } bool CDateTime::operator<=(const KODI::TIME::FileTime& right) const @@ -373,7 +334,10 @@ bool CDateTime::operator<=(const KODI::TIME::FileTime& right) const bool CDateTime::operator==(const KODI::TIME::FileTime& right) const { - return KODI::TIME::CompareFileTime(&m_time, &right) == 0; + time_t time; + KODI::TIME::FileTimeToTimeT(&right, &time); + + return m_time == std::chrono::system_clock::from_time_t(time); } bool CDateTime::operator!=(const KODI::TIME::FileTime& right) const @@ -422,10 +386,7 @@ bool CDateTime::operator!=(const KODI::TIME::SystemTime& right) const bool CDateTime::operator >(const time_t& right) const { - KODI::TIME::FileTime time; - ToFileTime(right, time); - - return operator >(time); + return m_time > std::chrono::system_clock::from_time_t(right); } bool CDateTime::operator >=(const time_t& right) const @@ -435,10 +396,7 @@ bool CDateTime::operator >=(const time_t& right) const bool CDateTime::operator <(const time_t& right) const { - KODI::TIME::FileTime time; - ToFileTime(right, time); - - return operator <(time); + return m_time < std::chrono::system_clock::from_time_t(right); } bool CDateTime::operator <=(const time_t& right) const @@ -448,10 +406,7 @@ bool CDateTime::operator <=(const time_t& right) const bool CDateTime::operator ==(const time_t& right) const { - KODI::TIME::FileTime time; - ToFileTime(right, time); - - return operator ==(time); + return m_time == std::chrono::system_clock::from_time_t(right); } bool CDateTime::operator !=(const time_t& right) const @@ -461,10 +416,7 @@ bool CDateTime::operator !=(const time_t& right) const bool CDateTime::operator >(const tm& right) const { - KODI::TIME::FileTime time; - ToFileTime(right, time); - - return operator >(time); + return m_time > std::chrono::system_clock::from_time_t(std::mktime(const_cast(&right))); } bool CDateTime::operator >=(const tm& right) const @@ -474,10 +426,7 @@ bool CDateTime::operator >=(const tm& right) const bool CDateTime::operator <(const tm& right) const { - KODI::TIME::FileTime time; - ToFileTime(right, time); - - return operator <(time); + return m_time < std::chrono::system_clock::from_time_t(std::mktime(const_cast(&right))); } bool CDateTime::operator <=(const tm& right) const @@ -487,10 +436,7 @@ bool CDateTime::operator <=(const tm& right) const bool CDateTime::operator ==(const tm& right) const { - KODI::TIME::FileTime time; - ToFileTime(right, time); - - return operator ==(time); + return m_time == std::chrono::system_clock::from_time_t(std::mktime(const_cast(&right))); } bool CDateTime::operator !=(const tm& right) const @@ -498,66 +444,64 @@ bool CDateTime::operator !=(const tm& right) const return !operator ==(right); } -CDateTime CDateTime::operator +(const CDateTimeSpan& right) const +bool CDateTime::operator>(const std::chrono::system_clock::time_point& right) const { - CDateTime left(*this); + return m_time > right; +} - LARGE_INTEGER timeLeft; - left.ToLargeInt(timeLeft); +bool CDateTime::operator>=(const std::chrono::system_clock::time_point& right) const +{ + return operator>(right) || operator==(right); +} - LARGE_INTEGER timeRight; - right.ToLargeInt(timeRight); +bool CDateTime::operator<(const std::chrono::system_clock::time_point& right) const +{ + return m_time < right; +} - timeLeft.QuadPart+=timeRight.QuadPart; +bool CDateTime::operator<=(const std::chrono::system_clock::time_point& right) const +{ + return operator<(right) || operator==(right); +} - left.FromLargeInt(timeLeft); +bool CDateTime::operator==(const std::chrono::system_clock::time_point& right) const +{ + return m_time == right; +} - return left; +bool CDateTime::operator!=(const std::chrono::system_clock::time_point& right) const +{ + return !operator==(right); } -CDateTime CDateTime::operator -(const CDateTimeSpan& right) const +CDateTime CDateTime::operator +(const CDateTimeSpan& right) const { CDateTime left(*this); - LARGE_INTEGER timeLeft; - left.ToLargeInt(timeLeft); + left.m_time + right.m_timeSpan; - LARGE_INTEGER timeRight; - right.ToLargeInt(timeRight); + return left; +} - timeLeft.QuadPart-=timeRight.QuadPart; +CDateTime CDateTime::operator -(const CDateTimeSpan& right) const +{ + CDateTime left(*this); - left.FromLargeInt(timeLeft); + left.m_time - right.m_timeSpan; return left; } const CDateTime& CDateTime::operator +=(const CDateTimeSpan& right) { - LARGE_INTEGER timeThis; - ToLargeInt(timeThis); - - LARGE_INTEGER timeRight; - right.ToLargeInt(timeRight); - - timeThis.QuadPart+=timeRight.QuadPart; - - FromLargeInt(timeThis); + m_time += right.m_timeSpan; return *this; } const CDateTime& CDateTime::operator -=(const CDateTimeSpan& right) { - LARGE_INTEGER timeThis; - ToLargeInt(timeThis); - - LARGE_INTEGER timeRight; - right.ToLargeInt(timeRight); - - timeThis.QuadPart-=timeRight.QuadPart; - - FromLargeInt(timeThis); + m_time -= right.m_timeSpan; return *this; } @@ -566,25 +510,16 @@ CDateTimeSpan CDateTime::operator -(const CDateTime& right) const { CDateTimeSpan left; - LARGE_INTEGER timeLeft; - left.ToLargeInt(timeLeft); - - LARGE_INTEGER timeThis; - ToLargeInt(timeThis); - - LARGE_INTEGER timeRight; - right.ToLargeInt(timeRight); - - timeLeft.QuadPart=timeThis.QuadPart-timeRight.QuadPart; - - left.FromLargeInt(timeLeft); - + left.m_timeSpan = std::chrono::duration_cast(m_time - right.m_time); return left; } CDateTime::operator KODI::TIME::FileTime() const { - return m_time; + KODI::TIME::FileTime fileTime; + time_t time = std::chrono::system_clock::to_time_t(m_time); + KODI::TIME::TimeTToFileTime(time, &fileTime); + return fileTime; } void CDateTime::Archive(CArchive& ar) @@ -609,25 +544,38 @@ void CDateTime::Archive(CArchive& ar) { KODI::TIME::SystemTime st; ar>>st; - ToFileTime(st, m_time); + ToTimePoint(st, m_time); } } } void CDateTime::Reset() { - SetDateTime(1601, 1, 1, 0, 0, 0); + m_time = {}; SetValid(false); } void CDateTime::SetValid(bool yesNo) { - m_state=yesNo ? valid : invalid; + m_state = yesNo ? valid : invalid; } bool CDateTime::IsValid() const { - return m_state==valid; + return m_state == valid; +} + +bool CDateTime::ToTimePoint(const KODI::TIME::SystemTime& systemTime, + std::chrono::system_clock::time_point& timePoint) const +{ + KODI::TIME::FileTime fileTime; + KODI::TIME::SystemTimeToFileTime(&systemTime, &fileTime); + + time_t time; + KODI::TIME::FileTimeToTimeT(&fileTime, &time); + + timePoint = std::chrono::system_clock::from_time_t(time); + return true; } bool CDateTime::ToFileTime(const KODI::TIME::SystemTime& time, KODI::TIME::FileTime& fileTime) const @@ -648,33 +596,6 @@ bool CDateTime::ToFileTime(const time_t& time, KODI::TIME::FileTime& fileTime) c return true; } -bool CDateTime::ToFileTime(const tm& time, KODI::TIME::FileTime& fileTime) const -{ - KODI::TIME::SystemTime st = {0}; - - st.year = time.tm_year + 1900; - st.month = time.tm_mon + 1; - st.dayOfWeek = time.tm_wday; - st.day = time.tm_mday; - st.hour = time.tm_hour; - st.minute = time.tm_min; - st.second = time.tm_sec; - - return SystemTimeToFileTime(&st, &fileTime) == 1; -} - -void CDateTime::ToLargeInt(LARGE_INTEGER& time) const -{ - time.u.HighPart = m_time.highDateTime; - time.u.LowPart = m_time.lowDateTime; -} - -void CDateTime::FromLargeInt(const LARGE_INTEGER& time) -{ - m_time.highDateTime = time.u.HighPart; - m_time.lowDateTime = time.u.LowPart; -} - bool CDateTime::SetFromDateString(const std::string &date) { //! @todo STRING_CLEANUP @@ -716,80 +637,83 @@ bool CDateTime::SetFromDateString(const std::string &date) int CDateTime::GetDay() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); + auto dp = date::floor(m_time); + auto ymd = date::year_month_day{dp}; - return st.day; + return static_cast(ymd.day()); } int CDateTime::GetMonth() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); + auto dp = date::floor(m_time); + auto ymd = date::year_month_day{dp}; - return st.month; + return static_cast(ymd.month()); } int CDateTime::GetYear() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); + auto dp = date::floor(m_time); + auto ymd = date::year_month_day{dp}; - return st.year; + return static_cast(ymd.year()); } int CDateTime::GetHour() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); + auto dp = date::floor(m_time); + auto time = date::make_time(m_time - dp); - return st.hour; + return time.hours().count(); } int CDateTime::GetMinute() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); + auto dp = date::floor(m_time); + auto time = date::make_time(m_time - dp); - return st.minute; + return time.minutes().count(); } int CDateTime::GetSecond() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); + auto dp = date::floor(m_time); + auto time = date::make_time(m_time - dp); - return st.second; + return time.seconds().count(); } int CDateTime::GetDayOfWeek() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); + auto dp = date::floor(m_time); + auto yww = iso_week::year_weeknum_weekday{dp}; - return st.dayOfWeek; + return static_cast(yww.weekday()); } int CDateTime::GetMinuteOfDay() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); - return st.hour * 60 + st.minute; + auto dp = date::floor(m_time); + ; + auto time = date::make_time(m_time - dp); + + return time.hours().count() * 60 + time.minutes().count(); } bool CDateTime::SetDateTime(int year, int month, int day, int hour, int minute, int second) { - KODI::TIME::SystemTime st = {0}; + auto ymd = date::year(year) / month / day; + if (!ymd.ok()) + { + SetValid(false); + return false; + } - st.year = year; - st.month = month; - st.day = day; - st.hour = hour; - st.minute = minute; - st.second = second; + m_time = date::sys_days(ymd) + std::chrono::hours(hour) + std::chrono::minutes(minute) + + std::chrono::seconds(second); - m_state = ToFileTime(st, m_time) ? valid : invalid; - return m_state == valid; + SetValid(true); + return true; } bool CDateTime::SetDate(int year, int month, int day) @@ -799,117 +723,75 @@ bool CDateTime::SetDate(int year, int month, int day) bool CDateTime::SetTime(int hour, int minute, int second) { - // 01.01.1601 00:00:00 is 0 as filetime - return SetDateTime(1601, 1, 1, hour, minute, second); + m_time = date::sys_seconds(std::chrono::seconds(0)) + std::chrono::hours(hour) + + std::chrono::minutes(minute) + std::chrono::seconds(second); + + SetValid(true); + return true; } -void CDateTime::GetAsSystemTime(KODI::TIME::SystemTime& time) const +void CDateTime::GetAsSystemTime(KODI::TIME::SystemTime& systemTime) const { - FileTimeToSystemTime(&m_time, &time); + const time_t time = std::chrono::system_clock::to_time_t(m_time); + KODI::TIME::FileTime fileTime; + ToFileTime(time, fileTime); + KODI::TIME::FileTimeToSystemTime(&fileTime, &systemTime); } -#define UNIX_BASE_TIME 116444736000000000LL /* nanoseconds since epoch */ void CDateTime::GetAsTime(time_t& time) const { - long long ll = (static_cast(m_time.highDateTime) << 32) + m_time.lowDateTime; - time=(time_t)((ll - UNIX_BASE_TIME) / 10000000); + time = std::chrono::system_clock::to_time_t(m_time); } void CDateTime::GetAsTm(tm& time) const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); - - time.tm_year = st.year - 1900; - time.tm_mon = st.month - 1; - time.tm_wday = st.dayOfWeek; - time.tm_mday = st.day; - time.tm_hour = st.hour; - time.tm_min = st.minute; - time.tm_sec = st.second; + auto t = std::chrono::system_clock::to_time_t(m_time); - mktime(&time); + localtime_r(&t, &time); } -void CDateTime::GetAsTimeStamp(KODI::TIME::FileTime& time) const +std::chrono::system_clock::time_point CDateTime::GetAsTimePoint() const { - KODI::TIME::LocalFileTimeToFileTime(&m_time, &time); + return m_time; } + +// void CDateTime::GetAsTimeStamp(KODI::TIME::FileTime& fileTime) const +// { +// time_t time = std::chrono::system_clock::to_time_t(m_time); +// KODI::TIME::TimeTToFileTime(time, &fileTime); +// } + std::string CDateTime::GetAsDBDate() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); - - return StringUtils::Format("%04i-%02i-%02i", st.year, st.month, st.day); + return date::format("%F", m_time); } std::string CDateTime::GetAsDBTime() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); - - return StringUtils::Format("%02i:%02i:%02i", st.hour, st.minute, st.second); + auto sp = date::floor(m_time); + return date::format("%T", sp); } std::string CDateTime::GetAsDBDateTime() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); + auto sp = date::floor(m_time); - return StringUtils::Format("%04i-%02i-%02i %02i:%02i:%02i", st.year, st.month, st.day, st.hour, - st.minute, st.second); + return date::format("%F %T", sp); } std::string CDateTime::GetAsSaveString() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); + auto sp = date::floor(m_time); - return StringUtils::Format("%04i%02i%02i_%02i%02i%02i", st.year, st.month, st.day, st.hour, - st.minute, st.second); + return date::format("%Y%m%d_%H%M%S", sp); } bool CDateTime::SetFromUTCDateTime(const CDateTime &dateTime) { - CDateTime tmp(dateTime); - tmp -= GetTimezoneBias(); - - m_time = tmp.m_time; - m_state = tmp.m_state; - return m_state == valid; -} - -static bool bGotTimezoneBias = false; - -void CDateTime::ResetTimezoneBias(void) -{ - bGotTimezoneBias = false; -} - -CDateTimeSpan CDateTime::GetTimezoneBias(void) -{ - static CDateTimeSpan timezoneBias; - - if (!bGotTimezoneBias) - { - bGotTimezoneBias = true; - KODI::TIME::TimeZoneInformation tz; - switch (KODI::TIME::GetTimeZoneInformation(&tz)) - { - case KODI::TIME::KODI_TIME_ZONE_ID_DAYLIGHT: - timezoneBias = CDateTimeSpan(0, 0, tz.bias + tz.daylightBias, 0); - break; - case KODI::TIME::KODI_TIME_ZONE_ID_STANDARD: - timezoneBias = CDateTimeSpan(0, 0, tz.bias + tz.standardBias, 0); - break; - case KODI::TIME::KODI_TIME_ZONE_ID_UNKNOWN: - timezoneBias = CDateTimeSpan(0, 0, tz.bias, 0); - break; - } - } - - return timezoneBias; + m_time = dateTime.m_time; + m_state = valid; + return true; } bool CDateTime::SetFromUTCDateTime(const time_t &dateTime) @@ -1511,56 +1393,31 @@ std::string CDateTime::GetAsLocalizedTime(TIME_FORMAT format, bool withSeconds / CDateTime CDateTime::GetAsUTCDateTime() const { CDateTime time(m_time); - time += GetTimezoneBias(); return time; } std::string CDateTime::GetAsRFC1123DateTime() const { - CDateTime time(GetAsUTCDateTime()); - - int weekDay = time.GetDayOfWeek(); - if (weekDay < 0) - weekDay = 0; - else if (weekDay > 6) - weekDay = 6; - if (weekDay != time.GetDayOfWeek()) - CLog::Log(LOGWARNING, "Invalid day of week %d in %s", time.GetDayOfWeek(), time.GetAsDBDateTime().c_str()); + auto time = date::floor(m_time); - int month = time.GetMonth(); - if (month < 1) - month = 1; - else if (month > 12) - month = 12; - if (month != time.GetMonth()) - CLog::Log(LOGWARNING, "Invalid month %d in %s", time.GetMonth(), time.GetAsDBDateTime().c_str()); - - return StringUtils::Format("%s, %02i %s %04i %02i:%02i:%02i GMT", DAY_NAMES[weekDay], time.GetDay(), MONTH_NAMES[month - 1], time.GetYear(), time.GetHour(), time.GetMinute(), time.GetSecond()); + return date::format("%a, %d %b %Y %T GMT", time); } std::string CDateTime::GetAsW3CDate() const { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); - - return StringUtils::Format("%04i-%02i-%02i", st.year, st.month, st.day); + return GetAsDBDate(); } std::string CDateTime::GetAsW3CDateTime(bool asUtc /* = false */) const { - CDateTime w3cDate = *this; - if (asUtc) - w3cDate = GetAsUTCDateTime(); - KODI::TIME::SystemTime st; - w3cDate.GetAsSystemTime(st); + auto time = date::floor(m_time); - std::string result = StringUtils::Format("%04i-%02i-%02iT%02i:%02i:%02i", st.year, st.month, - st.day, st.hour, st.minute, st.second); if (asUtc) - return result + "Z"; + return date::format("%FT%TZ", time); + + auto zt = date::make_zoned(date::current_zone(), time); - CDateTimeSpan bias = GetTimezoneBias(); - return result + StringUtils::Format("%c%02i:%02i", (bias.GetSecondsTotal() >= 0 ? '+' : '-'), abs(bias.GetHours()), abs(bias.GetMinutes())).c_str(); + return date::format("%FT%T%Ez", zt); } int CDateTime::MonthStringToMonthNum(const std::string& month) diff --git a/xbmc/XBDateTime.h b/xbmc/XBDateTime.h index 491db5a4eb..1e686a679c 100644 --- a/xbmc/XBDateTime.h +++ b/xbmc/XBDateTime.h @@ -11,6 +11,7 @@ #include "utils/IArchivable.h" #include "utils/XTimeUtils.h" +#include #include #include "PlatformDefs.h" @@ -78,7 +79,7 @@ class CDateTime; class CDateTimeSpan { public: - CDateTimeSpan(); + CDateTimeSpan() = default; CDateTimeSpan(const CDateTimeSpan& span); CDateTimeSpan(int day, int hour, int minute, int second); @@ -106,11 +107,7 @@ public: int GetSecondsTotal() const; private: - void ToLargeInt(LARGE_INTEGER& time) const; - void FromLargeInt(const LARGE_INTEGER& time); - -private: - KODI::TIME::FileTime m_timeSpan; + std::chrono::duration m_timeSpan{0}; friend class CDateTime; }; @@ -125,6 +122,7 @@ public: explicit CDateTime(const KODI::TIME::FileTime& time); explicit CDateTime(const time_t& time); explicit CDateTime(const tm& time); + explicit CDateTime(const std::chrono::system_clock::time_point& time); CDateTime(int year, int month, int day, int hour, int minute, int second); static CDateTime GetCurrentDateTime(); @@ -145,6 +143,7 @@ public: const CDateTime& operator=(const KODI::TIME::FileTime& right); const CDateTime& operator =(const time_t& right); const CDateTime& operator =(const tm& right); + const CDateTime& operator=(const std::chrono::system_clock::time_point& right); bool operator >(const CDateTime& right) const; bool operator >=(const CDateTime& right) const; @@ -181,6 +180,13 @@ public: bool operator ==(const tm& right) const; bool operator !=(const tm& right) const; + bool operator>(const std::chrono::system_clock::time_point& right) const; + bool operator>=(const std::chrono::system_clock::time_point& right) const; + bool operator<(const std::chrono::system_clock::time_point& right) const; + bool operator<=(const std::chrono::system_clock::time_point& right) const; + bool operator==(const std::chrono::system_clock::time_point& right) const; + bool operator!=(const std::chrono::system_clock::time_point& right) const; + CDateTime operator +(const CDateTimeSpan& right) const; CDateTime operator -(const CDateTimeSpan& right) const; @@ -225,7 +231,7 @@ public: void GetAsSystemTime(KODI::TIME::SystemTime& time) const; void GetAsTime(time_t& time) const; void GetAsTm(tm& time) const; - void GetAsTimeStamp(KODI::TIME::FileTime& time) const; + std::chrono::system_clock::time_point GetAsTimePoint() const; CDateTime GetAsUTCDateTime() const; std::string GetAsSaveString() const; @@ -244,19 +250,14 @@ public: void SetValid(bool yesNo); bool IsValid() const; - static void ResetTimezoneBias(void); - static CDateTimeSpan GetTimezoneBias(void); - private: + bool ToTimePoint(const KODI::TIME::SystemTime& time, + std::chrono::system_clock::time_point& timePoint) const; bool ToFileTime(const KODI::TIME::SystemTime& time, KODI::TIME::FileTime& fileTime) const; bool ToFileTime(const time_t& time, KODI::TIME::FileTime& fileTime) const; - bool ToFileTime(const tm& time, KODI::TIME::FileTime& fileTime) const; - - void ToLargeInt(LARGE_INTEGER& time) const; - void FromLargeInt(const LARGE_INTEGER& time); private: - KODI::TIME::FileTime m_time; + std::chrono::system_clock::time_point m_time; typedef enum _STATE { diff --git a/xbmc/platform/posix/PosixTimezone.cpp b/xbmc/platform/posix/PosixTimezone.cpp index 60ae5b9b2f..fbb705e2b4 100644 --- a/xbmc/platform/posix/PosixTimezone.cpp +++ b/xbmc/platform/posix/PosixTimezone.cpp @@ -144,8 +144,6 @@ void CPosixTimezone::OnSettingChanged(const std::shared_ptr& set if (settingId == CSettings::SETTING_LOCALE_TIMEZONE) { SetTimezone(std::static_pointer_cast(setting)->GetValue()); - - CDateTime::ResetTimezoneBias(); } else if (settingId == CSettings::SETTING_LOCALE_TIMEZONECOUNTRY) { @@ -158,7 +156,6 @@ void CPosixTimezone::OnSettingChanged(const std::shared_ptr& set void CPosixTimezone::OnSettingsLoaded() { SetTimezone(CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_TIMEZONE)); - CDateTime::ResetTimezoneBias(); } std::vector CPosixTimezone::GetCounties() diff --git a/xbmc/pvr/guilib/PVRGUIActions.cpp b/xbmc/pvr/guilib/PVRGUIActions.cpp index 69f181c907..38e31f459a 100644 --- a/xbmc/pvr/guilib/PVRGUIActions.cpp +++ b/xbmc/pvr/guilib/PVRGUIActions.cpp @@ -1722,10 +1722,7 @@ namespace PVR return false; } - CDateTime::ResetTimezoneBias(); - - CLog::LogFC(LOGDEBUG, LOGPVR, "PVR clearing {} database", - bResetEPGOnly ? "EPG" : "PVR and EPG"); + CLog::LogFC(LOGDEBUG, LOGPVR, "PVR clearing %s database", bResetEPGOnly ? "EPG" : "PVR and EPG"); pDlgProgress->SetHeading(CVariant{313}); // "Cleaning database" pDlgProgress->SetLine(0, CVariant{g_localizeStrings.Get(19187)}); // "Clearing all related data." -- 2.31.1 From e52da9238a0bc7f3ed490900d727a9576182a44d Mon Sep 17 00:00:00 2001 From: Lukas Rusak Date: Mon, 17 Feb 2020 22:40:56 -0800 Subject: [PATCH 04/17] [test] fix TestDateTime to work with std::chrono --- xbmc/test/TestDateTime.cpp | 89 ++++++++------------------------------ 1 file changed, 17 insertions(+), 72 deletions(-) diff --git a/xbmc/test/TestDateTime.cpp b/xbmc/test/TestDateTime.cpp index 3abc3c43e4..c55c5fe3ea 100644 --- a/xbmc/test/TestDateTime.cpp +++ b/xbmc/test/TestDateTime.cpp @@ -13,6 +13,10 @@ #include #include +#define USE_OS_TZDB 0 +#define HAS_REMOTE_API 0 +#include +#include #include class TestDateTime : public testing::Test @@ -32,24 +36,6 @@ TEST_F(TestDateTime, DateTimeOperators) EXPECT_FALSE(dateTime1 == dateTime2); } -TEST_F(TestDateTime, FileTimeOperators) -{ - CDateTime dateTime1(1991, 5, 14, 12, 34, 56); - CDateTime dateTime2(1991, 5, 14, 12, 34, 57); - - KODI::TIME::FileTime fileTime1; - KODI::TIME::FileTime fileTime2; - - dateTime1.GetAsTimeStamp(fileTime1); - dateTime2.GetAsTimeStamp(fileTime2); - - CDateTime dateTime3(fileTime1); - - EXPECT_TRUE(dateTime3 < fileTime2); - EXPECT_FALSE(dateTime3 > fileTime2); - EXPECT_FALSE(dateTime3 == fileTime2); -} - TEST_F(TestDateTime, SystemTimeOperators) { CDateTime dateTime1(1991, 5, 14, 12, 34, 56); @@ -130,7 +116,7 @@ TEST_F(TestDateTime, MonthStringToMonthNum) } // this method is broken as SetFromDBDate() will return true -TEST_F(TestDateTime, DISABLED_SetFromDateString) +TEST_F(TestDateTime, SetFromDateString) { CDateTime dateTime; EXPECT_TRUE(dateTime.SetFromDateString("tuesday may 14, 1991")); @@ -159,13 +145,7 @@ TEST_F(TestDateTime, SetFromDBDate) EXPECT_EQ(dateTime.GetDay(), 2); } -// disabled on osx and freebsd as their mktime functions -// don't work for dates before 1900 -#if defined(TARGET_DARWIN_OSX) || defined(TARGET_FREEBSD) -TEST_F(TestDateTime, DISABLED_SetFromDBTime) -#else TEST_F(TestDateTime, SetFromDBTime) -#endif { CDateTime dateTime1; EXPECT_TRUE(dateTime1.SetFromDBTime("12:34")); @@ -206,10 +186,8 @@ TEST_F(TestDateTime, SetFromW3CDate) TEST_F(TestDateTime, SetFromW3CDateTime) { - CDateTimeSpan bias = CDateTime::GetTimezoneBias(); CDateTime dateTime; dateTime.SetFromDBDateTime("1994-11-05 13:15:30"); - dateTime += bias; std::string dateTimeStr = dateTime.GetAsDBDate() + "T" + dateTime.GetAsDBTime() + "Z"; CDateTime dateTime1; @@ -233,11 +211,8 @@ TEST_F(TestDateTime, SetFromW3CDateTime) TEST_F(TestDateTime, SetFromUTCDateTime) { - CDateTimeSpan bias = CDateTime::GetTimezoneBias(); - CDateTime dateTime1; dateTime1.SetFromDBDateTime("1991-05-14 12:34:56"); - dateTime1 += bias; CDateTime dateTime2; EXPECT_TRUE(dateTime2.SetFromUTCDateTime(dateTime1)); @@ -248,7 +223,7 @@ TEST_F(TestDateTime, SetFromUTCDateTime) EXPECT_EQ(dateTime2.GetMinute(), 34); EXPECT_EQ(dateTime2.GetSecond(), 56); - const time_t time = 674224496 + bias.GetSecondsTotal(); + const time_t time = 674224496; CDateTime dateTime3; EXPECT_TRUE(dateTime3.SetFromUTCDateTime(time)); @@ -294,18 +269,14 @@ TEST_F(TestDateTime, SetDateTime) EXPECT_EQ(dateTime2.GetMinute(), 0); EXPECT_EQ(dateTime2.GetSecond(), 0); -// disabled on osx and freebsd as their mktime functions -// don't work for dates before 1900 -#if !defined(TARGET_DARWIN_OSX) && !defined(TARGET_FREEBSD) CDateTime dateTime3; EXPECT_TRUE(dateTime3.SetTime(12, 34, 56)); - EXPECT_EQ(dateTime3.GetYear(), 1601); + EXPECT_EQ(dateTime3.GetYear(), 1970); EXPECT_EQ(dateTime3.GetMonth(), 1); EXPECT_EQ(dateTime3.GetDay(), 1); EXPECT_EQ(dateTime3.GetHour(), 12); EXPECT_EQ(dateTime3.GetMinute(), 34); EXPECT_EQ(dateTime3.GetSecond(), 56); -#endif } TEST_F(TestDateTime, GetAsStrings) @@ -320,22 +291,20 @@ TEST_F(TestDateTime, GetAsStrings) EXPECT_EQ(dateTime.GetAsW3CDate(), "1991-05-14"); } -// disabled because we have no way to validate these values -// GetTimezoneBias() always returns a positive value so -// there is no way to detect the direction of the offset -TEST_F(TestDateTime, DISABLED_GetAsStringsWithBias) +TEST_F(TestDateTime, GetAsStringsWithBias) { - CDateTimeSpan bias = CDateTime::GetTimezoneBias(); - CDateTime dateTime; dateTime.SetDateTime(1991, 05, 14, 12, 34, 56); - CDateTime dateTimeWithBias(dateTime); - dateTimeWithBias += bias; + std::cout << dateTime.GetAsRFC1123DateTime() << std::endl; + std::cout << dateTime.GetAsW3CDateTime(false) << std::endl; + std::cout << dateTime.GetAsW3CDateTime(true) << std::endl; - EXPECT_EQ(dateTime.GetAsRFC1123DateTime(), "Tue, 14 May 1991 20:34:56 GMT"); - EXPECT_EQ(dateTime.GetAsW3CDateTime(false), "1991-05-14T12:34:56+08:00"); - EXPECT_EQ(dateTime.GetAsW3CDateTime(true), "1991-05-14T20:34:56Z"); + auto zone = date::make_zoned(date::current_zone(), dateTime.GetAsTimePoint()); + + EXPECT_EQ(dateTime.GetAsRFC1123DateTime(), "Tue, 14 May 1991 12:34:56 GMT"); + EXPECT_EQ(dateTime.GetAsW3CDateTime(false), "1991-05-14T05:34:56" + date::format("%Ez", zone)); + EXPECT_EQ(dateTime.GetAsW3CDateTime(true), "1991-05-14T12:34:56Z"); } TEST_F(TestDateTime, GetAsLocalized) @@ -562,31 +531,13 @@ TEST_F(TestDateTime, GetAsTm) EXPECT_TRUE(dateTime == time); } -// Disabled pending std::chrono and std::date changes. -TEST_F(TestDateTime, DISABLED_GetAsTimeStamp) -{ - CDateTimeSpan bias = CDateTime::GetTimezoneBias(); - - CDateTime dateTime; - dateTime.SetDateTime(1991, 05, 14, 12, 34, 56); - - KODI::TIME::FileTime fileTime; - dateTime.GetAsTimeStamp(fileTime); - dateTime += bias; - - EXPECT_TRUE(dateTime == fileTime); -} - TEST_F(TestDateTime, GetAsUTCDateTime) { - CDateTimeSpan bias = CDateTime::GetTimezoneBias(); - CDateTime dateTime1; dateTime1.SetDateTime(1991, 05, 14, 12, 34, 56); CDateTime dateTime2; dateTime2 = dateTime1.GetAsUTCDateTime(); - dateTime2 -= bias; EXPECT_EQ(dateTime2.GetYear(), 1991); EXPECT_EQ(dateTime2.GetMonth(), 5); @@ -596,20 +547,14 @@ TEST_F(TestDateTime, GetAsUTCDateTime) EXPECT_EQ(dateTime2.GetSecond(), 56); } -// disabled on osx and freebsd as their mktime functions -// don't work for dates before 1900 -#if defined(TARGET_DARWIN_OSX) || defined(TARGET_FREEBSD) -TEST_F(TestDateTime, DISABLED_Reset) -#else TEST_F(TestDateTime, Reset) -#endif { CDateTime dateTime; dateTime.SetDateTime(1991, 05, 14, 12, 34, 56); dateTime.Reset(); - EXPECT_EQ(dateTime.GetYear(), 1601); + EXPECT_EQ(dateTime.GetYear(), 1970); EXPECT_EQ(dateTime.GetMonth(), 1); EXPECT_EQ(dateTime.GetDay(), 1); EXPECT_EQ(dateTime.GetHour(), 0); -- 2.31.1 From 758c5404a7ad96f6b28a8e046b58615c14daa954 Mon Sep 17 00:00:00 2001 From: Lukas Rusak Date: Thu, 10 Sep 2020 08:19:35 -0700 Subject: [PATCH 05/17] [WIP] cleanup CPosixTimezone --- xbmc/Application.cpp | 4 + xbmc/platform/posix/PosixTimezone.cpp | 278 ++++++++++---------------- xbmc/platform/posix/PosixTimezone.h | 8 +- 3 files changed, 117 insertions(+), 173 deletions(-) diff --git a/xbmc/Application.cpp b/xbmc/Application.cpp index e57a1d63d7..deedb7bccd 100644 --- a/xbmc/Application.cpp +++ b/xbmc/Application.cpp @@ -344,6 +344,8 @@ void CApplication::Preflight() #endif } +#include "platform/posix/PosixTimezone.h" + bool CApplication::Create(const CAppParamParser ¶ms) { // Grab a handle to our thread to be used later in identifying the render thread. @@ -361,6 +363,8 @@ bool CApplication::Create(const CAppParamParser ¶ms) m_pSettingsComponent.reset(new CSettingsComponent()); m_pSettingsComponent->Init(params); + g_timezone.Init(); + // Announement service m_pAnnouncementManager = std::make_shared(); m_pAnnouncementManager->Start(); diff --git a/xbmc/platform/posix/PosixTimezone.cpp b/xbmc/platform/posix/PosixTimezone.cpp index fbb705e2b4..df3ffb9e36 100644 --- a/xbmc/platform/posix/PosixTimezone.cpp +++ b/xbmc/platform/posix/PosixTimezone.cpp @@ -6,7 +6,6 @@ * See LICENSES/README.md for more information. */ -#include #ifdef TARGET_ANDROID #include "platform/android/bionic_supplement/bionic_supplement.h" #endif @@ -24,120 +23,103 @@ #include "settings/SettingsComponent.h" #include -#include +#define USE_OS_TZDB 0 +#define HAS_REMOTE_API 0 +#include -CPosixTimezone::CPosixTimezone() +#include "platform/MessagePrinter.h" + +#include "filesystem/File.h" + +void CPosixTimezone::Init() { - char* line = NULL; - size_t linelen = 0; - int nameonfourthfield = 0; - std::string s; - std::vector tokens; - - // Load timezones - FILE* fp = fopen("/usr/share/zoneinfo/zone.tab", "r"); - if (fp) - { - std::string countryCode; - std::string timezoneName; - - while (getdelim(&line, &linelen, '\n', fp) > 0) - { - tokens.clear(); - s = line; - StringUtils::Trim(s); - - if (s.length() == 0) - continue; - - if (s[0] == '#') - continue; - - StringUtils::Tokenize(s, tokens, " \t"); - if (tokens.size() < 3) - continue; - - countryCode = tokens[0]; - timezoneName = tokens[2]; - - if (m_timezonesByCountryCode.count(countryCode) == 0) - { - std::vector timezones; - timezones.push_back(timezoneName); - m_timezonesByCountryCode[countryCode] = timezones; - } - else - { - std::vector& timezones = m_timezonesByCountryCode[countryCode]; - timezones.push_back(timezoneName); - } - - m_countriesByTimezoneName[timezoneName] = countryCode; - } - fclose(fp); - } - - if (line) - { - free(line); - line = NULL; - linelen = 0; - } - - // Load countries - fp = fopen("/usr/share/zoneinfo/iso3166.tab", "r"); - if (!fp) - { - fp = fopen("/usr/share/misc/iso3166", "r"); - nameonfourthfield = 1; - } - if (fp) - { - std::string countryCode; - std::string countryName; - - while (getdelim(&line, &linelen, '\n', fp) > 0) - { - s = line; - StringUtils::Trim(s); - - //! @todo STRING_CLEANUP - if (s.length() == 0) - continue; - - if (s[0] == '#') - continue; - - // Search for the first non space from the 2nd character and on - int i = 2; - while (s[i] == ' ' || s[i] == '\t') i++; - - if (nameonfourthfield) - { - // skip three letter - while (s[i] != ' ' && s[i] != '\t') i++; - while (s[i] == ' ' || s[i] == '\t') i++; - // skip number - while (s[i] != ' ' && s[i] != '\t') i++; - while (s[i] == ' ' || s[i] == '\t') i++; - } - - countryCode = s.substr(0, 2); - countryName = s.substr(i); - - m_counties.push_back(countryName); - m_countryByCode[countryCode] = countryName; - m_countryByName[countryName] = countryCode; - } - sort(m_counties.begin(), m_counties.end(), sortstringbyname()); - fclose(fp); - } - free(line); + XFILE::CFileStream zonetab; + + if(!zonetab.Open("special://xbmc/addons/resource.timezone/resources/tzdata/zone.tab")) + { + CMessagePrinter::DisplayMessage("failed to open zone.tab"); + return; + } + + std::string countryCode; + std::string timezoneName; + + std::vector tokens; + + for (std::string s; std::getline(zonetab, s);) + { + tokens.clear(); + std::string line = s; + StringUtils::Trim(line); + + if (line.length() == 0) + continue; + + if (line[0] == '#') + continue; + + StringUtils::Tokenize(line, tokens, " \t"); + if (tokens.size() < 3) + continue; + + countryCode = tokens[0]; + timezoneName = tokens[2]; + + if (m_timezonesByCountryCode.count(countryCode) == 0) + { + std::vector timezones; + timezones.push_back(timezoneName); + m_timezonesByCountryCode[countryCode] = timezones; + } + else + { + std::vector& timezones = m_timezonesByCountryCode[countryCode]; + timezones.push_back(timezoneName); + } + + m_countriesByTimezoneName[timezoneName] = countryCode; + } + + XFILE::CFileStream isotab; + + if (!isotab.Open("special://xbmc/addons/resource.timezone/resources/tzdata/iso3166.tab")) + { + CMessagePrinter::DisplayMessage("failed to open iso3166.tab"); + return; + } + + std::string countryName; + + for (std::string s; std::getline(isotab, s);) + { + tokens.clear(); + std::string line = s; + StringUtils::Trim(line); + + if (line.length() == 0) + continue; + + if (line[0] == '#') + continue; + + StringUtils::Tokenize(line, tokens, "\t"); + if (tokens.size() < 2) + continue; + + countryCode = tokens[0]; + countryName = tokens[1]; + + m_countries.push_back(countryName); + m_countryByCode[countryCode] = countryName; + m_countryByName[countryName] = countryCode; + } + + sort(m_countries.begin(), m_countries.end(), sortstringbyname()); } void CPosixTimezone::OnSettingChanged(const std::shared_ptr& setting) { - if (setting == NULL) + if (setting == nullptr) return; const std::string &settingId = setting->GetId(); @@ -158,82 +140,38 @@ void CPosixTimezone::OnSettingsLoaded() SetTimezone(CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_TIMEZONE)); } -std::vector CPosixTimezone::GetCounties() +std::vector CPosixTimezone::GetCountries() { - return m_counties; + return m_countries; } std::vector CPosixTimezone::GetTimezonesByCountry(const std::string& country) { - return m_timezonesByCountryCode[m_countryByName[country]]; + return m_timezonesByCountryCode[m_countryByName[country]]; } std::string CPosixTimezone::GetCountryByTimezone(const std::string& timezone) { #if defined(TARGET_DARWIN) - return "?"; -#else - return m_countryByCode[m_countriesByTimezoneName[timezone]]; + return "?"; #endif + + return m_countryByCode[m_countriesByTimezoneName[timezone]]; } void CPosixTimezone::SetTimezone(const std::string& timezoneName) { -#if !defined(TARGET_DARWIN) - bool use_timezone = true; -#else - bool use_timezone = false; +#if defined(TARGET_DARWIN) + return; #endif - if (use_timezone) - { - static char env_var[255]; - sprintf(env_var, "TZ=:%s", timezoneName.c_str()); - putenv(env_var); - tzset(); - } + setenv("TZ", timezoneName.c_str(), 1); + tzset(); } std::string CPosixTimezone::GetOSConfiguredTimezone() { - char timezoneName[255]; - - // try Slackware approach first - ssize_t rlrc = readlink("/etc/localtime-copied-from" - , timezoneName, sizeof(timezoneName)-1); - - // RHEL and maybe other distros make /etc/localtime a symlink - if (rlrc == -1) - rlrc = readlink("/etc/localtime", timezoneName, sizeof(timezoneName)-1); - - if (rlrc != -1) - { - timezoneName[rlrc] = '\0'; - - char* p = strrchr(timezoneName,'/'); - if (p) - { // we want the previous '/' - char* q = p; - *q = 0; - p = strrchr(timezoneName,'/'); - *q = '/'; - if (p) - p++; - } - return p; - } - - // now try Debian approach - timezoneName[0] = 0; - FILE* fp = fopen("/etc/timezone", "r"); - if (fp) - { - if (fgets(timezoneName, sizeof(timezoneName), fp)) - timezoneName[strlen(timezoneName)-1] = '\0'; - fclose(fp); - } - - return timezoneName; + return date::get_tzdb().current_zone()->name(); } void CPosixTimezone::SettingOptionsTimezoneCountriesFiller( @@ -242,9 +180,9 @@ void CPosixTimezone::SettingOptionsTimezoneCountriesFiller( std::string& current, void* data) { - std::vector countries = g_timezone.GetCounties(); - for (unsigned int i = 0; i < countries.size(); i++) - list.emplace_back(countries[i], countries[i]); + std::vector countries = g_timezone.GetCountries(); + for (const auto& country : countries) + list.emplace_back(country, country); } void CPosixTimezone::SettingOptionsTimezonesFiller(const std::shared_ptr& setting, @@ -255,12 +193,12 @@ void CPosixTimezone::SettingOptionsTimezonesFiller(const std::shared_ptr(setting)->GetValue(); bool found = false; std::vector timezones = g_timezone.GetTimezonesByCountry(CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_TIMEZONECOUNTRY)); - for (unsigned int i = 0; i < timezones.size(); i++) + for (const auto& timezone : timezones) { - if (!found && StringUtils::EqualsNoCase(timezones[i], current)) + if (!found && StringUtils::EqualsNoCase(timezone, current)) found = true; - list.emplace_back(timezones[i], timezones[i]); + list.emplace_back(timezone, timezone); } if (!found && !timezones.empty()) diff --git a/xbmc/platform/posix/PosixTimezone.h b/xbmc/platform/posix/PosixTimezone.h index 076e87fa51..843b55eba0 100644 --- a/xbmc/platform/posix/PosixTimezone.h +++ b/xbmc/platform/posix/PosixTimezone.h @@ -21,7 +21,9 @@ struct StringSettingOption; class CPosixTimezone : public ISettingCallback, public ISettingsHandler { public: - CPosixTimezone(); + CPosixTimezone() = default; + + void Init(); void OnSettingChanged(const std::shared_ptr& setting) override; @@ -29,7 +31,7 @@ public: std::string GetOSConfiguredTimezone(); - std::vector GetCounties(); + std::vector GetCountries(); std::vector GetTimezonesByCountry(const std::string& country); std::string GetCountryByTimezone(const std::string& timezone); @@ -46,7 +48,7 @@ public: void* data); private: - std::vector m_counties; + std::vector m_countries; std::map m_countryByCode; std::map m_countryByName; -- 2.31.1 From 5bd621db4e7ea2bcc0f3ce631ad34321535f1144 Mon Sep 17 00:00:00 2001 From: Lukas Rusak Date: Thu, 10 Sep 2020 08:41:57 -0700 Subject: [PATCH 06/17] utils/XTimeUtils: clean up SystemTime and FileTime functions --- xbmc/XBDateTime.cpp | 210 ++--------------- xbmc/XBDateTime.h | 27 --- .../addons/interfaces/gui/dialogs/Numeric.cpp | 10 +- xbmc/dialogs/GUIDialogNumeric.cpp | 196 +++++++++------- xbmc/dialogs/GUIDialogNumeric.h | 10 +- xbmc/filesystem/NFSDirectory.cpp | 16 +- xbmc/guilib/GUIEditControl.cpp | 11 +- xbmc/guilib/GUIRSSControl.h | 2 +- xbmc/interfaces/legacy/Dialog.cpp | 38 ++-- xbmc/music/infoscanner/MusicInfoScanner.cpp | 4 +- xbmc/network/upnp/UPnPInternal.cpp | 17 +- xbmc/platform/posix/XTimeUtils.cpp | 213 ------------------ .../posix/filesystem/PosixDirectory.cpp | 5 +- .../posix/filesystem/SMBDirectory.cpp | 14 +- .../pvr/dialogs/GUIDialogPVRTimerSettings.cpp | 19 +- xbmc/pvr/dialogs/GUIDialogPVRTimerSettings.h | 1 - xbmc/pvr/windows/GUIWindowPVRGuide.cpp | 7 +- xbmc/settings/windows/GUIControlSettings.cpp | 14 +- xbmc/test/TestDateTime.cpp | 18 +- xbmc/utils/Archive.cpp | 8 +- xbmc/utils/Archive.h | 4 +- xbmc/utils/RssManager.cpp | 2 +- xbmc/utils/RssManager.h | 2 +- xbmc/utils/RssReader.cpp | 19 +- xbmc/utils/RssReader.h | 6 +- xbmc/utils/XTimeUtils.h | 44 ---- xbmc/utils/test/TestArchive.cpp | 22 +- xbmc/video/VideoInfoScanner.cpp | 4 +- 28 files changed, 228 insertions(+), 715 deletions(-) diff --git a/xbmc/XBDateTime.cpp b/xbmc/XBDateTime.cpp index 7e77f266ba..24f8c0c7bf 100644 --- a/xbmc/XBDateTime.cpp +++ b/xbmc/XBDateTime.cpp @@ -171,23 +171,6 @@ CDateTime::CDateTime() Reset(); } -CDateTime::CDateTime(const KODI::TIME::SystemTime& systemTime) -{ - KODI::TIME::FileTime fileTime; - m_state = ToFileTime(systemTime, fileTime) ? valid : invalid; - - time_t time; - KODI::TIME::FileTimeToTimeT(&fileTime, &time); - m_time = std::chrono::system_clock::from_time_t(time); -} - -CDateTime::CDateTime(const KODI::TIME::FileTime& fileTime) -{ - time_t time; - KODI::TIME::FileTimeToTimeT(&fileTime, &time); - m_time = std::chrono::system_clock::from_time_t(time); -} - CDateTime::CDateTime(const CDateTime& time) { m_time = time.m_time; @@ -231,27 +214,6 @@ CDateTime CDateTime::GetUTCDateTime() return CDateTime(std::chrono::system_clock::now()); } -const CDateTime& CDateTime::operator=(const KODI::TIME::SystemTime& right) -{ - KODI::TIME::FileTime fileTime; - m_state = ToFileTime(right, fileTime) ? valid : invalid; - - time_t time; - KODI::TIME::FileTimeToTimeT(&fileTime, &time); - m_time = std::chrono::system_clock::from_time_t(time); - - return *this; -} - -const CDateTime& CDateTime::operator=(const KODI::TIME::FileTime& right) -{ - time_t time; - KODI::TIME::FileTimeToTimeT(&right, &time); - m_time = std::chrono::system_clock::from_time_t(time); - - return *this; -} - const CDateTime& CDateTime::operator =(const time_t& right) { m_time = std::chrono::system_clock::from_time_t(right); @@ -306,84 +268,6 @@ bool CDateTime::operator !=(const CDateTime& right) const return !operator ==(right); } -bool CDateTime::operator>(const KODI::TIME::FileTime& right) const -{ - time_t time; - KODI::TIME::FileTimeToTimeT(&right, &time); - - return m_time > std::chrono::system_clock::from_time_t(time); -} - -bool CDateTime::operator>=(const KODI::TIME::FileTime& right) const -{ - return operator >(right) || operator ==(right); -} - -bool CDateTime::operator<(const KODI::TIME::FileTime& right) const -{ - time_t time; - KODI::TIME::FileTimeToTimeT(&right, &time); - - return m_time < std::chrono::system_clock::from_time_t(time); -} - -bool CDateTime::operator<=(const KODI::TIME::FileTime& right) const -{ - return operator <(right) || operator ==(right); -} - -bool CDateTime::operator==(const KODI::TIME::FileTime& right) const -{ - time_t time; - KODI::TIME::FileTimeToTimeT(&right, &time); - - return m_time == std::chrono::system_clock::from_time_t(time); -} - -bool CDateTime::operator!=(const KODI::TIME::FileTime& right) const -{ - return !operator ==(right); -} - -bool CDateTime::operator>(const KODI::TIME::SystemTime& right) const -{ - KODI::TIME::FileTime time; - ToFileTime(right, time); - - return operator >(time); -} - -bool CDateTime::operator>=(const KODI::TIME::SystemTime& right) const -{ - return operator >(right) || operator ==(right); -} - -bool CDateTime::operator<(const KODI::TIME::SystemTime& right) const -{ - KODI::TIME::FileTime time; - ToFileTime(right, time); - - return operator <(time); -} - -bool CDateTime::operator<=(const KODI::TIME::SystemTime& right) const -{ - return operator <(right) || operator ==(right); -} - -bool CDateTime::operator==(const KODI::TIME::SystemTime& right) const -{ - KODI::TIME::FileTime time; - ToFileTime(right, time); - - return operator ==(time); -} - -bool CDateTime::operator!=(const KODI::TIME::SystemTime& right) const -{ - return !operator ==(right); -} - bool CDateTime::operator >(const time_t& right) const { return m_time > std::chrono::system_clock::from_time_t(right); @@ -514,14 +398,6 @@ CDateTimeSpan CDateTime::operator -(const CDateTime& right) const return left; } -CDateTime::operator KODI::TIME::FileTime() const -{ - KODI::TIME::FileTime fileTime; - time_t time = std::chrono::system_clock::to_time_t(m_time); - KODI::TIME::TimeTToFileTime(time, &fileTime); - return fileTime; -} - void CDateTime::Archive(CArchive& ar) { if (ar.IsStoring()) @@ -529,9 +405,7 @@ void CDateTime::Archive(CArchive& ar) ar<<(int)m_state; if (m_state==valid) { - KODI::TIME::SystemTime st; - GetAsSystemTime(st); - ar<>st; - ToTimePoint(st, m_time); + ar >> m_time; } } } @@ -565,37 +437,6 @@ bool CDateTime::IsValid() const return m_state == valid; } -bool CDateTime::ToTimePoint(const KODI::TIME::SystemTime& systemTime, - std::chrono::system_clock::time_point& timePoint) const -{ - KODI::TIME::FileTime fileTime; - KODI::TIME::SystemTimeToFileTime(&systemTime, &fileTime); - - time_t time; - KODI::TIME::FileTimeToTimeT(&fileTime, &time); - - timePoint = std::chrono::system_clock::from_time_t(time); - return true; -} - -bool CDateTime::ToFileTime(const KODI::TIME::SystemTime& time, KODI::TIME::FileTime& fileTime) const -{ - return KODI::TIME::SystemTimeToFileTime(&time, &fileTime) == 1 && - (fileTime.lowDateTime > 0 || fileTime.highDateTime > 0); -} - -bool CDateTime::ToFileTime(const time_t& time, KODI::TIME::FileTime& fileTime) const -{ - long long ll = time; - ll *= 10000000ll; - ll += 0x19DB1DED53E8000LL; - - fileTime.lowDateTime = (DWORD)(ll & 0xFFFFFFFF); - fileTime.highDateTime = (DWORD)(ll >> 32); - - return true; -} - bool CDateTime::SetFromDateString(const std::string &date) { //! @todo STRING_CLEANUP @@ -730,14 +571,6 @@ bool CDateTime::SetTime(int hour, int minute, int second) return true; } -void CDateTime::GetAsSystemTime(KODI::TIME::SystemTime& systemTime) const -{ - const time_t time = std::chrono::system_clock::to_time_t(m_time); - KODI::TIME::FileTime fileTime; - ToFileTime(time, fileTime); - KODI::TIME::FileTimeToSystemTime(&fileTime, &systemTime); -} - void CDateTime::GetAsTime(time_t& time) const { time = std::chrono::system_clock::to_time_t(m_time); @@ -755,13 +588,6 @@ std::chrono::system_clock::time_point CDateTime::GetAsTimePoint() const return m_time; } - -// void CDateTime::GetAsTimeStamp(KODI::TIME::FileTime& fileTime) const -// { -// time_t time = std::chrono::system_clock::to_time_t(m_time); -// KODI::TIME::TimeTToFileTime(time, &fileTime); -// } - std::string CDateTime::GetAsDBDate() const { return date::format("%F", m_time); @@ -1053,12 +879,9 @@ std::string CDateTime::GetAsLocalizedTime(const std::string &format, bool withSe std::string strOut; const std::string& strFormat = format.empty() ? g_langInfo.GetTimeFormat() : format; - KODI::TIME::SystemTime dateTime; - GetAsSystemTime(dateTime); - // Prefetch meridiem symbol const std::string& strMeridiem = - CLangInfo::MeridiemSymbolToString(dateTime.hour > 11 ? MeridiemSymbolPM : MeridiemSymbolAM); + CLangInfo::MeridiemSymbolToString(GetHour() > 11 ? MeridiemSymbolPM : MeridiemSymbolAM); size_t length = strFormat.size(); for (size_t i=0; i < length; ++i) @@ -1107,7 +930,7 @@ std::string CDateTime::GetAsLocalizedTime(const std::string &format, bool withSe i=length; } - int hour = dateTime.hour; + int hour = GetHour(); if (c=='h') { // recalc to 12 hour clock if (hour > 11) @@ -1146,9 +969,9 @@ std::string CDateTime::GetAsLocalizedTime(const std::string &format, bool withSe // Format minute string with the length of the mask std::string str; if (partLength==1) - str = StringUtils::Format("%d", dateTime.minute); + str = StringUtils::Format("%d", GetMinute()); else - str = StringUtils::Format("%02d", dateTime.minute); + str = StringUtils::Format("%02d", GetMinute()); strOut+=str; } @@ -1175,9 +998,9 @@ std::string CDateTime::GetAsLocalizedTime(const std::string &format, bool withSe // Format seconds string with the length of the mask std::string str; if (partLength==1) - str = StringUtils::Format("%d", dateTime.second); + str = StringUtils::Format("%d", GetSecond()); else - str = StringUtils::Format("%02d", dateTime.second); + str = StringUtils::Format("%02d", GetSecond()); strOut+=str; } @@ -1216,9 +1039,6 @@ std::string CDateTime::GetAsLocalizedDate(const std::string &strFormat) const { std::string strOut; - KODI::TIME::SystemTime dateTime; - GetAsSystemTime(dateTime); - size_t length = strFormat.size(); for (size_t i = 0; i < length; ++i) { @@ -1268,12 +1088,12 @@ std::string CDateTime::GetAsLocalizedDate(const std::string &strFormat) const // Format string with the length of the mask std::string str; if (partLength==1) // single-digit number - str = StringUtils::Format("%d", dateTime.day); + str = StringUtils::Format("%d", GetDay()); else if (partLength==2) // two-digit number - str = StringUtils::Format("%02d", dateTime.day); + str = StringUtils::Format("%02d", GetDay()); else // Day of week string { - int wday = dateTime.dayOfWeek; + int wday = GetDayOfWeek(); if (wday < 1 || wday > 7) wday = 7; str = g_localizeStrings.Get((c =='d' ? 40 : 10) + wday); } @@ -1300,12 +1120,12 @@ std::string CDateTime::GetAsLocalizedDate(const std::string &strFormat) const // Format string with the length of the mask std::string str; if (partLength==1) // single-digit number - str = StringUtils::Format("%d", dateTime.month); + str = StringUtils::Format("%d", GetMonth()); else if (partLength==2) // two-digit number - str = StringUtils::Format("%02d", dateTime.month); + str = StringUtils::Format("%02d", GetMonth()); else // Month string { - int wmonth = dateTime.month; + int wmonth = GetMonth(); if (wmonth < 1 || wmonth > 12) wmonth = 12; str = g_localizeStrings.Get((c =='m' ? 50 : 20) + wmonth); } @@ -1330,7 +1150,7 @@ std::string CDateTime::GetAsLocalizedDate(const std::string &strFormat) const } // Format string with the length of the mask - std::string str = StringUtils::Format("%d", dateTime.year); // four-digit number + std::string str = StringUtils::Format("%d", GetYear()); // four-digit number if (partLength <= 2) str.erase(0, 2); // two-digit number diff --git a/xbmc/XBDateTime.h b/xbmc/XBDateTime.h index 1e686a679c..208b938ae8 100644 --- a/xbmc/XBDateTime.h +++ b/xbmc/XBDateTime.h @@ -118,8 +118,6 @@ class CDateTime final : public IArchivable public: CDateTime(); CDateTime(const CDateTime& time); - explicit CDateTime(const KODI::TIME::SystemTime& time); - explicit CDateTime(const KODI::TIME::FileTime& time); explicit CDateTime(const time_t& time); explicit CDateTime(const tm& time); explicit CDateTime(const std::chrono::system_clock::time_point& time); @@ -139,8 +137,6 @@ public: static CDateTime FromUTCDateTime(const time_t &dateTime); static CDateTime FromRFC1123DateTime(const std::string &dateTime); - const CDateTime& operator=(const KODI::TIME::SystemTime& right); - const CDateTime& operator=(const KODI::TIME::FileTime& right); const CDateTime& operator =(const time_t& right); const CDateTime& operator =(const tm& right); const CDateTime& operator=(const std::chrono::system_clock::time_point& right); @@ -152,20 +148,6 @@ public: bool operator ==(const CDateTime& right) const; bool operator !=(const CDateTime& right) const; - bool operator>(const KODI::TIME::FileTime& right) const; - bool operator>=(const KODI::TIME::FileTime& right) const; - bool operator<(const KODI::TIME::FileTime& right) const; - bool operator<=(const KODI::TIME::FileTime& right) const; - bool operator==(const KODI::TIME::FileTime& right) const; - bool operator!=(const KODI::TIME::FileTime& right) const; - - bool operator>(const KODI::TIME::SystemTime& right) const; - bool operator>=(const KODI::TIME::SystemTime& right) const; - bool operator<(const KODI::TIME::SystemTime& right) const; - bool operator<=(const KODI::TIME::SystemTime& right) const; - bool operator==(const KODI::TIME::SystemTime& right) const; - bool operator!=(const KODI::TIME::SystemTime& right) const; - bool operator >(const time_t& right) const; bool operator >=(const time_t& right) const; bool operator <(const time_t& right) const; @@ -195,8 +177,6 @@ public: CDateTimeSpan operator -(const CDateTime& right) const; - operator KODI::TIME::FileTime() const; - void Archive(CArchive& ar) override; void Reset(); @@ -228,7 +208,6 @@ public: */ bool SetFromDBDateTime(const std::string &dateTime); - void GetAsSystemTime(KODI::TIME::SystemTime& time) const; void GetAsTime(time_t& time) const; void GetAsTm(tm& time) const; std::chrono::system_clock::time_point GetAsTimePoint() const; @@ -250,12 +229,6 @@ public: void SetValid(bool yesNo); bool IsValid() const; -private: - bool ToTimePoint(const KODI::TIME::SystemTime& time, - std::chrono::system_clock::time_point& timePoint) const; - bool ToFileTime(const KODI::TIME::SystemTime& time, KODI::TIME::FileTime& fileTime) const; - bool ToFileTime(const time_t& time, KODI::TIME::FileTime& fileTime) const; - private: std::chrono::system_clock::time_point m_time; diff --git a/xbmc/addons/interfaces/gui/dialogs/Numeric.cpp b/xbmc/addons/interfaces/gui/dialogs/Numeric.cpp index a78aa4af60..3acc48e768 100644 --- a/xbmc/addons/interfaces/gui/dialogs/Numeric.cpp +++ b/xbmc/addons/interfaces/gui/dialogs/Numeric.cpp @@ -135,12 +135,9 @@ bool Interface_GUIDialogNumeric::show_and_get_time(KODI_HANDLE kodiBase, return false; } - KODI::TIME::SystemTime systemTime; CDateTime dateTime(*time); - dateTime.GetAsSystemTime(systemTime); - if (CGUIDialogNumeric::ShowAndGetTime(systemTime, heading)) + if (CGUIDialogNumeric::ShowAndGetTime(dateTime, heading)) { - dateTime = systemTime; dateTime.GetAsTm(*time); return true; } @@ -167,12 +164,9 @@ bool Interface_GUIDialogNumeric::show_and_get_date(KODI_HANDLE kodiBase, return false; } - KODI::TIME::SystemTime systemTime; CDateTime dateTime(*date); - dateTime.GetAsSystemTime(systemTime); - if (CGUIDialogNumeric::ShowAndGetDate(systemTime, heading)) + if (CGUIDialogNumeric::ShowAndGetDate(dateTime, heading)) { - dateTime = systemTime; dateTime.GetAsTm(*date); return true; } diff --git a/xbmc/dialogs/GUIDialogNumeric.cpp b/xbmc/dialogs/GUIDialogNumeric.cpp index 174d07a611..22b79ea9a1 100644 --- a/xbmc/dialogs/GUIDialogNumeric.cpp +++ b/xbmc/dialogs/GUIDialogNumeric.cpp @@ -44,7 +44,7 @@ CGUIDialogNumeric::CGUIDialogNumeric(void) , m_lastblock{0} , m_dirty{false} { - memset(&m_datetime, 0, sizeof(KODI::TIME::SystemTime)); + m_datetime.Reset(); m_loadType = KEEP_IN_MEMORY; } @@ -230,59 +230,76 @@ void CGUIDialogNumeric::OnBackSpace() } else if (m_mode == INPUT_TIME) { + int hour = m_datetime.GetHour(); + int minute = m_datetime.GetMinute(); + if (m_block == 0) - m_datetime.hour /= 10; - else if (m_datetime.minute) - m_datetime.minute /= 10; + hour /= 10; + else if (minute) + minute /= 10; else { m_block = 0; m_dirty = false; } + + m_datetime.SetTime(hour, minute, 0); } else if (m_mode == INPUT_TIME_SECONDS) { + int hour = m_datetime.GetHour(); + int minute = m_datetime.GetMinute(); + int second = m_datetime.GetSecond(); + if (m_block == 0) - m_datetime.hour /= 10; + hour /= 10; else if (m_block == 1) { - if (m_datetime.minute) - m_datetime.minute /= 10; + if (minute) + minute /= 10; else { m_block = 0; m_dirty = false; } } - else if (m_datetime.second) - m_datetime.minute /= 10; + else if (second) + minute /= 10; else { m_block = 0; m_dirty = false; } + + m_datetime.SetTime(hour, minute, second); } else if (m_mode == INPUT_DATE) { + int day = m_datetime.GetDay(); + int month = m_datetime.GetMonth(); + int year = m_datetime.GetYear(); + if (m_block == 0) - m_datetime.day /= 10; + day /= 10; else if (m_block == 1) { - if (m_datetime.month) - m_datetime.month /= 10; + if (month) + month /= 10; else { m_block = 0; m_dirty = false; } } - else if (m_datetime.year) // m_block == 2 - m_datetime.year /= 10; + else if (year) // m_block == 2 + year /= 10; else { m_block = 1; m_dirty = false; } + + m_datetime.SetDate(year, month, day); } } @@ -316,21 +333,21 @@ void CGUIDialogNumeric::FrameMove() strLabel = m_number; else if (m_mode == INPUT_TIME) { // format up the time - strLabel = StringUtils::Format("%2d:%02d", m_datetime.hour, m_datetime.minute); + strLabel = StringUtils::Format("%2d:%02d", m_datetime.GetHour(), m_datetime.GetMinute()); start = m_block * 3; end = m_block * 3 + 2; } else if (m_mode == INPUT_TIME_SECONDS) { // format up the time strLabel = - StringUtils::Format("%2d:%02d:%02d", m_datetime.hour, m_datetime.minute, m_datetime.second); + StringUtils::Format("%2d:%02d:%02d", m_datetime.GetHour(), m_datetime.GetMinute(), m_datetime.GetSecond()); start = m_block * 3; end = m_block * 3 + 2; } else if (m_mode == INPUT_DATE) { // format up the date strLabel = - StringUtils::Format("%2d/%2d/%4d", m_datetime.day, m_datetime.month, m_datetime.year); + StringUtils::Format("%2d/%2d/%4d", m_datetime.GetDay(), m_datetime.GetMonth(), m_datetime.GetYear()); start = m_block * 3; end = m_block * 3 + 2; if (m_block == 2) @@ -376,7 +393,7 @@ void CGUIDialogNumeric::OnNumber(uint32_t num) } } -void CGUIDialogNumeric::SetMode(INPUT_MODE mode, const KODI::TIME::SystemTime& initial) +void CGUIDialogNumeric::SetMode(INPUT_MODE mode, const CDateTime& initial) { m_mode = mode; m_block = 0; @@ -424,7 +441,7 @@ void CGUIDialogNumeric::SetMode(INPUT_MODE mode, const std::string &initial) if (!dateTime.IsValid()) return; - dateTime.GetAsSystemTime(m_datetime); + m_datetime = dateTime; m_lastblock = (m_mode == INPUT_DATE) ? 2 : 1; } else if (m_mode == INPUT_IP_ADDRESS) @@ -446,7 +463,7 @@ void CGUIDialogNumeric::SetMode(INPUT_MODE mode, const std::string &initial) m_number = initial; } -KODI::TIME::SystemTime CGUIDialogNumeric::GetOutput() const +CDateTime CGUIDialogNumeric::GetOutput() const { assert(m_mode == INPUT_TIME || m_mode == INPUT_TIME_SECONDS || m_mode == INPUT_DATE); return m_datetime; @@ -457,12 +474,12 @@ std::string CGUIDialogNumeric::GetOutputString() const switch (m_mode) { case INPUT_DATE: - return StringUtils::Format("%02i/%02i/%04i", m_datetime.day, m_datetime.month, m_datetime.year); + return StringUtils::Format("%02i/%02i/%04i", m_datetime.GetDay(), m_datetime.GetMonth(), m_datetime.GetYear()); case INPUT_TIME: - return StringUtils::Format("%i:%02i", m_datetime.hour, m_datetime.minute); + return StringUtils::Format("%i:%02i", m_datetime.GetHour(), m_datetime.GetMinute()); case INPUT_TIME_SECONDS: - return StringUtils::Format("%i:%02i:%02i", m_datetime.hour, m_datetime.minute, - m_datetime.second); + return StringUtils::Format("%i:%02i:%02i", m_datetime.GetHour(), m_datetime.GetMinute(), + m_datetime.GetSecond()); case INPUT_IP_ADDRESS: return StringUtils::Format("%d.%d.%d.%d", m_ip[0], m_ip[1], m_ip[2], m_ip[3]); case INPUT_NUMBER: @@ -478,23 +495,23 @@ bool CGUIDialogNumeric::ShowAndGetSeconds(std::string &timeString, const std::st { CGUIDialogNumeric *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_DIALOG_NUMERIC); if (!pDialog) return false; - int seconds = StringUtils::TimeStringToSeconds(timeString); - KODI::TIME::SystemTime time = {0}; - time.hour = seconds / 3600; - time.minute = (seconds - time.hour * 3600) / 60; - time.second = seconds - time.hour * 3600 - time.minute * 60; - pDialog->SetMode(INPUT_TIME_SECONDS, time); + + std::chrono::system_clock::time_point time{std::chrono::seconds{StringUtils::TimeStringToSeconds(timeString)}}; + + CDateTime datetime(time); + + pDialog->SetMode(INPUT_TIME_SECONDS, datetime); pDialog->SetHeading(heading); pDialog->Open(); if (!pDialog->IsConfirmed() || pDialog->IsCanceled()) return false; - time = pDialog->GetOutput(); - seconds = time.hour * 3600 + time.minute * 60 + time.second; - timeString = StringUtils::SecondsToTimeString(seconds); + datetime = pDialog->GetOutput(); + time = datetime.GetAsTimePoint(); + timeString = StringUtils::SecondsToTimeString(std::chrono::duration_cast(time.time_since_epoch()).count()); return true; } -bool CGUIDialogNumeric::ShowAndGetTime(KODI::TIME::SystemTime& time, const std::string& heading) +bool CGUIDialogNumeric::ShowAndGetTime(CDateTime& time, const std::string& heading) { CGUIDialogNumeric *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_DIALOG_NUMERIC); if (!pDialog) return false; @@ -507,7 +524,7 @@ bool CGUIDialogNumeric::ShowAndGetTime(KODI::TIME::SystemTime& time, const std:: return true; } -bool CGUIDialogNumeric::ShowAndGetDate(KODI::TIME::SystemTime& date, const std::string& heading) +bool CGUIDialogNumeric::ShowAndGetDate(CDateTime& date, const std::string& heading) { CGUIDialogNumeric *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_DIALOG_NUMERIC); if (!pDialog) return false; @@ -677,28 +694,34 @@ void CGUIDialogNumeric::SetHeading(const std::string& strHeading) void CGUIDialogNumeric::VerifyDate(bool checkYear) { - if (m_datetime.day == 0) - m_datetime.day = 1; - if (m_datetime.month == 0) - m_datetime.month = 1; + int day = m_datetime.GetDay(); + int month = m_datetime.GetMonth(); + int year = m_datetime.GetYear(); + + if (day == 0) + day = 1; + if (month == 0) + month = 1; // check for number of days in the month - if (m_datetime.day == 31) + if (day == 31) { - if (m_datetime.month == 4 || m_datetime.month == 6 || m_datetime.month == 9 || - m_datetime.month == 11) - m_datetime.day = 30; + if (month == 4 || month == 6 || month == 9 || month == 11) + day = 30; } - if (m_datetime.month == 2 && m_datetime.day > 28) + if (month == 2 && day > 28) { - m_datetime.day = 29; // max in february. + day = 29; // max in february. if (checkYear) { // leap years occur when the year is divisible by 4 but not by 100, or the year is divisible by 400 // thus they don't occur, if the year has a remainder when divided by 4, or when the year is divisible by 100 but not by 400 - if ((m_datetime.year % 4) || (!(m_datetime.year % 100) && (m_datetime.year % 400))) - m_datetime.day = 28; + if ((year % 4) || (!(year % 100) && (year % 400))) + day = 28; } } + + m_datetime.SetDate(year, month, day); + } void CGUIDialogNumeric::OnOK() @@ -738,17 +761,21 @@ void CGUIDialogNumeric::HandleInputIP(uint32_t num) void CGUIDialogNumeric::HandleInputDate(uint32_t num) { + int day = m_datetime.GetDay(); + int month = m_datetime.GetMonth(); + int year = m_datetime.GetYear(); + if (m_block == 0) // day of month { - if (m_dirty && (m_datetime.day < 3 || num < 2)) + if (m_dirty && (day < 3 || num < 2)) { - m_datetime.day *= 10; - m_datetime.day += num; + day *= 10; + day += num; } else - m_datetime.day = num; + day = num; - if (m_datetime.day > 3) + if (day > 3) { m_block = 1; // move to months m_dirty = false; @@ -760,13 +787,13 @@ void CGUIDialogNumeric::HandleInputDate(uint32_t num) { if (m_dirty && num < 3) { - m_datetime.month *= 10; - m_datetime.month += num; + month *= 10; + month += num; } else - m_datetime.month = num; + month = num; - if (m_datetime.month > 1) + if (month > 1) { VerifyDate(false); m_block = 2; // move to year @@ -777,15 +804,15 @@ void CGUIDialogNumeric::HandleInputDate(uint32_t num) } else // year { - if (m_dirty && m_datetime.year < 1000) // have taken input + if (m_dirty && year < 1000) // have taken input { - m_datetime.year *= 10; - m_datetime.year += num; + year *= 10; + year += num; } else - m_datetime.year = num; + year = num; - if (m_datetime.year > 1000) + if (year > 1000) { VerifyDate(true); m_block = 0; // move to day of month @@ -794,22 +821,28 @@ void CGUIDialogNumeric::HandleInputDate(uint32_t num) else m_dirty = true; } + + m_datetime.SetDate(year, month, day); } void CGUIDialogNumeric::HandleInputSeconds(uint32_t num) { + int hour = m_datetime.GetHour(); + int minute = m_datetime.GetMinute(); + int second = m_datetime.GetSecond(); + if (m_block == 0) // hour { if (m_dirty) // have input the first digit { - m_datetime.hour *= 10; - m_datetime.hour += num; + hour *= 10; + hour += num; m_block = 1; // move to minutes - allows up to 99 hours m_dirty = false; } else // this is the first digit { - m_datetime.hour = num; + hour = num; m_dirty = true; } } @@ -817,14 +850,14 @@ void CGUIDialogNumeric::HandleInputSeconds(uint32_t num) { if (m_dirty) // have input the first digit { - m_datetime.minute *= 10; - m_datetime.minute += num; + minute *= 10; + minute += num; m_block = 2; // move to seconds - allows up to 99 minutes m_dirty = false; } else // this is the first digit { - m_datetime.minute = num; + minute = num; if (num > 5) { m_block = 2; // move to seconds @@ -838,14 +871,14 @@ void CGUIDialogNumeric::HandleInputSeconds(uint32_t num) { if (m_dirty) // have input the first digit { - m_datetime.second *= 10; - m_datetime.second += num; + second *= 10; + second += num; m_block = 0; // move to hours m_dirty = false; } else // this is the first digit { - m_datetime.second = num; + second = num; if (num > 5) { m_block = 0; // move to hours @@ -855,28 +888,33 @@ void CGUIDialogNumeric::HandleInputSeconds(uint32_t num) m_dirty = true; } } + + m_datetime.SetTime(hour, minute, second); } void CGUIDialogNumeric::HandleInputTime(uint32_t num) { + int hour = m_datetime.GetHour(); + int minute = m_datetime.GetMinute(); + if (m_block == 0) // hour { if (m_dirty) // have input the first digit { - if (m_datetime.hour < 2 || num < 4) + if (hour < 2 || num < 4) { - m_datetime.hour *= 10; - m_datetime.hour += num; + hour *= 10; + hour += num; } else - m_datetime.hour = num; + hour = num; m_block = 1; // move to minutes m_dirty = false; } else // this is the first digit { - m_datetime.hour = num; + hour = num; if (num > 2) { @@ -891,14 +929,14 @@ void CGUIDialogNumeric::HandleInputTime(uint32_t num) { if (m_dirty) // have input the first digit { - m_datetime.minute *= 10; - m_datetime.minute += num; + minute *= 10; + minute += num; m_block = 0; // move to hours m_dirty = false; } else // this is the first digit { - m_datetime.minute = num; + minute = num; if (num > 5) { @@ -909,5 +947,7 @@ void CGUIDialogNumeric::HandleInputTime(uint32_t num) m_dirty = true; } } + + m_datetime.SetTime(hour, minute, 0); } diff --git a/xbmc/dialogs/GUIDialogNumeric.h b/xbmc/dialogs/GUIDialogNumeric.h index 2fa2344c73..534b2bb960 100644 --- a/xbmc/dialogs/GUIDialogNumeric.h +++ b/xbmc/dialogs/GUIDialogNumeric.h @@ -41,13 +41,13 @@ public: static InputVerificationResult ShowAndVerifyInput(std::string& strPassword, const std::string& strHeading, bool bGetUserInput); void SetHeading(const std::string &strHeading); - void SetMode(INPUT_MODE mode, const KODI::TIME::SystemTime& initial); + void SetMode(INPUT_MODE mode, const CDateTime& initial); void SetMode(INPUT_MODE mode, const std::string &initial); - KODI::TIME::SystemTime GetOutput() const; + CDateTime GetOutput() const; std::string GetOutputString() const; - static bool ShowAndGetTime(KODI::TIME::SystemTime& time, const std::string& heading); - static bool ShowAndGetDate(KODI::TIME::SystemTime& date, const std::string& heading); + static bool ShowAndGetTime(CDateTime& time, const std::string& heading); + static bool ShowAndGetDate(CDateTime& date, const std::string& heading); static bool ShowAndGetIPAddress(std::string &IPAddress, const std::string &heading); static bool ShowAndGetNumber(std::string& strInput, const std::string &strHeading, unsigned int iAutoCloseTimeoutMs = 0, bool bSetHidden = false); static bool ShowAndGetSeconds(std::string& timeString, const std::string &heading); @@ -73,7 +73,7 @@ protected: bool m_bCanceled; INPUT_MODE m_mode; // the current input mode - KODI::TIME::SystemTime m_datetime; // for time and date modes + CDateTime m_datetime; // for time and date modes uint8_t m_ip[4]; // for ip address mode uint32_t m_block; // for time, date, and IP methods. uint32_t m_lastblock; diff --git a/xbmc/filesystem/NFSDirectory.cpp b/xbmc/filesystem/NFSDirectory.cpp index 24119d3ada..a8fcd00c9f 100644 --- a/xbmc/filesystem/NFSDirectory.cpp +++ b/xbmc/filesystem/NFSDirectory.cpp @@ -180,7 +180,6 @@ bool CNFSDirectory::GetDirectory(const CURL& url, CFileItemList &items) { // We accept nfs://server/path[/file]]]] int ret = 0; - KODI::TIME::FileTime fileTime, localTime; CSingleLock lock(gNfsConnection); std::string strDirName=""; std::string myStrPath(url.Get()); @@ -243,25 +242,12 @@ bool CNFSDirectory::GetDirectory(const CURL& url, CFileItemList &items) iSize = tmpDirent.size; bIsDir = tmpDirent.type == NF3DIR; - lTimeDate = tmpDirent.mtime.tv_sec; if (!StringUtils::EqualsNoCase(strName,".") && !StringUtils::EqualsNoCase(strName,"..") && !StringUtils::EqualsNoCase(strName,"lost+found")) { - if(lTimeDate == 0) // if modification date is missing, use create date - { - lTimeDate = tmpDirent.ctime.tv_sec; - } - - long long ll = lTimeDate & 0xffffffff; - ll *= 10000000ll; - ll += 116444736000000000ll; - fileTime.lowDateTime = (DWORD)(ll & 0xffffffff); - fileTime.highDateTime = (DWORD)(ll >> 32); - KODI::TIME::FileTimeToLocalFileTime(&fileTime, &localTime); - CFileItemPtr pItem(new CFileItem(tmpDirent.name)); - pItem->m_dateTime=localTime; + pItem->m_dateTime = tmpDirent.mtime.tv_sec != 0 ? tmpDirent.mtime.tv_sec : tmpDirent.ctime.tv_sec; pItem->m_dwSize = iSize; if (bIsDir) diff --git a/xbmc/guilib/GUIEditControl.cpp b/xbmc/guilib/GUIEditControl.cpp index 179512f953..8e48e2777b 100644 --- a/xbmc/guilib/GUIEditControl.cpp +++ b/xbmc/guilib/GUIEditControl.cpp @@ -296,11 +296,8 @@ void CGUIEditControl::OnClick() { CDateTime dateTime; dateTime.SetFromDBTime(utf8); - KODI::TIME::SystemTime time; - dateTime.GetAsSystemTime(time); - if (CGUIDialogNumeric::ShowAndGetTime(time, !m_inputHeading.empty() ? m_inputHeading : g_localizeStrings.Get(21420))) + if (CGUIDialogNumeric::ShowAndGetTime(dateTime, !m_inputHeading.empty() ? m_inputHeading : g_localizeStrings.Get(21420))) { - dateTime = CDateTime(time); utf8 = dateTime.GetAsLocalizedTime("", false); textChanged = true; } @@ -312,11 +309,9 @@ void CGUIEditControl::OnClick() dateTime.SetFromDBDate(utf8); if (dateTime < CDateTime(2000,1, 1, 0, 0, 0)) dateTime = CDateTime(2000, 1, 1, 0, 0, 0); - KODI::TIME::SystemTime date; - dateTime.GetAsSystemTime(date); - if (CGUIDialogNumeric::ShowAndGetDate(date, !m_inputHeading.empty() ? m_inputHeading : g_localizeStrings.Get(21420))) + + if (CGUIDialogNumeric::ShowAndGetDate(dateTime, !m_inputHeading.empty() ? m_inputHeading : g_localizeStrings.Get(21420))) { - dateTime = CDateTime(date); utf8 = dateTime.GetAsDBDate(); textChanged = true; } diff --git a/xbmc/guilib/GUIRSSControl.h b/xbmc/guilib/GUIRSSControl.h index 96b9f2f3f3..a30a495f52 100644 --- a/xbmc/guilib/GUIRSSControl.h +++ b/xbmc/guilib/GUIRSSControl.h @@ -62,7 +62,7 @@ protected: KODI::GUILIB::GUIINFO::CGUIInfoColor m_headlineColor; std::vector m_vecUrls; - std::vector m_vecIntervals; + std::vector m_vecIntervals; bool m_rtl; CScrollInfo m_scrollInfo; bool m_dirty; diff --git a/xbmc/interfaces/legacy/Dialog.cpp b/xbmc/interfaces/legacy/Dialog.cpp index 00ac78077c..8b8746458c 100644 --- a/xbmc/interfaces/legacy/Dialog.cpp +++ b/xbmc/interfaces/legacy/Dialog.cpp @@ -278,8 +278,8 @@ namespace XBMCAddon { DelayedCallGuard dcguard(languageHook); std::string value; - KODI::TIME::SystemTime timedate; - KODI::TIME::GetLocalTime(&timedate); + + auto timedate = CDateTime::GetCurrentDateTime(); if (!heading.empty()) { @@ -287,13 +287,11 @@ namespace XBMCAddon { if (!defaultt.empty() && defaultt.size() == 10) { - const std::string& sDefault = defaultt; - timedate.day = atoi(sDefault.substr(0, 2).c_str()); - timedate.month = atoi(sDefault.substr(3, 4).c_str()); - timedate.year = atoi(sDefault.substr(sDefault.size() - 4).c_str()); + const std::string sDefault = defaultt; + timedate.SetFromDBDate(sDefault.substr(sDefault.size() - 4) + "-" + sDefault.substr(3, 4) + "-" + sDefault.substr(0, 2)); } if (CGUIDialogNumeric::ShowAndGetDate(timedate, heading)) - value = StringUtils::Format("%2d/%2d/%4d", timedate.day, timedate.month, timedate.year); + value = StringUtils::Format("%2d/%2d/%4d", timedate.GetDay(), timedate.GetMonth(), timedate.GetYear()); else return emptyString; } @@ -301,12 +299,11 @@ namespace XBMCAddon { if (!defaultt.empty() && defaultt.size() == 5) { - const std::string& sDefault = defaultt; - timedate.hour = atoi(sDefault.substr(0, 2).c_str()); - timedate.minute = atoi(sDefault.substr(3, 2).c_str()); + const std::string sDefault = defaultt; + timedate.SetFromDBTime(sDefault.substr(0, 2) + ":" + sDefault.substr(3, 2)); } if (CGUIDialogNumeric::ShowAndGetTime(timedate, heading)) - value = StringUtils::Format("%2d:%02d", timedate.hour, timedate.minute); + value = StringUtils::Format("%2d:%02d", timedate.GetHour(), timedate.GetMinute()); else return emptyString; } @@ -358,8 +355,8 @@ namespace XBMCAddon { DelayedCallGuard dcguard(languageHook); std::string value(defaultt); - KODI::TIME::SystemTime timedate; - KODI::TIME::GetLocalTime(&timedate); + + auto timedate = CDateTime::GetCurrentDateTime(); switch (type) { @@ -380,14 +377,12 @@ namespace XBMCAddon { if (!defaultt.empty() && defaultt.size() == 10) { - const std::string& sDefault = defaultt; - timedate.day = atoi(sDefault.substr(0, 2).c_str()); - timedate.month = atoi(sDefault.substr(3, 4).c_str()); - timedate.year = atoi(sDefault.substr(sDefault.size() - 4).c_str()); + const std::string sDefault = defaultt; + timedate.SetFromDBDate(sDefault.substr(sDefault.size() - 4) + "-" + sDefault.substr(3, 4) + "-" + sDefault.substr(0, 2)); } if (CGUIDialogNumeric::ShowAndGetDate(timedate, heading)) value = - StringUtils::Format("%2d/%2d/%4d", timedate.day, timedate.month, timedate.year); + StringUtils::Format("%2d/%2d/%4d", timedate.GetDay(), timedate.GetMonth(), timedate.GetYear()); else value = emptyString; } @@ -396,12 +391,11 @@ namespace XBMCAddon { if (!defaultt.empty() && defaultt.size() == 5) { - const std::string& sDefault = defaultt; - timedate.hour = atoi(sDefault.substr(0, 2).c_str()); - timedate.minute = atoi(sDefault.substr(3, 2).c_str()); + const std::string sDefault = defaultt; + timedate.SetFromDBTime(sDefault.substr(0, 2) + ":" + sDefault.substr(3, 2)); } if (CGUIDialogNumeric::ShowAndGetTime(timedate, heading)) - value = StringUtils::Format("%2d:%02d", timedate.hour, timedate.minute); + value = StringUtils::Format("%2d:%02d", timedate.GetHour(), timedate.GetMinute()); else value = emptyString; } diff --git a/xbmc/music/infoscanner/MusicInfoScanner.cpp b/xbmc/music/infoscanner/MusicInfoScanner.cpp index 13859b3bdb..3638870a79 100644 --- a/xbmc/music/infoscanner/MusicInfoScanner.cpp +++ b/xbmc/music/infoscanner/MusicInfoScanner.cpp @@ -1263,8 +1263,8 @@ int CMusicInfoScanner::GetPathHash(const CFileItemList &items, std::string &hash const CFileItemPtr pItem = items[i]; digest.Update(pItem->GetPath()); digest.Update((unsigned char *)&pItem->m_dwSize, sizeof(pItem->m_dwSize)); - KODI::TIME::FileTime time = pItem->m_dateTime; - digest.Update((unsigned char*)&time, sizeof(KODI::TIME::FileTime)); + const auto time = pItem->m_dateTime.GetAsTimePoint().time_since_epoch().count(); + digest.Update(&time, sizeof(std::chrono::nanoseconds)); if (pItem->IsAudio() && !pItem->IsPlayList() && !pItem->IsNFO()) count++; } diff --git a/xbmc/network/upnp/UPnPInternal.cpp b/xbmc/network/upnp/UPnPInternal.cpp index c232e972f2..1541f79eff 100644 --- a/xbmc/network/upnp/UPnPInternal.cpp +++ b/xbmc/network/upnp/UPnPInternal.cpp @@ -979,11 +979,18 @@ CFileItemPtr BuildObject(PLT_MediaObject* entry, } // look for date? - if(entry->m_Description.date.GetLength()) { - KODI::TIME::SystemTime time = {}; - sscanf(entry->m_Description.date, "%hu-%hu-%huT%hu:%hu:%hu", &time.year, &time.month, &time.day, - &time.hour, &time.minute, &time.second); - pItem->m_dateTime = time; + if (entry->m_Description.date.GetLength()) + { + int year; + int month; + int day; + int hour; + int minute; + int second; + + sscanf(entry->m_Description.date, "%hu-%hu-%huT%hu:%hu:%hu", &year, &month, &day, &hour, &minute, &second); + + pItem->m_dateTime.SetDateTime(year, month, day, hour, minute, second); } // if there is a thumbnail available set it here diff --git a/xbmc/platform/posix/XTimeUtils.cpp b/xbmc/platform/posix/XTimeUtils.cpp index 07bcf055b5..dc68651ac5 100644 --- a/xbmc/platform/posix/XTimeUtils.cpp +++ b/xbmc/platform/posix/XTimeUtils.cpp @@ -8,36 +8,14 @@ #include "utils/XTimeUtils.h" -#include "PosixTimezone.h" - -#include -#include - #include -#include #include -#if defined(TARGET_DARWIN) -#include "threads/Atomics.h" -#endif - -#if defined(TARGET_ANDROID) && !defined(__LP64__) -#include -#endif - -#define WIN32_TIME_OFFSET ((unsigned long long)(369 * 365 + 89) * 24 * 3600 * 10000000) - namespace KODI { namespace TIME { -/* - * A Leap year is any year that is divisible by four, but not by 100 unless also - * divisible by 400 - */ -#define IsLeapYear(y) ((!(y % 4)) ? (((!(y % 400)) && (y % 100)) ? 1 : 0) : 0) - void Sleep(uint32_t milliSeconds) { #if _POSIX_PRIORITY_SCHEDULING @@ -51,196 +29,5 @@ void Sleep(uint32_t milliSeconds) usleep(milliSeconds * 1000); } -uint32_t GetTimeZoneInformation(TimeZoneInformation* timeZoneInformation) -{ - if (!timeZoneInformation) - return KODI_TIME_ZONE_ID_INVALID; - - struct tm t; - time_t tt = time(NULL); - if (localtime_r(&tt, &t)) - timeZoneInformation->bias = -t.tm_gmtoff / 60; - - timeZoneInformation->standardName = tzname[0]; - timeZoneInformation->daylightName = tzname[1]; - - return KODI_TIME_ZONE_ID_UNKNOWN; -} - -void GetLocalTime(SystemTime* systemTime) -{ - const time_t t = time(NULL); - struct tm now; - - localtime_r(&t, &now); - systemTime->year = now.tm_year + 1900; - systemTime->month = now.tm_mon + 1; - systemTime->dayOfWeek = now.tm_wday; - systemTime->day = now.tm_mday; - systemTime->hour = now.tm_hour; - systemTime->minute = now.tm_min; - systemTime->second = now.tm_sec; - systemTime->milliseconds = 0; - // NOTE: localtime_r() is not required to set this, but we Assume that it's set here. - g_timezone.m_IsDST = now.tm_isdst; -} - -int FileTimeToLocalFileTime(const FileTime* fileTime, FileTime* localFileTime) -{ - ULARGE_INTEGER l; - l.u.LowPart = fileTime->lowDateTime; - l.u.HighPart = fileTime->highDateTime; - - time_t ft; - struct tm tm_ft; - FileTimeToTimeT(fileTime, &ft); - localtime_r(&ft, &tm_ft); - - l.QuadPart += static_cast(tm_ft.tm_gmtoff) * 10000000; - - localFileTime->lowDateTime = l.u.LowPart; - localFileTime->highDateTime = l.u.HighPart; - return 1; -} - -int SystemTimeToFileTime(const SystemTime* systemTime, FileTime* fileTime) -{ - static const int dayoffset[12] = {0, 31, 59, 90, 120, 151, 182, 212, 243, 273, 304, 334}; -#if defined(TARGET_DARWIN) - static std::atomic_flag timegm_lock = ATOMIC_FLAG_INIT; -#endif - - struct tm sysTime = {}; - sysTime.tm_year = systemTime->year - 1900; - sysTime.tm_mon = systemTime->month - 1; - sysTime.tm_wday = systemTime->dayOfWeek; - sysTime.tm_mday = systemTime->day; - sysTime.tm_hour = systemTime->hour; - sysTime.tm_min = systemTime->minute; - sysTime.tm_sec = systemTime->second; - sysTime.tm_yday = dayoffset[sysTime.tm_mon] + (sysTime.tm_mday - 1); - sysTime.tm_isdst = g_timezone.m_IsDST; - - // If this is a leap year, and we're past the 28th of Feb, increment tm_yday. - if (IsLeapYear(systemTime->year) && (sysTime.tm_yday > 58)) - sysTime.tm_yday++; - -#if defined(TARGET_DARWIN) - CAtomicSpinLock lock(timegm_lock); -#endif - -#if defined(TARGET_ANDROID) && !defined(__LP64__) - time64_t t = timegm64(&sysTime); -#else - time_t t = timegm(&sysTime); -#endif - - LARGE_INTEGER result; - result.QuadPart = (long long)t * 10000000 + (long long)systemTime->milliseconds * 10000; - result.QuadPart += WIN32_TIME_OFFSET; - - fileTime->lowDateTime = result.u.LowPart; - fileTime->highDateTime = result.u.HighPart; - - return 1; -} - -long CompareFileTime(const FileTime* fileTime1, const FileTime* fileTime2) -{ - ULARGE_INTEGER t1; - t1.u.LowPart = fileTime1->lowDateTime; - t1.u.HighPart = fileTime1->highDateTime; - - ULARGE_INTEGER t2; - t2.u.LowPart = fileTime2->lowDateTime; - t2.u.HighPart = fileTime2->highDateTime; - - if (t1.QuadPart == t2.QuadPart) - return 0; - else if (t1.QuadPart < t2.QuadPart) - return -1; - else - return 1; -} - -int FileTimeToSystemTime(const FileTime* fileTime, SystemTime* systemTime) -{ - LARGE_INTEGER file; - file.u.LowPart = fileTime->lowDateTime; - file.u.HighPart = fileTime->highDateTime; - - file.QuadPart -= WIN32_TIME_OFFSET; - file.QuadPart /= 10000; /* to milliseconds */ - systemTime->milliseconds = file.QuadPart % 1000; - file.QuadPart /= 1000; /* to seconds */ - - time_t ft = file.QuadPart; - - struct tm tm_ft; - gmtime_r(&ft,&tm_ft); - - systemTime->year = tm_ft.tm_year + 1900; - systemTime->month = tm_ft.tm_mon + 1; - systemTime->dayOfWeek = tm_ft.tm_wday; - systemTime->day = tm_ft.tm_mday; - systemTime->hour = tm_ft.tm_hour; - systemTime->minute = tm_ft.tm_min; - systemTime->second = tm_ft.tm_sec; - - return 1; -} - -int LocalFileTimeToFileTime(const FileTime* localFileTime, FileTime* fileTime) -{ - ULARGE_INTEGER l; - l.u.LowPart = localFileTime->lowDateTime; - l.u.HighPart = localFileTime->highDateTime; - - l.QuadPart += (unsigned long long) timezone * 10000000; - - fileTime->lowDateTime = l.u.LowPart; - fileTime->highDateTime = l.u.HighPart; - - return 1; -} - - -int FileTimeToTimeT(const FileTime* localFileTime, time_t* pTimeT) -{ - if (!localFileTime || !pTimeT) - return false; - - ULARGE_INTEGER fileTime; - fileTime.u.LowPart = localFileTime->lowDateTime; - fileTime.u.HighPart = localFileTime->highDateTime; - - fileTime.QuadPart -= WIN32_TIME_OFFSET; - fileTime.QuadPart /= 10000; /* to milliseconds */ - fileTime.QuadPart /= 1000; /* to seconds */ - - time_t ft = fileTime.QuadPart; - - struct tm tm_ft; - localtime_r(&ft,&tm_ft); - - *pTimeT = mktime(&tm_ft); - return 1; -} - -int TimeTToFileTime(time_t timeT, FileTime* localFileTime) -{ - if (!localFileTime) - return false; - - ULARGE_INTEGER result; - result.QuadPart = (unsigned long long) timeT * 10000000; - result.QuadPart += WIN32_TIME_OFFSET; - - localFileTime->lowDateTime = result.u.LowPart; - localFileTime->highDateTime = result.u.HighPart; - - return 1; -} - } // namespace TIME } // namespace KODI diff --git a/xbmc/platform/posix/filesystem/PosixDirectory.cpp b/xbmc/platform/posix/filesystem/PosixDirectory.cpp index 6685c0e1db..7482a73960 100644 --- a/xbmc/platform/posix/filesystem/PosixDirectory.cpp +++ b/xbmc/platform/posix/filesystem/PosixDirectory.cpp @@ -79,10 +79,7 @@ bool CPosixDirectory::GetDirectory(const CURL& url, CFileItemList &items) { if (bStat || stat(pItem->GetPath().c_str(), &buffer) == 0) { - KODI::TIME::FileTime fileTime, localTime; - KODI::TIME::TimeTToFileTime(buffer.st_mtime, &fileTime); - KODI::TIME::FileTimeToLocalFileTime(&fileTime, &localTime); - pItem->m_dateTime = localTime; + pItem->m_dateTime = buffer.st_mtime; if (!pItem->m_bIsFolder) pItem->m_dwSize = buffer.st_size; diff --git a/xbmc/platform/posix/filesystem/SMBDirectory.cpp b/xbmc/platform/posix/filesystem/SMBDirectory.cpp index 127cd7993b..8902d34dd0 100644 --- a/xbmc/platform/posix/filesystem/SMBDirectory.cpp +++ b/xbmc/platform/posix/filesystem/SMBDirectory.cpp @@ -105,9 +105,8 @@ bool CSMBDirectory::GetDirectory(const CURL& url, CFileItemList &items) && strFile != "lost+found" && aDir.type != SMBC_PRINTER_SHARE && aDir.type != SMBC_IPC_SHARE) { - int64_t iSize = 0; + int64_t iSize = 0; bool bIsDir = true; - int64_t lTimeDate = 0; bool hidden = false; if(StringUtils::EndsWith(strFile, "$") && aDir.type == SMBC_FILE_SHARE ) @@ -152,9 +151,6 @@ bool CSMBDirectory::GetDirectory(const CURL& url, CFileItemList &items) CLog::Log(LOGERROR, "Getting extended attributes for the share: '%s'\nunix_err:'%x' error: '%s'", CURL::GetRedacted(strFullName).c_str(), errno, strerror(errno)); bIsDir = S_ISDIR(info.st_mode); - lTimeDate = info.st_mtime; - if(lTimeDate == 0) // if modification date is missing, use create date - lTimeDate = info.st_ctime; iSize = info.st_size; } else @@ -164,10 +160,6 @@ bool CSMBDirectory::GetDirectory(const CURL& url, CFileItemList &items) } } - KODI::TIME::FileTime fileTime, localTime; - KODI::TIME::TimeTToFileTime(lTimeDate, &fileTime); - KODI::TIME::FileTimeToLocalFileTime(&fileTime, &localTime); - if (bIsDir) { CFileItemPtr pItem(new CFileItem(strFile)); @@ -187,7 +179,7 @@ bool CSMBDirectory::GetDirectory(const CURL& url, CFileItemList &items) URIUtils::AddSlashAtEnd(path); pItem->SetPath(path); pItem->m_bIsFolder = true; - pItem->m_dateTime=localTime; + pItem->m_dateTime = info.st_mtime != 0 ? info.st_mtime : info.st_ctime; if (hidden) pItem->SetProperty("file:hidden", true); items.Add(pItem); @@ -198,7 +190,7 @@ bool CSMBDirectory::GetDirectory(const CURL& url, CFileItemList &items) pItem->SetPath(strRoot + aDir.name); pItem->m_bIsFolder = false; pItem->m_dwSize = iSize; - pItem->m_dateTime=localTime; + pItem->m_dateTime = info.st_mtime != 0 ? info.st_mtime : info.st_ctime; if (hidden) pItem->SetProperty("file:hidden", true); items.Add(pItem); diff --git a/xbmc/pvr/dialogs/GUIDialogPVRTimerSettings.cpp b/xbmc/pvr/dialogs/GUIDialogPVRTimerSettings.cpp index 49e1d65ad2..3be889ab3d 100644 --- a/xbmc/pvr/dialogs/GUIDialogPVRTimerSettings.cpp +++ b/xbmc/pvr/dialogs/GUIDialogPVRTimerSettings.cpp @@ -506,22 +506,16 @@ void CGUIDialogPVRTimerSettings::OnSettingAction(const std::shared_ptrGetId(); if (settingId == SETTING_TMR_BEGIN) { - KODI::TIME::SystemTime timerStartTime; - m_startLocalTime.GetAsSystemTime(timerStartTime); - if (CGUIDialogNumeric::ShowAndGetTime(timerStartTime, g_localizeStrings.Get(14066))) + if (CGUIDialogNumeric::ShowAndGetTime(m_startLocalTime, g_localizeStrings.Get(14066))) { - SetTimeFromSystemTime(m_startLocalTime, timerStartTime); m_timerStartTimeStr = m_startLocalTime.GetAsLocalizedTime("", false); SetButtonLabels(); } } else if (settingId == SETTING_TMR_END) { - KODI::TIME::SystemTime timerEndTime; - m_endLocalTime.GetAsSystemTime(timerEndTime); - if (CGUIDialogNumeric::ShowAndGetTime(timerEndTime, g_localizeStrings.Get(14066))) + if (CGUIDialogNumeric::ShowAndGetTime(m_endLocalTime, g_localizeStrings.Get(14066))) { - SetTimeFromSystemTime(m_endLocalTime, timerEndTime); m_timerEndTimeStr = m_endLocalTime.GetAsLocalizedTime("", false); SetButtonLabels(); } @@ -727,15 +721,6 @@ void CGUIDialogPVRTimerSettings::SetDateFromIndex(CDateTime& datetime, int date) datetime.GetHour(), datetime.GetMinute(), datetime.GetSecond()); } -void CGUIDialogPVRTimerSettings::SetTimeFromSystemTime(CDateTime& datetime, - const KODI::TIME::SystemTime& time) -{ - const CDateTime newTime(time); - datetime.SetDateTime( - datetime.GetYear(), datetime.GetMonth(), datetime.GetDay(), - newTime.GetHour(), newTime.GetMinute(), newTime.GetSecond()); -} - void CGUIDialogPVRTimerSettings::InitializeTypesList() { m_typeEntries.clear(); diff --git a/xbmc/pvr/dialogs/GUIDialogPVRTimerSettings.h b/xbmc/pvr/dialogs/GUIDialogPVRTimerSettings.h index cf7458a98c..970059035d 100644 --- a/xbmc/pvr/dialogs/GUIDialogPVRTimerSettings.h +++ b/xbmc/pvr/dialogs/GUIDialogPVRTimerSettings.h @@ -59,7 +59,6 @@ namespace PVR static int GetDateAsIndex(const CDateTime& datetime); static void SetDateFromIndex(CDateTime& datetime, int date); - static void SetTimeFromSystemTime(CDateTime& datetime, const KODI::TIME::SystemTime& time); static int GetWeekdaysFromSetting(const std::shared_ptr& setting); diff --git a/xbmc/pvr/windows/GUIWindowPVRGuide.cpp b/xbmc/pvr/windows/GUIWindowPVRGuide.cpp index 2f06ed7303..89aa247205 100644 --- a/xbmc/pvr/windows/GUIWindowPVRGuide.cpp +++ b/xbmc/pvr/windows/GUIWindowPVRGuide.cpp @@ -762,13 +762,12 @@ bool CGUIWindowPVRGuideBase::OpenDateSelectionDialog() { bool bReturn = false; - KODI::TIME::SystemTime date; CGUIEPGGridContainer* epgGridContainer = GetGridControl(); - epgGridContainer->GetSelectedDate().GetAsSystemTime(date); + CDateTime datetime = epgGridContainer->GetSelectedDate(); - if (CGUIDialogNumeric::ShowAndGetDate(date, g_localizeStrings.Get(19288))) /* Go to date */ + if (CGUIDialogNumeric::ShowAndGetDate(datetime, g_localizeStrings.Get(19288))) /* Go to date */ { - epgGridContainer->GoToDate(CDateTime(date)); + epgGridContainer->GoToDate(datetime); bReturn = true; } diff --git a/xbmc/settings/windows/GUIControlSettings.cpp b/xbmc/settings/windows/GUIControlSettings.cpp index c4b1e5e6ef..085ce16a0e 100644 --- a/xbmc/settings/windows/GUIControlSettings.cpp +++ b/xbmc/settings/windows/GUIControlSettings.cpp @@ -927,21 +927,19 @@ bool CGUIControlButtonSetting::OnClick() std::shared_ptr settingDate = std::static_pointer_cast(m_pSetting); - KODI::TIME::SystemTime systemdate; - settingDate->GetDate().GetAsSystemTime(systemdate); - if (CGUIDialogNumeric::ShowAndGetDate(systemdate, Localize(buttonControl->GetHeading()))) - SetValid(settingDate->SetDate(CDateTime(systemdate))); + CDateTime datetime = settingDate->GetDate(); + if (CGUIDialogNumeric::ShowAndGetDate(datetime, Localize(buttonControl->GetHeading()))) + SetValid(settingDate->SetDate(datetime)); } else if (controlFormat == "time") { std::shared_ptr settingTime = std::static_pointer_cast(m_pSetting); - KODI::TIME::SystemTime systemtime; - settingTime->GetTime().GetAsSystemTime(systemtime); + CDateTime datetime = settingTime->GetTime(); - if (CGUIDialogNumeric::ShowAndGetTime(systemtime, Localize(buttonControl->GetHeading()))) - SetValid(settingTime->SetTime(CDateTime(systemtime))); + if (CGUIDialogNumeric::ShowAndGetTime(datetime, Localize(buttonControl->GetHeading()))) + SetValid(settingTime->SetTime(datetime)); } else if (controlFormat == "action") { diff --git a/xbmc/test/TestDateTime.cpp b/xbmc/test/TestDateTime.cpp index c55c5fe3ea..1dc37b03f0 100644 --- a/xbmc/test/TestDateTime.cpp +++ b/xbmc/test/TestDateTime.cpp @@ -36,17 +36,16 @@ TEST_F(TestDateTime, DateTimeOperators) EXPECT_FALSE(dateTime1 == dateTime2); } -TEST_F(TestDateTime, SystemTimeOperators) +TEST_F(TestDateTime, TimePointOperators) { CDateTime dateTime1(1991, 5, 14, 12, 34, 56); CDateTime dateTime2(1991, 5, 14, 12, 34, 57); - KODI::TIME::SystemTime systemTime; - dateTime2.GetAsSystemTime(systemTime); + auto tp = dateTime2.GetAsTimePoint(); - EXPECT_TRUE(dateTime1 < systemTime); - EXPECT_FALSE(dateTime1 > systemTime); - EXPECT_FALSE(dateTime1 == systemTime); + EXPECT_TRUE(dateTime1 < tp); + EXPECT_FALSE(dateTime1 > tp); + EXPECT_FALSE(dateTime1 == tp); } TEST_F(TestDateTime, TimeTOperators) @@ -498,15 +497,14 @@ TEST_F(TestDateTime, GetAsLocalized) EXPECT_EQ(dateTime2.GetAsLocalizedTime(TIME_FORMAT(256)), "5"); } -TEST_F(TestDateTime, GetAsSystemTime) +TEST_F(TestDateTime, GetAsTimePoint) { CDateTime dateTime; dateTime.SetDateTime(1991, 05, 14, 12, 34, 56); - KODI::TIME::SystemTime systemTime; - dateTime.GetAsSystemTime(systemTime); + auto tp = dateTime.GetAsTimePoint(); - EXPECT_TRUE(dateTime == systemTime); + EXPECT_TRUE(dateTime == tp); } TEST_F(TestDateTime, GetAsTime) diff --git a/xbmc/utils/Archive.cpp b/xbmc/utils/Archive.cpp index 1b8392b7b6..3d2ddf8da9 100644 --- a/xbmc/utils/Archive.cpp +++ b/xbmc/utils/Archive.cpp @@ -151,9 +151,9 @@ CArchive& CArchive::operator<<(const std::wstring& wstr) return streamout(wstr.data(), size * sizeof(wchar_t)); } -CArchive& CArchive::operator<<(const KODI::TIME::SystemTime& time) +CArchive& CArchive::operator<<(const std::chrono::system_clock::time_point& time) { - return streamout(&time, sizeof(KODI::TIME::SystemTime)); + return streamout(&time, sizeof(std::chrono::system_clock::time_point)); } CArchive& CArchive::operator<<(IArchivable& obj) @@ -264,9 +264,9 @@ CArchive& CArchive::operator>>(std::wstring& wstr) return *this; } -CArchive& CArchive::operator>>(KODI::TIME::SystemTime& time) +CArchive& CArchive::operator>>(std::chrono::system_clock::time_point& time) { - return streamin(&time, sizeof(KODI::TIME::SystemTime)); + return streamin(&time, sizeof(std::chrono::system_clock::time_point)); } CArchive& CArchive::operator>>(IArchivable& obj) diff --git a/xbmc/utils/Archive.h b/xbmc/utils/Archive.h index f8c7513bef..313c6615f6 100644 --- a/xbmc/utils/Archive.h +++ b/xbmc/utils/Archive.h @@ -54,7 +54,7 @@ public: CArchive& operator<<(char c); CArchive& operator<<(const std::string &str); CArchive& operator<<(const std::wstring& wstr); - CArchive& operator<<(const KODI::TIME::SystemTime& time); + CArchive& operator<<(const std::chrono::system_clock::time_point& time); CArchive& operator<<(IArchivable& obj); CArchive& operator<<(const CVariant& variant); CArchive& operator<<(const std::vector& strArray); @@ -123,7 +123,7 @@ public: CArchive& operator>>(std::string &str); CArchive& operator>>(std::wstring& wstr); - CArchive& operator>>(KODI::TIME::SystemTime& time); + CArchive& operator>>(std::chrono::system_clock::time_point& time); CArchive& operator>>(IArchivable& obj); CArchive& operator>>(CVariant& variant); CArchive& operator>>(std::vector& strArray); diff --git a/xbmc/utils/RssManager.cpp b/xbmc/utils/RssManager.cpp index 4c2a2f06b3..16ed363253 100644 --- a/xbmc/utils/RssManager.cpp +++ b/xbmc/utils/RssManager.cpp @@ -143,7 +143,7 @@ bool CRssManager::Load() //! What about the xml encoding? std::string strUrl = pFeed->FirstChild()->ValueStr(); set.url.push_back(strUrl); - set.interval.push_back(iInterval); + set.interval.push_back(std::chrono::minutes(iInterval)); } pFeed = pFeed->NextSiblingElement("feed"); } diff --git a/xbmc/utils/RssManager.h b/xbmc/utils/RssManager.h index 2b807d739f..59ac506307 100644 --- a/xbmc/utils/RssManager.h +++ b/xbmc/utils/RssManager.h @@ -22,7 +22,7 @@ class IRssObserver; typedef struct { bool rtl; - std::vector interval; + std::vector interval; std::vector url; } RssSet; typedef std::map RssUrls; diff --git a/xbmc/utils/RssReader.cpp b/xbmc/utils/RssReader.cpp index ecebc93a9f..924eed7bbc 100644 --- a/xbmc/utils/RssReader.cpp +++ b/xbmc/utils/RssReader.cpp @@ -49,11 +49,10 @@ CRssReader::~CRssReader() if (m_pObserver) m_pObserver->OnFeedRelease(); StopThread(); - for (unsigned int i = 0; i < m_vecTimeStamps.size(); i++) - delete m_vecTimeStamps[i]; + m_vecTimeStamps.clear(); } -void CRssReader::Create(IRssObserver* aObserver, const std::vector& aUrls, const std::vector ×, int spacesBetweenFeeds, bool rtl) +void CRssReader::Create(IRssObserver* aObserver, const std::vector& aUrls, const std::vector ×, int spacesBetweenFeeds, bool rtl) { CSingleLock lock(m_critical); @@ -71,9 +70,7 @@ void CRssReader::Create(IRssObserver* aObserver, const std::vector& for (unsigned int i = 0; i < m_vecUpdateTimes.size(); ++i) { AddToQueue(i); - KODI::TIME::SystemTime* time = new KODI::TIME::SystemTime; - KODI::TIME::GetLocalTime(time); - m_vecTimeStamps.push_back(time); + m_vecTimeStamps.push_back(std::chrono::system_clock::now().time_since_epoch()); } } @@ -393,18 +390,14 @@ void CRssReader::UpdateObserver() void CRssReader::CheckForUpdates() { - KODI::TIME::SystemTime time; - KODI::TIME::GetLocalTime(&time); + for (unsigned int i = 0;i < m_vecUpdateTimes.size(); ++i ) { - if (m_requestRefresh || ((time.day * 24 * 60) + (time.hour * 60) + time.minute) - - ((m_vecTimeStamps[i]->day * 24 * 60) + - (m_vecTimeStamps[i]->hour * 60) + m_vecTimeStamps[i]->minute) > - m_vecUpdateTimes[i]) + if (m_requestRefresh || (std::chrono::system_clock::now().time_since_epoch() - m_vecTimeStamps[i] > m_vecUpdateTimes[i])) { CLog::Log(LOGDEBUG, "Updating RSS"); - KODI::TIME::GetLocalTime(m_vecTimeStamps[i]); + m_vecTimeStamps[i] = std::chrono::system_clock::now().time_since_epoch(); AddToQueue(i); } } diff --git a/xbmc/utils/RssReader.h b/xbmc/utils/RssReader.h index 6e259ff147..fce86a9e45 100644 --- a/xbmc/utils/RssReader.h +++ b/xbmc/utils/RssReader.h @@ -24,7 +24,7 @@ public: CRssReader(); ~CRssReader() override; - void Create(IRssObserver* aObserver, const std::vector& aUrl, const std::vector& times, int spacesBetweenFeeds, bool rtl); + void Create(IRssObserver* aObserver, const std::vector& aUrl, const std::vector& times, int spacesBetweenFeeds, bool rtl); bool Parse(const std::string& data, int iFeed, const std::string& charset); void getFeed(vecText &text); void AddTag(const std::string &addTag); @@ -48,8 +48,8 @@ private: std::vector m_strFeed; std::vector m_strColors; - std::vector m_vecTimeStamps; - std::vector m_vecUpdateTimes; + std::vector m_vecTimeStamps; + std::vector m_vecUpdateTimes; int m_spacesBetweenFeeds; CXBMCTinyXML m_xml; std::list m_tagSet; diff --git a/xbmc/utils/XTimeUtils.h b/xbmc/utils/XTimeUtils.h index 721c1f70f9..839e3e3e1f 100644 --- a/xbmc/utils/XTimeUtils.h +++ b/xbmc/utils/XTimeUtils.h @@ -25,52 +25,8 @@ namespace KODI { namespace TIME { -struct SystemTime -{ - unsigned short year; - unsigned short month; - unsigned short dayOfWeek; - unsigned short day; - unsigned short hour; - unsigned short minute; - unsigned short second; - unsigned short milliseconds; -}; - -struct TimeZoneInformation -{ - long bias; - std::string standardName; - SystemTime standardDate; - long standardBias; - std::string daylightName; - SystemTime daylightDate; - long daylightBias; -}; - -constexpr int KODI_TIME_ZONE_ID_INVALID{-1}; -constexpr int KODI_TIME_ZONE_ID_UNKNOWN{0}; -constexpr int KODI_TIME_ZONE_ID_STANDARD{1}; -constexpr int KODI_TIME_ZONE_ID_DAYLIGHT{2}; - -struct FileTime -{ - unsigned int lowDateTime; - unsigned int highDateTime; -}; - -void GetLocalTime(SystemTime* systemTime); -uint32_t GetTimeZoneInformation(TimeZoneInformation* timeZoneInformation); void Sleep(uint32_t milliSeconds); -int FileTimeToLocalFileTime(const FileTime* fileTime, FileTime* localFileTime); -int SystemTimeToFileTime(const SystemTime* systemTime, FileTime* fileTime); -long CompareFileTime(const FileTime* fileTime1, const FileTime* fileTime2); -int FileTimeToSystemTime(const FileTime* fileTime, SystemTime* systemTime); -int LocalFileTimeToFileTime(const FileTime* LocalFileTime, FileTime* fileTime); - -int FileTimeToTimeT(const FileTime* localFileTime, time_t* pTimeT); -int TimeTToFileTime(time_t timeT, FileTime* localFileTime); } // namespace TIME } // namespace KODI diff --git a/xbmc/utils/test/TestArchive.cpp b/xbmc/utils/test/TestArchive.cpp index 65023fddd4..41841c41df 100644 --- a/xbmc/utils/test/TestArchive.cpp +++ b/xbmc/utils/test/TestArchive.cpp @@ -220,22 +220,22 @@ TEST_F(TestArchive, StringArchive) EXPECT_STREQ(string_ref.c_str(), string_var.c_str()); } -TEST_F(TestArchive, SystemTimeArchive) +TEST_F(TestArchive, TimePointArchive) { ASSERT_NE(nullptr, file); - KODI::TIME::SystemTime SystemTime_ref = {1, 2, 3, 4, 5, 6, 7, 8}; - KODI::TIME::SystemTime SystemTime_var = {0, 0, 0, 0, 0, 0, 0, 0}; + std::chrono::system_clock::time_point tp_ref = std::chrono::system_clock::now(); + std::chrono::system_clock::time_point tp_var; CArchive arstore(file, CArchive::store); - arstore << SystemTime_ref; + arstore << tp_ref; arstore.Close(); ASSERT_EQ(0, file->Seek(0, SEEK_SET)); CArchive arload(file, CArchive::load); - arload >> SystemTime_var; + arload >> tp_var; arload.Close(); - EXPECT_TRUE(!memcmp(&SystemTime_ref, &SystemTime_var, sizeof(KODI::TIME::SystemTime))); + EXPECT_TRUE(!memcmp(&tp_ref, &tp_var, sizeof(std::chrono::system_clock::time_point))); } TEST_F(TestArchive, CVariantArchive) @@ -335,8 +335,8 @@ TEST_F(TestArchive, MultiTypeArchive) char char_ref = 'A', char_var = '\0'; std::string string_ref = "test string", string_var; std::wstring wstring_ref = L"test wstring", wstring_var; - KODI::TIME::SystemTime SystemTime_ref = {1, 2, 3, 4, 5, 6, 7, 8}; - KODI::TIME::SystemTime SystemTime_var = {0, 0, 0, 0, 0, 0, 0, 0}; + std::chrono::system_clock::time_point tp_ref = std::chrono::system_clock::now(); + std::chrono::system_clock::time_point tp_var; CVariant CVariant_ref((int)1), CVariant_var; std::vector strArray_ref, strArray_var; strArray_ref.emplace_back("test strArray_ref 0"); @@ -362,7 +362,7 @@ TEST_F(TestArchive, MultiTypeArchive) arstore << char_ref; arstore << string_ref; arstore << wstring_ref; - arstore << SystemTime_ref; + arstore << tp_ref; arstore << CVariant_ref; arstore << strArray_ref; arstore << iArray_ref; @@ -382,7 +382,7 @@ TEST_F(TestArchive, MultiTypeArchive) arload >> char_var; arload >> string_var; arload >> wstring_var; - arload >> SystemTime_var; + arload >> tp_var; arload >> CVariant_var; arload >> strArray_var; arload >> iArray_var; @@ -398,7 +398,7 @@ TEST_F(TestArchive, MultiTypeArchive) EXPECT_EQ(char_ref, char_var); EXPECT_STREQ(string_ref.c_str(), string_var.c_str()); EXPECT_STREQ(wstring_ref.c_str(), wstring_var.c_str()); - EXPECT_TRUE(!memcmp(&SystemTime_ref, &SystemTime_var, sizeof(KODI::TIME::SystemTime))); + EXPECT_TRUE(!memcmp(&tp_ref, &tp_var, sizeof(std::chrono::system_clock::time_point))); EXPECT_TRUE(CVariant_var.isInteger()); EXPECT_STREQ("test strArray_ref 0", strArray_var.at(0).c_str()); EXPECT_STREQ("test strArray_ref 1", strArray_var.at(1).c_str()); diff --git a/xbmc/video/VideoInfoScanner.cpp b/xbmc/video/VideoInfoScanner.cpp index bfb3ea5eb9..94d71db37f 100644 --- a/xbmc/video/VideoInfoScanner.cpp +++ b/xbmc/video/VideoInfoScanner.cpp @@ -1924,8 +1924,8 @@ namespace VIDEO else { digest.Update(&pItem->m_dwSize, sizeof(pItem->m_dwSize)); - KODI::TIME::FileTime time = pItem->m_dateTime; - digest.Update(&time, sizeof(KODI::TIME::FileTime)); + const auto time = pItem->m_dateTime.GetAsTimePoint().time_since_epoch().count(); + digest.Update(&time, sizeof(std::chrono::nanoseconds)); } if (pItem->IsVideo() && !pItem->IsPlayList() && !pItem->IsNFO()) count++; -- 2.31.1 From a5f566c603a4440df292e0488861bc0ebc2974ea Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Tue, 20 Oct 2020 09:23:44 +0300 Subject: [PATCH 07/17] SMBDirectory.cpp: Fix compile error --- xbmc/platform/posix/filesystem/SMBDirectory.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xbmc/platform/posix/filesystem/SMBDirectory.cpp b/xbmc/platform/posix/filesystem/SMBDirectory.cpp index 8902d34dd0..4a3b488182 100644 --- a/xbmc/platform/posix/filesystem/SMBDirectory.cpp +++ b/xbmc/platform/posix/filesystem/SMBDirectory.cpp @@ -108,6 +108,7 @@ bool CSMBDirectory::GetDirectory(const CURL& url, CFileItemList &items) int64_t iSize = 0; bool bIsDir = true; bool hidden = false; + struct stat info = {0}; if(StringUtils::EndsWith(strFile, "$") && aDir.type == SMBC_FILE_SHARE ) continue; @@ -122,7 +123,6 @@ bool CSMBDirectory::GetDirectory(const CURL& url, CFileItemList &items) // set this here to if the stat should fail bIsDir = (aDir.type == SMBC_DIR); - struct stat info = {0}; if ((m_flags & DIR_FLAG_NO_FILE_INFO)==0 && CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_sambastatfiles) { // make sure we use the authenticated path wich contains any default username -- 2.31.1 From 0ad7e997a335175e501405201a6f109eaa161425 Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Wed, 21 Oct 2020 09:17:33 +0300 Subject: [PATCH 08/17] TestDateTime: fix GetAsStringsWithBias and add Tzdata tests The 'GetAsStringsWithBias' test logic assumed the timezone on machine bullding Kodi is set to 'UTC'. This is not always the case, plus hour value was declared with a typo. To address this, we compare outputs of two runs of date library, and instead add a 'Tzdata' test case comparing local date and time against computed values from different timezones: find /usr/share/zoneinfo/Etc/ -type f | sort -Vu | sed 's,^/usr/share/zoneinfo/,,' | while read TZ do TMSTR=$(LANG=C TZ="$TZ" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/') echo " // LANG=C TZ=\"$TZ\" date '+%Y-%m-%dT%H:%M:%S%Ez' -d \"1991-05-14 12:34:56 UTC\" | sed 's/[0-9][0-9]$/:&/'" echo " tps = date::floor(dateTime.GetAsTimePoint());" echo " zone = date::make_zoned(\"$TZ\", tps);" echo " EXPECT_EQ(date::format(\"%FT%T%Ez\", zone), \"$TMSTR\") << \"tzdata information not valid for '$TZ'\";" echo "" done --- xbmc/test/TestDateTime.cpp | 142 ++++++++++++++++++++++++++++++++++++- 1 file changed, 140 insertions(+), 2 deletions(-) diff --git a/xbmc/test/TestDateTime.cpp b/xbmc/test/TestDateTime.cpp index 1dc37b03f0..41887ae096 100644 --- a/xbmc/test/TestDateTime.cpp +++ b/xbmc/test/TestDateTime.cpp @@ -11,6 +11,7 @@ #include "guilib/LocalizeStrings.h" #include +#include #include #define USE_OS_TZDB 0 @@ -299,10 +300,11 @@ TEST_F(TestDateTime, GetAsStringsWithBias) std::cout << dateTime.GetAsW3CDateTime(false) << std::endl; std::cout << dateTime.GetAsW3CDateTime(true) << std::endl; - auto zone = date::make_zoned(date::current_zone(), dateTime.GetAsTimePoint()); + auto tps = date::floor(dateTime.GetAsTimePoint()); + auto zone = date::make_zoned(date::current_zone(), tps); EXPECT_EQ(dateTime.GetAsRFC1123DateTime(), "Tue, 14 May 1991 12:34:56 GMT"); - EXPECT_EQ(dateTime.GetAsW3CDateTime(false), "1991-05-14T05:34:56" + date::format("%Ez", zone)); + EXPECT_EQ(dateTime.GetAsW3CDateTime(false), date::format("%FT%T%Ez", zone)); EXPECT_EQ(dateTime.GetAsW3CDateTime(true), "1991-05-14T12:34:56Z"); } @@ -559,3 +561,139 @@ TEST_F(TestDateTime, Reset) EXPECT_EQ(dateTime.GetMinute(), 0); EXPECT_EQ(dateTime.GetSecond(), 0); } + +TEST_F(TestDateTime, Tzdata) +{ + CDateTime dateTime; + dateTime.SetDateTime(1991, 05, 14, 12, 34, 56); + + // LANG=C TZ="Etc/GMT+1" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + auto tps = date::floor(dateTime.GetAsTimePoint()); + auto zone = date::make_zoned("Etc/GMT+1", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T11:34:56-01:00") << "tzdata information not valid for 'Etc/GMT+1'"; + + // LANG=C TZ="Etc/GMT+2" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+2", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T10:34:56-02:00") << "tzdata information not valid for 'Etc/GMT+2'"; + + // LANG=C TZ="Etc/GMT+3" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+3", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T09:34:56-03:00") << "tzdata information not valid for 'Etc/GMT+3'"; + + // LANG=C TZ="Etc/GMT+4" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+4", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T08:34:56-04:00") << "tzdata information not valid for 'Etc/GMT+4'"; + + // LANG=C TZ="Etc/GMT+5" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+5", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T07:34:56-05:00") << "tzdata information not valid for 'Etc/GMT+5'"; + + // LANG=C TZ="Etc/GMT+6" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+6", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T06:34:56-06:00") << "tzdata information not valid for 'Etc/GMT+6'"; + + // LANG=C TZ="Etc/GMT+7" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+7", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T05:34:56-07:00") << "tzdata information not valid for 'Etc/GMT+7'"; + + // LANG=C TZ="Etc/GMT+8" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+8", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T04:34:56-08:00") << "tzdata information not valid for 'Etc/GMT+8'"; + + // LANG=C TZ="Etc/GMT+9" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+9", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T03:34:56-09:00") << "tzdata information not valid for 'Etc/GMT+9'"; + + // LANG=C TZ="Etc/GMT+10" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+10", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T02:34:56-10:00") << "tzdata information not valid for 'Etc/GMT+10'"; + + // LANG=C TZ="Etc/GMT+11" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+11", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T01:34:56-11:00") << "tzdata information not valid for 'Etc/GMT+11'"; + + // LANG=C TZ="Etc/GMT+12" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT+12", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T00:34:56-12:00") << "tzdata information not valid for 'Etc/GMT+12'"; + + // LANG=C TZ="Etc/GMT-1" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-1", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T13:34:56+01:00") << "tzdata information not valid for 'Etc/GMT-1'"; + + // LANG=C TZ="Etc/GMT-2" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-2", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T14:34:56+02:00") << "tzdata information not valid for 'Etc/GMT-2'"; + + // LANG=C TZ="Etc/GMT-3" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-3", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T15:34:56+03:00") << "tzdata information not valid for 'Etc/GMT-3'"; + + // LANG=C TZ="Etc/GMT-4" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-4", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T16:34:56+04:00") << "tzdata information not valid for 'Etc/GMT-4'"; + + // LANG=C TZ="Etc/GMT-5" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-5", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T17:34:56+05:00") << "tzdata information not valid for 'Etc/GMT-5'"; + + // LANG=C TZ="Etc/GMT-6" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-6", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T18:34:56+06:00") << "tzdata information not valid for 'Etc/GMT-6'"; + + // LANG=C TZ="Etc/GMT-7" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-7", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T19:34:56+07:00") << "tzdata information not valid for 'Etc/GMT-7'"; + + // LANG=C TZ="Etc/GMT-8" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-8", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T20:34:56+08:00") << "tzdata information not valid for 'Etc/GMT-8'"; + + // LANG=C TZ="Etc/GMT-9" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-9", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T21:34:56+09:00") << "tzdata information not valid for 'Etc/GMT-9'"; + + // LANG=C TZ="Etc/GMT-10" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-10", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T22:34:56+10:00") << "tzdata information not valid for 'Etc/GMT-10'"; + + // LANG=C TZ="Etc/GMT-11" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-11", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-14T23:34:56+11:00") << "tzdata information not valid for 'Etc/GMT-11'"; + + // LANG=C TZ="Etc/GMT-12" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-12", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-15T00:34:56+12:00") << "tzdata information not valid for 'Etc/GMT-12'"; + + // LANG=C TZ="Etc/GMT-13" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-13", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-15T01:34:56+13:00") << "tzdata information not valid for 'Etc/GMT-13'"; + + // LANG=C TZ="Etc/GMT-14" date '+%Y-%m-%dT%H:%M:%S%Ez' -d "1991-05-14 12:34:56 UTC" | sed 's/[0-9][0-9]$/:&/' + tps = date::floor(dateTime.GetAsTimePoint()); + zone = date::make_zoned("Etc/GMT-14", tps); + EXPECT_EQ(date::format("%FT%T%Ez", zone), "1991-05-15T02:34:56+14:00") << "tzdata information not valid for 'Etc/GMT-14'"; +} -- 2.31.1 From 9833e4eaa0a9b64e033b5e5d9a76a3201d81e947 Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Wed, 21 Oct 2020 12:41:17 +0300 Subject: [PATCH 09/17] CDateTime: fix DateTimeSpan arithmetics typo --- xbmc/XBDateTime.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/xbmc/XBDateTime.cpp b/xbmc/XBDateTime.cpp index 24f8c0c7bf..36d15d122b 100644 --- a/xbmc/XBDateTime.cpp +++ b/xbmc/XBDateTime.cpp @@ -362,7 +362,7 @@ CDateTime CDateTime::operator +(const CDateTimeSpan& right) const { CDateTime left(*this); - left.m_time + right.m_timeSpan; + left.m_time += right.m_timeSpan; return left; } @@ -371,7 +371,7 @@ CDateTime CDateTime::operator -(const CDateTimeSpan& right) const { CDateTime left(*this); - left.m_time - right.m_timeSpan; + left.m_time -= right.m_timeSpan; return left; } -- 2.31.1 From e399fd2ca31c5d71ef6e69e8a3ca327c02e5fcaa Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Tue, 3 Nov 2020 17:51:26 +0200 Subject: [PATCH 10/17] Remove GetAsUTCDateTime and add GetAsLocalDateTime The 'm_time' now represents a UTC time-point, so 'GetAsUTCDateTime' does nothing useful. Remove it fully, and add 'GetAsLocalDateTime' function that we will use later to convert UTC (system) time to the local time needed to get displayed in UI. Signed-off-by: Vasyl Gello --- xbmc/XBDateTime.cpp | 9 ++++++--- xbmc/XBDateTime.h | 4 +++- xbmc/network/WebServer.cpp | 6 +++--- xbmc/pvr/epg/EpgContainer.cpp | 14 +++++++------- xbmc/pvr/epg/EpgInfoTag.cpp | 4 ++-- xbmc/pvr/guilib/PVRGUIActions.cpp | 1 - xbmc/pvr/timers/PVRTimerRuleMatcher.cpp | 2 +- xbmc/pvr/timers/PVRTimers.cpp | 1 - xbmc/pvr/windows/GUIWindowPVRGuide.cpp | 2 +- xbmc/test/TestDateTime.cpp | 16 ++++++++-------- 10 files changed, 31 insertions(+), 28 deletions(-) diff --git a/xbmc/XBDateTime.cpp b/xbmc/XBDateTime.cpp index 36d15d122b..141e9eb25d 100644 --- a/xbmc/XBDateTime.cpp +++ b/xbmc/XBDateTime.cpp @@ -1210,10 +1210,13 @@ std::string CDateTime::GetAsLocalizedTime(TIME_FORMAT format, bool withSeconds / return GetAsLocalizedTime("", false); } -CDateTime CDateTime::GetAsUTCDateTime() const +CDateTime CDateTime::GetAsLocalDateTime() const { - CDateTime time(m_time); - return time; + auto zone = date::make_zoned(date::current_zone(), m_time); + + return CDateTime( + std::chrono::duration_cast(zone.get_local_time().time_since_epoch()) + .count()); } std::string CDateTime::GetAsRFC1123DateTime() const diff --git a/xbmc/XBDateTime.h b/xbmc/XBDateTime.h index 208b938ae8..355f06979a 100644 --- a/xbmc/XBDateTime.h +++ b/xbmc/XBDateTime.h @@ -212,7 +212,9 @@ public: void GetAsTm(tm& time) const; std::chrono::system_clock::time_point GetAsTimePoint() const; - CDateTime GetAsUTCDateTime() const; + /*! \brief convert UTC datetime to local datetime + */ + CDateTime GetAsLocalDateTime() const; std::string GetAsSaveString() const; std::string GetAsDBDateTime() const; std::string GetAsDBDate() const; diff --git a/xbmc/network/WebServer.cpp b/xbmc/network/WebServer.cpp index c9eae2269a..31f6b2913a 100644 --- a/xbmc/network/WebServer.cpp +++ b/xbmc/network/WebServer.cpp @@ -228,7 +228,7 @@ MHD_RESULT CWebServer::HandlePartialRequest(struct MHD_Connection* connection, CDateTime ifUnmodifiedSinceDate; // handle If-Modified-Since (but only if the response is cacheable) if (cacheable && ifModifiedSinceDate.SetFromRFC1123DateTime(ifModifiedSince) && - lastModified.GetAsUTCDateTime() <= ifModifiedSinceDate) + lastModified <= ifModifiedSinceDate) { struct MHD_Response* response = create_response(0, nullptr, MHD_NO, MHD_NO); if (response == nullptr) @@ -241,7 +241,7 @@ MHD_RESULT CWebServer::HandlePartialRequest(struct MHD_Connection* connection, } // handle If-Unmodified-Since else if (ifUnmodifiedSinceDate.SetFromRFC1123DateTime(ifUnmodifiedSince) && - lastModified.GetAsUTCDateTime() > ifUnmodifiedSinceDate) + lastModified > ifUnmodifiedSinceDate) return SendErrorResponse(request, MHD_HTTP_PRECONDITION_FAILED, request.method); } @@ -515,7 +515,7 @@ bool CWebServer::IsRequestRanged(const HTTPRequest& request, const CDateTime& la // check if the last modification is newer than the If-Range date // if so we have to server the whole file instead - if (lastModified.GetAsUTCDateTime() > ifRangeDate) + if (lastModified > ifRangeDate) ranges.Clear(); } } diff --git a/xbmc/pvr/epg/EpgContainer.cpp b/xbmc/pvr/epg/EpgContainer.cpp index 867c6db0e4..a5916f5028 100644 --- a/xbmc/pvr/epg/EpgContainer.cpp +++ b/xbmc/pvr/epg/EpgContainer.cpp @@ -330,7 +330,7 @@ void CPVREpgContainer::Process() while (!m_bStop) { - CDateTime::GetCurrentDateTime().GetAsUTCDateTime().GetAsTime(iNow); + CDateTime::GetUTCDateTime().GetAsTime(iNow); { CSingleLock lock(m_critSection); bUpdateEpg = (iNow >= m_iNextEpgUpdate) && !m_bSuspended; @@ -587,7 +587,7 @@ std::shared_ptr CPVREpgContainer::CreateChannelEpg(int iEpgId, const st { CSingleLock lock(m_critSection); m_bPreventUpdates = false; - CDateTime::GetCurrentDateTime().GetAsUTCDateTime().GetAsTime(m_iNextEpgUpdate); + CDateTime::GetUTCDateTime().GetAsTime(m_iNextEpgUpdate); } m_events.Publish(PVREvent::EpgContainer); @@ -607,7 +607,7 @@ bool CPVREpgContainer::RemoveOldEntries() epgEntry.second->Cleanup(cleanupTime); CSingleLock lock(m_critSection); - CDateTime::GetCurrentDateTime().GetAsUTCDateTime().GetAsTime(m_iLastEpgCleanup); + CDateTime::GetUTCDateTime().GetAsTime(m_iLastEpgCleanup); return true; } @@ -788,7 +788,7 @@ bool CPVREpgContainer::UpdateEPG(bool bOnlyPending /* = false */) { /* the update has been interrupted. try again later */ time_t iNow; - CDateTime::GetCurrentDateTime().GetAsUTCDateTime().GetAsTime(iNow); + CDateTime::GetUTCDateTime().GetAsTime(iNow); CSingleLock lock(m_critSection); m_iNextEpgUpdate = iNow + advancedSettings->m_iEpgRetryInterruptedUpdateInterval; @@ -796,7 +796,7 @@ bool CPVREpgContainer::UpdateEPG(bool bOnlyPending /* = false */) else { CSingleLock lock(m_critSection); - CDateTime::GetCurrentDateTime().GetAsUTCDateTime().GetAsTime(m_iNextEpgUpdate); + CDateTime::GetUTCDateTime().GetAsTime(m_iNextEpgUpdate); m_iNextEpgUpdate += advancedSettings->m_iEpgUpdateCheckInterval; if (m_pendingUpdates == pendingUpdates) m_pendingUpdates = 0; @@ -859,13 +859,13 @@ bool CPVREpgContainer::CheckPlayingEvents() m_critSection.unlock(); time_t iNow; - CDateTime::GetCurrentDateTime().GetAsUTCDateTime().GetAsTime(iNow); + CDateTime::GetUTCDateTime().GetAsTime(iNow); if (iNow >= iNextEpgActiveTagCheck) { for (const auto& epgEntry : epgs) bFoundChanges = epgEntry.second->CheckPlayingEvent() || bFoundChanges; - CDateTime::GetCurrentDateTime().GetAsUTCDateTime().GetAsTime(iNextEpgActiveTagCheck); + CDateTime::GetUTCDateTime().GetAsTime(iNextEpgActiveTagCheck); iNextEpgActiveTagCheck += CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_iEpgActiveTagCheckInterval; /* pvr tags always start on the full minute */ diff --git a/xbmc/pvr/epg/EpgInfoTag.cpp b/xbmc/pvr/epg/EpgInfoTag.cpp index 74ce5e4f3f..8132b3cb6e 100644 --- a/xbmc/pvr/epg/EpgInfoTag.cpp +++ b/xbmc/pvr/epg/EpgInfoTag.cpp @@ -219,7 +219,7 @@ float CPVREpgInfoTag::ProgressPercentage() const float fReturn = 0.0f; time_t currentTime, startTime, endTime; - CDateTime::GetCurrentDateTime().GetAsUTCDateTime().GetAsTime(currentTime); + CDateTime::GetUTCDateTime().GetAsTime(currentTime); m_startTime.GetAsTime(startTime); m_endTime.GetAsTime(endTime); int iDuration = endTime - startTime > 0 ? endTime - startTime : 3600; @@ -235,7 +235,7 @@ float CPVREpgInfoTag::ProgressPercentage() const int CPVREpgInfoTag::Progress() const { time_t currentTime, startTime; - CDateTime::GetCurrentDateTime().GetAsUTCDateTime().GetAsTime(currentTime); + CDateTime::GetUTCDateTime().GetAsTime(currentTime); m_startTime.GetAsTime(startTime); int iDuration = currentTime - startTime; diff --git a/xbmc/pvr/guilib/PVRGUIActions.cpp b/xbmc/pvr/guilib/PVRGUIActions.cpp index 38e31f459a..c8909fc856 100644 --- a/xbmc/pvr/guilib/PVRGUIActions.cpp +++ b/xbmc/pvr/guilib/PVRGUIActions.cpp @@ -1908,7 +1908,6 @@ namespace PVR CDateTime dailywakeuptime; dailywakeuptime.SetFromDBTime(m_settings.GetStringValue(CSettings::SETTING_PVRPOWERMANAGEMENT_DAILYWAKEUPTIME)); - dailywakeuptime = dailywakeuptime.GetAsUTCDateTime(); const CDateTimeSpan diff(dailywakeuptime - now); int mins = diff.GetSecondsTotal() / 60; diff --git a/xbmc/pvr/timers/PVRTimerRuleMatcher.cpp b/xbmc/pvr/timers/PVRTimerRuleMatcher.cpp index e728f89765..c5f6ad6cfd 100644 --- a/xbmc/pvr/timers/PVRTimerRuleMatcher.cpp +++ b/xbmc/pvr/timers/PVRTimerRuleMatcher.cpp @@ -66,7 +66,7 @@ CDateTime CPVRTimerRuleMatcher::GetNextTimerStart() const } } - return nextStart.GetAsUTCDateTime(); + return nextStart; } bool CPVRTimerRuleMatcher::Matches(const std::shared_ptr& epgTag) const diff --git a/xbmc/pvr/timers/PVRTimers.cpp b/xbmc/pvr/timers/PVRTimers.cpp index d1dfa4c790..4b91016de0 100644 --- a/xbmc/pvr/timers/PVRTimers.cpp +++ b/xbmc/pvr/timers/PVRTimers.cpp @@ -1258,7 +1258,6 @@ CDateTime CPVRTimers::GetNextEventTime() const { CDateTime dailywakeuptime; dailywakeuptime.SetFromDBTime(m_settings.GetStringValue(CSettings::SETTING_PVRPOWERMANAGEMENT_DAILYWAKEUPTIME)); - dailywakeuptime = dailywakeuptime.GetAsUTCDateTime(); dailywakeuptime.SetDateTime( now.GetYear(), now.GetMonth(), now.GetDay(), diff --git a/xbmc/pvr/windows/GUIWindowPVRGuide.cpp b/xbmc/pvr/windows/GUIWindowPVRGuide.cpp index 89aa247205..0a0ce3d492 100644 --- a/xbmc/pvr/windows/GUIWindowPVRGuide.cpp +++ b/xbmc/pvr/windows/GUIWindowPVRGuide.cpp @@ -679,7 +679,7 @@ bool CGUIWindowPVRGuideBase::RefreshTimelineItems() CDateTime startDate(group->GetFirstEPGDate()); CDateTime endDate(group->GetLastEPGDate()); - const CDateTime currentDate(CDateTime::GetCurrentDateTime().GetAsUTCDateTime()); + const CDateTime currentDate(CDateTime::GetUTCDateTime()); if (!startDate.IsValid()) startDate = currentDate; diff --git a/xbmc/test/TestDateTime.cpp b/xbmc/test/TestDateTime.cpp index 41887ae096..a4de3372dc 100644 --- a/xbmc/test/TestDateTime.cpp +++ b/xbmc/test/TestDateTime.cpp @@ -531,20 +531,20 @@ TEST_F(TestDateTime, GetAsTm) EXPECT_TRUE(dateTime == time); } -TEST_F(TestDateTime, GetAsUTCDateTime) +TEST_F(TestDateTime, GetAsLocalDateTime) { CDateTime dateTime1; dateTime1.SetDateTime(1991, 05, 14, 12, 34, 56); CDateTime dateTime2; - dateTime2 = dateTime1.GetAsUTCDateTime(); + dateTime2 = dateTime1.GetAsLocalDateTime(); - EXPECT_EQ(dateTime2.GetYear(), 1991); - EXPECT_EQ(dateTime2.GetMonth(), 5); - EXPECT_EQ(dateTime2.GetDay(), 14); - EXPECT_EQ(dateTime2.GetHour(), 12); - EXPECT_EQ(dateTime2.GetMinute(), 34); - EXPECT_EQ(dateTime2.GetSecond(), 56); + auto zoned_time = date::make_zoned(date::current_zone(), dateTime1.GetAsTimePoint()); + auto time = zoned_time.get_local_time().time_since_epoch(); + + CDateTime cmpTime(std::chrono::duration_cast(time).count()); + + EXPECT_TRUE(dateTime1 == cmpTime); } TEST_F(TestDateTime, Reset) -- 2.31.1 From 7777a33c71d47685f2770eb5e6fd14b1278efdf0 Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Tue, 3 Nov 2020 22:49:09 +0200 Subject: [PATCH 11/17] Compensate the representation change ... from local time by default to UTC time by default. Namely, 'CDateTime::SetFromUTCDateTime' converted the UTC time to local time in the implementation of CDateTime before 'std::chrono'. Now this conversion has gone, and to avoid displaying PVR times in UTC, 'GetAsLocalDateTime' is added where necessary. Signed-off-by: Vasyl Gello --- xbmc/pvr/epg/EpgInfoTag.cpp | 8 ++------ xbmc/pvr/epg/EpgSearchData.cpp | 10 +++++----- xbmc/pvr/guilib/GUIEPGGridContainerModel.cpp | 4 ++-- xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp | 2 +- xbmc/pvr/recordings/PVRRecording.cpp | 4 ++-- 5 files changed, 12 insertions(+), 16 deletions(-) diff --git a/xbmc/pvr/epg/EpgInfoTag.cpp b/xbmc/pvr/epg/EpgInfoTag.cpp index 8132b3cb6e..7b48fc7197 100644 --- a/xbmc/pvr/epg/EpgInfoTag.cpp +++ b/xbmc/pvr/epg/EpgInfoTag.cpp @@ -273,9 +273,7 @@ CDateTime CPVREpgInfoTag::StartAsUTC() const CDateTime CPVREpgInfoTag::StartAsLocalTime() const { - CDateTime retVal; - retVal.SetFromUTCDateTime(m_startTime); - return retVal; + return m_startTime.GetAsLocalDateTime(); } CDateTime CPVREpgInfoTag::EndAsUTC() const @@ -285,9 +283,7 @@ CDateTime CPVREpgInfoTag::EndAsUTC() const CDateTime CPVREpgInfoTag::EndAsLocalTime() const { - CDateTime retVal; - retVal.SetFromUTCDateTime(m_endTime); - return retVal; + return m_endTime.GetAsLocalDateTime(); } void CPVREpgInfoTag::SetEndFromUTC(const CDateTime& end) diff --git a/xbmc/pvr/epg/EpgSearchData.cpp b/xbmc/pvr/epg/EpgSearchData.cpp index 331a61225b..bc01cfb876 100644 --- a/xbmc/pvr/epg/EpgSearchData.cpp +++ b/xbmc/pvr/epg/EpgSearchData.cpp @@ -21,21 +21,21 @@ void PVREpgSearchData::Reset() m_iGenreType = EPG_SEARCH_UNSET; m_startDateTime.SetFromUTCDateTime( - CServiceBroker::GetPVRManager().EpgContainer().GetFirstEPGDate()); + CServiceBroker::GetPVRManager().EpgContainer().GetFirstEPGDate().GetAsLocalDateTime()); if (!m_startDateTime.IsValid()) { CLog::Log(LOGWARNING, "No valid epg start time. Defaulting search start time to 'now'"); - m_startDateTime.SetFromUTCDateTime(CDateTime::GetUTCDateTime()); // default to 'now' + m_startDateTime.SetFromUTCDateTime(CDateTime::GetCurrentDateTime()); // default to 'now' } - m_endDateTime.SetFromUTCDateTime(CServiceBroker::GetPVRManager().EpgContainer().GetLastEPGDate()); + m_endDateTime.SetFromUTCDateTime(CServiceBroker::GetPVRManager().EpgContainer().GetLastEPGDate().GetAsLocalDateTime()); if (!m_endDateTime.IsValid()) { CLog::Log( LOGWARNING, "No valid epg end time. Defaulting search end time to search start time plus 10 days"); - m_endDateTime.SetFromUTCDateTime(m_startDateTime + - CDateTimeSpan(10, 0, 0, 0)); // default to start + 10 days + m_endDateTime.SetFromUTCDateTime((m_startDateTime + + CDateTimeSpan(10, 0, 0, 0)).GetAsLocalDateTime()); // default to start + 10 days } m_iUniqueBroadcastId = EPG_TAG_INVALID_UID; diff --git a/xbmc/pvr/guilib/GUIEPGGridContainerModel.cpp b/xbmc/pvr/guilib/GUIEPGGridContainerModel.cpp index 8adcab2056..5c88a4cb0f 100644 --- a/xbmc/pvr/guilib/GUIEPGGridContainerModel.cpp +++ b/xbmc/pvr/guilib/GUIEPGGridContainerModel.cpp @@ -123,9 +123,9 @@ void CGUIEPGGridContainerModel::Initialize(const std::unique_ptr& //////////////////////////////////////////////////////////////////////// // Create ruler items CDateTime ruler; - ruler.SetFromUTCDateTime(m_gridStart); + ruler.SetFromUTCDateTime(m_gridStart.GetAsLocalDateTime()); CDateTime rulerEnd; - rulerEnd.SetFromUTCDateTime(m_gridEnd); + rulerEnd.SetFromUTCDateTime(m_gridEnd.GetAsLocalDateTime()); CFileItemPtr rulerItem(new CFileItem(ruler.GetAsLocalizedDate(true))); rulerItem->SetProperty("DateLabel", true); m_rulerItems.emplace_back(rulerItem); diff --git a/xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp b/xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp index 2aed7de473..5c16886bab 100644 --- a/xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp +++ b/xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp @@ -236,7 +236,7 @@ std::string CPVRGUITimesInfo::TimeToTimeString(time_t datetime, TIME_FORMAT form { CDateTime time; time.SetFromUTCDateTime(datetime); - return time.GetAsLocalizedTime(format, withSeconds); + return time.GetAsLocalDateTime().GetAsLocalizedTime(format, withSeconds); } std::string CPVRGUITimesInfo::GetTimeshiftStartTime(TIME_FORMAT format) const diff --git a/xbmc/pvr/recordings/PVRRecording.cpp b/xbmc/pvr/recordings/PVRRecording.cpp index fbc345d06e..7a52773356 100644 --- a/xbmc/pvr/recordings/PVRRecording.cpp +++ b/xbmc/pvr/recordings/PVRRecording.cpp @@ -466,7 +466,7 @@ void CPVRRecording::UpdatePath() const CDateTime& CPVRRecording::RecordingTimeAsLocalTime() const { static CDateTime tmp; - tmp.SetFromUTCDateTime(m_recordingTime); + tmp.SetFromUTCDateTime(m_recordingTime.GetAsLocalDateTime()); return tmp; } @@ -480,7 +480,7 @@ CDateTime CPVRRecording::EndTimeAsUTC() const CDateTime CPVRRecording::EndTimeAsLocalTime() const { CDateTime ret; - ret.SetFromUTCDateTime(EndTimeAsUTC()); + ret.SetFromUTCDateTime(EndTimeAsUTC().GetAsLocalDateTime()); return ret; } -- 2.31.1 From c681095ef7c2e3bf0a71d4e3c8eb64f5f82a6e2d Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Wed, 4 Nov 2020 11:13:15 +0200 Subject: [PATCH 12/17] Get rid of {Set,}FromUTCDateTime * The 'const CDateTime& CPVRRecording::RecordingTimeAsLocalTime() const' method needs 'static' CDateTime instance set explicitly. This manifested in Debian Bug #980038 : the return value of function is explicitly nulled out causing immediate crash when using any PVR addon manipulating PVR recordings. Signed-off-by: Vasyl Gello --- xbmc/XBDateTime.cpp | 33 ++------------------ xbmc/XBDateTime.h | 4 --- xbmc/pvr/epg/EpgSearchData.cpp | 10 +++--- xbmc/pvr/guilib/GUIEPGGridContainerModel.cpp | 4 +-- xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp | 3 +- xbmc/pvr/recordings/PVRRecording.cpp | 8 ++--- xbmc/test/TestDateTime.cpp | 26 --------------- 7 files changed, 11 insertions(+), 77 deletions(-) diff --git a/xbmc/XBDateTime.cpp b/xbmc/XBDateTime.cpp index 141e9eb25d..2d1873af58 100644 --- a/xbmc/XBDateTime.cpp +++ b/xbmc/XBDateTime.cpp @@ -613,19 +613,6 @@ std::string CDateTime::GetAsSaveString() const return date::format("%Y%m%d_%H%M%S", sp); } -bool CDateTime::SetFromUTCDateTime(const CDateTime &dateTime) -{ - m_time = dateTime.m_time; - m_state = valid; - return true; -} - -bool CDateTime::SetFromUTCDateTime(const time_t &dateTime) -{ - CDateTime tmp(dateTime); - return SetFromUTCDateTime(tmp); -} - bool CDateTime::SetFromW3CDate(const std::string &dateTime) { std::string date; @@ -700,10 +687,8 @@ bool CDateTime::SetFromW3CDateTime(const std::string &dateTime, bool ignoreTimez if (!ignoreTimezone && !zone.empty()) { - // check if the timezone is UTC - if (StringUtils::StartsWith(zone, "Z")) - return SetFromUTCDateTime(tmpDateTime); - else + // check if the timezone is not UTC + if (!StringUtils::StartsWith(zone, "Z")) { // retrieve the timezone offset (ignoring the + or -) CDateTimeSpan zoneSpan; zoneSpan.SetFromTimeString(zone.substr(1)); @@ -853,20 +838,6 @@ CDateTime CDateTime::FromW3CDateTime(const std::string &date, bool ignoreTimezon return dt; } -CDateTime CDateTime::FromUTCDateTime(const CDateTime &dateTime) -{ - CDateTime dt; - dt.SetFromUTCDateTime(dateTime); - return dt; -} - -CDateTime CDateTime::FromUTCDateTime(const time_t &dateTime) -{ - CDateTime dt; - dt.SetFromUTCDateTime(dateTime); - return dt; -} - CDateTime CDateTime::FromRFC1123DateTime(const std::string &dateTime) { CDateTime dt; diff --git a/xbmc/XBDateTime.h b/xbmc/XBDateTime.h index 355f06979a..fbb07a26ee 100644 --- a/xbmc/XBDateTime.h +++ b/xbmc/XBDateTime.h @@ -133,8 +133,6 @@ public: static CDateTime FromDBTime(const std::string &time); static CDateTime FromW3CDate(const std::string &date); static CDateTime FromW3CDateTime(const std::string &date, bool ignoreTimezone = false); - static CDateTime FromUTCDateTime(const CDateTime &dateTime); - static CDateTime FromUTCDateTime(const time_t &dateTime); static CDateTime FromRFC1123DateTime(const std::string &dateTime); const CDateTime& operator =(const time_t& right); @@ -199,8 +197,6 @@ public: bool SetFromDBTime(const std::string &time); bool SetFromW3CDate(const std::string &date); bool SetFromW3CDateTime(const std::string &date, bool ignoreTimezone = false); - bool SetFromUTCDateTime(const CDateTime &dateTime); - bool SetFromUTCDateTime(const time_t &dateTime); bool SetFromRFC1123DateTime(const std::string &dateTime); /*! \brief set from a database datetime format YYYY-MM-DD HH:MM:SS diff --git a/xbmc/pvr/epg/EpgSearchData.cpp b/xbmc/pvr/epg/EpgSearchData.cpp index bc01cfb876..d86c549ce0 100644 --- a/xbmc/pvr/epg/EpgSearchData.cpp +++ b/xbmc/pvr/epg/EpgSearchData.cpp @@ -20,22 +20,20 @@ void PVREpgSearchData::Reset() m_bSearchInDescription = false; m_iGenreType = EPG_SEARCH_UNSET; - m_startDateTime.SetFromUTCDateTime( - CServiceBroker::GetPVRManager().EpgContainer().GetFirstEPGDate().GetAsLocalDateTime()); + m_startDateTime = CServiceBroker::GetPVRManager().EpgContainer().GetFirstEPGDate().GetAsLocalDateTime(); if (!m_startDateTime.IsValid()) { CLog::Log(LOGWARNING, "No valid epg start time. Defaulting search start time to 'now'"); - m_startDateTime.SetFromUTCDateTime(CDateTime::GetCurrentDateTime()); // default to 'now' + m_startDateTime = CDateTime::GetCurrentDateTime(); // default to 'now' } - m_endDateTime.SetFromUTCDateTime(CServiceBroker::GetPVRManager().EpgContainer().GetLastEPGDate().GetAsLocalDateTime()); + m_endDateTime = CServiceBroker::GetPVRManager().EpgContainer().GetLastEPGDate().GetAsLocalDateTime(); if (!m_endDateTime.IsValid()) { CLog::Log( LOGWARNING, "No valid epg end time. Defaulting search end time to search start time plus 10 days"); - m_endDateTime.SetFromUTCDateTime((m_startDateTime + - CDateTimeSpan(10, 0, 0, 0)).GetAsLocalDateTime()); // default to start + 10 days + m_endDateTime = (m_startDateTime + CDateTimeSpan(10, 0, 0, 0)).GetAsLocalDateTime(); // default to start + 10 days } m_iUniqueBroadcastId = EPG_TAG_INVALID_UID; diff --git a/xbmc/pvr/guilib/GUIEPGGridContainerModel.cpp b/xbmc/pvr/guilib/GUIEPGGridContainerModel.cpp index 5c88a4cb0f..2447fb07b2 100644 --- a/xbmc/pvr/guilib/GUIEPGGridContainerModel.cpp +++ b/xbmc/pvr/guilib/GUIEPGGridContainerModel.cpp @@ -123,9 +123,9 @@ void CGUIEPGGridContainerModel::Initialize(const std::unique_ptr& //////////////////////////////////////////////////////////////////////// // Create ruler items CDateTime ruler; - ruler.SetFromUTCDateTime(m_gridStart.GetAsLocalDateTime()); + ruler = m_gridStart.GetAsLocalDateTime(); CDateTime rulerEnd; - rulerEnd.SetFromUTCDateTime(m_gridEnd.GetAsLocalDateTime()); + rulerEnd = m_gridEnd.GetAsLocalDateTime(); CFileItemPtr rulerItem(new CFileItem(ruler.GetAsLocalizedDate(true))); rulerItem->SetProperty("DateLabel", true); m_rulerItems.emplace_back(rulerItem); diff --git a/xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp b/xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp index 5c16886bab..c1fd2fc30f 100644 --- a/xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp +++ b/xbmc/pvr/guilib/guiinfo/PVRGUITimesInfo.cpp @@ -234,8 +234,7 @@ void CPVRGUITimesInfo::Update() std::string CPVRGUITimesInfo::TimeToTimeString(time_t datetime, TIME_FORMAT format, bool withSeconds) { - CDateTime time; - time.SetFromUTCDateTime(datetime); + CDateTime time(datetime); return time.GetAsLocalDateTime().GetAsLocalizedTime(format, withSeconds); } diff --git a/xbmc/pvr/recordings/PVRRecording.cpp b/xbmc/pvr/recordings/PVRRecording.cpp index 7a52773356..f4dbea91fe 100644 --- a/xbmc/pvr/recordings/PVRRecording.cpp +++ b/xbmc/pvr/recordings/PVRRecording.cpp @@ -465,9 +465,7 @@ void CPVRRecording::UpdatePath() const CDateTime& CPVRRecording::RecordingTimeAsLocalTime() const { - static CDateTime tmp; - tmp.SetFromUTCDateTime(m_recordingTime.GetAsLocalDateTime()); - + static CDateTime tmp = m_recordingTime.GetAsLocalDateTime(); return tmp; } @@ -479,9 +477,7 @@ CDateTime CPVRRecording::EndTimeAsUTC() const CDateTime CPVRRecording::EndTimeAsLocalTime() const { - CDateTime ret; - ret.SetFromUTCDateTime(EndTimeAsUTC().GetAsLocalDateTime()); - return ret; + return EndTimeAsUTC().GetAsLocalDateTime(); } bool CPVRRecording::WillBeExpiredWithNewLifetime(int iLifetime) const diff --git a/xbmc/test/TestDateTime.cpp b/xbmc/test/TestDateTime.cpp index a4de3372dc..33ea1e3695 100644 --- a/xbmc/test/TestDateTime.cpp +++ b/xbmc/test/TestDateTime.cpp @@ -209,32 +209,6 @@ TEST_F(TestDateTime, SetFromW3CDateTime) EXPECT_EQ(dateTime2.GetSecond(), 30); } -TEST_F(TestDateTime, SetFromUTCDateTime) -{ - CDateTime dateTime1; - dateTime1.SetFromDBDateTime("1991-05-14 12:34:56"); - - CDateTime dateTime2; - EXPECT_TRUE(dateTime2.SetFromUTCDateTime(dateTime1)); - EXPECT_EQ(dateTime2.GetYear(), 1991); - EXPECT_EQ(dateTime2.GetMonth(), 5); - EXPECT_EQ(dateTime2.GetDay(), 14); - EXPECT_EQ(dateTime2.GetHour(), 12); - EXPECT_EQ(dateTime2.GetMinute(), 34); - EXPECT_EQ(dateTime2.GetSecond(), 56); - - const time_t time = 674224496; - - CDateTime dateTime3; - EXPECT_TRUE(dateTime3.SetFromUTCDateTime(time)); - EXPECT_EQ(dateTime3.GetYear(), 1991); - EXPECT_EQ(dateTime3.GetMonth(), 5); - EXPECT_EQ(dateTime3.GetDay(), 14); - EXPECT_EQ(dateTime3.GetHour(), 12); - EXPECT_EQ(dateTime3.GetMinute(), 34); - EXPECT_EQ(dateTime3.GetSecond(), 56); -} - TEST_F(TestDateTime, SetFromRFC1123DateTime) { std::string dateTime1("Mon, 21 Oct 2018 12:16:24 GMT"); -- 2.31.1 From 0016dcfb75108ad4a622907b4941767ac68c00fc Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Wed, 6 Jan 2021 22:26:46 +0000 Subject: [PATCH 13/17] Fix changes introduced in PR#19032 Signed-off-by: Vasyl Gello --- xbmc/pvr/epg/Epg.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xbmc/pvr/epg/Epg.cpp b/xbmc/pvr/epg/Epg.cpp index 39e40b5112..279a9024bd 100644 --- a/xbmc/pvr/epg/Epg.cpp +++ b/xbmc/pvr/epg/Epg.cpp @@ -266,7 +266,7 @@ bool CPVREpg::Update(time_t start, if (!m_lastScanTime.IsValid()) { - m_lastScanTime.SetFromUTCDateTime(time_t(0)); + m_lastScanTime = time_t(0); m_bUpdateLastScanTime = true; } } -- 2.31.1 From c5883c119426f82f936373db112c8de13ab84f68 Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Thu, 13 May 2021 11:18:31 +0000 Subject: [PATCH 14/17] Fix one-time assignment of PVR recording times Fixes pvr.dvbviewer#49 Closes: #984682 Signed-off-by: Vasyl Gello --- xbmc/pvr/recordings/PVRRecording.cpp | 5 ++--- xbmc/pvr/recordings/PVRRecording.h | 2 +- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/xbmc/pvr/recordings/PVRRecording.cpp b/xbmc/pvr/recordings/PVRRecording.cpp index f4dbea91fe..e7a073b1b7 100644 --- a/xbmc/pvr/recordings/PVRRecording.cpp +++ b/xbmc/pvr/recordings/PVRRecording.cpp @@ -463,10 +463,9 @@ void CPVRRecording::UpdatePath() m_bIsDeleted, m_bRadio, m_strDirectory, m_strTitle, m_iSeason, m_iEpisode, GetYear(), m_strShowTitle, m_strChannelName, m_recordingTime, m_strRecordingId); } -const CDateTime& CPVRRecording::RecordingTimeAsLocalTime() const +const CDateTime CPVRRecording::RecordingTimeAsLocalTime() const { - static CDateTime tmp = m_recordingTime.GetAsLocalDateTime(); - return tmp; + return m_recordingTime.GetAsLocalDateTime(); } CDateTime CPVRRecording::EndTimeAsUTC() const diff --git a/xbmc/pvr/recordings/PVRRecording.h b/xbmc/pvr/recordings/PVRRecording.h index d472dcadcb..13ceefb6c5 100644 --- a/xbmc/pvr/recordings/PVRRecording.h +++ b/xbmc/pvr/recordings/PVRRecording.h @@ -207,7 +207,7 @@ namespace PVR * @brief Retrieve the recording start as local time * @return the recording start time */ - const CDateTime& RecordingTimeAsLocalTime() const; + const CDateTime RecordingTimeAsLocalTime() const; /*! * @brief Retrieve the recording end as UTC time -- 2.31.1 From edd044843736310f45304726d45ab9ca18ffc3d7 Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Fri, 14 May 2021 09:39:55 +0000 Subject: [PATCH 15/17] Use double as underlying storage type for time points This should fix the GUI date dialog issue: https://github.com/xbmc/xbmc/pull/18727#issuecomment-840805031 https://github.com/xbmc/xbmc/pull/18727#issuecomment-840805031 Signed-off-by: Vasyl Gello --- xbmc/XBDateTime.cpp | 18 +++++++++--------- xbmc/XBDateTime.h | 20 ++++++++++---------- xbmc/dialogs/GUIDialogNumeric.cpp | 2 +- xbmc/utils/Archive.cpp | 8 ++++---- xbmc/utils/Archive.h | 4 ++-- xbmc/utils/test/TestArchive.cpp | 12 ++++++------ 6 files changed, 32 insertions(+), 32 deletions(-) diff --git a/xbmc/XBDateTime.cpp b/xbmc/XBDateTime.cpp index 2d1873af58..9ecb83a86b 100644 --- a/xbmc/XBDateTime.cpp +++ b/xbmc/XBDateTime.cpp @@ -183,7 +183,7 @@ CDateTime::CDateTime(const time_t& time) SetValid(true); } -CDateTime::CDateTime(const std::chrono::system_clock::time_point& time) +CDateTime::CDateTime(const std::chrono::time_point>& time) { m_time = time; SetValid(true); @@ -230,7 +230,7 @@ const CDateTime& CDateTime::operator =(const tm& right) return *this; } -const CDateTime& CDateTime::operator=(const std::chrono::system_clock::time_point& right) +const CDateTime& CDateTime::operator=(const std::chrono::time_point>& right) { m_time = right; SetValid(true); @@ -328,32 +328,32 @@ bool CDateTime::operator !=(const tm& right) const return !operator ==(right); } -bool CDateTime::operator>(const std::chrono::system_clock::time_point& right) const +bool CDateTime::operator>(const std::chrono::time_point>& right) const { return m_time > right; } -bool CDateTime::operator>=(const std::chrono::system_clock::time_point& right) const +bool CDateTime::operator>=(const std::chrono::time_point>& right) const { return operator>(right) || operator==(right); } -bool CDateTime::operator<(const std::chrono::system_clock::time_point& right) const +bool CDateTime::operator<(const std::chrono::time_point>& right) const { return m_time < right; } -bool CDateTime::operator<=(const std::chrono::system_clock::time_point& right) const +bool CDateTime::operator<=(const std::chrono::time_point>& right) const { return operator<(right) || operator==(right); } -bool CDateTime::operator==(const std::chrono::system_clock::time_point& right) const +bool CDateTime::operator==(const std::chrono::time_point>& right) const { return m_time == right; } -bool CDateTime::operator!=(const std::chrono::system_clock::time_point& right) const +bool CDateTime::operator!=(const std::chrono::time_point>& right) const { return !operator==(right); } @@ -583,7 +583,7 @@ void CDateTime::GetAsTm(tm& time) const localtime_r(&t, &time); } -std::chrono::system_clock::time_point CDateTime::GetAsTimePoint() const +std::chrono::time_point> CDateTime::GetAsTimePoint() const { return m_time; } diff --git a/xbmc/XBDateTime.h b/xbmc/XBDateTime.h index fbb07a26ee..31b8192bf5 100644 --- a/xbmc/XBDateTime.h +++ b/xbmc/XBDateTime.h @@ -120,7 +120,7 @@ public: CDateTime(const CDateTime& time); explicit CDateTime(const time_t& time); explicit CDateTime(const tm& time); - explicit CDateTime(const std::chrono::system_clock::time_point& time); + explicit CDateTime(const std::chrono::time_point>& time); CDateTime(int year, int month, int day, int hour, int minute, int second); static CDateTime GetCurrentDateTime(); @@ -137,7 +137,7 @@ public: const CDateTime& operator =(const time_t& right); const CDateTime& operator =(const tm& right); - const CDateTime& operator=(const std::chrono::system_clock::time_point& right); + const CDateTime& operator=(const std::chrono::time_point>& right); bool operator >(const CDateTime& right) const; bool operator >=(const CDateTime& right) const; @@ -160,12 +160,12 @@ public: bool operator ==(const tm& right) const; bool operator !=(const tm& right) const; - bool operator>(const std::chrono::system_clock::time_point& right) const; - bool operator>=(const std::chrono::system_clock::time_point& right) const; - bool operator<(const std::chrono::system_clock::time_point& right) const; - bool operator<=(const std::chrono::system_clock::time_point& right) const; - bool operator==(const std::chrono::system_clock::time_point& right) const; - bool operator!=(const std::chrono::system_clock::time_point& right) const; + bool operator>(const std::chrono::time_point>& right) const; + bool operator>=(const std::chrono::time_point>& right) const; + bool operator<(const std::chrono::time_point>& right) const; + bool operator<=(const std::chrono::time_point>& right) const; + bool operator==(const std::chrono::time_point>& right) const; + bool operator!=(const std::chrono::time_point>& right) const; CDateTime operator +(const CDateTimeSpan& right) const; CDateTime operator -(const CDateTimeSpan& right) const; @@ -206,7 +206,7 @@ public: void GetAsTime(time_t& time) const; void GetAsTm(tm& time) const; - std::chrono::system_clock::time_point GetAsTimePoint() const; + std::chrono::time_point> GetAsTimePoint() const; /*! \brief convert UTC datetime to local datetime */ @@ -228,7 +228,7 @@ public: bool IsValid() const; private: - std::chrono::system_clock::time_point m_time; + std::chrono::time_point> m_time; typedef enum _STATE { diff --git a/xbmc/dialogs/GUIDialogNumeric.cpp b/xbmc/dialogs/GUIDialogNumeric.cpp index 22b79ea9a1..4bb1272ace 100644 --- a/xbmc/dialogs/GUIDialogNumeric.cpp +++ b/xbmc/dialogs/GUIDialogNumeric.cpp @@ -496,7 +496,7 @@ bool CGUIDialogNumeric::ShowAndGetSeconds(std::string &timeString, const std::st CGUIDialogNumeric *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_DIALOG_NUMERIC); if (!pDialog) return false; - std::chrono::system_clock::time_point time{std::chrono::seconds{StringUtils::TimeStringToSeconds(timeString)}}; + std::chrono::time_point> time{std::chrono::seconds{StringUtils::TimeStringToSeconds(timeString)}}; CDateTime datetime(time); diff --git a/xbmc/utils/Archive.cpp b/xbmc/utils/Archive.cpp index 3d2ddf8da9..be267b6d22 100644 --- a/xbmc/utils/Archive.cpp +++ b/xbmc/utils/Archive.cpp @@ -151,9 +151,9 @@ CArchive& CArchive::operator<<(const std::wstring& wstr) return streamout(wstr.data(), size * sizeof(wchar_t)); } -CArchive& CArchive::operator<<(const std::chrono::system_clock::time_point& time) +CArchive& CArchive::operator<<(const std::chrono::time_point>& time) { - return streamout(&time, sizeof(std::chrono::system_clock::time_point)); + return streamout(&time, sizeof(std::chrono::time_point>)); } CArchive& CArchive::operator<<(IArchivable& obj) @@ -264,9 +264,9 @@ CArchive& CArchive::operator>>(std::wstring& wstr) return *this; } -CArchive& CArchive::operator>>(std::chrono::system_clock::time_point& time) +CArchive& CArchive::operator>>(std::chrono::time_point>& time) { - return streamin(&time, sizeof(std::chrono::system_clock::time_point)); + return streamin(&time, sizeof(std::chrono::time_point>)); } CArchive& CArchive::operator>>(IArchivable& obj) diff --git a/xbmc/utils/Archive.h b/xbmc/utils/Archive.h index 313c6615f6..f3ee978ca1 100644 --- a/xbmc/utils/Archive.h +++ b/xbmc/utils/Archive.h @@ -54,7 +54,7 @@ public: CArchive& operator<<(char c); CArchive& operator<<(const std::string &str); CArchive& operator<<(const std::wstring& wstr); - CArchive& operator<<(const std::chrono::system_clock::time_point& time); + CArchive& operator<<(const std::chrono::time_point>& time); CArchive& operator<<(IArchivable& obj); CArchive& operator<<(const CVariant& variant); CArchive& operator<<(const std::vector& strArray); @@ -123,7 +123,7 @@ public: CArchive& operator>>(std::string &str); CArchive& operator>>(std::wstring& wstr); - CArchive& operator>>(std::chrono::system_clock::time_point& time); + CArchive& operator>>(std::chrono::time_point>& time); CArchive& operator>>(IArchivable& obj); CArchive& operator>>(CVariant& variant); CArchive& operator>>(std::vector& strArray); diff --git a/xbmc/utils/test/TestArchive.cpp b/xbmc/utils/test/TestArchive.cpp index 41841c41df..5a63252cb5 100644 --- a/xbmc/utils/test/TestArchive.cpp +++ b/xbmc/utils/test/TestArchive.cpp @@ -223,8 +223,8 @@ TEST_F(TestArchive, StringArchive) TEST_F(TestArchive, TimePointArchive) { ASSERT_NE(nullptr, file); - std::chrono::system_clock::time_point tp_ref = std::chrono::system_clock::now(); - std::chrono::system_clock::time_point tp_var; + std::chrono::time_point> tp_ref = std::chrono::system_clock::now(); + std::chrono::time_point> tp_var; CArchive arstore(file, CArchive::store); arstore << tp_ref; @@ -235,7 +235,7 @@ TEST_F(TestArchive, TimePointArchive) arload >> tp_var; arload.Close(); - EXPECT_TRUE(!memcmp(&tp_ref, &tp_var, sizeof(std::chrono::system_clock::time_point))); + EXPECT_TRUE(!memcmp(&tp_ref, &tp_var, sizeof(std::chrono::time_point>))); } TEST_F(TestArchive, CVariantArchive) @@ -335,8 +335,8 @@ TEST_F(TestArchive, MultiTypeArchive) char char_ref = 'A', char_var = '\0'; std::string string_ref = "test string", string_var; std::wstring wstring_ref = L"test wstring", wstring_var; - std::chrono::system_clock::time_point tp_ref = std::chrono::system_clock::now(); - std::chrono::system_clock::time_point tp_var; + std::chrono::time_point> tp_ref = std::chrono::system_clock::now(); + std::chrono::time_point> tp_var; CVariant CVariant_ref((int)1), CVariant_var; std::vector strArray_ref, strArray_var; strArray_ref.emplace_back("test strArray_ref 0"); @@ -398,7 +398,7 @@ TEST_F(TestArchive, MultiTypeArchive) EXPECT_EQ(char_ref, char_var); EXPECT_STREQ(string_ref.c_str(), string_var.c_str()); EXPECT_STREQ(wstring_ref.c_str(), wstring_var.c_str()); - EXPECT_TRUE(!memcmp(&tp_ref, &tp_var, sizeof(std::chrono::system_clock::time_point))); + EXPECT_TRUE(!memcmp(&tp_ref, &tp_var, sizeof(std::chrono::time_point>))); EXPECT_TRUE(CVariant_var.isInteger()); EXPECT_STREQ("test strArray_ref 0", strArray_var.at(0).c_str()); EXPECT_STREQ("test strArray_ref 1", strArray_var.at(1).c_str()); -- 2.31.1 From 73305050967664e3a85dc7704134eeb43360a6c2 Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Fri, 14 May 2021 12:35:54 +0000 Subject: [PATCH 16/17] Use "long double" type in time_t / tm conversions Signed-off-by: Vasyl Gello --- xbmc/XBDateTime.cpp | 60 +++++++++++++++++++++++++++------------------ 1 file changed, 36 insertions(+), 24 deletions(-) diff --git a/xbmc/XBDateTime.cpp b/xbmc/XBDateTime.cpp index 9ecb83a86b..2bc22c5809 100644 --- a/xbmc/XBDateTime.cpp +++ b/xbmc/XBDateTime.cpp @@ -99,10 +99,10 @@ const CDateTimeSpan& CDateTimeSpan::operator -=(const CDateTimeSpan& right) void CDateTimeSpan::SetDateTimeSpan(int day, int hour, int minute, int second) { - m_timeSpan = std::chrono::duration_cast(date::days(day)) + - std::chrono::duration_cast(std::chrono::hours(hour)) + - std::chrono::duration_cast(std::chrono::minutes(minute)) + - std::chrono::duration_cast(std::chrono::seconds(second)); + m_timeSpan = date::floor(date::days(day)) + + date::floor(std::chrono::hours(hour)) + + date::floor(std::chrono::minutes(minute)) + + date::floor(std::chrono::seconds(second)); } void CDateTimeSpan::SetFromTimeString(const std::string& time) // hh:mm @@ -146,7 +146,7 @@ int CDateTimeSpan::GetSeconds() const int CDateTimeSpan::GetSecondsTotal() const { - return std::chrono::duration_cast(m_timeSpan).count(); + return date::floor(m_timeSpan).count(); } void CDateTimeSpan::SetFromPeriod(const std::string &period) @@ -179,7 +179,8 @@ CDateTime::CDateTime(const CDateTime& time) CDateTime::CDateTime(const time_t& time) { - m_time = std::chrono::system_clock::from_time_t(time); + Reset(); + m_time += std::chrono::duration(time); SetValid(true); } @@ -191,7 +192,8 @@ CDateTime::CDateTime(const std::chrono::time_point(&time))); + Reset(); + m_time += std::chrono::duration(std::mktime(const_cast(&time))); SetValid(true); } @@ -205,7 +207,7 @@ CDateTime CDateTime::GetCurrentDateTime() auto zone = date::make_zoned(date::current_zone(), std::chrono::system_clock::now()); return CDateTime( - std::chrono::duration_cast(zone.get_local_time().time_since_epoch()) + date::floor(zone.get_local_time().time_since_epoch()) .count()); } @@ -216,7 +218,8 @@ CDateTime CDateTime::GetUTCDateTime() const CDateTime& CDateTime::operator =(const time_t& right) { - m_time = std::chrono::system_clock::from_time_t(right); + Reset(); + m_time += std::chrono::duration(right); SetValid(true); return *this; @@ -224,7 +227,8 @@ const CDateTime& CDateTime::operator =(const time_t& right) const CDateTime& CDateTime::operator =(const tm& right) { - m_time = std::chrono::system_clock::from_time_t(std::mktime(const_cast(&right))); + Reset(); + m_time += std::chrono::duration(std::mktime(const_cast(&right))); SetValid(true); return *this; @@ -270,7 +274,8 @@ bool CDateTime::operator !=(const CDateTime& right) const bool CDateTime::operator >(const time_t& right) const { - return m_time > std::chrono::system_clock::from_time_t(right); + return m_time > std::chrono::system_clock::from_time_t(0) + + std::chrono::duration(right); } bool CDateTime::operator >=(const time_t& right) const @@ -280,7 +285,8 @@ bool CDateTime::operator >=(const time_t& right) const bool CDateTime::operator <(const time_t& right) const { - return m_time < std::chrono::system_clock::from_time_t(right); + return m_time < std::chrono::system_clock::from_time_t(0) + + std::chrono::duration(right); } bool CDateTime::operator <=(const time_t& right) const @@ -290,7 +296,8 @@ bool CDateTime::operator <=(const time_t& right) const bool CDateTime::operator ==(const time_t& right) const { - return m_time == std::chrono::system_clock::from_time_t(right); + return m_time == std::chrono::system_clock::from_time_t(0) + + std::chrono::duration(right); } bool CDateTime::operator !=(const time_t& right) const @@ -300,7 +307,8 @@ bool CDateTime::operator !=(const time_t& right) const bool CDateTime::operator >(const tm& right) const { - return m_time > std::chrono::system_clock::from_time_t(std::mktime(const_cast(&right))); + return m_time > std::chrono::system_clock::from_time_t(0) + + std::chrono::duration(std::mktime(const_cast(&right))); } bool CDateTime::operator >=(const tm& right) const @@ -310,7 +318,8 @@ bool CDateTime::operator >=(const tm& right) const bool CDateTime::operator <(const tm& right) const { - return m_time < std::chrono::system_clock::from_time_t(std::mktime(const_cast(&right))); + return m_time < std::chrono::system_clock::from_time_t(0) + + std::chrono::duration(std::mktime(const_cast(&right))); } bool CDateTime::operator <=(const tm& right) const @@ -320,7 +329,8 @@ bool CDateTime::operator <=(const tm& right) const bool CDateTime::operator ==(const tm& right) const { - return m_time == std::chrono::system_clock::from_time_t(std::mktime(const_cast(&right))); + return m_time == std::chrono::system_clock::from_time_t(0) + + std::chrono::duration(std::mktime(const_cast(&right))); } bool CDateTime::operator !=(const tm& right) const @@ -394,7 +404,7 @@ CDateTimeSpan CDateTime::operator -(const CDateTime& right) const { CDateTimeSpan left; - left.m_timeSpan = std::chrono::duration_cast(m_time - right.m_time); + left.m_timeSpan = date::floor(m_time - right.m_time); return left; } @@ -503,7 +513,7 @@ int CDateTime::GetYear() const int CDateTime::GetHour() const { auto dp = date::floor(m_time); - auto time = date::make_time(m_time - dp); + auto time = date::make_time(date::floor(m_time - dp)); return time.hours().count(); } @@ -511,7 +521,7 @@ int CDateTime::GetHour() const int CDateTime::GetMinute() const { auto dp = date::floor(m_time); - auto time = date::make_time(m_time - dp); + auto time = date::make_time(date::floor(m_time - dp)); return time.minutes().count(); } @@ -519,7 +529,7 @@ int CDateTime::GetMinute() const int CDateTime::GetSecond() const { auto dp = date::floor(m_time); - auto time = date::make_time(m_time - dp); + auto time = date::make_time(date::floor(m_time - dp)); return time.seconds().count(); } @@ -536,7 +546,7 @@ int CDateTime::GetMinuteOfDay() const { auto dp = date::floor(m_time); ; - auto time = date::make_time(m_time - dp); + auto time = date::make_time(date::floor(m_time - dp)); return time.hours().count() * 60 + time.minutes().count(); } @@ -573,12 +583,14 @@ bool CDateTime::SetTime(int hour, int minute, int second) void CDateTime::GetAsTime(time_t& time) const { - time = std::chrono::system_clock::to_time_t(m_time); + time = date::floor(m_time.time_since_epoch()) + .count(); } void CDateTime::GetAsTm(tm& time) const { - auto t = std::chrono::system_clock::to_time_t(m_time); + auto t = date::floor(m_time.time_since_epoch()) + .count(); localtime_r(&t, &time); } @@ -1186,7 +1198,7 @@ CDateTime CDateTime::GetAsLocalDateTime() const auto zone = date::make_zoned(date::current_zone(), m_time); return CDateTime( - std::chrono::duration_cast(zone.get_local_time().time_since_epoch()) + date::floor(zone.get_local_time().time_since_epoch()) .count()); } -- 2.31.1 From 84717876235e70622e6436314942374707dd28fe Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Mon, 17 May 2021 09:41:32 +0000 Subject: [PATCH 17/17] Avoid time_t in tm conversions This should leave the possibility of time_t truncation on 32-bit architectures only in GetAsTime(), what we can do nothing with. Signed-off-by: Vasyl Gello --- xbmc/XBDateTime.cpp | 52 +++++++++++++++++++++++++++++++++++---------- 1 file changed, 41 insertions(+), 11 deletions(-) diff --git a/xbmc/XBDateTime.cpp b/xbmc/XBDateTime.cpp index 2bc22c5809..ba0d16243f 100644 --- a/xbmc/XBDateTime.cpp +++ b/xbmc/XBDateTime.cpp @@ -193,7 +193,14 @@ CDateTime::CDateTime(const std::chrono::time_point(std::mktime(const_cast(&time))); + + auto ymd = date::local_days(date::year(time.tm_year + 1900) / date::month(time.tm_mon + 1) / time.tm_mday); + auto dur = ymd + std::chrono::hours(time.tm_hour) + std::chrono::minutes(time.tm_min) + std::chrono::seconds(time.tm_sec); + + auto timeT = date::floor(dur.time_since_epoch()).count(); + + m_time += std::chrono::duration(timeT); + SetValid(true); } @@ -228,7 +235,14 @@ const CDateTime& CDateTime::operator =(const time_t& right) const CDateTime& CDateTime::operator =(const tm& right) { Reset(); - m_time += std::chrono::duration(std::mktime(const_cast(&right))); + + auto ymd = date::local_days(date::year(right.tm_year + 1900) / date::month(right.tm_mon + 1) / right.tm_mday); + auto dur = ymd + std::chrono::hours(right.tm_hour) + std::chrono::minutes(right.tm_min) + std::chrono::seconds(right.tm_sec); + + auto timeT = date::floor(dur.time_since_epoch()).count(); + + m_time += std::chrono::duration(timeT); + SetValid(true); return *this; @@ -307,8 +321,8 @@ bool CDateTime::operator !=(const time_t& right) const bool CDateTime::operator >(const tm& right) const { - return m_time > std::chrono::system_clock::from_time_t(0) + - std::chrono::duration(std::mktime(const_cast(&right))); + CDateTime temp(right); + return m_time > temp.m_time; } bool CDateTime::operator >=(const tm& right) const @@ -318,8 +332,8 @@ bool CDateTime::operator >=(const tm& right) const bool CDateTime::operator <(const tm& right) const { - return m_time < std::chrono::system_clock::from_time_t(0) + - std::chrono::duration(std::mktime(const_cast(&right))); + CDateTime temp(right); + return m_time < temp.m_time; } bool CDateTime::operator <=(const tm& right) const @@ -329,8 +343,8 @@ bool CDateTime::operator <=(const tm& right) const bool CDateTime::operator ==(const tm& right) const { - return m_time == std::chrono::system_clock::from_time_t(0) + - std::chrono::duration(std::mktime(const_cast(&right))); + CDateTime temp(right); + return m_time == temp.m_time; } bool CDateTime::operator !=(const tm& right) const @@ -589,10 +603,26 @@ void CDateTime::GetAsTime(time_t& time) const void CDateTime::GetAsTm(tm& time) const { - auto t = date::floor(m_time.time_since_epoch()) - .count(); + auto dp = date::floor(m_time); + + auto ymd = date::year_month_day{dp}; + time.tm_year = int(ymd.year()) - 1900; + time.tm_mon = unsigned(ymd.month()) - 1; + time.tm_mday = unsigned(ymd.day()); + + auto hms = date::make_time(date::floor(m_time - dp)); + time.tm_hour = hms.hours().count(); + time.tm_min = hms.minutes().count(); + time.tm_sec = hms.seconds().count(); + + date::weekday wd{dp}; + time.tm_wday = wd.c_encoding(); + + auto newyear = date::sys_days(date::year(time.tm_year + 1900) / 1 / 1); + auto seconds_to_newyear = date::floor(m_time - newyear); + time.tm_yday = seconds_to_newyear.count() / 86400; - localtime_r(&t, &time); + time.tm_isdst = date::current_zone()->get_info(m_time).save.count() != 0; } std::chrono::time_point> CDateTime::GetAsTimePoint() const -- 2.31.1