VersionChecker.cpp

Go to the documentation of this file.

namespace krotos
{
    /* Version internal class implementation */
    VersionChecker::Version::Version(String versionString) { m_isValid = parseString(versionString); }
 
    bool VersionChecker::Version::parseString(String v)
    {
        // Parse the versionString and split with std::strtok
        StringArray versionArray;
        versionArray.addTokens(v.removeCharacters("v"), ".", "");
 
        if (versionArray.size() != NUM_FIELDS)
        {
            return false;
        }
 
        for (int i = 0; i < NUM_FIELDS; i++)
        {
            m_version[i] = versionArray[i].getIntValue();
        }
 
        return true;
    }
 
    VersionChecker::Version::eRtn VersionChecker::Version::compare(Version v)
    {
        // Work through maj, min, rev in turn to test
        // return LT, EQUAL, GT for this<v, this==v, this>v
        for (int i = 0; i < NUM_FIELDS; i++)
        {
            if (this->m_version[i] > v.m_version[i])
                return GT;
            else if (this->m_version[i] < v.m_version[i])
                return LT;
        }
        return EQUAL;
    }
 
    String VersionChecker::Version::toString()
    {
        String versionString("");
        if (m_isValid)
        {
            String dot(".");
            versionString = String("v") + std::to_string(m_version[MAJOR]) + dot + std::to_string(m_version[MINOR]) +
                            dot + std::to_string(m_version[REVISION]);
        }
        return versionString;
    }
 
    VersionChecker::VersionChecker(String pluginVersion, URL versionUrl, URL popupTextUrl, String versionFilePath)
        : Thread{"VersionChecker"}, m_pluginVersion(pluginVersion), m_versionFilePath(versionFilePath)
    {
        m_versionUrl = versionUrl;
        m_updateTextUrl = popupTextUrl;
 
        // TODO Replace with settingsFile
        m_dontCheckForUpdatesPath = utils::StringsIntoPath(m_versionFilePath, "DontCheckForUpdates.txt");
 
        this->addListener(this);
 
#if !IS_RELEASE_BUILD
        testHelper();
#endif
    }
 
    VersionChecker::~VersionChecker() { stopThread(1000); }
 
    void VersionChecker::testHelper()
    {
        // custom version and update text files which can be used for QA
        File customVersion = utils::StringsIntoPath(m_versionFilePath, "UpdaterCustomVersion.txt");
 
        if (customVersion.existsAsFile())
        {
            m_versionUrl = URL(customVersion);
        }
 
        File customText = utils::StringsIntoPath(m_versionFilePath, "UpdaterCustomText.txt");
 
        if (customText.existsAsFile())
        {
            m_updateTextUrl = URL(customText);
        }
    }
 
    void VersionChecker::runCheck() { startThread(); }
 
    bool VersionChecker::updateLatestVersion()
    {
        m_latestVersion = Version(m_versionUrl.readEntireTextStream());
        return m_latestVersion.isValid();
    }
 
    bool VersionChecker::isNewerVersion(Version testVersion)
    {
        if (testVersion.isValid())
            return testVersion.compare(m_pluginVersion) == Version::eRtn::GT;
 
        // Not valid, ignore
        return false;
    }
 
    bool VersionChecker::isVersionInDontCheckFile(Version version)
    {
        File dontCheckFile(m_dontCheckForUpdatesPath);
 
        if (dontCheckFile.existsAsFile())
        {
            StringArray versionInCheckFile;
            dontCheckFile.readLines(versionInCheckFile);
            String ignoredVersion = versionInCheckFile[0];
            if (ignoredVersion.compareIgnoreCase(version.toString()) == 0)
            {
                return true;
            }
        }
 
        return false;
    }
 
    // TODO replace with settingsFile and get rid of the don't check for updates .txt
    bool VersionChecker::dontCheckFileExists()
    {
        File dontCheckFile(m_dontCheckForUpdatesPath);
        return (dontCheckFile.existsAsFile());
    }
 
    void VersionChecker::run()
    {
        if (!threadShouldExit())
        {
            const bool connectedToServer = updateLatestVersion();
            if (threadShouldExit())
            {
                return;
            }
            if (connectedToServer && isNewerVersion(m_latestVersion))
            {
                if (!isVersionInDontCheckFile(m_latestVersion))
                {
                    // This version is new
                    m_updateText = m_updateTextUrl.readEntireTextStream();
                    if (m_updateText.isNotEmpty())
                    {
                        m_updateAvailable = true;
                    }
                }
            }
            signalThreadShouldExit();
        }
    }
 
    VersionChecker::eReturn VersionChecker::doRemoteVersionCheck()
    {
        if (!updateLatestVersion())
        {
            return CONNECTION_ERROR;
        }
 
        if (!isNewerVersion(m_latestVersion))
        {
            return IS_UP_TO_DATE;
        }
        else
        {
            m_updateText = m_updateTextUrl.readEntireTextStream();
            return UPDATE_AVAILABLE;
        }
    }
 
    void VersionChecker::exitSignalSent()
    {
        if (onFinished != nullptr)
            onFinished(m_updateAvailable);
    }
 
    void VersionChecker::storeRetrievedVersionId()
    {
        // TODO replace with settingsFile and get rid of the don't check for updates .txt
        File dontCheckFile(m_dontCheckForUpdatesPath);
 
        // if DoNotCheckForUpdates.txt doesn't exist, create it
        if (!dontCheckFile.existsAsFile())
        {
            dontCheckFile.create();
        }
 
        // if DoNotCheckForUpdates.txt exists, replace version number from AWS
        if (dontCheckFile.existsAsFile())
        {
            dontCheckFile.replaceWithText(m_latestVersion.toString());
        }
    }
 
    bool VersionChecker::resetDoNotCheckStatus()
    {
        File dontCheckFile(m_dontCheckForUpdatesPath);
        return dontCheckFile.deleteFile();
    }
} // namespace krotos