AssetManager.cpp

Go to the documentation of this file.

namespace krotos
{
    const String AssetManager::SupportedAudioTypes("wav;aif;aiff;flac;ogg;kaf");
 
    AssetManager::AssetManager()
    {
// do not try to init resources/directories when running unit tests!
#ifndef UNIT_TEST
        PluginHostType host;
 
        if (!host.isPluginval()) // pluginval currently not compatible with state loading
        {
            try
            {
                initializeAssetResources();
            }
            catch (AssetException& ex)
            {
                std::cout << ex.what() << std::endl;
            }
        }
#endif
    }
 
    void AssetManager::initializeAssetResources()
    {
        // TODO: Wes port over custom asset paths to settingsFile
        auto samplesPathDotTxt = getSamplesPathDotTxt();
        auto factoryAssetPath = readFactorySamplesPath();
 
        auto dragAndDropPathSetting = KwidgetAudioProcessor::settingsFile.getSetting("drag_and_drop_path").toString();
        auto dragAndDropPath = readDragAndDropPath(); // Kwidget_Recorder dragged dir
 
        if (samplesPathDotTxt.exists() != true) // does samplesPath.txt exist?
        {
            if (samplesPathDotTxt.create() == Result::ok()) // if not create it
            {
                // write default path to it, but don't move any assets!
                editFactorySamplesPath(factoryAssetPath,
                                       false); // there are exceptions that would be thrown if writing fails here...
            }
            else
            {
                // if we can't create a samplesPath.txt, throw
                throw AssetException(/*what*/ "Error: Cannot create missing samplesPath.txt",
                                     /*when*/ "On init of AssetManager");
            }
        }
 
        // let's double check the factory asset path exists on startup
        if (File(factoryAssetPath).isDirectory() != true)
        {
            // no factory asset folder, critical failure, no factory presets can be loaded
            throw AssetException(/*what*/ "Error: Factory asset folder does not exist",
                                 /*when*/ "On init of factory asset dir");
        }
 
        if (!File(dragAndDropPathSetting).isDirectory()) // does the set drag and drop path exist
        {
            // write default path to it, but don't move any assets!
            editDragAndDropPath(dragAndDropPath); // there are exceptions that would be thrown if writing fails here...
        }
 
        // let's double check the recorder asset path exists on startup
        if (File(dragAndDropPath).isDirectory() != true)
        {
            if (File(dragAndDropPath).createDirectory() != Result::ok())
            {
                throw AssetException(/*what*/ "Error: Cannot find or create Kwidget_Recorder directory",
                                     /*when*/ "On init of AssetManager dirs");
            }
        }
    }
 
    File AssetManager::getManifestDirectory()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::commonApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name + "/CPM_Manifests";
#else
        return File("C:\\ProgramData\\Krotos\\" JucePlugin_Name "\\CPM_Manifests");
#endif
    }
 
    File AssetManager::getSamplesPathDotTxt()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::commonApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name + "/samplesPath.txt";
#else
        return File("C:\\ProgramData\\Krotos\\" JucePlugin_Name "\\samplesPath.txt");
#endif
    }
 
    bool AssetManager::isFactoryContentInstalled(const String& dirPath, const int expectedDirCount)
    {
        const auto factoryAssetsDir = AssetManager::readFactorySamplesPath();
        const auto path = utils::StringsIntoPath(factoryAssetsDir, "Factory Assets", dirPath);
        const File dir = File(path);
        
        if (!dir.exists())
        {
            return false;
        }
        
        Array<File> subDirectories;
        dir.findChildFiles(subDirectories, File::findDirectories, false);
 
        return subDirectories.size() > expectedDirCount;
    }
 
    String AssetManager::readFactorySamplesPath()
    {
        auto samplesPathDotTxt = getSamplesPathDotTxt();
 
        if (samplesPathDotTxt.exists())
        {
            return samplesPathDotTxt.loadFileAsString();
        }
        else // return default path if samplesPath.txt doesn't exist, just in case! ...might be safer to just fail here?
        {
            return getPluginDirectory().getFullPathName();
        }
    }
 
    bool AssetManager::editFactorySamplesPath(const String& newFactorySamplesPath, bool moveFiles)
    {
        auto samplesPathDotTxt = getSamplesPathDotTxt();           // samplesPath.txt
        auto currentFactorySamplesPath = readFactorySamplesPath(); // samplesPath.txt contents
 
        if (samplesPathDotTxt.exists() && samplesPathDotTxt.hasWriteAccess()) // make sure we can edit samplesPath.txt
        {
            if (moveFiles) // if we want to move our factory assets...
            {
                if (File(currentFactorySamplesPath).isDirectory() // ..and the assets exist at their present location
                    && File(newFactorySamplesPath).isDirectory()) // ..and the new location can allow for that
                {
                    // first we do a test 'move', before committing to starting the move operation
                    auto testSuccessful = testFactoryAssetsRelocation(currentFactorySamplesPath, newFactorySamplesPath);
 
                    if (!testSuccessful) // should have failed before here
                    {
                        throw AssetException(/*what*/ "Error: Test move failed, aborting asset relocation",
                                             /*when*/ "Test move factory assets");
                    }
 
                    // let's do the actual moving now...
                    auto copySuccessful =
                            copyFactoryAssets(currentFactorySamplesPath, newFactorySamplesPath); // do the actual move
 
                    if (!copySuccessful) // move failed, should have failed before here
                    {
                        // if move failed we dont want to try the write
                        throw AssetException(/*what*/ "Error: Moving factory assets failed!",
                                             /*when*/ "Try to moveFactoryAssets");
                    }
 
                    auto writePathSuccessful = samplesPathDotTxt.replaceWithText(newFactorySamplesPath);
 
                    if (!writePathSuccessful) // write failed
                    {
                        throw AssetException(/*what*/ "Error: Writing new asset path failed!",
                                             /*when*/ "Try to moveFactoryAssets");
                    }
 
                    // only delete old assets folder after write is successful
                    auto cleanUpSuccessful = cleanUpFactoryAssetsRelocation(currentFactorySamplesPath);
 
                    if (!cleanUpSuccessful) // cleanup failed, should have failed before here
                    {
                        throw AssetException(/*what*/ "Error: Deleting old factory assets dir failed!",
                                             /*when*/ "Try to moveFactoryAssets");
                    }
 
                    return true; // it worked!
                }
                else // if either dirs doesn't exist (should be impossible!)
                {
                    throw AssetException(/*what*/ "Error: Missing source or destination asset directory",
                                         /*when*/ "Try to moveFactoryAssets");
                }
            }
            else
            {
                const String assetsDirectory = "Factory Assets";
 
                String finalPath = newFactorySamplesPath;
 
                // if a user selects the factory assets folder instead of the parent, correct to the path we want to
                // write to samplesPath.txt
                if (newFactorySamplesPath.contains(assetsDirectory))
                {
                    finalPath = newFactorySamplesPath.upToFirstOccurrenceOf(assetsDirectory, false, true);
                }
 
                // since we don't need to move, just write the path!
                auto writePathSuccessful = samplesPathDotTxt.replaceWithText(finalPath);
 
                if (!writePathSuccessful)
                {
                    throw AssetException(/*what*/ "Error: Writing new asset path failed",
                                         /*when*/ "Try to write new factory assets path");
                }
 
                return true; // our write-only operation was successful!
            }
        }
        else // missing samplesPath.txt, so can't write! how did we get here?!
        {
            throw AssetException(/*what*/ "Error: Missing samplesPath.txt,\nplease restart the plugin",
                                 /*when*/ "Try to moveFactoryAssets");
        }
    }
 
    bool AssetManager::testFactoryAssetsRelocation(const String& currentFactorySamplesPath,
                                                   const String& newFactorySamplesPath)
    {
#ifdef JUCE_MAC
        const String testFile = "/Factory Assets/samplesPath.test";
#else
        const String testFile = "\\Factory Assets\\samplesPath.test";
#endif
 
        // test create and delete in current factory samples path
        auto oldPathTestCreate = File(currentFactorySamplesPath + testFile).create();
        auto oldPathTestDelete = File(currentFactorySamplesPath + testFile).deleteRecursively();
 
        if (!oldPathTestCreate || !oldPathTestDelete)
        {
            throw AssetException(/*what*/ "Error: Test move failed due to access issue with current asset path",
                                 /*when*/ "Test move factory assets");
        }
 
        // test create and delete in destination factory samples path
        auto newPathTestCreate = File(newFactorySamplesPath + testFile).create();
        auto newPathTestDelete = File(newFactorySamplesPath + testFile).deleteRecursively();
 
        if (!newPathTestCreate || !newPathTestDelete)
        {
            throw AssetException(/*what*/ "Error: Test move failed due to access issue with desired asset path",
                                 /*when*/ "Test move factory assets");
        }
 
        return true; // test move was successful
    }
 
    bool AssetManager::copyFactoryAssets(const String& currentFactorySamplesPath, const String& newFactorySamplesPath)
    {
#ifdef JUCE_MAC
        auto copySucessful = File(currentFactorySamplesPath + "/Factory Assets")
                                     .copyDirectoryTo(newFactorySamplesPath + "/Factory Assets");
#else // windows
        auto copySucessful = File(currentFactorySamplesPath + "\\Factory Assets")
                                     .copyDirectoryTo(newFactorySamplesPath + "\\Factory Assets");
#endif
        if (!copySucessful)
        {
            throw AssetException(/*what*/ "Error: Moving assets failed due to issue copying to new location.\nCheck "
                                          "permissions on destination folder.",
                                 /*when*/ "Try to moveFactoryAssets");
        }
 
        return true; // we did it!
    }
 
    bool AssetManager::cleanUpFactoryAssetsRelocation(const String& currentFactorySamplesPath)
    {
#ifdef JUCE_MAC
        auto deleteSuccessful = File(currentFactorySamplesPath + "/Factory Assets").deleteRecursively();
#else
        auto deleteSuccessful = File(currentFactorySamplesPath + "\\Factory Assets").deleteRecursively();
#endif
        if (!deleteSuccessful)
        {
            throw AssetException(
                    /*what*/ "Error: Deleting old asset path failed.\nMove was successful, please try manual deletion.",
                    /*when*/ "Try to moveFactoryAssets"); // delete failed if the copy failed!
        }
 
        return true; // clean up was fully successful
    }
 
    void AssetManager::destroyTempDirs()
    {
        auto tempDirPath = getSystemTempDirectory(); // Kwidget_Recorder temp dir(s)
 
        // delete ALL recorder temp dirs
        if (tempDirPath.isDirectory())
        {
            if (!tempDirPath.deleteRecursively())
            {
                throw AssetException(/*what*/ "Error: Cannot delete recorder temp directories",
                                     /*when*/ "On call of dev destroy function");
            }
        }
    }
 
    void AssetManager::deleteEmbeddingsCacheFile()
    {
        auto deleteSuccessful = File(utils::StringsIntoPath(AssetManager::getPluginDirectory().getFullPathName(),
                                                            "ttpResources", ".ttfEmbCache"))
                                        .deleteFile();
        if (!deleteSuccessful)
        {
            throw AssetException(
                    /*what*/ "Error: Cannot delete embeddings cache file",
                    /*when*/ "On call of dev delete cache function");
        }
    }
 
    void AssetManager::deleteEmbeddingsStatusFile()
    {
        auto deleteSuccessful = File(utils::StringsIntoPath(AssetManager::getPluginDirectory().getFullPathName(),
                                                            "ttpResources", ".ttfStatus"))
                                        .deleteFile();
        if (!deleteSuccessful)
        {
            throw AssetException(
                    /*what*/ "Error: Cannot delete embeddings status file",
                    /*when*/ "On call of dev delete status function");
        }
    }
 
    File AssetManager::getSystemTempDirectory()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::tempDirectory).getFullPathName();
#else
        return File::getSpecialLocation(File::tempDirectory).getFullPathName() + "\\Krotos\\" + JucePlugin_Name;
#endif
    }
 
    File AssetManager::newTempDirectory(const String& subDirectory)
    {
        File newTempDirectory = File::addTrailingSeparator(getSystemTempDirectory().getFullPathName()) + subDirectory;
 
        if (newTempDirectory.createDirectory() != Result::ok())
        {
            jassertfalse; // could not create recorder temp dir
        }
 
        return newTempDirectory;
    }
 
    File AssetManager::getEULADirectory()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::commonApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name + "/Documentation/EULA/";
#else
        return File("C:\\ProgramData\\Krotos\\" JucePlugin_Name "\\Documentation\\EULA\\");
#endif
    }
 
    File AssetManager::getManualDirectory()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::commonApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name + "/Documentation/Manual/";
#else
        return File("C:\\ProgramData\\Krotos\\" JucePlugin_Name "\\Documentation\\Manual\\");
#endif
    }
 
    File AssetManager::getDLC1AssetDirectory()
    {
#ifdef JUCE_MAC
        return readFactorySamplesPath() + "/Factory Assets/DLC1";
#else
        return readFactorySamplesPath() + "\\Factory Assets\\DLC1";
#endif
    }
 
    File AssetManager::getSubscriberAssetDirectory()
    {
#ifdef JUCE_MAC
        return readFactorySamplesPath() + "/Factory Assets/CCFactory";
#else
        return readFactorySamplesPath() + "\\Factory Assets\\CCFactory";
#endif
    }
 
    File AssetManager::getAssetDirectory()
    {
#ifdef JUCE_MAC
        return readFactorySamplesPath() + "/Factory Assets";
#else
        return readFactorySamplesPath() + "\\Factory Assets";
#endif
    }
 
    File AssetManager::getPluginDirectory()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::commonApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name;
#else
        return File("C:\\ProgramData\\Krotos\\" JucePlugin_Name);
#endif
    }
 
    File AssetManager::getUserDataDirectory()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::userApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name;
#else
        return File::getSpecialLocation(File::userApplicationDataDirectory).getFullPathName() + "\\Krotos\\" +
               JucePlugin_Name;
#endif
    }
 
    File AssetManager::getMLEmbeddingsFile()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::commonApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name + "/embeddings_full_paths.csv";
#else
        return File("C:\\ProgramData\\Krotos\\" JucePlugin_Name "\\embeddings_full_paths.csv");
#endif
    }
 
    bool AssetManager::editDragAndDropPath(const String& newDragAndDropPath)
    {
        if (KwidgetAudioProcessor::settingsFile.existsAsFile()) // make sure we can edit the path
        {
            const String outputDirectory = "Output Assets";
 
            String finalPath = newDragAndDropPath;
 
            // if a user selects the factory assets folder instead of the parent, correct to the path we want to write
            // to samplesPath.txt
            if (newDragAndDropPath.contains(outputDirectory))
            {
                finalPath = newDragAndDropPath.upToFirstOccurrenceOf(outputDirectory, false, true);
            }
 
            // since we don't need to move, just write the path!
            KwidgetAudioProcessor::settingsFile.setSetting("drag_and_drop_path", finalPath);
 
            return true; // our write-only operation was successful!
        }
        else // missing dragAndDropPath.txt, so can't write! how did we get here?!
        {
            throw AssetException(/*what*/ "Error: Missing settings.json file,\nplease restart the plugin",
                                 /*when*/ "Try to editDragAndDropPath");
        }
    }
 
    String AssetManager::readDragAndDropPath()
    {
        auto dragAndDropPath = KwidgetAudioProcessor::settingsFile.getSetting("drag_and_drop_path").toString();
 
        if (File(dragAndDropPath).isDirectory())
        {
            return dragAndDropPath;
        }
        else // return default path if settings can't be found or settings.json doesn't exist
        {
            return getDefaultDragAndDropPath().getFullPathName();
        }
    }
 
    File AssetManager::getDefaultDragAndDropPath()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::userApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name + "/OutputAssets/";
#else
        return File::getSpecialLocation(File::userApplicationDataDirectory).getFullPathName() + "\\Krotos\\" +
               JucePlugin_Name + "\\OutputAssets\\";
#endif
    }
 
    Array<File> AssetManager::loadFiles(const StringArray& files, bool convertPaths, bool willLoadSpecificFiles)
    {
        const String assetsDirectory = "Factory Assets";
 
        Array<File> filesToLoad;
 
        for (auto& file : files)
        {
            // file which will combine relative path with actual factory asset location
            File locatedFile;
            String dynamicPath;
            File finalPath;
 
            if (file.contains(assetsDirectory)) // its a factory asset path
            {
                if (convertPaths)
                {
                    locatedFile = convertFilePath(file); // convert between mac and windows file system
                    dynamicPath = locatedFile.getFullPathName().fromFirstOccurrenceOf(assetsDirectory, true, true);
                    finalPath = File::addTrailingSeparator(readFactorySamplesPath()) +
                                dynamicPath; // take the part after Factory assets and combine with root
                }
                else
                {
                    locatedFile = file;
                    dynamicPath = locatedFile.getFullPathName().fromFirstOccurrenceOf(assetsDirectory, true, true);
                    finalPath = File::addTrailingSeparator(readFactorySamplesPath()) + dynamicPath;
                }
            }
            else // user asset path must be loaded in the traditional way
            {
                if (convertPaths)
                {
                    finalPath = convertFilePath(file); // convert between mac and windows file system
                }
                else
                {
                    finalPath = file;
                }
            }
 
            // file allocation/management
            if (finalPath.existsAsFile())
            {
                if (finalPath.hasFileExtension(kafFileExtension)) // it's a kaf file to begin with
                {
                    if (willLoadSpecificFiles) // kaf file reading is enabled
                    {
                        filesToLoad.add(finalPath);
                    }
                    else
                    {
                        throw EncryptedAssetException(/*what*/ "Error: Non authorised user loading .kaf files",
                                                      /*when*/ "During loadFiles function");
                    }
                }
                else
                {
                    // is a .wav file that exists already, just load it
                    filesToLoad.add(finalPath);
                }
            }
            else if (finalPath.withFileExtension(kafFileExtension).existsAsFile()) // is a .kaf file that exists
            {
                // check sub
                if (willLoadSpecificFiles)
                {
                    filesToLoad.add(finalPath.withFileExtension(kafFileExtension));
                }
                else
                {
                    throw EncryptedAssetException(/*what*/ "Error: Non authorised user loading .kaf files",
                                                  /*when*/ "During loadFiles function");
                }
            }
            else if (finalPath.isDirectory()) // exists as a directory
            {
                const auto kafFiles = finalPath.findChildFiles(File::TypesOfFileToFind::findFiles, true, "*.kaf");
 
                const auto wavFiles = finalPath.findChildFiles(File::TypesOfFileToFind::findFiles, true, "*.wav");
 
                if (!wavFiles.isEmpty() && kafFiles.isEmpty()) // dir contains ONLY .wav files, just load it
                {
                    filesToLoad.add(finalPath);
                }
                else if ((!wavFiles.isEmpty() &&
                          !kafFiles.isEmpty()) // mixture of .wav AND .kaf files in the same directory
                         || (wavFiles.isEmpty() && !kafFiles.isEmpty())) // dir contains ONLY .kaf files
                {
                    if (willLoadSpecificFiles) // check sub
                    {
                        filesToLoad.add(finalPath);
                    }
                    else
                    {
                        throw EncryptedAssetException(/*what*/ "Error: Non authorised user loading .kaf files",
                                                      /*when*/ "During loadFiles function");
                    }
                }
            }
            else
            {
                DBG("File not found: " << finalPath.getFileNameWithoutExtension());
            }
        }
        return filesToLoad;
    }
 
    String AssetManager::convertFilePathString(const String& path)
    {
        const String winRoot = "C:\\ProgramData\\Krotos";
        const String macRoot = "/Library/Application Support/Krotos";
 
#ifdef JUCE_WINDOWS
        auto convertedPath = path.replaceFirstOccurrenceOf(macRoot, winRoot).replaceCharacter('/', '\\');
#else
        auto convertedPath = path.replaceFirstOccurrenceOf(winRoot, macRoot).replaceCharacter('\\', '/');
#endif
        return convertedPath;
    }
 
    String AssetManager::convertFilePathToOSX(const String& path)
    {
        const String winRoot = "C:\\ProgramData\\Krotos";
        const String macRoot = "/Library/Application Support/Krotos";
        auto convertedPath = path.replaceFirstOccurrenceOf(winRoot, macRoot).replaceCharacter('\\', '/');
        return convertedPath;
    }
 
    File AssetManager::convertFilePath(const String& path) { return File(convertFilePathString(path)); }
 
    String AssetManager::checkSamplePaths(const File& presetFile)
    {
        jassert(presetFile.hasFileExtension("ksp")); // is valid preset
 
        String missingFiles;
 
        auto incomingPreset = PresetManager::getPresetFromFile(presetFile);
        auto valueTree = PresetManager::getValueTreeFromFile(incomingPreset.path);
 
        auto kwidgets = valueTree.getChildWithName(XmlType::Tag::kwidgets);
 
        for (const auto& kwidget : kwidgets)
        {
            if (kwidget.getProperty(XmlType::Property::type).equals("CoreEngine"))
            {
                auto customParams = kwidget.getChildWithName(XmlType::Tag::customParams);
                auto samplePaths = customParams.getChildWithProperty(XmlType::Property::id, "SamplePaths");
                auto pathsValue = samplePaths.getProperty(XmlType::Property::value);
                StringArray cleanPaths = StringArray::fromLines(pathsValue.toString());
 
                for (auto& path : cleanPaths)
                {
                    File locatedFile;
                    String dynamicPath;
                    File finalPath;
 
                    if (path.contains("Factory Assets")) // its a factory asset path
                    {
                        locatedFile = convertFilePath(path); // convert between mac and windows file system if needed
                        dynamicPath = locatedFile.getFullPathName().fromFirstOccurrenceOf("Factory Assets", true, true);
                        finalPath = File::addTrailingSeparator(readFactorySamplesPath()) +
                                    dynamicPath; // take the part after Factory assets and combine with root
 
                        if (!finalPath.isDirectory() && !finalPath.existsAsFile() &&
                            !finalPath.withFileExtension(kafFileExtension).existsAsFile())
                        {
                            missingFiles += finalPath.getFullPathName() + "\n";
                        }
                    }
                    else // checking for missing samples in user preset
                    {
                        path = convertFilePath(path).getFullPathName();
 
                        if (File(path).isDirectory() != true && File(path).exists() != true)
                        {
                            missingFiles += path + "\n";
                        }
                    }
                }
            }
        }
        return missingFiles;
    }
 
    char const* AssetException::what() const noexcept { return runtime_error::what(); }
 
    String AssetException::when() const { return m_whenDidItHappen; }
 
    char const* EncryptedAssetException::what() const noexcept { return runtime_error::what(); }
 
    String EncryptedAssetException::when() const { return m_whenDidItHappen; }
} // namespace krotos