chore: 整理electron目录

packages/electron/main/cache.ts

@@ -0,0 +1,288 @@
+import { db, Tables } from './db'
+import type { FetchTracksResponse } from '@/shared/api/Track'
+import { app } from 'electron'
+import { Request, Response } from 'express'
+import log from './log'
+import fs from 'fs'
+import * as musicMetadata from 'music-metadata'
+import { APIs, APIsParams, APIsResponse } from '@/shared/CacheAPIs'
+import { TablesStructures } from './db'
+
+class Cache {
+  constructor() {
+    //
+  }
+
+  async set(api: string, data: any, query: any = {}) {
+    switch (api) {
+      case APIs.UserPlaylist:
+      case APIs.UserAccount:
+      case APIs.Personalized:
+      case APIs.RecommendResource:
+      case APIs.UserAlbums:
+      case APIs.UserArtists:
+      case APIs.Likelist: {
+        if (!data) return
+        db.upsert(Tables.AccountData, {
+          id: api,
+          json: JSON.stringify(data),
+          updatedAt: Date.now(),
+        })
+        break
+      }
+      case APIs.Track: {
+        if (!data.songs) return
+        const tracks = (data as FetchTracksResponse).songs.map(t => ({
+          id: t.id,
+          json: JSON.stringify(t),
+          updatedAt: Date.now(),
+        }))
+        db.upsertMany(Tables.Track, tracks)
+        break
+      }
+      case APIs.Album: {
+        if (!data.album) return
+        data.album.songs = data.songs
+        db.upsert(Tables.Album, {
+          id: data.album.id,
+          json: JSON.stringify(data.album),
+          updatedAt: Date.now(),
+        })
+        break
+      }
+      case APIs.Playlist: {
+        if (!data.playlist) return
+        db.upsert(Tables.Playlist, {
+          id: data.playlist.id,
+          json: JSON.stringify(data),
+          updatedAt: Date.now(),
+        })
+        break
+      }
+      case APIs.Artist: {
+        if (!data.artist) return
+        db.upsert(Tables.Artist, {
+          id: data.artist.id,
+          json: JSON.stringify(data),
+          updatedAt: Date.now(),
+        })
+        break
+      }
+      case APIs.ArtistAlbum: {
+        if (!data.hotAlbums) return
+        db.createMany(
+          Tables.Album,
+          data.hotAlbums.map((a: Album) => ({
+            id: a.id,
+            json: JSON.stringify(a),
+            updatedAt: Date.now(),
+          }))
+        )
+        const modifiedData = {
+          ...data,
+          hotAlbums: data.hotAlbums.map((a: Album) => a.id),
+        }
+        db.upsert(Tables.ArtistAlbum, {
+          id: data.artist.id,
+          json: JSON.stringify(modifiedData),
+          updatedAt: Date.now(),
+        })
+        break
+      }
+      case APIs.Lyric: {
+        if (!data.lrc) return
+        db.upsert(Tables.Lyric, {
+          id: query.id,
+          json: JSON.stringify(data),
+          updatedAt: Date.now(),
+        })
+        break
+      }
+      case APIs.CoverColor: {
+        if (!data.id || !data.color) return
+        if (/^#([a-fA-F0-9]){3}$|[a-fA-F0-9]{6}$/.test(data.color) === false) {
+          return
+        }
+        db.upsert(Tables.CoverColor, {
+          id: data.id,
+          color: data.color,
+        })
+      }
+    }
+  }
+
+  get<T extends keyof APIsParams>(api: T, params: any): any {
+    switch (api) {
+      case APIs.UserPlaylist:
+      case APIs.UserAccount:
+      case APIs.Personalized:
+      case APIs.RecommendResource:
+      case APIs.Likelist: {
+        const data = db.find(Tables.AccountData, api)
+        if (data?.json) return JSON.parse(data.json)
+        break
+      }
+      case APIs.Track: {
+        const ids: number[] = params?.ids
+          .split(',')
+          .map((id: string) => Number(id))
+        if (ids.length === 0) return
+
+        if (ids.includes(NaN)) return
+
+        const tracksRaw = db.findMany(Tables.Track, ids)
+
+        if (tracksRaw.length !== ids.length) {
+          return
+        }
+        const tracks = ids.map(id => {
+          const track = tracksRaw.find(t => t.id === Number(id)) as any
+          return JSON.parse(track.json)
+        })
+        return {
+          code: 200,
+          songs: tracks,
+          privileges: {},
+        }
+      }
+      case APIs.Album: {
+        if (isNaN(Number(params?.id))) return
+        const data = db.find(Tables.Album, params.id)
+        if (data?.json)
+          return {
+            resourceState: true,
+            songs: [],
+            code: 200,
+            album: JSON.parse(data.json),
+          }
+        break
+      }
+      case APIs.Playlist: {
+        if (isNaN(Number(params?.id))) return
+        const data = db.find(Tables.Playlist, params.id)
+        if (data?.json) return JSON.parse(data.json)
+        break
+      }
+      case APIs.Artist: {
+        if (isNaN(Number(params?.id))) return
+        const data = db.find(Tables.Artist, params.id)
+        if (data?.json) return JSON.parse(data.json)
+        break
+      }
+      case APIs.ArtistAlbum: {
+        if (isNaN(Number(params?.id))) return
+
+        const artistAlbumsRaw = db.find(Tables.ArtistAlbum, params.id)
+        if (!artistAlbumsRaw?.json) return
+        const artistAlbums = JSON.parse(artistAlbumsRaw.json)
+
+        const albumsRaw = db.findMany(Tables.Album, artistAlbums.hotAlbums)
+        if (albumsRaw.length !== artistAlbums.hotAlbums.length) return
+        const albums = albumsRaw.map(a => JSON.parse(a.json))
+
+        artistAlbums.hotAlbums = artistAlbums.hotAlbums.map((id: number) =>
+          albums.find(a => a.id === id)
+        )
+        return artistAlbums
+      }
+      case APIs.Lyric: {
+        if (isNaN(Number(params?.id))) return
+        const data = db.find(Tables.Lyric, params.id)
+        if (data?.json) return JSON.parse(data.json)
+        break
+      }
+      case APIs.CoverColor: {
+        if (isNaN(Number(params?.id))) return
+        return db.find(Tables.CoverColor, params.id)?.color
+      }
+    }
+  }
+
+  getForExpress(api: string, req: Request) {
+    // Get track detail cache
+    if (api === APIs.Track) {
+      const cache = this.get(api, req.query)
+      if (cache) {
+        log.debug(`[cache] Cache hit for ${req.path}`)
+        return cache
+      }
+    }
+  }
+
+  getAudio(fileName: string, res: Response) {
+    if (!fileName) {
+      return res.status(400).send({ error: 'No filename provided' })
+    }
+    const id = Number(fileName.split('-')[0])
+
+    try {
+      const path = `${app.getPath('userData')}/audio_cache/${fileName}`
+      const audio = fs.readFileSync(path)
+      if (audio.byteLength === 0) {
+        db.delete(Tables.Audio, id)
+        fs.unlinkSync(path)
+        return res.status(404).send({ error: 'Audio not found' })
+      }
+      res
+        .status(206)
+        .setHeader('Accept-Ranges', 'bytes')
+        .setHeader('Connection', 'keep-alive')
+        .setHeader(
+          'Content-Range',
+          `bytes 0-${audio.byteLength - 1}/${audio.byteLength}`
+        )
+        .send(audio)
+    } catch (error) {
+      res.status(500).send({ error })
+    }
+  }
+
+  async setAudio(buffer: Buffer, { id, url }: { id: number; url: string }) {
+    const path = `${app.getPath('userData')}/audio_cache`
+
+    try {
+      fs.statSync(path)
+    } catch (e) {
+      fs.mkdirSync(path)
+    }
+
+    const meta = await musicMetadata.parseBuffer(buffer)
+    const br =
+      meta?.format?.codec === 'OPUS' ? 165000 : meta.format.bitrate ?? 0
+    const type =
+      {
+        'MPEG 1 Layer 3': 'mp3',
+        'Ogg Vorbis': 'ogg',
+        AAC: 'm4a',
+        FLAC: 'flac',
+        OPUS: 'opus',
+      }[meta.format.codec ?? ''] ?? 'unknown'
+
+    let source: TablesStructures[Tables.Audio]['source'] = 'unknown'
+    if (url.includes('googlevideo.com')) source = 'youtube'
+    if (url.includes('126.net')) source = 'netease'
+    if (url.includes('migu.cn')) source = 'migu'
+    if (url.includes('kuwo.cn')) source = 'kuwo'
+    if (url.includes('bilivideo.com')) source = 'bilibili'
+    // TODO: missing kugou qq joox
+
+    fs.writeFile(`${path}/${id}-${br}.${type}`, buffer, error => {
+      if (error) {
+        return log.error(`[cache] cacheAudio failed: ${error}`)
+      }
+      log.info(`Audio file ${id}-${br}.${type} cached!`)
+
+      db.upsert(Tables.Audio, {
+        id,
+        br,
+        type: type as TablesStructures[Tables.Audio]['type'],
+        source,
+        updatedAt: Date.now(),
+      })
+
+      log.info(`[cache] cacheAudio ${id}-${br}.${type}`)
+    })
+  }
+}
+
+export default new Cache()

packages/electron/main/db.ts

@@ -0,0 +1,221 @@
+import path from 'path'
+import { app } from 'electron'
+import fs from 'fs'
+import SQLite3 from 'better-sqlite3'
+import log from './log'
+import { createFileIfNotExist, dirname } from './utils'
+import pkg from '../../../package.json'
+import { compare, validate } from 'compare-versions'
+
+export const enum Tables {
+  Track = 'Track',
+  Album = 'Album',
+  Artist = 'Artist',
+  Playlist = 'Playlist',
+  ArtistAlbum = 'ArtistAlbum',
+  Lyric = 'Lyric',
+  Audio = 'Audio',
+  AccountData = 'AccountData',
+  CoverColor = 'CoverColor',
+  AppData = 'AppData',
+}
+interface CommonTableStructure {
+  id: number
+  json: string
+  updatedAt: number
+}
+export interface TablesStructures {
+  [Tables.Track]: CommonTableStructure
+  [Tables.Album]: CommonTableStructure
+  [Tables.Artist]: CommonTableStructure
+  [Tables.Playlist]: CommonTableStructure
+  [Tables.ArtistAlbum]: CommonTableStructure
+  [Tables.Lyric]: CommonTableStructure
+  [Tables.AccountData]: {
+    id: string
+    json: string
+    updatedAt: number
+  }
+  [Tables.Audio]: {
+    id: number
+    br: number
+    type: 'mp3' | 'flac' | 'ogg' | 'wav' | 'm4a' | 'aac' | 'unknown' | 'opus'
+    source:
+      | 'unknown'
+      | 'netease'
+      | 'migu'
+      | 'kuwo'
+      | 'kugou'
+      | 'youtube'
+      | 'qq'
+      | 'bilibili'
+      | 'joox'
+    updatedAt: number
+  }
+  [Tables.CoverColor]: {
+    id: number
+    color: string
+  }
+  [Tables.AppData]: {
+    id: 'appVersion' | 'skippedVersion'
+    value: string
+  }
+}
+
+type TableNames = keyof TablesStructures
+
+const readSqlFile = (filename: string) => {
+  return fs.readFileSync(path.join(dirname, `./migrations/${filename}`), 'utf8')
+}
+
+class DB {
+  sqlite: SQLite3.Database
+  dbFilePath: string = path.resolve(
+    app.getPath('userData'),
+    './api_cache/db.sqlite'
+  )
+
+  constructor() {
+    log.info('[db] Initializing database...')
+
+    createFileIfNotExist(this.dbFilePath)
+
+    this.sqlite = new SQLite3(this.dbFilePath, {
+      nativeBinding: path.join(
+        __dirname,
+        `./binary/better_sqlite3_${process.arch}.node`
+      ),
+    })
+    this.sqlite.pragma('auto_vacuum = FULL')
+    this.initTables()
+    this.migrate()
+
+    log.info('[db] Database initialized')
+  }
+
+  initTables() {
+    const init = readSqlFile('init.sql')
+    this.sqlite.exec(init)
+  }
+
+  migrate() {
+    const key = 'appVersion'
+    const appVersion = this.find(Tables.AppData, key)
+    const updateAppVersionInDB = () => {
+      this.upsert(Tables.AppData, {
+        id: key,
+        value: pkg.version,
+      })
+    }
+
+    if (!appVersion?.value) {
+      updateAppVersionInDB()
+      return
+    }
+
+    const sqlFiles = fs.readdirSync(path.join(dirname, './migrations'))
+    sqlFiles.forEach((sqlFile: string) => {
+      const version = sqlFile.split('.').shift() || ''
+      if (!validate(version)) return
+      if (compare(version, pkg.version, '>')) {
+        const file = readSqlFile(sqlFile)
+        this.sqlite.exec(file)
+      }
+    })
+
+    updateAppVersionInDB()
+  }
+
+  find<T extends TableNames>(
+    table: T,
+    key: TablesStructures[T]['id']
+  ): TablesStructures[T] | undefined {
+    return this.sqlite
+      .prepare(`SELECT * FROM ${table} WHERE id = ? LIMIT 1`)
+      .get(key)
+  }
+
+  findMany<T extends TableNames>(
+    table: T,
+    keys: TablesStructures[T]['id'][]
+  ): TablesStructures[T][] {
+    const idsQuery = keys.map(key => `id = ${key}`).join(' OR ')
+    return this.sqlite.prepare(`SELECT * FROM ${table} WHERE ${idsQuery}`).all()
+  }
+
+  findAll<T extends TableNames>(table: T): TablesStructures[T][] {
+    return this.sqlite.prepare(`SELECT * FROM ${table}`).all()
+  }
+
+  create<T extends TableNames>(
+    table: T,
+    data: TablesStructures[T],
+    skipWhenExist: boolean = true
+  ) {
+    if (skipWhenExist && db.find(table, data.id)) return
+    return this.sqlite.prepare(`INSERT INTO ${table} VALUES (?)`).run(data)
+  }
+
+  createMany<T extends TableNames>(
+    table: T,
+    data: TablesStructures[T][],
+    skipWhenExist: boolean = true
+  ) {
+    const valuesQuery = Object.keys(data[0])
+      .map(key => `:${key}`)
+      .join(', ')
+    const insert = this.sqlite.prepare(
+      `INSERT ${
+        skipWhenExist ? 'OR IGNORE' : ''
+      } INTO ${table} VALUES (${valuesQuery})`
+    )
+    const insertMany = this.sqlite.transaction((rows: any[]) => {
+      rows.forEach((row: any) => insert.run(row))
+    })
+    insertMany(data)
+  }
+
+  upsert<T extends TableNames>(table: T, data: TablesStructures[T]) {
+    const valuesQuery = Object.keys(data)
+      .map(key => `:${key}`)
+      .join(', ')
+    return this.sqlite
+      .prepare(`INSERT OR REPLACE INTO ${table} VALUES (${valuesQuery})`)
+      .run(data)
+  }
+
+  upsertMany<T extends TableNames>(table: T, data: TablesStructures[T][]) {
+    const valuesQuery = Object.keys(data[0])
+      .map(key => `:${key}`)
+      .join(', ')
+    const upsert = this.sqlite.prepare(
+      `INSERT OR REPLACE INTO ${table} VALUES (${valuesQuery})`
+    )
+    const upsertMany = this.sqlite.transaction((rows: any[]) => {
+      rows.forEach((row: any) => upsert.run(row))
+    })
+    upsertMany(data)
+  }
+
+  delete<T extends TableNames>(table: T, key: TablesStructures[T]['id']) {
+    return this.sqlite.prepare(`DELETE FROM ${table} WHERE id = ?`).run(key)
+  }
+
+  deleteMany<T extends TableNames>(
+    table: T,
+    keys: TablesStructures[T]['id'][]
+  ) {
+    const idsQuery = keys.map(key => `id = ${key}`).join(' OR ')
+    return this.sqlite.prepare(`DELETE FROM ${table} WHERE ${idsQuery}`).run()
+  }
+
+  truncate<T extends TableNames>(table: T) {
+    return this.sqlite.prepare(`DELETE FROM ${table}`).run()
+  }
+
+  vacuum() {
+    return this.sqlite.prepare('VACUUM').run()
+  }
+}
+
+export const db = new DB()

packages/electron/main/index.ts

@@ -0,0 +1,226 @@
+import './preload' // must be first
+import './sentry'
+import './server'
+import {
+  BrowserWindow,
+  BrowserWindowConstructorOptions,
+  app,
+  shell,
+} from 'electron'
+import Store from 'electron-store'
+import { release } from 'os'
+import { join } from 'path'
+import log from './log'
+import { initIpcMain } from './ipcMain'
+import { createTray, YPMTray } from './tray'
+import { IpcChannels } from '@/shared/IpcChannels'
+import { createTaskbar, Thumbar } from './windowsTaskbar'
+import { createMenu } from './menu'
+import { Store as State, initialState } from '@/shared/store'
+import { isDev, isWindows, isLinux, isMac } from './utils'
+
+export interface TypedElectronStore {
+  window: {
+    width: number
+    height: number
+    x?: number
+    y?: number
+  }
+  settings: State['settings']
+}
+
+class Main {
+  win: BrowserWindow | null = null
+  tray: YPMTray | null = null
+  thumbar: Thumbar | null = null
+  store = new Store<TypedElectronStore>({
+    defaults: {
+      window: {
+        width: 1440,
+        height: 960,
+      },
+      settings: initialState.settings,
+    },
+  })
+
+  constructor() {
+    log.info('[index] Main process start')
+
+    // Disable GPU Acceleration for Windows 7
+    if (release().startsWith('6.1')) app.disableHardwareAcceleration()
+
+    // Set application name for Windows 10+ notifications
+    if (process.platform === 'win32') app.setAppUserModelId(app.getName())
+
+    // Make sure the app only run on one instance
+    if (!app.requestSingleInstanceLock()) {
+      app.quit()
+      process.exit(0)
+    }
+
+    app.whenReady().then(() => {
+      log.info('[index] App ready')
+      this.createWindow()
+      this.handleAppEvents()
+      this.handleWindowEvents()
+      this.createTray()
+      createMenu(this.win!)
+      this.createThumbar()
+      initIpcMain(this.win, this.tray, this.thumbar, this.store)
+      this.initDevTools()
+    })
+  }
+
+  initDevTools() {
+    if (!isDev || !this.win) return
+
+    // Install devtool extension
+    const {
+      default: installExtension,
+      REACT_DEVELOPER_TOOLS,
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+    } = require('electron-devtools-installer')
+    installExtension(REACT_DEVELOPER_TOOLS.id).catch((err: unknown) =>
+      log.info('An error occurred: ', err)
+    )
+
+    this.win.webContents.openDevTools()
+  }
+
+  createTray() {
+    if (isWindows || isLinux || isDev) {
+      this.tray = createTray(this.win!)
+    }
+  }
+
+  createThumbar() {
+    if (isWindows) this.thumbar = createTaskbar(this.win!)
+  }
+
+  createWindow() {
+    const options: BrowserWindowConstructorOptions = {
+      title: 'YesPlayMusic',
+      webPreferences: {
+        preload: join(__dirname, 'rendererPreload.js'),
+      },
+      width: this.store.get('window.width'),
+      height: this.store.get('window.height'),
+      minWidth: 1080,
+      minHeight: 720,
+      vibrancy: 'fullscreen-ui',
+      titleBarStyle: 'hiddenInset',
+      frame: !(isWindows || isLinux), // TODO: 适用于linux下独立的启用开关
+    }
+    if (this.store.get('window')) {
+      options.x = this.store.get('window.x')
+      options.y = this.store.get('window.y')
+    }
+    this.win = new BrowserWindow(options)
+
+    // Web server
+    const url = `http://localhost:${process.env.ELECTRON_WEB_SERVER_PORT}`
+    this.win.loadURL(url)
+
+    // Make all links open with the browser, not with the application
+    this.win.webContents.setWindowOpenHandler(({ url }) => {
+      if (url.startsWith('https:')) shell.openExternal(url)
+      return { action: 'deny' }
+    })
+
+    this.disableCORS()
+  }
+
+  disableCORS() {
+    if (!this.win) return
+    const upsertKeyValue = (
+      object: Record<string, string | string[]>,
+      keyToChange: string,
+      value: string[]
+    ) => {
+      if (!object) return
+      for (const key of Object.keys(object)) {
+        if (key.toLowerCase() === keyToChange.toLowerCase()) {
+          object[key] = value
+        }
+      }
+      object[keyToChange] = value
+    }
+
+    this.win.webContents.session.webRequest.onBeforeSendHeaders(
+      (details, callback) => {
+        const { requestHeaders, url } = details
+        upsertKeyValue(requestHeaders, 'access-control-allow-origin', ['*'])
+
+        // 不加这几个 header 的话，使用 axios 加载 YouTube 音频会很慢
+        if (url.includes('googlevideo.com')) {
+          requestHeaders['Sec-Fetch-Mode'] = 'no-cors'
+          requestHeaders['Sec-Fetch-Dest'] = 'audio'
+          requestHeaders['Range'] = 'bytes=0-'
+        }
+
+        callback({ requestHeaders })
+      }
+    )
+
+    this.win.webContents.session.webRequest.onHeadersReceived(
+      (details, callback) => {
+        const { responseHeaders } = details
+        if (responseHeaders) {
+          upsertKeyValue(responseHeaders, 'access-control-allow-origin', ['*'])
+          upsertKeyValue(responseHeaders, 'access-control-allow-headers', ['*'])
+        }
+        callback({
+          responseHeaders,
+        })
+      }
+    )
+  }
+
+  handleWindowEvents() {
+    if (!this.win) return
+
+    // Window maximize and minimize
+    this.win.on('maximize', () => {
+      this.win && this.win.webContents.send(IpcChannels.IsMaximized, true)
+    })
+
+    this.win.on('unmaximize', () => {
+      this.win && this.win.webContents.send(IpcChannels.IsMaximized, false)
+    })
+
+    // Save window position
+    const saveBounds = () => {
+      const bounds = this.win?.getBounds()
+      if (bounds) {
+        this.store.set('window', bounds)
+      }
+    }
+    this.win.on('resized', saveBounds)
+    this.win.on('moved', saveBounds)
+  }
+
+  handleAppEvents() {
+    app.on('window-all-closed', () => {
+      this.win = null
+      if (!isMac) app.quit()
+    })
+
+    app.on('second-instance', () => {
+      if (!this.win) return
+      // Focus on the main window if the user tried to open another
+      if (this.win.isMinimized()) this.win.restore()
+      this.win.focus()
+    })
+
+    app.on('activate', () => {
+      const allWindows = BrowserWindow.getAllWindows()
+      if (allWindows.length) {
+        allWindows[0].focus()
+      } else {
+        this.createWindow()
+      }
+    })
+  }
+}
+
+new Main()

packages/electron/main/ipcMain.ts

@@ -0,0 +1,172 @@
+import { BrowserWindow, ipcMain, app } from 'electron'
+import { db, Tables } from './db'
+import { IpcChannels, IpcChannelsParams } from '@/shared/IpcChannels'
+import cache from './cache'
+import log from './log'
+import fs from 'fs'
+import Store from 'electron-store'
+import { TypedElectronStore } from './index'
+import { APIs } from '@/shared/CacheAPIs'
+import { YPMTray } from './tray'
+import { Thumbar } from './windowsTaskbar'
+import fastFolderSize from 'fast-folder-size'
+import path from 'path'
+import prettyBytes from 'pretty-bytes'
+
+const on = <T extends keyof IpcChannelsParams>(
+  channel: T,
+  listener: (event: Electron.IpcMainEvent, params: IpcChannelsParams[T]) => void
+) => {
+  ipcMain.on(channel, listener)
+}
+
+export function initIpcMain(
+  win: BrowserWindow | null,
+  tray: YPMTray | null,
+  thumbar: Thumbar | null,
+  store: Store<TypedElectronStore>
+) {
+  initWindowIpcMain(win)
+  initTrayIpcMain(tray)
+  initTaskbarIpcMain(thumbar)
+  initStoreIpcMain(store)
+  initOtherIpcMain()
+}
+
+/**
+ * 处理需要win对象的事件
+ * @param {BrowserWindow} win
+ */
+function initWindowIpcMain(win: BrowserWindow | null) {
+  on(IpcChannels.Minimize, () => {
+    win?.minimize()
+  })
+
+  on(IpcChannels.MaximizeOrUnmaximize, () => {
+    if (!win) return
+    win.isMaximized() ? win.unmaximize() : win.maximize()
+  })
+
+  on(IpcChannels.Close, () => {
+    app.exit()
+  })
+}
+
+/**
+ * 处理需要tray对象的事件
+ * @param {YPMTray} tray
+ */
+function initTrayIpcMain(tray: YPMTray | null) {
+  on(IpcChannels.SetTrayTooltip, (e, { text }) => tray?.setTooltip(text))
+
+  on(IpcChannels.Like, (e, { isLiked }) => tray?.setLikeState(isLiked))
+
+  on(IpcChannels.Play, () => tray?.setPlayState(true))
+  on(IpcChannels.Pause, () => tray?.setPlayState(false))
+
+  on(IpcChannels.Repeat, (e, { mode }) => tray?.setRepeatMode(mode))
+}
+
+/**
+ * 处理需要thumbar对象的事件
+ * @param {Thumbar} thumbar
+ */
+function initTaskbarIpcMain(thumbar: Thumbar | null) {
+  on(IpcChannels.Play, () => thumbar?.setPlayState(true))
+  on(IpcChannels.Pause, () => thumbar?.setPlayState(false))
+}
+
+/**
+ * 处理需要electron-store的事件
+ * @param {Store<TypedElectronStore>} store
+ */
+function initStoreIpcMain(store: Store<TypedElectronStore>) {
+  /**
+   * 同步设置到Main
+   */
+  on(IpcChannels.SyncSettings, (event, settings) => {
+    store.set('settings', settings)
+  })
+}
+
+/**
+ * 处理其他事件
+ */
+function initOtherIpcMain() {
+  /**
+   * 清除API缓存
+   */
+  on(IpcChannels.ClearAPICache, () => {
+    db.truncate(Tables.Track)
+    db.truncate(Tables.Album)
+    db.truncate(Tables.Artist)
+    db.truncate(Tables.Playlist)
+    db.truncate(Tables.ArtistAlbum)
+    db.truncate(Tables.AccountData)
+    db.truncate(Tables.Audio)
+    db.vacuum()
+  })
+
+  /**
+   * Get API cache
+   */
+  on(IpcChannels.GetApiCacheSync, (event, args) => {
+    const { api, query } = args
+    const data = cache.get(api, query)
+    event.returnValue = data
+  })
+
+  /**
+   * 缓存封面颜色
+   */
+  on(IpcChannels.CacheCoverColor, (event, args) => {
+    const { id, color } = args
+    cache.set(APIs.CoverColor, { id, color })
+  })
+
+  /**
+   * 获取音频缓存文件夹大小
+   */
+  on(IpcChannels.GetAudioCacheSize, event => {
+    fastFolderSize(
+      path.join(app.getPath('userData'), './audio_cache'),
+      (error, bytes) => {
+        if (error) throw error
+
+        event.returnValue = prettyBytes(bytes ?? 0)
+      }
+    )
+  })
+
+  /**
+   * 导出tables到json文件，方便查看table大小（dev环境）
+   */
+  if (process.env.NODE_ENV === 'development') {
+    on(IpcChannels.DevDbExportJson, () => {
+      const tables = [
+        Tables.ArtistAlbum,
+        Tables.Playlist,
+        Tables.Album,
+        Tables.Track,
+        Tables.Artist,
+        Tables.Audio,
+        Tables.AccountData,
+        Tables.Lyric,
+      ]
+      tables.forEach(table => {
+        const data = db.findAll(table)
+
+        fs.writeFile(
+          `./tmp/${table}.json`,
+          JSON.stringify(data),
+          function (err) {
+            if (err) {
+              return console.log(err)
+            }
+            console.log('The file was saved!')
+          }
+        )
+      })
+    })
+  }
+}

packages/electron/main/log.ts

@@ -0,0 +1,31 @@
+/**  By default, it writes logs to the following locations:
+ * on Linux: ~/.config/{app name}/logs/{process type}.log
+ * on macOS: ~/Library/Logs/{app name}/{process type}.log
+ * on Windows: %USERPROFILE%\AppData\Roaming\{app name}\logs\{process type}.log
+ * @see https://www.npmjs.com/package/electron-log
+ */
+
+import log from 'electron-log'
+import pc from 'picocolors'
+import { isDev } from './utils'
+
+Object.assign(console, log.functions)
+log.variables.process = 'main'
+if (log.transports.ipc) log.transports.ipc.level = false
+log.transports.console.format = `${
+  isDev ? '' : pc.dim('{h}:{i}:{s}{scope} ')
+}{level} › {text}`
+log.transports.file.level = 'info'
+
+log.info(
+  `\n\n██╗   ██╗███████╗███████╗██████╗ ██╗      █████╗ ██╗   ██╗███╗   ███╗██╗   ██╗███████╗██╗ ██████╗
+╚██╗ ██╔╝██╔════╝██╔════╝██╔══██╗██║     ██╔══██╗╚██╗ ██╔╝████╗ ████║██║   ██║██╔════╝██║██╔════╝
+ ╚████╔╝ █████╗  ███████╗██████╔╝██║     ███████║ ╚████╔╝ ██╔████╔██║██║   ██║███████╗██║██║     
+  ╚██╔╝  ██╔══╝  ╚════██║██╔═══╝ ██║     ██╔══██║  ╚██╔╝  ██║╚██╔╝██║██║   ██║╚════██║██║██║     
+   ██║   ███████╗███████║██║     ███████╗██║  ██║   ██║   ██║ ╚═╝ ██║╚██████╔╝███████║██║╚██████╗
+   ╚═╝   ╚══════╝╚══════╝╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚═╝     ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═════╝\n`
+)
+
+export default log
+
+log.info(`[logger] logger initialized`)

packages/electron/main/menu.ts

@@ -0,0 +1,74 @@
+import {
+  BrowserWindow,
+  Menu,
+  MenuItem,
+  MenuItemConstructorOptions,
+  shell,
+} from 'electron'
+import { logsPath, isMac } from './utils'
+import { exec } from 'child_process'
+
+export const createMenu = (win: BrowserWindow) => {
+  const template: Array<MenuItemConstructorOptions | MenuItem> = [
+    { role: 'appMenu' },
+    { role: 'editMenu' },
+    { role: 'viewMenu' },
+    { role: 'windowMenu' },
+    {
+      label: '帮助',
+      submenu: [
+        {
+          label: '打开日志文件目录',
+          click: async () => {
+            if (isMac) {
+              exec(`open ${logsPath}`)
+            } else {
+              // TODO: 测试Windows和Linux是否能正确打开日志目录
+              shell.openPath(logsPath)
+            }
+          },
+        },
+        {
+          label: '打开开发者工具',
+          click: async () => {
+            win.webContents.openDevTools()
+          },
+        },
+        {
+          label: '反馈问题',
+          click: async () => {
+            await shell.openExternal(
+              'https://github.com/qier222/YesPlayMusic/issues/new'
+            )
+          },
+        },
+        { type: 'separator' },
+        {
+          label: '访问 GitHub 仓库',
+          click: async () => {
+            await shell.openExternal('https://github.com/qier222/YesPlayMusic')
+          },
+        },
+        {
+          label: '访问论坛',
+          click: async () => {
+            await shell.openExternal(
+              'https://github.com/qier222/YesPlayMusic/discussions'
+            )
+          },
+        },
+        {
+          label: '加入交流群',
+          click: async () => {
+            await shell.openExternal(
+              'https://github.com/qier222/YesPlayMusic/discussions'
+            )
+          },
+        },
+      ],
+    },
+  ]
+
+  const menu = Menu.buildFromTemplate(template)
+  Menu.setApplicationMenu(menu)
+}

packages/electron/main/preload.ts

@@ -0,0 +1,19 @@
+import log from './log'
+import { app } from 'electron'
+import {
+  createDirIfNotExist,
+  devUserDataPath,
+  isDev,
+  portableUserDataPath,
+} from './utils'
+
+if (isDev) {
+  createDirIfNotExist(devUserDataPath)
+  app.setPath('appData', devUserDataPath)
+}
+if (process.env.PORTABLE_EXECUTABLE_DIR) {
+  createDirIfNotExist(portableUserDataPath)
+  app.setPath('appData', portableUserDataPath)
+}
+
+log.info(`[index] userData path: ${app.getPath('userData')}`)

packages/electron/main/rendererPreload.ts

@@ -0,0 +1,33 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+import { IpcChannels } from '@/shared/IpcChannels'
+import { isLinux, isMac, isWindows } from './utils'
+const { contextBridge, ipcRenderer } = require('electron')
+const log = require('electron-log')
+
+log.transports.file.level = 'info'
+log.transports.ipc.level = false
+log.variables.process = 'renderer'
+contextBridge.exposeInMainWorld('log', log)
+
+contextBridge.exposeInMainWorld('ipcRenderer', {
+  sendSync: ipcRenderer.sendSync,
+  send: ipcRenderer.send,
+  on: (
+    channel: IpcChannels,
+    listener: (event: Electron.IpcRendererEvent, ...args: any[]) => void
+  ) => {
+    ipcRenderer.on(channel, listener)
+    return () => {
+      ipcRenderer.removeListener(channel, listener)
+    }
+  },
+})
+
+contextBridge.exposeInMainWorld('env', {
+  isElectron: true,
+  isEnableTitlebar:
+    process.platform === 'win32' || process.platform === 'linux',
+  isLinux,
+  isMac,
+  isWindows,
+})

packages/electron/main/sentry.ts

@@ -0,0 +1,19 @@
+import * as Sentry from '@sentry/node'
+import * as Tracing from '@sentry/tracing'
+import pkg from '../../../package.json'
+import log from './log'
+
+log.info(`[sentry] sentry initializing`)
+
+Sentry.init({
+  dsn: 'https://2aaaa67f1c3d4d6baefafa5d58fcf340@o436528.ingest.sentry.io/6274637',
+  release: `yesplaymusic@${pkg.version}`,
+  environment: process.env.NODE_ENV,
+
+  // Set tracesSampleRate to 1.0 to capture 100%
+  // of transactions for performance monitoring.
+  // We recommend adjusting this value in production
+  tracesSampleRate: 1.0,
+})
+
+log.info(`[sentry] sentry initialized`)

packages/electron/main/server.ts

@@ -0,0 +1,330 @@
+import { pathCase } from 'change-case'
+import cookieParser from 'cookie-parser'
+import express, { Request, Response } from 'express'
+import log from './log'
+import cache from './cache'
+import fileUpload from 'express-fileupload'
+import path from 'path'
+import fs from 'fs'
+import { db, Tables } from './db'
+import { app } from 'electron'
+import type { FetchAudioSourceResponse } from '@/shared/api/Track'
+import UNM from '@unblockneteasemusic/rust-napi'
+import { APIs as CacheAPIs } from '@/shared/CacheAPIs'
+import { isProd } from './utils'
+
+class Server {
+  port = Number(
+    isProd
+      ? process.env.ELECTRON_WEB_SERVER_PORT ?? 42710
+      : process.env.ELECTRON_DEV_NETEASE_API_PORT ?? 3000
+  )
+  app = express()
+
+  constructor() {
+    log.info('[server] starting http server')
+    this.app.use(cookieParser())
+    this.app.use(fileUpload())
+    this.getAudioUrlHandler()
+    this.neteaseHandler()
+    this.cacheAudioHandler()
+    this.serveStaticForProd()
+    this.listen()
+  }
+
+  neteaseHandler() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const neteaseApi = require('NeteaseCloudMusicApi') as (params: any) => any[]
+
+    Object.entries(neteaseApi).forEach(([name, handler]) => {
+      if (['serveNcmApi', 'getModulesDefinitions', 'song_url'].includes(name)) {
+        return
+      }
+
+      name = pathCase(name)
+
+      const wrappedHandler = async (req: Request, res: Response) => {
+        log.debug(`[server] Handling request: ${req.path}`)
+
+        // Get from cache
+        const cacheData = await cache.getForExpress(name, req)
+        if (cacheData) return res.json(cacheData)
+
+        // Request netease api
+        try {
+          const result = await handler({
+            ...req.query,
+            cookie: req.cookies,
+          })
+
+          cache.set(name, result.body, req.query)
+          return res.send(result.body)
+        } catch (error: any) {
+          if ([400, 301].includes(error.status)) {
+            return res.status(error.status).send(error.body)
+          }
+          return res.status(500)
+        }
+      }
+
+      this.app.get(`/netease/${name}`, wrappedHandler)
+      this.app.post(`/netease/${name}`, wrappedHandler)
+    })
+  }
+
+  serveStaticForProd() {
+    if (isProd) {
+      this.app.use('/', express.static(path.join(__dirname, '../web/')))
+    }
+  }
+
+  getAudioUrlHandler() {
+    const getFromCache = (id: number) => {
+      // get from cache
+      const cache = db.find(Tables.Audio, id)
+      if (!cache) return
+
+      const audioFileName = `${cache.id}-${cache.br}.${cache.type}`
+
+      const isAudioFileExists = fs.existsSync(
+        `${app.getPath('userData')}/audio_cache/${audioFileName}`
+      )
+      if (!isAudioFileExists) return
+
+      log.debug(`[server] Audio cache hit for song/url`)
+
+      return {
+        data: [
+          {
+            source: cache.source,
+            id: cache.id,
+            url: `http://127.0.0.1:42710/yesplaymusic/audio/${audioFileName}`,
+            br: cache.br,
+            size: 0,
+            md5: '',
+            code: 200,
+            expi: 0,
+            type: cache.type,
+            gain: 0,
+            fee: 8,
+            uf: null,
+            payed: 0,
+            flag: 4,
+            canExtend: false,
+            freeTrialInfo: null,
+            level: 'standard',
+            encodeType: cache.type,
+            freeTrialPrivilege: {
+              resConsumable: false,
+              userConsumable: false,
+              listenType: null,
+            },
+            freeTimeTrialPrivilege: {
+              resConsumable: false,
+              userConsumable: false,
+              type: 0,
+              remainTime: 0,
+            },
+            urlSource: 0,
+          },
+        ],
+        code: 200,
+      }
+    }
+
+    const getFromNetease = async (
+      req: Request
+    ): Promise<FetchAudioSourceResponse | undefined> => {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const getSongUrl = (require('NeteaseCloudMusicApi') as any).song_url
+
+        const result = await getSongUrl({ ...req.query, cookie: req.cookies })
+
+        return result.body
+      } catch (error: any) {
+        return
+      }
+    }
+
+    const unmExecutor = new UNM.Executor()
+    const getFromUNM = async (id: number, req: Request) => {
+      log.debug('[server] Fetching audio url from UNM')
+      let track: Track = cache.get(CacheAPIs.Track, { ids: String(id) })
+        ?.songs?.[0]
+      if (!track) {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const getSongDetail = (require('NeteaseCloudMusicApi') as any)
+          .song_detail
+
+        track = await getSongDetail({ ...req.query, cookie: req.cookies })
+      }
+      if (!track) return
+
+      const trackForUNM = {
+        id: String(track.id),
+        name: track.name,
+        duration: track.dt,
+        album: {
+          id: String(track.al.id),
+          name: track.al.name,
+        },
+        artists: [
+          ...track.ar.map((a: Artist) => ({
+            id: String(a.id),
+            name: a.name,
+          })),
+        ],
+      }
+
+      const sourceList = ['ytdl']
+      const context = {}
+      const matchedAudio = await unmExecutor.search(
+        sourceList,
+        trackForUNM,
+        context
+      )
+      const retrievedSong = await unmExecutor.retrieve(matchedAudio, context)
+      const source =
+        retrievedSong.source === 'ytdl' ? 'youtube' : retrievedSong.source
+      if (retrievedSong.url) {
+        return {
+          data: [
+            {
+              source,
+              id,
+              url: retrievedSong.url,
+              br: 128000,
+              size: 0,
+              md5: '',
+              code: 200,
+              expi: 0,
+              type: 'unknown',
+              gain: 0,
+              fee: 8,
+              uf: null,
+              payed: 0,
+              flag: 4,
+              canExtend: false,
+              freeTrialInfo: null,
+              level: 'standard',
+              encodeType: 'unknown',
+              freeTrialPrivilege: {
+                resConsumable: false,
+                userConsumable: false,
+                listenType: null,
+              },
+              freeTimeTrialPrivilege: {
+                resConsumable: false,
+                userConsumable: false,
+                type: 0,
+                remainTime: 0,
+              },
+              urlSource: 0,
+              unm: {
+                source,
+                song: matchedAudio.song,
+              },
+            },
+          ],
+          code: 200,
+        }
+      }
+    }
+
+    const handler = async (req: Request, res: Response) => {
+      const id = Number(req.query.id) || 0
+      if (id === 0) {
+        return res.status(400).send({
+          code: 400,
+          msg: 'id is required or id is invalid',
+        })
+      }
+
+      try {
+        const fromCache = await getFromCache(id)
+        if (fromCache) {
+          res.status(200).send(fromCache)
+          return
+        }
+      } catch (error) {
+        log.error(`[server] getFromCache failed: ${String(error)}`)
+      }
+
+      const fromNetease = await getFromNetease(req)
+      if (fromNetease?.code === 200 && !fromNetease?.data?.[0].freeTrialInfo) {
+        res.status(200).send(fromNetease)
+        return
+      }
+
+      try {
+        const fromUNM = await getFromUNM(id, req)
+        if (fromUNM) {
+          res.status(200).send(fromUNM)
+          return
+        }
+      } catch (error) {
+        log.error(`[server] getFromNetease failed: ${String(error)}`)
+      }
+
+      if (fromNetease?.data?.[0].freeTrialInfo) {
+        fromNetease.data[0].url = ''
+      }
+
+      res.status(fromNetease?.code ?? 500).send(fromNetease)
+    }
+
+    this.app.get('/netease/song/url', handler)
+  }
+
+  cacheAudioHandler() {
+    this.app.get(
+      '/yesplaymusic/audio/:filename',
+      async (req: Request, res: Response) => {
+        cache.getAudio(req.params.filename, res)
+      }
+    )
+    this.app.post(
+      '/yesplaymusic/audio/:id',
+      async (req: Request, res: Response) => {
+        const id = Number(req.params.id)
+        const { url } = req.query
+        if (isNaN(id)) {
+          return res.status(400).send({ error: 'Invalid param id' })
+        }
+        if (!url) {
+          return res.status(400).send({ error: 'Invalid query url' })
+        }
+
+        if (
+          !req.files ||
+          Object.keys(req.files).length === 0 ||
+          !req.files.file
+        ) {
+          return res.status(400).send('No audio were uploaded.')
+        }
+        if ('length' in req.files.file) {
+          return res.status(400).send('Only can upload one audio at a time.')
+        }
+
+        try {
+          await cache.setAudio(req.files.file.data, {
+            id,
+            url: String(req.query.url) || '',
+          })
+          res.status(200).send('Audio cached!')
+        } catch (error) {
+          res.status(500).send({ error })
+        }
+      }
+    )
+  }
+
+  listen() {
+    this.app.listen(this.port, () => {
+      log.info(`[server] API server listening on port ${this.port}`)
+    })
+  }
+}
+
+export default new Server()

packages/electron/main/tray.ts

@@ -0,0 +1,173 @@
+import path from 'path'
+import {
+  app,
+  BrowserWindow,
+  Menu,
+  MenuItemConstructorOptions,
+  nativeImage,
+  Tray,
+} from 'electron'
+import { IpcChannels } from '@/shared/IpcChannels'
+import { RepeatMode } from '@/shared/playerDataTypes'
+
+const iconDirRoot =
+  process.env.NODE_ENV === 'development'
+    ? path.join(process.cwd(), './src/main/assets/icons/tray')
+    : path.join(__dirname, './assets/icons/tray')
+
+enum MenuItemIDs {
+  Play = 'play',
+  Pause = 'pause',
+  Like = 'like',
+  Unlike = 'unlike',
+}
+
+export interface YPMTray {
+  setTooltip(text: string): void
+  setLikeState(isLiked: boolean): void
+  setPlayState(isPlaying: boolean): void
+  setRepeatMode(mode: RepeatMode): void
+}
+
+function createNativeImage(filename: string) {
+  return nativeImage.createFromPath(path.join(iconDirRoot, filename))
+}
+
+function createMenuTemplate(win: BrowserWindow): MenuItemConstructorOptions[] {
+  const template: MenuItemConstructorOptions[] =
+    process.platform === 'linux'
+      ? [
+          {
+            label: '显示主面板',
+            click: () => win.show(),
+          },
+          {
+            type: 'separator',
+          },
+        ]
+      : []
+
+  return template.concat([
+    {
+      label: '播放',
+      click: () => win.webContents.send(IpcChannels.Play),
+      icon: createNativeImage('play.png'),
+      id: MenuItemIDs.Play,
+    },
+    {
+      label: '暂停',
+      click: () => win.webContents.send(IpcChannels.Pause),
+      icon: createNativeImage('pause.png'),
+      id: MenuItemIDs.Pause,
+      visible: false,
+    },
+    {
+      label: '上一首',
+      click: () => win.webContents.send(IpcChannels.Previous),
+      icon: createNativeImage('left.png'),
+    },
+    {
+      label: '下一首',
+      click: () => win.webContents.send(IpcChannels.Next),
+      icon: createNativeImage('right.png'),
+    },
+    {
+      label: '循环模式',
+      icon: createNativeImage('repeat.png'),
+      submenu: [
+        {
+          label: '关闭循环',
+          click: () => win.webContents.send(IpcChannels.Repeat, RepeatMode.Off),
+          id: RepeatMode.Off,
+          checked: true,
+          type: 'radio',
+        },
+        {
+          label: '列表循环',
+          click: () => win.webContents.send(IpcChannels.Repeat, RepeatMode.On),
+          id: RepeatMode.On,
+          type: 'radio',
+        },
+        {
+          label: '单曲循环',
+          click: () => win.webContents.send(IpcChannels.Repeat, RepeatMode.One),
+          id: RepeatMode.One,
+          type: 'radio',
+        },
+      ],
+    },
+    {
+      label: '加入喜欢',
+      click: () => win.webContents.send(IpcChannels.Like),
+      icon: createNativeImage('like.png'),
+      id: MenuItemIDs.Like,
+    },
+    {
+      label: '取消喜欢',
+      click: () => win.webContents.send(IpcChannels.Like),
+      icon: createNativeImage('unlike.png'),
+      id: MenuItemIDs.Unlike,
+      visible: false,
+    },
+    {
+      label: '退出',
+      click: () => app.exit(),
+      icon: createNativeImage('exit.png'),
+    },
+  ])
+}
+
+class YPMTrayImpl implements YPMTray {
+  private _win: BrowserWindow
+  private _tray: Tray
+  private _template: MenuItemConstructorOptions[]
+  private _contextMenu: Menu
+
+  constructor(win: BrowserWindow) {
+    this._win = win
+    const icon = createNativeImage('menu@88.png').resize({
+      height: 20,
+      width: 20,
+    })
+    this._tray = new Tray(icon)
+    this._template = createMenuTemplate(this._win)
+    this._contextMenu = Menu.buildFromTemplate(this._template)
+
+    this._updateContextMenu()
+    this.setTooltip('YesPlayMusic')
+
+    this._tray.on('click', () => win.show())
+  }
+
+  private _updateContextMenu() {
+    this._tray.setContextMenu(this._contextMenu)
+  }
+
+  setTooltip(text: string) {
+    this._tray.setToolTip(text)
+  }
+
+  setLikeState(isLiked: boolean) {
+    this._contextMenu.getMenuItemById(MenuItemIDs.Like)!.visible = !isLiked
+    this._contextMenu.getMenuItemById(MenuItemIDs.Unlike)!.visible = isLiked
+    this._updateContextMenu()
+  }
+
+  setPlayState(isPlaying: boolean) {
+    this._contextMenu.getMenuItemById(MenuItemIDs.Play)!.visible = !isPlaying
+    this._contextMenu.getMenuItemById(MenuItemIDs.Pause)!.visible = isPlaying
+    this._updateContextMenu()
+  }
+
+  setRepeatMode(mode: RepeatMode) {
+    const item = this._contextMenu.getMenuItemById(mode)
+    if (item) {
+      item.checked = true
+      this._updateContextMenu()
+    }
+  }
+}
+
+export function createTray(win: BrowserWindow): YPMTray {
+  return new YPMTrayImpl(win)
+}

packages/electron/main/utils.ts

@@ -0,0 +1,33 @@
+import fs from 'fs'
+import path from 'path'
+import pkg from '../../../package.json'
+
+export const isDev = process.env.NODE_ENV === 'development'
+export const isProd = process.env.NODE_ENV === 'production'
+export const isWindows = process.platform === 'win32'
+export const isMac = process.platform === 'darwin'
+export const isLinux = process.platform === 'linux'
+export const dirname = isDev ? process.cwd() : __dirname
+export const devUserDataPath = path.resolve(process.cwd(), '../../tmp/userData')
+export const portableUserDataPath = path.resolve(
+  process.env.PORTABLE_EXECUTABLE_DIR || '',
+  './YesPlayMusic-UserData'
+)
+export const logsPath = {
+  linux: `~/.config/${pkg.productName}/logs`,
+  darwin: `~/Library/Logs/${pkg.productName}/`,
+  win32: `%USERPROFILE%\\AppData\\Roaming\\${pkg.productName}\\logs`,
+}[process.platform as 'darwin' | 'win32' | 'linux']
+
+export const createDirIfNotExist = (dir: string) => {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+}
+
+export const createFileIfNotExist = (file: string) => {
+  createDirIfNotExist(path.dirname(file))
+  if (!fs.existsSync(file)) {
+    fs.writeFileSync(file, '')
+  }
+}

packages/electron/main/windowsTaskbar.ts

@@ -0,0 +1,84 @@
+import { IpcChannels } from '@/shared/IpcChannels'
+import { BrowserWindow, nativeImage, ThumbarButton } from 'electron'
+import path from 'path'
+
+enum ItemKeys {
+  Play = 'play',
+  Pause = 'pause',
+  Previous = 'previous',
+  Next = 'next',
+}
+
+type ThumbarButtonMap = Map<ItemKeys, ThumbarButton>
+
+const iconDirRoot =
+  process.env.NODE_ENV === 'development'
+    ? path.join(process.cwd(), './src/main/assets/icons/taskbar')
+    : path.join(__dirname, './assets/icons/taskbar')
+
+function createNativeImage(filename: string) {
+  return nativeImage.createFromPath(path.join(iconDirRoot, filename))
+}
+
+function createThumbarButtons(win: BrowserWindow): ThumbarButtonMap {
+  return new Map<ItemKeys, ThumbarButton>()
+    .set(ItemKeys.Play, {
+      click: () => win.webContents.send(IpcChannels.Play),
+      icon: createNativeImage('play.png'),
+      tooltip: '播放',
+    })
+    .set(ItemKeys.Pause, {
+      click: () => win.webContents.send(IpcChannels.Pause),
+      icon: createNativeImage('pause.png'),
+      tooltip: '暂停',
+    })
+    .set(ItemKeys.Previous, {
+      click: () => win.webContents.send(IpcChannels.Previous),
+      icon: createNativeImage('previous.png'),
+      tooltip: '上一首',
+    })
+    .set(ItemKeys.Next, {
+      click: () => win.webContents.send(IpcChannels.Next),
+      icon: createNativeImage('next.png'),
+      tooltip: '下一首',
+    })
+}
+
+export interface Thumbar {
+  setPlayState(isPlaying: boolean): void
+}
+
+class ThumbarImpl implements Thumbar {
+  private _win: BrowserWindow
+  private _buttons: ThumbarButtonMap
+
+  private _playOrPause: ThumbarButton
+  private _previous: ThumbarButton
+  private _next: ThumbarButton
+
+  constructor(win: BrowserWindow) {
+    this._win = win
+    this._buttons = createThumbarButtons(win)
+
+    this._playOrPause = this._buttons.get(ItemKeys.Play)!
+    this._previous = this._buttons.get(ItemKeys.Previous)!
+    this._next = this._buttons.get(ItemKeys.Next)!
+  }
+
+  private _updateThumbarButtons(clear: boolean) {
+    this._win.setThumbarButtons(
+      clear ? [] : [this._previous, this._playOrPause, this._next]
+    )
+  }
+
+  setPlayState(isPlaying: boolean) {
+    this._playOrPause = this._buttons.get(
+      isPlaying ? ItemKeys.Pause : ItemKeys.Play
+    )!
+    this._updateThumbarButtons(false)
+  }
+}
+
+export function createTaskbar(win: BrowserWindow): Thumbar {
+  return new ThumbarImpl(win)
+}