Line data    Source code

       1             : /*
       2             :  *  Copyright (C) 2004-2024 Savoir-faire Linux Inc.
       3             :  *
       4             :  *  This program is free software: you can redistribute it and/or modify
       5             :  *  it under the terms of the GNU General Public License as published by
       6             :  *  the Free Software Foundation, either version 3 of the License, or
       7             :  *  (at your option) any later version.
       8             :  *
       9             :  *  This program is distributed in the hope that it will be useful,
      10             :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      12             :  *  GNU General Public License for more details.
      13             :  *
      14             :  *  You should have received a copy of the GNU General Public License
      15             :  *  along with this program. If not, see <https://www.gnu.org/licenses/>.
      16             :  */
      17             : 
      18             : #ifndef __PREFERENCE_H__
      19             : #define __PREFERENCE_H__
      20             : 
      21             : #include "config/serializable.h"
      22             : #include "client/ring_signal.h"
      23             : #include <string>
      24             : #include <map>
      25             : #include <set>
      26             : #include <vector>
      27             : 
      28             : namespace YAML {
      29             : class Emitter;
      30             : class Node;
      31             : } // namespace YAML
      32             : 
      33             : extern "C" {
      34             : struct pjsip_msg;
      35             : }
      36             : 
      37             : namespace jami {
      38             : 
      39             : class AudioLayer;
      40             : 
      41             : class Preferences : public Serializable
      42             : {
      43             : public:
      44             :     static const char* const DFT_ZONE;
      45             :     static const char* const REGISTRATION_EXPIRE_KEY;
      46             : 
      47             :     Preferences();
      48             : 
      49             :     void serialize(YAML::Emitter& out) const override;
      50             :     void unserialize(const YAML::Node& in) override;
      51             : 
      52        3016 :     const std::string& getAccountOrder() const { return accountOrder_; }
      53             : 
      54             :     // flush invalid accountIDs from account order
      55             :     void verifyAccountOrder(const std::vector<std::string>& accounts);
      56             : 
      57             :     void addAccount(const std::string& acc);
      58             :     void removeAccount(const std::string& acc);
      59             : 
      60           0 :     void setAccountOrder(const std::string& ord) { accountOrder_ = ord; }
      61             : 
      62           0 :     int getHistoryLimit() const { return historyLimit_; }
      63             : 
      64           0 :     void setHistoryLimit(int lim) { historyLimit_ = lim; }
      65             : 
      66         108 :     int getRingingTimeout() const { return ringingTimeout_; }
      67             : 
      68           0 :     void setRingingTimeout(int timeout) { ringingTimeout_ = timeout; }
      69             : 
      70             :     int getHistoryMaxCalls() const { return historyMaxCalls_; }
      71             : 
      72             :     void setHistoryMaxCalls(int max) { historyMaxCalls_ = max; }
      73             : 
      74          33 :     std::string getZoneToneChoice() const { return zoneToneChoice_; }
      75             : 
      76             :     void setZoneToneChoice(const std::string& str) { zoneToneChoice_ = str; }
      77             : 
      78             :     int getPortNum() const { return portNum_; }
      79             : 
      80             :     void setPortNum(int port) { portNum_ = port; }
      81             : 
      82             :     bool getSearchBarDisplay() const { return searchBarDisplay_; }
      83             : 
      84             :     void setSearchBarDisplay(bool search) { searchBarDisplay_ = search; }
      85             : 
      86          24 :     bool getMd5Hash() const { return md5Hash_; }
      87             :     void setMd5Hash(bool md5) { md5Hash_ = md5; }
      88             : 
      89             : private:
      90             :     std::string accountOrder_;
      91             :     int historyLimit_;
      92             :     int historyMaxCalls_;
      93             :     int ringingTimeout_;
      94             :     std::string zoneToneChoice_;
      95             :     int portNum_;
      96             :     bool searchBarDisplay_;
      97             :     bool md5Hash_;
      98             :     constexpr static const char* const CONFIG_LABEL = "preferences";
      99             : };
     100             : 
     101             : class VoipPreference : public Serializable
     102             : {
     103             : public:
     104             :     VoipPreference();
     105             : 
     106             :     void serialize(YAML::Emitter& out) const override;
     107             :     void unserialize(const YAML::Node& in) override;
     108             : 
     109           0 :     bool getPlayDtmf() const { return playDtmf_; }
     110             : 
     111           0 :     void setPlayDtmf(bool dtmf) { playDtmf_ = dtmf; }
     112             : 
     113         668 :     bool getPlayTones() const { return playTones_; }
     114             : 
     115             :     void setPlayTones(bool tone) { playTones_ = tone; }
     116             : 
     117           0 :     int getPulseLength() const { return pulseLength_; }
     118             : 
     119             :     void setPulseLength(int length) { pulseLength_ = length; }
     120             : 
     121             : private:
     122             :     bool playDtmf_;
     123             :     bool playTones_;
     124             :     int pulseLength_;
     125             :     constexpr static const char* const CONFIG_LABEL = "voipPreferences";
     126             : };
     127             : 
     128             : class AudioPreference : public Serializable
     129             : {
     130             : public:
     131             :     AudioPreference();
     132             :     AudioLayer* createAudioLayer();
     133             : 
     134             :     static std::vector<std::string> getSupportedAudioManagers();
     135             : 
     136           0 :     const std::string& getAudioApi() const { return audioApi_; }
     137             : 
     138           0 :     void setAudioApi(const std::string& api) { audioApi_ = api; }
     139             : 
     140             :     void serialize(YAML::Emitter& out) const override;
     141             : 
     142             :     void unserialize(const YAML::Node& in) override;
     143             : 
     144             :     // alsa preference
     145          33 :     int getAlsaCardin() const { return alsaCardin_; }
     146             : 
     147           0 :     void setAlsaCardin(int c) { alsaCardin_ = c; }
     148             : 
     149          33 :     int getAlsaCardout() const { return alsaCardout_; }
     150             : 
     151           0 :     void setAlsaCardout(int c) { alsaCardout_ = c; }
     152             : 
     153          33 :     int getAlsaCardRingtone() const { return alsaCardRingtone_; }
     154             : 
     155           0 :     void setAlsaCardRingtone(int c) { alsaCardRingtone_ = c; }
     156             : 
     157          33 :     const std::string& getAlsaPlugin() const { return alsaPlugin_; }
     158             : 
     159           0 :     void setAlsaPlugin(const std::string& p) { alsaPlugin_ = p; }
     160             : 
     161             :     int getAlsaSmplrate() const { return alsaSmplrate_; }
     162             : 
     163             :     void setAlsaSmplrate(int r) { alsaSmplrate_ = r; }
     164             : 
     165             :     // pulseaudio preference
     166           0 :     const std::string& getPulseDevicePlayback() const { return pulseDevicePlayback_; }
     167             : 
     168           0 :     void setPulseDevicePlayback(const std::string& p) { pulseDevicePlayback_ = p; }
     169             : 
     170           0 :     const std::string& getPulseDeviceRecord() const { return pulseDeviceRecord_; }
     171           0 :     void setPulseDeviceRecord(const std::string& r) { pulseDeviceRecord_ = r; }
     172             : 
     173           0 :     const std::string& getPulseDeviceRingtone() const { return pulseDeviceRingtone_; }
     174             : 
     175           0 :     void setPulseDeviceRingtone(const std::string& r) { pulseDeviceRingtone_ = r; }
     176             : 
     177             :     // portaudio preference
     178             :     const std::string& getPortAudioDevicePlayback() const { return portaudioDevicePlayback_; }
     179             : 
     180             :     void setPortAudioDevicePlayback(const std::string& p) { portaudioDevicePlayback_ = p; }
     181             : 
     182             :     const std::string& getPortAudioDeviceRecord() const { return portaudioDeviceRecord_; }
     183             : 
     184             :     void setPortAudioDeviceRecord(const std::string& r) { portaudioDeviceRecord_ = r; }
     185             : 
     186             :     const std::string& getPortAudioDeviceRingtone() const { return portaudioDeviceRingtone_; }
     187             : 
     188             :     void setPortAudioDeviceRingtone(const std::string& r) { portaudioDeviceRingtone_ = r; }
     189             : 
     190             :     // general preference
     191          11 :     const std::string& getRecordPath() const { return recordpath_; }
     192             : 
     193             :     // Returns true if directory is writeable
     194             :     bool setRecordPath(const std::string& r);
     195             : 
     196         194 :     bool getIsAlwaysRecording() const { return alwaysRecording_; }
     197             : 
     198           6 :     void setIsAlwaysRecording(bool rec) { alwaysRecording_ = rec; }
     199             : 
     200          36 :     double getVolumemic() const { return volumemic_; }
     201        1733 :     void setVolumemic(double m) { volumemic_ = m; }
     202             : 
     203          36 :     double getVolumespkr() const { return volumespkr_; }
     204        1733 :     void setVolumespkr(double s) { volumespkr_ = s; }
     205             : 
     206          36 :     bool isAGCEnabled() const { return agcEnabled_; }
     207             : 
     208           0 :     void setAGCState(bool enabled) { agcEnabled_ = enabled; }
     209             : 
     210          36 :     const std::string& getNoiseReduce() const { return denoise_; }
     211             : 
     212           0 :     void setNoiseReduce(const std::string& enabled) { denoise_ = enabled; }
     213             : 
     214          36 :     bool getCaptureMuted() const { return captureMuted_; }
     215             : 
     216        1733 :     void setCaptureMuted(bool muted) { captureMuted_ = muted; }
     217             : 
     218          36 :     bool getPlaybackMuted() const { return playbackMuted_; }
     219             : 
     220        1733 :     void setPlaybackMuted(bool muted) { playbackMuted_ = muted; }
     221             : 
     222          36 :     const std::string& getAudioProcessor() const { return audioProcessor_; }
     223             : 
     224             :     void setAudioProcessor(const std::string& ap) { audioProcessor_ = ap; }
     225             : 
     226          36 :     bool getVadEnabled() const { return vadEnabled_; }
     227             : 
     228             :     void setVad(bool enable) { vadEnabled_ = enable; }
     229             : 
     230          36 :     const std::string& getEchoCanceller() const { return echoCanceller_; }
     231             : 
     232             :     void setEchoCancel(std::string& canceller) { echoCanceller_ = canceller; }
     233             : 
     234             : private:
     235             :     std::string audioApi_;
     236             : 
     237             :     // alsa preference
     238             :     int alsaCardin_;
     239             :     int alsaCardout_;
     240             :     int alsaCardRingtone_;
     241             :     std::string alsaPlugin_;
     242             :     int alsaSmplrate_;
     243             : 
     244             :     // pulseaudio preference
     245             :     std::string pulseDevicePlayback_;
     246             :     std::string pulseDeviceRecord_;
     247             :     std::string pulseDeviceRingtone_;
     248             : 
     249             :     // portaudio preference
     250             :     std::string portaudioDevicePlayback_;
     251             :     std::string portaudioDeviceRecord_;
     252             :     std::string portaudioDeviceRingtone_;
     253             : 
     254             :     // general preference
     255             :     std::string recordpath_;
     256             :     bool alwaysRecording_;
     257             :     double volumemic_;
     258             :     double volumespkr_;
     259             : 
     260             :     // audio processor preferences
     261             :     std::string audioProcessor_;
     262             :     std::string denoise_;
     263             :     bool agcEnabled_;
     264             :     bool vadEnabled_;
     265             :     std::string echoCanceller_;
     266             : 
     267             :     bool captureMuted_;
     268             :     bool playbackMuted_;
     269             :     constexpr static const char* const CONFIG_LABEL = "audio";
     270             : };
     271             : 
     272             : #ifdef ENABLE_VIDEO
     273             : class VideoPreferences : public Serializable
     274             : {
     275             : public:
     276             :     VideoPreferences();
     277             : 
     278             :     void serialize(YAML::Emitter& out) const override;
     279             :     void unserialize(const YAML::Node& in) override;
     280             : 
     281         358 :     bool getDecodingAccelerated() const { return decodingAccelerated_; }
     282             : 
     283           0 :     bool setDecodingAccelerated(bool decodingAccelerated)
     284             :     {
     285           0 :         if (decodingAccelerated_ != decodingAccelerated) {
     286           0 :             decodingAccelerated_ = decodingAccelerated;
     287           0 :             emitSignal<libjami::ConfigurationSignal::HardwareDecodingChanged>(decodingAccelerated_);
     288           0 :             return true;
     289             :         }
     290           0 :         return false;
     291             :     }
     292             : 
     293         785 :     bool getEncodingAccelerated() const { return encodingAccelerated_; }
     294             : 
     295           0 :     bool setEncodingAccelerated(bool encodingAccelerated)
     296             :     {
     297           0 :         if (encodingAccelerated_ != encodingAccelerated) {
     298           0 :             encodingAccelerated_ = encodingAccelerated;
     299           0 :             emitSignal<libjami::ConfigurationSignal::HardwareEncodingChanged>(encodingAccelerated_);
     300           0 :             return true;
     301             :         }
     302           0 :         return false;
     303             :     }
     304             : 
     305           0 :     bool getRecordPreview() const { return recordPreview_; }
     306             : 
     307           0 :     void setRecordPreview(bool rec) { recordPreview_ = rec; }
     308             : 
     309           6 :     int getRecordQuality() const { return recordQuality_; }
     310             : 
     311           0 :     void setRecordQuality(int rec) { recordQuality_ = rec; }
     312             : 
     313          38 :     const std::string& getConferenceResolution() const { return conferenceResolution_; }
     314             : 
     315             :     void setConferenceResolution(const std::string& res) { conferenceResolution_ = res; }
     316             : 
     317             : private:
     318             :     bool decodingAccelerated_;
     319             :     bool encodingAccelerated_;
     320             :     bool recordPreview_;
     321             :     int recordQuality_;
     322             :     std::string conferenceResolution_;
     323             :     constexpr static const char* const CONFIG_LABEL = "video";
     324             : };
     325             : #endif // ENABLE_VIDEO
     326             : 
     327             : #ifdef ENABLE_PLUGIN
     328             : class PluginPreferences : public Serializable
     329             : {
     330             : public:
     331             :     PluginPreferences();
     332             : 
     333             :     void serialize(YAML::Emitter& out) const override;
     334             :     void unserialize(const YAML::Node& in) override;
     335             : 
     336          45 :     bool getPluginsEnabled() const { return pluginsEnabled_; }
     337             : 
     338          11 :     void setPluginsEnabled(bool pluginsEnabled) { pluginsEnabled_ = pluginsEnabled; }
     339             : 
     340          10 :     std::vector<std::string> getLoadedPlugins() const
     341             :     {
     342          10 :         std::vector<std::string> v(loadedPlugins_.begin(), loadedPlugins_.end());
     343          10 :         return v;
     344             :     }
     345             : 
     346           2 :     std::vector<std::string> getInstalledPlugins() const
     347             :     {
     348           2 :         return std::vector<std::string>(installedPlugins_.begin(), installedPlugins_.end());
     349             :     }
     350             : 
     351          12 :     void saveStateLoadedPlugins(std::string plugin, bool loaded)
     352             :     {
     353          12 :         if (loaded) {
     354           7 :             if (loadedPlugins_.find(plugin) != loadedPlugins_.end())
     355           2 :                 return;
     356           5 :             loadedPlugins_.emplace(plugin);
     357             :         } else {
     358           5 :             auto it = loadedPlugins_.find(plugin);
     359           5 :             if (it != loadedPlugins_.end())
     360           5 :                 loadedPlugins_.erase(it);
     361             :         }
     362             :     }
     363             : 
     364             : private:
     365             :     bool pluginsEnabled_;
     366             :     std::set<std::string> installedPlugins_;
     367             :     std::set<std::string> loadedPlugins_;
     368             :     constexpr static const char* const CONFIG_LABEL = "plugins";
     369             : };
     370             : #endif // ENABLE_PLUGIN
     371             : 
     372             : } // namespace jami
     373             : 
     374             : #endif