From 44d2afc32338ed723733196f6ceae1ed022abd65 Mon Sep 17 00:00:00 2001
From: pandadev <70103896+0PandaDEV@users.noreply.github.com>
Date: Sat, 13 Apr 2024 02:31:44 +0200
Subject: [PATCH] added eq and volume restoring from config

---
 components/Player.vue          |  83 +++++++++++++++++--------
 lib/{Settings.ts => Config.ts} |  26 +++++---
 lib/Player.ts                  |  88 +++++++++++++++++----------
 pages/index.vue                |  31 +++++++---
 src-tauri/src/config.rs        | 108 ++++++++++++++++++++-------------
 5 files changed, 222 insertions(+), 114 deletions(-)
 rename lib/{Settings.ts => Config.ts} (50%)

diff --git a/components/Player.vue b/components/Player.vue
index 3ad3990..b57c9a3 100644
--- a/components/Player.vue
+++ b/components/Player.vue
@@ -3,7 +3,7 @@
     <p class="element-title">Player</p>
     <div class="top">
       <div class="info">
-        <img :src="cover || '/cover.png'" class="cover"></img>
+        <img :src="cover || '/cover.png'" class="cover" />
         <div class="h">
           <div class="title">{{ title }}</div>
           <div class="artist">{{ artist }}</div>
@@ -22,34 +22,50 @@
         <IconsVolumeMid v-else-if="volume > 0" />
         <IconsVolumeMute v-else />
 
-        <input class="volume" @input="setVolume" v-model="volume" step="1" min="0" max="100" type="range" name="" id="">
+        <input
+          class="volume"
+          @input="setVolume"
+          v-model="volume"
+          step="1"
+          min="0"
+          max="100"
+          type="range"
+          name=""
+          id=""
+        />
       </div>
     </div>
     <div class="bottom">
-      <input type="range" class="progress" v-model="progress" @input="seekTo" min="0" max="100" step=".1">
+      <input
+        type="range"
+        class="progress"
+        v-model="progress"
+        @input="seekTo"
+        min="0"
+        max="100"
+        step=".1"
+      />
       <div class="progress-indicator" :style="{ width: progress + '%' }"></div>
-      <div class="numbers">
-        {{ time }} / {{ duration }}
-      </div>
+      <div class="numbers">{{ time }} / {{ duration }}</div>
     </div>
   </div>
 </template>
 
 <script>
-import Player from '@/lib/Player.ts';
+import Player from "@/lib/Player.ts";
 
 export default {
   data() {
     return {
       player: Player.getInstance(),
-      title: 'Title',
-      artist: 'Artist',
+      title: "Title",
+      artist: "Artist",
       cover: "",
       volume: 100,
       time: "0:00",
       duration: "0:00",
       progress: 0,
-      playing: false
+      playing: false,
     };
   },
   methods: {
@@ -65,8 +81,9 @@ export default {
       this.player.pause();
       this.playing = false;
     },
-    setVolume() {
-      this.player.setVolume(this.volume / 100);
+    async setVolume() {
+      await this.player.updateVolumeSetting(this.volume);
+      await this.player.setVolume(this.volume);
     },
     async rewind() {
       await this.player.rewind();
@@ -85,33 +102,49 @@ export default {
     },
   },
   watch: {
-    'player.currentTime': function(newTime) {
+    "player.currentTime": function (newTime) {
       this.progress = (newTime / this.player.getDuration()) * 100;
-    }
+    },
   },
   mounted() {
-    this.player.audio.addEventListener('timeupdate', () => {
+    this.player.audio.addEventListener("timeupdate", () => {
       const time = this.player.getCurrentTime();
-      this.time = time > 0 ? new Date(time * 1000).toISOString().substr(14, 5) : '0:00';
-      this.progress = (this.player.getCurrentTime() / this.player.getDuration()) * 100;
+      this.time =
+        time > 0 ? new Date(time * 1000).toISOString().substr(14, 5) : "0:00";
+      this.progress =
+        (this.player.getCurrentTime() / this.player.getDuration()) * 100;
     });
-    this.player.audio.addEventListener('loadedmetadata', async () => {
+    this.player.audio.addEventListener("loadedmetadata", async () => {
       const duration = this.player.getDuration();
-      this.duration = duration > 0 ? new Date(duration * 1000).toISOString().substr(14, 5) : '0:00';
+      this.duration =
+        duration > 0
+          ? new Date(duration * 1000).toISOString().substr(14, 5)
+          : "0:00";
       await this.getTitle();
       await this.getArtist();
       await this.getCover();
     });
-    this.player.audio.addEventListener('play', () => {
+    this.player.audio.addEventListener("play", () => {
       this.playing = true;
     });
-    this.player.audio.addEventListener('pause', () => {
+    this.player.audio.addEventListener("pause", () => {
       this.playing = false;
     });
-  }
-}
+
+    this.player
+      .ensureVolumeInitialized()
+      .then(() => {
+        const volume = this.player.getVolume();
+        this.volume = volume;
+        console.log("Volume initialized to:", volume);
+      })
+      .catch((error) => {
+        console.error("Error initializing volume:", error);
+      });
+  },
+};
 </script>
 
 <style lang="scss">
-@import '~/assets/styles/components/player.scss';
-</style>
\ No newline at end of file
+@import "~/assets/styles/components/player.scss";
+</style>
diff --git a/lib/Settings.ts b/lib/Config.ts
similarity index 50%
rename from lib/Settings.ts
rename to lib/Config.ts
index a5220e2..e976080 100644
--- a/lib/Settings.ts
+++ b/lib/Config.ts
@@ -2,10 +2,10 @@ interface EQSettings {
   [key: string]: string;
 }
 
-class Settings {
+export class Config {
   static async readSettings(): Promise<Map<string, string>> {
     try {
-      const settings: { [key: string]: string } = await window.__TAURI__.invoke('read_settings');
+      const settings: { [key: string]: string } = await window.__TAURI__.core.invoke('read_settings');
       return new Map(Object.entries(settings));
     } catch (error) {
       console.error('Error reading settings:', error);
@@ -13,19 +13,27 @@ class Settings {
     }
   }
 
-  static async readEQSettings(): Promise<Map<string, string>> {
+  static async readEQSettings(): Promise<Map<string, number>> {
     try {
-      const eqSettings: { [key: string]: string } = await window.__TAURI__.invoke('read_eq_settings');
-      return new Map(Object.entries(eqSettings));
+      const eqSettings: { [key: string]: string } = await window.__TAURI__.core.invoke('read_eq_settings');
+      const eqSettingsNum: { [key: string]: number } = {};
+      for (const key in eqSettings) {
+        eqSettingsNum[key] = parseFloat(eqSettings[key]);
+      }
+      return new Map(Object.entries(eqSettingsNum));
     } catch (error) {
       console.error('Error reading EQ settings:', error);
       throw error;
     }
   }
 
-  static async writeEQSettings(eqSettings: EQSettings): Promise<void> {
+  static async writeEQSettings(eqSettings: Map<string, number>): Promise<void> {
     try {
-      await window.__TAURI__.invoke('write_eq_settings', { eqSettings });
+      const eqSettingsObj: { [key: string]: string } = {};
+      eqSettings.forEach((value, key) => {
+        eqSettingsObj[key] = value.toString();
+      });
+      await window.__TAURI__.core.invoke('write_eq_settings', { eqSettings: eqSettingsObj });
     } catch (error) {
       console.error('Error writing EQ settings:', error);
       throw error;
@@ -34,7 +42,7 @@ class Settings {
 
   static async updateUserSetting(key: string, value: string): Promise<void> {
     try {
-      await window.__TAURI__.invoke('update_user_setting', { key, value });
+      await window.__TAURI__.core.invoke('update_user_setting', { key, value });
     } catch (error) {
       console.error('Error updating user setting:', error);
       throw error;
@@ -42,4 +50,4 @@ class Settings {
   }
 }
 
-export default Settings;
\ No newline at end of file
+export default Config;
\ No newline at end of file
diff --git a/lib/Player.ts b/lib/Player.ts
index addcbe7..f8091ac 100644
--- a/lib/Player.ts
+++ b/lib/Player.ts
@@ -1,4 +1,5 @@
 import { readSongs } from './Songs';
+import Config from './Config';
 
 class Player {
   private static instance: Player;
@@ -7,20 +8,64 @@ class Player {
   private audioContext: AudioContext;
   private sourceNode: MediaElementAudioSourceNode;
   private eqFilters: BiquadFilterNode[];
+  private volumeInitialized: Promise<void>;
 
   private constructor() {
-    if (!Player.instance) {
-      this.audio = new Audio();
-      this.audio.volume = 1;
-      this.audio.preload = 'auto';
-      this.currentSongId = '';
-      this.audioContext = new AudioContext();
-      this.sourceNode = this.audioContext.createMediaElementSource(this.audio);
-      this.eqFilters = this.createEqFilters();
-      this.connectEqFilters();
-      Player.instance = this;
+    this.audio = new Audio();
+    this.audio.preload = 'auto';
+    this.currentSongId = '';
+    this.audioContext = new AudioContext();
+    this.sourceNode = this.audioContext.createMediaElementSource(this.audio);
+    this.eqFilters = this.createEqFilters();
+    this.connectEqFilters();
+    this.volumeInitialized = this.initVolume();
+  }
+
+  private async initVolume() {
+    const settings = await Config.readSettings();
+    const volume = settings.get('volume');
+    this.setVolume(volume);
+  }
+
+  public async ensureVolumeInitialized() {
+    await this.volumeInitialized;
+  }
+
+  public setVolume(volume: number) {
+    const minVolume = 0;
+    const maxVolume = 100;
+    volume = Math.max(minVolume, Math.min(maxVolume, volume));
+
+    const minp = 0;
+    const maxp = 100;
+    const minv = Math.log(0.01);
+    const maxv = Math.log(1);
+    const scale = (maxv - minv) / (maxp - minp);
+    const volumeFraction = Math.exp(minv + scale * (volume - minp));
+
+    this.audio.volume = volumeFraction;
+  }
+
+  public async updateVolumeSetting(volume: number) {
+    await Config.updateUserSetting('volume', volume.toString());
+  }
+
+  public getVolume(): number {
+    const minp = 0;
+    const maxp = 100;
+    const minv = Math.log(0.01);
+    const maxv = Math.log(1);
+    const scale = (maxv - minv) / (maxp - minp);
+
+    const volumeFraction = this.audio.volume;
+
+    if (volumeFraction === 0) {
+      return 0;
     }
-    return Player.instance;
+
+    const volume = (Math.log(volumeFraction) - minv) / scale + minp;
+
+    return Math.round(volume);
   }
 
   private createEqFilters(): BiquadFilterNode[] {
@@ -108,27 +153,6 @@ class Player {
     await this.setSong(songIds[prevIndex]);
   }
 
-  public setVolume(volume: number) {
-    if (volume == 0) {
-      this.audio.volume = 0;
-      return;
-    }
-
-    const minVolume = 1;
-    const maxVolume = 100;
-    volume = Math.max(minVolume, Math.min(maxVolume, volume));
-
-    const minp = 0;
-    const maxp = 100;
-
-    const minv = Math.log(0.01);
-    const maxv = Math.log(1);
-
-    const scale = (maxv - minv) / (maxp - minp);
-
-    this.audio.volume = Math.exp(minv + scale * (volume - minp));
-  }
-
   public seek(percentage: number) {
     const seekTime = this.audio.duration * (percentage / 100);
     this.audio.currentTime = seekTime;
diff --git a/pages/index.vue b/pages/index.vue
index 25d111f..a3a34dc 100644
--- a/pages/index.vue
+++ b/pages/index.vue
@@ -6,12 +6,12 @@
           type="range"
           min="-12"
           max="12"
-          step="1"
-          v-model="eqGains[index]"
-          @input="updateEqGain(index, $event.target.value)"
+          step="0.1"
+          v-model.number="eqGains[index]"
+          @input="updateEqGain(index, $event.target.valueAsNumber)"
         />
         <label>{{ freq }} Hz</label>
-        <span>{{ eqGains[index] }}</span>
+        <span>{{ eqGains[index].toFixed(1) }}</span>
       </div>
     </div>
     <li v-for="song in songs" :key="song.id" class="song-item">
@@ -29,21 +29,38 @@
 </template>
 
 <script setup>
-import { onMounted, ref } from "vue";
+import { onMounted, ref, watch } from "vue";
+import Config from "~/lib/Config.ts";
 import { readSongs } from "~/lib/Songs.ts";
 import Player from "~/lib/Player.ts";
 
 const songs = ref([]);
 const player = Player.getInstance();
 const frequencies = [32, 64, 125, 250, 500, 1000, 2000, 4000, 8000, 16000];
-const eqGains = reactive(new Array(frequencies.length).fill(0));
+const eqGains = ref(new Array(frequencies.length).fill(0));
+
+async function loadEqSettings() {
+  const eqSettings = await Config.readEQSettings();
+  frequencies.forEach((freq, index) => {
+    const gain = eqSettings.get(freq.toString());
+    if (gain !== undefined) {
+      eqGains.value[index] = gain;
+    }
+  });
+}
 
 function updateEqGain(filterIndex, gain) {
-  player.setEqGain(filterIndex, parseFloat(gain));
+  player.setEqGain(filterIndex, gain); // No need to parseFloat as it's already a number
+  const eqSettingsMap = new Map();
+  frequencies.forEach((freq, index) => {
+    eqSettingsMap.set(freq.toString(), eqGains.value[index]);
+  });
+  Config.writeEQSettings(eqSettingsMap);
 }
 
 onMounted(async () => {
   try {
+    await loadEqSettings();
     const songsConfig = await readSongs();
     songs.value = await Promise.all(
       Object.entries(songsConfig.songs).map(async ([id, song]) => {
diff --git a/src-tauri/src/config.rs b/src-tauri/src/config.rs
index fc3b565..78f30fc 100644
--- a/src-tauri/src/config.rs
+++ b/src-tauri/src/config.rs
@@ -1,23 +1,21 @@
 use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use std::collections::BTreeMap;
 use std::fs::{self, File};
-use std::io::Error as IoError; // Renamed for clarity
+use std::io::{Error as IoError, Write};
 use std::path::PathBuf;
-use std::collections::HashMap;
-use tauri::Error as TauriError; // Import Tauri's Error type
+use tauri::Error as TauriError;
 
 #[derive(Serialize, Deserialize)]
 pub struct UserSettings {
-    settings: HashMap<String, String>,
+    settings: BTreeMap<String, Value>,
 }
 
 impl UserSettings {
-    pub fn new() -> Self {
-        UserSettings {
-            settings: HashMap::new(),
-        }
-    }
-
     pub fn load(path: &PathBuf) -> Result<Self, IoError> {
+        if !path.exists() {
+            Self::initialize_default(path)?;
+        }
         let file = File::open(path)?;
         let config = serde_json::from_reader(file)?;
         Ok(config)
@@ -29,9 +27,36 @@ impl UserSettings {
         Ok(())
     }
 
-    pub fn update_setting(&mut self, key: String, value: String) {
+    pub fn update_setting(&mut self, key: String, value: Value) {
         self.settings.insert(key, value);
     }
+
+    fn initialize_default(path: &PathBuf) -> Result<(), IoError> {
+        let default_settings = json!({
+            "settings": {
+                "volume": "100",
+                "currentSong": "",
+                "eq": {
+                    "32": "0.0",
+                    "64": "0.0",
+                    "125": "0.0",
+                    "250": "0.0",
+                    "500": "0.0",
+                    "1000": "0.0",
+                    "2000": "0.0",
+                    "4000": "0.0",
+                    "8000": "0.0",
+                    "16000": "0.0"
+                }
+            }
+        });
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        let mut file = File::create(path)?;
+        file.write_all(serde_json::to_string_pretty(&default_settings)?.as_bytes())?;
+        Ok(())
+    }
 }
 
 pub fn get_settings_path() -> PathBuf {
@@ -54,51 +79,52 @@ pub fn get_settings_path() -> PathBuf {
 #[tauri::command]
 pub fn update_user_setting(key: String, value: String) -> Result<(), TauriError> {
     let path = get_settings_path();
-    if !path.exists() {
-        fs::create_dir_all(path.parent().unwrap())?;
-        File::create(&path)?;
-        UserSettings::new().save(&path)?;
-    }
     let mut settings = UserSettings::load(&path)?;
-    settings.update_setting(key, value);
+    settings.update_setting(key, Value::String(value));
     settings.save(&path).map_err(TauriError::from)
 }
 
 #[tauri::command]
-pub fn read_settings() -> Result<HashMap<String, String>, TauriError> {
+pub fn read_settings() -> Result<BTreeMap<String, String>, TauriError> {
     let path = get_settings_path();
-    if !path.exists() {
-        return Err(TauriError::from(IoError::new(std::io::ErrorKind::NotFound, "Settings file not found")));
-    }
     let settings = UserSettings::load(&path)?;
-    Ok(settings.settings)
+    let settings_str: BTreeMap<String, String> = settings
+        .settings
+        .iter()
+        .map(|(k, v)| (k.clone(), v.as_str().unwrap_or_default().to_string()))
+        .collect();
+    Ok(settings_str)
 }
 
 #[tauri::command]
-pub fn read_eq_settings() -> Result<HashMap<String, String>, TauriError> {
+pub fn read_eq_settings() -> Result<BTreeMap<String, String>, TauriError> {
     let path = get_settings_path();
-    if !path.exists() {
-        return Err(TauriError::from(IoError::new(std::io::ErrorKind::NotFound, "Settings file not found")));
-    }
     let settings = UserSettings::load(&path)?;
-    if let Some(eq_settings) = settings.settings.get("eq") {
-        let eq: HashMap<String, String> = serde_json::from_str(eq_settings).map_err(|_| TauriError::from(IoError::new(std::io::ErrorKind::InvalidData, "Failed to parse EQ settings")))?;
-        Ok(eq)
-    } else {
-        Err(TauriError::from(IoError::new(std::io::ErrorKind::NotFound, "EQ settings not found")))
+    match settings.settings.get("eq") {
+        Some(Value::Object(eq_settings)) => {
+            let eq: BTreeMap<String, String> = eq_settings
+                .iter()
+                .map(|(k, v)| (k.clone(), v.as_str().unwrap_or_default().to_string()))
+                .collect();
+            Ok(eq)
+        }
+        _ => Err(TauriError::from(IoError::new(
+            std::io::ErrorKind::NotFound,
+            "EQ settings not found",
+        ))),
     }
 }
 
 #[tauri::command]
-pub fn write_eq_settings(eq_settings: HashMap<String, String>) -> Result<(), TauriError> {
-   let path = get_settings_path();
-    if !path.exists() {
-        fs::create_dir_all(path.parent().unwrap())?;
-        File::create(&path)?;
-        UserSettings::new().save(&path)?;
-    }
+pub fn write_eq_settings(eq_settings: BTreeMap<String, String>) -> Result<(), TauriError> {
+    let path = get_settings_path();
     let mut settings = UserSettings::load(&path)?;
-    let eq_settings_str = serde_json::to_string(&eq_settings).map_err(TauriError::from)?;
-    settings.update_setting("eq".to_string(), eq_settings_str);
+
+    let eq_settings_value = eq_settings
+        .into_iter()
+        .map(|(k, v)| (k, Value::String(v)))
+        .collect::<serde_json::Map<_, _>>();
+
+    settings.update_setting("eq".to_string(), Value::Object(eq_settings_value));
     settings.save(&path).map_err(TauriError::from)
-}
\ No newline at end of file
+}