electron+vue项目的一些小方法

一、自动获取视频第一帧并回显，将图片作为封面存储到本地文件夹

electron:

  /**
   * 保存图片到指定文件夹
   */
  async saveBase64Img(args) {
    try {
      const { data, name } = args
      const imageBuffer = new Buffer.from(data, "base64");
      const time = (new Date()).getTime()
      // '../../build/extraResources/imagelib'为指定文件夹目录，各位可自行替换
      // 此处为查找该文件夹是否存在，不存在便创建
      fs.exists('../../build/extraResources/imagelib', function (exists) {
        if (!exists) {
          fs.mkdirSync('../../build/extraResources/imagelib');
        }
      });
      let newFilePath = path.resolve(__dirname, `../../build/extraResources/imagelib/${time}`);
      // 新建并写入
      fs.mkdirSync(newFilePath);
      fs.writeFileSync(path.join(newFilePath, name), imageBuffer);
      const url = path.join(newFilePath, name)
      // 添加数据到本地sqlite数据库（根据业务来）
      await Services.get('database.sqlitedb').addJzyDataSqlite('images', { name: name, src: url, groupId: 0 })
      return url
    } catch (error) {
      Log.error('saveBase64Img->' + JSON.stringify(error))
    }
  }

vue:

// 自动截取视频第一帧作为封面
const captureImage = () => {
  // 查找视频dom
  const video = document.getElementById('video')
  // 创建一个canvas
  const canvas = document.createElement('canvas')    
  // canvas的宽高等于视频的宽高                        
  canvas.width = video.offsetWidth
  canvas.height = video.offsetHeight
  // 绘制图像
  canvas.getContext('2d').drawImage(video, 0, 0, canvas.width, canvas.height)
  // 创建img
  const img = new Image()                                                    
  img.src = canvas.toDataURL('image/png')

  console.log(img.src)
  // 调用electron的方法
  ipc.invoke(ipcApiRoute.saveBase64Img, { data: img.src.replace('data:image/png;base64,', ''), name: videoName.value.split('.')[0] + '.png' }).then((result) => {
    //将绘制的图像用img显示
    cover.value = result
    console.log(cover.value)
  }).catch((r) => {
    console.log(r);
  })
}

二：复制文件到指定目录

  /**
   * 复制文件到指定目录并自动添加进表格
   * @param src
   * @param dest
   * @param callbackFun
   */
  copyFile(arg) {
    try {
      const time = (new Date()).getTime()
      const name = path.basename(arg.src);
      let newFilePath = path.resolve(__dirname, `../../build/extraResources/imagelib/${time}`)
      let oldFilePath = path.resolve(__dirname, arg.src)
      // 新建目录
      fs.mkdir(newFilePath, async (rr) => {
        // 创建表
        Services.get('database.sqlitedb').checkAndCreateTableSqlite(arg.type).then(async res => {
          console.log('hasTable');
          // 将目标文件复制进新建目录里 
          const url = path.join(newFilePath, name);//newFilePath + '\\' + name
          fs.mkdirSync(newFilePath, { recursive: true });
          fs.copyFileSync(oldFilePath, url);
          // 添加数据到sqlite本地数据库
          await Services.get('database.sqlitedb').addJzyDataSqlite(arg.type, { name: name, src: url, groupId: 0 })
        })
      });
    } catch (error) {
      Log.error('copyFile->' + JSON.stringify(error))
    }
  }

三：打开新窗口，并且获取cookie和头像昵称（示例为electron-egg框架）

  createWindow(args) {
    // 获取一些参数，比如跳转链接，进去后进行什么操作
    const { content, jumpUrl, windowName, windowTitle, loginClick, name, pictureUrl, info } = args;
    // partition的作用是session隔离，id每次都不一样
    let opt = {
      title: windowTitle,
      webPreferences: { webSecurity: false, partition: info.id, nodeIntegration: true }
    }
    // 创建新窗口
    const win = Addon.get('window').create(windowName, opt);
    let contentUrl = content;
    // 监听跳转完成
    win.webContents.on('did-navigate', (event, url) => {
      let nameStr, pictureUrlStr = '';
      const mySession = session.fromPartition(`${info.id}`);
      mySession.cookies.get({}).then(cookies => {
        if (cookies.length && cookieLength === cookies.length) {
          // 主进程向渲染进程发送cookies
          const id = Addon.get('window').getWCid('main');
          const winMain = BaseWindow.fromId(id);
          const v = { cookiesJsonArr: cookies, cookiesJson: JSON.stringify(cookies), name: nameStr, pictureUrl: pictureUrlStr, platformId: info.platformId, ...info }
          winMain.webContents.send("cookies", v);
          // 关闭窗口
          win.hide();
          return;
        }
        cookieLength = cookies.length;
      })

    })
    // 执行js
    loginClick && win.webContents.executeJavaScript(loginClick)
    // load page
    win.loadURL(contentUrl);
    return info.id;
  }

四：sqlite数据库操作

1、封装一个方法进行增删改查

/**
   * sqlite数据库操作
   */
  async sqlitedbOperation(args) {
    // action为“增删改查”操作方式，tabel_name为表明，info为数据
    const { action, tabel_name, info } = args;
    // 打印日志
    Log.info('sqlitedbOperation参数->' + JSON.stringify(args))
    // 定义返回数据
    let data = {
      action,
      result: null,
      all_list: [],
      code: 0
    };

    try {
      // 检查是否有库
      Services.get('database.sqlitedb').getDataDir();
    } catch (err) {
      Log.error('getDataDir错误->' + JSON.stringify(err))
      console.log(err);
      data.code = -1;
      return data;
    }

    try {
      switch (action) {
        case 'add':
          data.result = await Services.get('database.sqlitedb').addTestDataSqlite(tabel_name, info);
          break;
        case 'del':
          data.result = await Services.get('database.sqlitedb').delTestDataSqlite(tabel_name, info.key, info.value);
          break;
        case 'update':
          data.result = await Services.get('database.sqlitedb').updateTestDataSqlite(tabel_name, info.fromkey, info.fromvalue, info.setkey, info.setvalue);
          break;
        case 'get':
          data.result = await Services.get('database.sqlitedb').getTestDataSqlite(tabel_name, info.fromkey, info.fromvalue);
          break;
        case 'getDataDir':
          data.result = await Services.get('database.sqlitedb').getDataDir();
          break;
        case 'setDataDir':
          data.result = await Services.get('database.sqlitedb').setCustomDataDir(data_dir);
          break;
      }
    }
    catch (error) {
      Log.error('sqlitedbOperation->' + JSON.stringify(error))
      Log.error('' + JSON.stringify(data))
      console.log(error);
    }

    return data;
  }

2、数据操作层

  /*
   * 检查并创建表 (sqlite)
   */
  checkAndCreateTableSqlite(tableName = '') {

    return new Promise((resolve, reject) => {
      if (_.isEmpty(tableName)) {
        Log.error('checkAndCreateTableSqlite->' + 'table name is required');
        throw new Error(`table name is required`);
      }
      // 检查表是否存在
      const userTable = this.demoSqliteDB.db.prepare('SELECT * FROM sqlite_master WHERE type=? AND name = ?');
      const result = userTable.get('table', tableName);
      let jsonStringResult = '';
      if (result) {
        Log.info('checkAndCreateTableSqlite->' + 'hasTable');
        resolve('hasTable')
        return;
      }


      switch (tableName) {
        case 'images':
          // 创建图片表
          /** 
          * @param id:自增id 
          * @param name:图片名称 
          * @param src:图片路径  
          * @param groupId:分组id
          */

          const create_table_images =
            `CREATE TABLE ${tableName}
                (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    name CHAR(200),
                    src CHAR(200),
                    groupId INT
                );`
          jsonStringResult = this.demoSqliteDB.db.exec(create_table_images);
          break;

      }
      Log.error('checkAndCreateTableSqlite->new-Table!');
      resolve('new-Table!')
    })
  }


  /*
   * 增 Test data (sqlite)
   */
  async addTestDataSqlite(tableName, data) {
    // 检查并创建表
    await this.checkAndCreateTableSqlite(tableName);
    let result = ''
    try {
      switch (tableName) {
        case 'images':
          const images = this.demoSqliteDB.db.prepare(`INSERT INTO ${tableName} (name, src,groupId) VALUES (@name, @src,@groupId)`);
          result = images.run(data);
          break;
        default:
          break;
      }
    } catch (error) {
      console.log(error);
      Log.error('addTestDataSqlite->' + JSON.stringify(error));
    }

    return result;
  }

  /*
   * 删 Test data (sqlite)
   */
  async delTestDataSqlite(tableName, key = 'id', value = '') {
    //console.log("delete name:", name);

    try {
      await this.checkAndCreateTableSqlite(tableName);

      const delUser = this.demoSqliteDB.db.prepare(`DELETE FROM ${tableName} WHERE ${key} = ?`);
      delUser.run(value);

      return true;
    } catch (e) {
      Log.error('delTestDataSqlite->' + JSON.stringify(e));
    }
  }

  /*
   * 改 Test data (sqlite)
   */
  async updateTestDataSqlite(tableName, fromkey = 'id', fromvalue = '', setkey = 0, setvalue = '') {
    // console.log(fromkey,fromvalue,setkey,setvalue);
    //console.log("update :", {name, age});

    try {
      await this.checkAndCreateTableSqlite(tableName);

      const updateUser = this.demoSqliteDB.db.prepare(`UPDATE ${tableName} SET ${setkey} = ? WHERE ${fromkey} = ?`);
      updateUser.run(setvalue, fromvalue);

      return true;
    } catch (e) {
      Log.error('updateTestDataSqlite->' + JSON.stringify(e));
    }

  }

  /*
   * 查 Test data (sqlite)
   */
  async getTestDataSqlite(tableName, fromkey = 'id', fromvalue = 0) {
    console.log({ fromkey }, "select :", { fromvalue });
    try {
      await this.checkAndCreateTableSqlite(tableName);
      const selectUser = this.demoSqliteDB.db.prepare(`SELECT * FROM ${tableName} WHERE ${fromkey} = ?`);
      const users = selectUser.all(fromvalue);
      return users;
    } catch (e) {
      Log.error('getTestDataSqlite->' + JSON.stringify(e));
    }

  }