qoperatingsystemversion.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2021 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
 
#include "qoperatingsystemversion.h"
 
#if !defined(Q_OS_DARWIN) && !defined(Q_OS_WIN)
#include "qoperatingsystemversion_p.h"
#endif
 
#if defined(Q_OS_DARWIN)
#include <QtCore/private/qcore_mac_p.h>
#endif
 
#include <qversionnumber.h>
#include <qdebug.h>
 
#ifdef Q_OS_ANDROID
#include <QJniObject>
#endif
 
QT_BEGIN_NAMESPACE
 
QOperatingSystemVersion QOperatingSystemVersion::current()
{
    return QOperatingSystemVersionBase::current();
}
 
#if !defined(Q_OS_DARWIN) && !defined(Q_OS_WIN)
QOperatingSystemVersionBase QOperatingSystemVersionBase::current_impl()
{
    QOperatingSystemVersionBase version;
    version.m_os = currentType();
#ifdef Q_OS_ANDROID
#ifndef QT_BOOTSTRAPPED
    const QVersionNumber v = QVersionNumber::fromString(QJniObject::getStaticObjectField(
        "android/os/Build$VERSION", "RELEASE", "Ljava/lang/String;").toString());
    if (!v.isNull()) {
        version.m_major = v.majorVersion();
        version.m_minor = v.minorVersion();
        version.m_micro = v.microVersion();
        return version;
    }
#endif
 
    version.m_major = -1;
    version.m_minor = -1;
 
    static const struct {
        uint major : 4;
        uint minor : 4;
    } versions[] = {
        { 1, 0 }, // API level 1
        { 1, 1 }, // API level 2
        { 1, 5 }, // API level 3
        { 1, 6 }, // API level 4
        { 2, 0 }, // API level 5
        { 2, 0 }, // API level 6
        { 2, 1 }, // API level 7
        { 2, 2 }, // API level 8
        { 2, 3 }, // API level 9
        { 2, 3 }, // API level 10
        { 3, 0 }, // API level 11
        { 3, 1 }, // API level 12
        { 3, 2 }, // API level 13
        { 4, 0 }, // API level 14
        { 4, 0 }, // API level 15
        { 4, 1 }, // API level 16
        { 4, 2 }, // API level 17
        { 4, 3 }, // API level 18
        { 4, 4 }, // API level 19
        { 4, 4 }, // API level 20
        { 5, 0 }, // API level 21
        { 5, 1 }, // API level 22
        { 6, 0 }, // API level 23
        { 7, 0 }, // API level 24
        { 7, 1 }, // API level 25
        { 8, 0 }, // API level 26
        { 8, 1 }, // API level 27
        { 9, 0 }, // API level 28
        { 10, 0 }, // API level 29
        { 11, 0 }, // API level 30
    };
 
    // This will give us at least the first 2 version components
    const size_t versionIdx = size_t(QJniObject::getStaticField<jint>(
        "android/os/Build$VERSION", "SDK_INT")) - 1;
    if (versionIdx < sizeof(versions) / sizeof(versions[0])) {
        version.m_major = versions[versionIdx].major;
        version.m_minor = versions[versionIdx].minor;
    }
 
    // API level 6 was exactly version 2.0.1
    version.m_micro = versionIdx == 5 ? 1 : -1;
#else
    version.m_major = -1;
    version.m_minor = -1;
    version.m_micro = -1;
#endif
    return version;
}
 
QOperatingSystemVersionBase QOperatingSystemVersionBase::current()
{
    static const QOperatingSystemVersionBase v = current_impl();
    return v;
}
#endif
 
static inline int compareVersionComponents(int lhs, int rhs)
{
    return lhs >= 0 && rhs >= 0 ? lhs - rhs : 0;
}
 
int QOperatingSystemVersionBase::compare(QOperatingSystemVersionBase v1,
                                         QOperatingSystemVersionBase v2)
{
    if (v1.m_major == v2.m_major) {
        if (v1.m_minor == v2.m_minor) {
            return compareVersionComponents(v1.m_micro, v2.m_micro);
        }
        return compareVersionComponents(v1.m_minor, v2.m_minor);
    }
    return compareVersionComponents(v1.m_major, v2.m_major);
}
 
QString QOperatingSystemVersion::name() const
{
    return QOperatingSystemVersionBase::name();
}
 
QString QOperatingSystemVersionBase::name(QOperatingSystemVersionBase osversion)
{
    switch (osversion.type()) {
    case QOperatingSystemVersionBase::Windows:
        return QStringLiteral("Windows");
    case QOperatingSystemVersionBase::MacOS: {
        if (osversion.majorVersion() < 10)
            return QStringLiteral("Mac OS");
        if (osversion.majorVersion() == 10 && osversion.minorVersion() < 8)
            return QStringLiteral("Mac OS X");
        if (osversion.majorVersion() == 10 && osversion.minorVersion() < 12)
            return QStringLiteral("OS X");
        return QStringLiteral("macOS");
    }
    case QOperatingSystemVersionBase::IOS: {
        if (osversion.majorVersion() < 4)
            return QStringLiteral("iPhone OS");
        return QStringLiteral("iOS");
    }
    case QOperatingSystemVersionBase::TvOS:
        return QStringLiteral("tvOS");
    case QOperatingSystemVersionBase::WatchOS:
        return QStringLiteral("watchOS");
    case QOperatingSystemVersionBase::Android:
        return QStringLiteral("Android");
    case QOperatingSystemVersionBase::Unknown:
    default:
        return QString();
    }
}
 
bool QOperatingSystemVersion::isAnyOfType(std::initializer_list<OSType> types) const
{
    // ### Qt7: Remove this function
    return std::find(types.begin(), types.end(), type()) != types.end();
}
 
bool QOperatingSystemVersionBase::isAnyOfType(std::initializer_list<OSType> types, OSType type)
{
    return std::find(types.begin(), types.end(), type) != types.end();
}
 
const QOperatingSystemVersion QOperatingSystemVersion::Windows7 =
    QOperatingSystemVersion(QOperatingSystemVersion::Windows, 6, 1);
 
const QOperatingSystemVersion QOperatingSystemVersion::Windows8 =
    QOperatingSystemVersion(QOperatingSystemVersion::Windows, 6, 2);
 
const QOperatingSystemVersion QOperatingSystemVersion::Windows8_1 =
    QOperatingSystemVersion(QOperatingSystemVersion::Windows, 6, 3);
 
const QOperatingSystemVersion QOperatingSystemVersion::Windows10 =
    QOperatingSystemVersion(QOperatingSystemVersion::Windows, 10);
 
const QOperatingSystemVersion QOperatingSystemVersion::OSXMavericks =
    QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 10, 9);
 
const QOperatingSystemVersion QOperatingSystemVersion::OSXYosemite =
    QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 10, 10);
 
const QOperatingSystemVersion QOperatingSystemVersion::OSXElCapitan =
    QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 10, 11);
 
const QOperatingSystemVersion QOperatingSystemVersion::MacOSSierra =
    QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 10, 12);
 
const QOperatingSystemVersion QOperatingSystemVersion::MacOSHighSierra =
    QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 10, 13);
 
const QOperatingSystemVersion QOperatingSystemVersion::MacOSMojave =
    QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 10, 14);
 
const QOperatingSystemVersion QOperatingSystemVersion::MacOSCatalina =
    QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 10, 15);
 
const QOperatingSystemVersion QOperatingSystemVersion::MacOSBigSur = [] {
#if defined(Q_OS_DARWIN)
    if (QMacVersion::buildSDK(QMacVersion::ApplicationBinary) >= QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 10, 16))
        return QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 11, 0);
    else
#endif
        return QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 10, 16);
}();
 
const QOperatingSystemVersion QOperatingSystemVersion::MacOSMonterey =
    QOperatingSystemVersion(QOperatingSystemVersion::MacOS, 12, 0);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidJellyBean =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 4, 1);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidJellyBean_MR1 =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 4, 2);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidJellyBean_MR2 =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 4, 3);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidKitKat =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 4, 4);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidLollipop =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 5, 0);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidLollipop_MR1 =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 5, 1);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidMarshmallow =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 6, 0);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidNougat =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 7, 0);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidNougat_MR1 =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 7, 1);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidOreo =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 8, 0);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidOreo_MR1 =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 8, 1);
 
const QOperatingSystemVersion QOperatingSystemVersion::AndroidPie =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 9, 0);
 
const QOperatingSystemVersion QOperatingSystemVersion::Android10 =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 10, 0);
 
const QOperatingSystemVersion QOperatingSystemVersion::Android11 =
    QOperatingSystemVersion(QOperatingSystemVersion::Android, 11, 0);
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, const QOperatingSystemVersion &ov)
{
    QDebugStateSaver saver(debug);
    debug.nospace();
    debug << "QOperatingSystemVersion(" << ov.name()
        << ", " << ov.majorVersion() << '.' << ov.minorVersion()
        << '.' << ov.microVersion() << ')';
    return debug;
}
#endif // !QT_NO_DEBUG_STREAM
 
QT_END_NAMESPACE