xbmc/platform/linux/AppParamParserLinux.cpp

   1 /*
   2  *  Copyright (C) 2005-2021 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "AppParamParserLinux.h"
  10
  11 #include "CompileInfo.h"
  12 #include "application/AppParams.h"
  13 #include "utils/StringUtils.h"
  14
  15 #include <algorithm>
  16 #include <array>
  17 #include <iostream>
  18 #include <vector>
  19
  20 namespace
  21 {
  22 std::vector<std::string> availableWindowSystems = CCompileInfo::GetAvailableWindowSystems();
  23 std::array<std::string, 1> availableLogTargets = {"console"};
  24 std::vector<std::string> availableAudioBackends = CCompileInfo::GetAvailableAudioBackends();
  25 std::vector<std::string> availableGlInterfaces = CCompileInfo::GetAvailableGlInterfaces();
  26
  27 constexpr const char* windowingText =
  28     R"""(
  29 Selected window system not available: {}
  30     Available window systems: {}
  31 )""";
  32
  33 constexpr const char* loggingText =
  34     R"""(
  35 Selected logging target not available: {}
  36     Available log targest: {}
  37 )""";
  38
  39 constexpr const char* audioBackendsText =
  40     R"""(
  41 Selected audio backend not available: {}
  42     Available audio backends: {}
  43 )""";
  44
  45 constexpr const char* glInterfaceText =
  46     R"""(
  47 Selected GL interface not available: {}
  48     Available GL interfaces: {}
  49 )""";
  50
  51 constexpr const char* helpText =
  52     R"""(
  53 Linux Specific Arguments:
  54   --windowing=<system>  Select which windowing method to use.
  55                           Available window systems are: {}
  56   --logging=<target>    Select which log target to use (log file will always be used in conjunction).
  57                           Available log targets are: {}
  58   --audio-backend=<backend> Select which audio backend to use.
  59                           Available audio backends are: {}
  60   --gl-interface=<interface> Select which GL interface to use (X11 only).
  61                           Available GL interfaces are: {}
  62 )""";
  63
  64 } // namespace
  65
  66 CAppParamParserLinux::CAppParamParserLinux() : CAppParamParser()
  67 {
  68 }
  69
  70 CAppParamParserLinux::~CAppParamParserLinux() = default;
  71
  72 void CAppParamParserLinux::ParseArg(const std::string& arg)
  73 {
  74   CAppParamParser::ParseArg(arg);
  75
  76   if (arg.substr(0, 12) == "--windowing=")
  77   {
  78     if (std::find(availableWindowSystems.begin(), availableWindowSystems.end(), arg.substr(12)) !=
  79         availableWindowSystems.end())
  80       GetAppParams()->SetWindowing(arg.substr(12));
  81     else
  82     {
  83       std::cout << StringUtils::Format(windowingText, arg.substr(12),
  84                                        StringUtils::Join(availableWindowSystems, ", "));
  85       exit(0);
  86     }
  87   }
  88   else if (arg.substr(0, 10) == "--logging=")
  89   {
  90     if (std::find(availableLogTargets.begin(), availableLogTargets.end(), arg.substr(10)) !=
  91         availableLogTargets.end())
  92     {
  93       GetAppParams()->SetLogTarget(arg.substr(10));
  94     }
  95     else
  96     {
  97       std::cout << StringUtils::Format(loggingText, arg.substr(10),
  98                                        StringUtils::Join(availableLogTargets, ", "));
  99       exit(0);
 100     }
 101   }
 102   else if (arg.find("--audio-backend=") != std::string::npos)
 103   {
 104     const auto argValue = arg.substr(16);
 105     const auto it =
 106         std::find(availableAudioBackends.cbegin(), availableAudioBackends.cend(), argValue);
 107     if (it != availableAudioBackends.cend())
 108     {
 109       GetAppParams()->SetAudioBackend(argValue);
 110     }
 111     else
 112     {
 113       std::cout << StringUtils::Format(audioBackendsText, argValue,
 114                                        StringUtils::Join(availableAudioBackends, ", "));
 115
 116       exit(0);
 117     }
 118   }
 119   else if (arg.find("--gl-interface=") != std::string::npos)
 120   {
 121     const auto argValue = arg.substr(15);
 122     const auto it =
 123         std::find(availableGlInterfaces.cbegin(), availableGlInterfaces.cend(), argValue);
 124     if (it != availableGlInterfaces.cend())
 125     {
 126       GetAppParams()->SetGlInterface(argValue);
 127     }
 128     else
 129     {
 130       std::cout << StringUtils::Format(glInterfaceText, argValue,
 131                                        StringUtils::Join(availableGlInterfaces, ", "));
 132
 133       exit(0);
 134     }
 135   }
 136 }
 137
 138 void CAppParamParserLinux::DisplayHelp()
 139 {
 140   CAppParamParser::DisplayHelp();
 141
 142   std::cout << StringUtils::Format(helpText, StringUtils::Join(availableWindowSystems, ", "),
 143                                    StringUtils::Join(availableLogTargets, ", "),
 144                                    StringUtils::Join(availableAudioBackends, ", "),
 145                                    StringUtils::Join(availableGlInterfaces, ", "));
 146 }