# yach.electron.ipcrenderer

yach 渲染进程 ipc 封装

# owner

# 王文杰(153729)

# 安装

npm i yach.electron.ipcrenderer

# ipc-channel

# broadcast && subscribe

向所有窗口广播,订阅的窗口回调中会收到数据

import { broadcast, subscribe } from "yach.electron.ipcrenderer";
/**
 * 向所有窗口发广播
 * @params eventName String  约定事件名称
 * @params sender String 发送方
 * @params data Obj 数据包
 */
broadcast({ eventName, sender, data });

/**
 * 收听方订阅相应广播
 * @params eventName String 需订阅的事件名
 * @params sender String 指明被订阅者
 * @params channelId String【optional】 为不同回调处理函数指定特定通道,不指定,则callback会相互覆盖。
 * @params callback function
 */
subscribe({ eventName, sender, channelId, callback });

# sendToMessage && receiveMessage

/**
 * 向指定窗口发数据
 * @params winId String
 * @params eventName String 约定的事件名
 * @params sender String 发送方
 * @params data Obj 数据包
 */
sendToMessage({ winId, eventName, sender, data });
/**
 * 接收方收取数据
 * @params eventName String 事件名
 * @params sender String 发送者
 * @params channelId String【optional】 为不同回调处理函数指定特定通道,不指定,则callback会相互覆盖。
 * @params callback function
 */
receiveMessage({ eventName, sender, channelId, callback });

# ipc-channel-listener

# electronChannelListen

import { electronChannelListen } from "yach.electron.ipcrenderer";

//注册ipc监听事件
electronChannelListen(name, callback);

# ipc-debug

# electronDebugInfo

import { electronDebugInfo } from "yach.electron.ipcrenderer";
// debug info
electronDebugInfo(apicaller, debugInfo, callback);

# ipc-download

# electronFileDownloadStatus

import { electronFileDownloadStatus } from "yach.electron.ipcrenderer";
//文件下载
electronFileDownloadStatus({
  apicaller,
  channelid,
  data,
  rescallback,
  progresscallback,
});

# electronDownloadFileDestory

import { electronDownloadFileDestory } from "yach.electron.ipcrenderer";
//取消下载
electronDownloadFileDestory(data);

# electronReceiveDownloadCancel

import { electronReceiveDownloadCancel } from "yach.electron.ipcrenderer";
//Receive Download Cancel
electronReceiveDownloadCancel(apicaller, callback);

# electronReceiveProgress

import { electronReceiveProgress } from "yach.electron.ipcrenderer";
//Receive Progress
electronReceiveProgress(apicaller, callback);

# electronDownloadFlies

import { electronDownloadFlies } from "yach.electron.ipcrenderer";
//Download Flies
electronDownloadFlies(apicaller, callback);

# electronVideoWindowDownloadVideo

import { electronVideoWindowDownloadVideo } from "yach.electron.ipcrenderer";
//Video Window Download Video
electronVideoWindowDownloadVideo(win, data);

# electronVideoWindowDownloadCancel

import { electronVideoWindowDownloadCancel } from "yach.electron.ipcrenderer";
//Video Window Download Cancel
electronVideoWindowDownloadCancel(win, data);

# electronSendToMainWindowCancelDownload

import { electronSendToMainWindowCancelDownload } from "yach.electron.ipcrenderer";
/// 主窗口取消下载
electronSendToMainWindowCancelDownload({ win, data });

# electronSendToDownloadProgress

import { electronSendToDownloadProgress } from "yach.electron.ipcrenderer";
/// sent to download progress
electronSendToDownloadProgress({ win, data });

# electronOnVideoWindowDownloadCancel

import { electronOnVideoWindowDownloadCancel } from "yach.electron.ipcrenderer";
// 监听 视频预览窗口取消下载
electronOnVideoWindowDownloadCancel({ apicaller, callback });

# electronOnVideoWindowDownloadVideo

import { electronOnVideoWindowDownloadVideo } from "yach.electron.ipcrenderer";
// 监听 视频预览窗口点击下载
electronOnVideoWindowDownloadVideo({ apicaller, callback });

# ipc-email

# electronGetEmailPreviewData

import { electronGetEmailPreviewData } from "yach.electron.ipcrenderer";
//get email preview data
electronGetEmailPreviewData(apicaller, callback);

# emailNoticeAction

import { emailNoticeAction } from "yach.electron.ipcrenderer";
// notice action
emailNoticeAction(win, data);

# emailDialogClickAction

import { emailDialogClickAction } from "yach.electron.ipcrenderer";
// email dialog click action
emailDialogClickAction(win, data);

# electronOnEmailMsgNoticeAction

import { electronOnEmailMsgNoticeAction } from "yach.electron.ipcrenderer";
// 监听 email 初始化
electronOnEmailMsgNoticeAction({ apicaller, callback });

# electronOnEmailDiaClickedAction

import { electronOnEmailDiaClickedAction } from "yach.electron.ipcrenderer";
//监听 email 第一次打开弹窗标识位
electronOnEmailDiaClickedAction({ apicaller, callback });

# electronEmailWindowIsFocused

import { electronEmailWindowIsFocused } from "yach.electron.ipcrenderer";
//email window is focused
electronEmailWindowIsFocused({ apicaller, callback });
import { electronOnEmailWindowLink } from "yach.electron.ipcrenderer";
//email window link
electronOnEmailWindowLink({ apicaller, callback });

# ipc-file

# electronOpenDirectory

import { electronOpenDirectory } from "yach.electron.ipcrenderer";
// open driectory
electronOpenDirectory(apicaller, data);

# electronChangeVoicesData

import { electronChangeVoicesData } from "yach.electron.ipcrenderer";
//change voices data
electronChangeVoicesData(apicaller, callback);

# electronCheckFile

import { electronCheckFile } from "yach.electron.ipcrenderer";
// check 本地文件是否有变动
electronCheckFile(data, callback);

# electronOpenFile

import { electronOpenFile } from "yach.electron.ipcrenderer";
// 打开文件
electronOpenFile(apicaller, data);

# electronFilepreviewWinOpen

import { electronFilepreviewWinOpen } from "yach.electron.ipcrenderer";
// File preview Win Open
electronFilepreviewWinOpen(apicaller, data);

# electronSendToVideoWindowOpenFolder

import { electronSendToVideoWindowOpenFolder } from "yach.electron.ipcrenderer";
// SendTo Video Window Open Folder
electronSendToVideoWindowOpenFolder(win, data);

# electronVideoWindowShare

import { electronVideoWindowShare } from "yach.electron.ipcrenderer";
// Video Window Share
electronVideoWindowShare(win, data);

# electronVoiceDataGet

import { electronVoiceDataGet } from "yach.electron.ipcrenderer";
// Voice data get
electronVoiceDataGet(win, data, callback);

# electronClipboardAnalysis

import { electronClipboardAnalysis } from "yach.electron.ipcrenderer";
// clipboard analysis
electronClipboardAnalysis(apicaller, callback);

# electronGetFilePath

import { electronGetFilePath } from "yach.electron.ipcrenderer";
// 获取系统文件路径
electronGetFilePath({ apicaller, data, callback });

# electronFileWrite

import { electronFileWrite } from "yach.electron.ipcrenderer";
// 文件写入
electronFileWrite({ apicaller, channelid, data, callback });

# electronGetFileStat

import { electronGetFileStat } from "yach.electron.ipcrenderer";
// 获取文件描述符
electronGetFileStat({ apicaller, data, callback });

# electronOpenFileDialog

import { electronOpenFileDialog } from "yach.electron.ipcrenderer";
// 打开文件选择框
electronOpenFileDialog({ apicaller, data, callback });

# electronDownloadSign

import { electronDownloadSign } from "yach.electron.ipcrenderer";
// 为下载文件夹中的每一项添加签名
electronDownloadSign({ apicaller, path, callback });

# electronMutilFileUploadReg

import { electronMutilFileUploadReg } from "yach.electron.ipcrenderer";
/**
 * 多文件上传校验获取列表
 * {
    apicaller: 'xxx'
    list: [ 'a/b/c' , 'a/b/x.js' , ...... ]
   }
 */
electronMutilFileUploadReg({ apicaller, list, callback });

# electronOnVideoWindowOpenFolder

import { electronOnVideoWindowOpenFolder } from "yach.electron.ipcrenderer";
// on video window open folder
electronOnVideoWindowOpenFolder({ apicaller, callback });

# electronOnVideoWindowShare

import { electronOnVideoWindowShare } from "yach.electron.ipcrenderer";
// on video window share
electronOnVideoWindowShare({ apicaller, callback });

# electronOpeningVideoPreview

import { electronOpeningVideoPreview } from "yach.electron.ipcrenderer";
// opening video preview
electronOpeningVideoPreview({ apicaller, data });

# electronVoiceWindowOpen

import { electronVoiceWindowOpen } from "yach.electron.ipcrenderer";
// voice window open
electronVoiceWindowOpen(data);

# electronOnVoiceDataGet

import { electronOnVoiceDataGet } from "yach.electron.ipcrenderer";
// voice get data
electronOnVoiceDataGet({ apicaller, callback });

# electronSendToVoiceDataRes

import { electronSendToVoiceDataRes } from "yach.electron.ipcrenderer";
// send to voice data res
electronSendToVoiceDataRes({ win, data });

# ipc-images

# electronImagesGet

import { electronImagesGet } from "yach.electron.ipcrenderer";
// images get
electronImagesGet(id, callback);

# electronImagWinOpen

import { electronImagWinOpen } from "yach.electron.ipcrenderer";
// image win open
electronImagWinOpen(data);

# electronOnImageWindowRetry

import { electronOnImageWindowRetry } from "yach.electron.ipcrenderer";
// on image window retry
electronOnImageWindowRetry({ apicaller, callback });

# electronImageWindowRetryData

import { electronImageWindowRetryData } from "yach.electron.ipcrenderer";
// image window retry
electronImageWindowRetryData({ apicaller, callback });

# electronFileImageInfoGet

import { electronFileImageInfoGet } from "yach.electron.ipcrenderer";
// file image info get
electronFileImageInfoGet({ apicaller, data, callback });

# ipc-info

# getVersion

import { getVersion } from "yach.electron.ipcrenderer";

// 获取客户端版本号
getVersion((v) => {
  console.log(v);
});

# getClientEnv

import { getClientEnv } from "yach.electron.ipcrenderer";

// 获取客户端环境
getClientEnv((e) => {
  console.log(e);
});

# getClientOsinfo

import { getClientOsinfo } from "yach.electron.ipcrenderer";

// 获取客户端os
getClientOsinfo((o) => {
  console.log(o);
});

# electronSendGroupData

import { electronSendGroupData } from "yach.electron.ipcrenderer";

// send group data 窗口类型需要包含在sendData中
electronSendGroupData(sendData, callback);

# electronGetWindowInfo

import { electronGetWindowInfo } from "yach.electron.ipcrenderer";
// get window info
electronGetWindowInfo(apicaller);

# electronSendMainWinGroupData

import { electronSendMainWinGroupData } from "yach.electron.ipcrenderer";
// send main win group data
electronSendMainWinGroupData(win, data);

# OnPluginWindowSendGroupData

import { OnPluginWindowSendGroupData } from "yach.electron.ipcrenderer";
// on plugin window send group data
OnPluginWindowSendGroupData(apicaller, callback);

# ipc-log

# log

import { log } from "yach.electron.ipcrenderer";

/**
 * log
 *  project,所属项目,例如yach_13_im
 *  namespace,命名空间,采用开发者姓名全拼,例如qiaowenbin
 *  unit,业务单元,例如session list
 *  …msg,其他信息,以下几种情况会过滤
	1.无msg或msg总个数超过10个
	2.各个msg的长度总和超过100
	3.任一msg非null, number, string, boolean, undefined类型,如需传object自行json化
 */
log(project, namespace, unit, ...msg);

# ipc-meeting

# electronSendMsgEnterMeeting

import { electronSendMsgEnterMeeting } from "yach.electron.ipcrenderer";

//加入会议
electronSendMsgEnterMeeting(data);

# agoraRtmReceiveMessage

import { agoraRtmReceiveMessage } from "yach.electron.ipcrenderer";

// agora 收到消息回调
agoraRtmReceiveMessage(apicaller, callback);

# zoomMeetingstatusChange

import { zoomMeetingstatusChange } from "yach.electron.ipcrenderer";

// zoom会议室状态监听
zoomMeetingstatusChange(apicaller, callback);

# electronOpenInvite

import { electronOpenInvite } from "yach.electron.ipcrenderer";

// Open Invite
electronOpenInvite(data);

# electronReceiveMsg

import { electronReceiveMsg } from "yach.electron.ipcrenderer";

// Receive Messsage
electronReceiveMsg(apicaller, callback);

# zoomMeetingUserJoin

import { zoomMeetingUserJoin } from "yach.electron.ipcrenderer";

// zoom会议室用户加入监听
zoomMeetingUserJoin(apicaller, callback);

# zoomMeetingUserLeft

import { zoomMeetingUserLeft } from "yach.electron.ipcrenderer";

//  zoom会议室用户离开监听
zoomMeetingUserLeft(apicaller, callback);

# zoomMeetingHostChange

import { zoomMeetingHostChange } from "yach.electron.ipcrenderer";

//  zoom会议主持人变更
zoomMeetingHostChange(apicaller, callback);

# agoraRtmUserLeave

import { agoraRtmUserLeave } from "yach.electron.ipcrenderer";

// agora 收到用户离开频道的回调
agoraRtmUserLeave(apicaller, callback);

# electronZoomCallFn

import { electronZoomCallFn } from "yach.electron.ipcrenderer";

// zoom方法调用
electronZoomCallFn(fnName, data, winName, callback);

# elelctronMainWindowZoominvitebuttonClicked

import { elelctronMainWindowZoominvitebuttonClicked } from "yach.electron.ipcrenderer";

// Main Window Zoom invite button Clicked
elelctronMainWindowZoominvitebuttonClicked(win, data);

# electronZoomRefresh

import { electronZoomRefresh } from "yach.electron.ipcrenderer";

// Zoom Refresh
electronZoomRefresh(win, data);

# electronStartCall

import { electronStartCall } from "yach.electron.ipcrenderer";

// start call
electronStartCall(win, data);

# electronOpenZoomUserList

import { electronOpenZoomUserList } from "yach.electron.ipcrenderer";

// zoom会议-参会人列表弹框
electronOpenZoomUserList(data);

# electronOpenZoomCalled

import { electronOpenZoomCalled } from "yach.electron.ipcrenderer";

// zoom会议-被呼叫弹框
electronOpenZoomCalled(data);

# electronInitReceiveMessagecb

import { electronInitReceiveMessagecb } from "yach.electron.ipcrenderer";

//zoom视频会议邀请功能-agora 注册receive message事件的回调
electronInitReceiveMessagecb({ win, data });

# electronInitUserLeavecb

import { electronInitUserLeavecb } from "yach.electron.ipcrenderer";

//zoom视频会议邀请功能-agora 注册user leave事件的回调
electronInitUserLeavecb({ win, data });

# electronOnZoomMeetingAudioStatusChange

import { electronOnZoomMeetingAudioStatusChange } from "yach.electron.ipcrenderer";

// zoom会议室音频状态监听
electronOnZoomMeetingAudioStatusChange(apicaller, callback);

# electronOnZoomMeetingAudioActiveChange

import { electronOnZoomMeetingAudioActiveChange } from "yach.electron.ipcrenderer";

// zoom会议室音频活跃监听
electronOnZoomMeetingAudioActiveChange(apicaller, callback);

# electronOnZoomMeetingCurrUserChange

import { electronOnZoomMeetingCurrUserChange } from "yach.electron.ipcrenderer";

// zoom会议室当前用户变更监听
electronOnZoomMeetingCurrUserChange(apicaller, callback);

# electronOnZoomVideoStatusChange

import { electronOnZoomVideoStatusChange } from "yach.electron.ipcrenderer";

// zoom视频状态变更监听
electronOnZoomVideoStatusChange(apicaller, callback);

# electronOnMainWindowZoominvitebuttonClicked

import { electronOnMainWindowZoominvitebuttonClicked } from "yach.electron.ipcrenderer";

// zoom视频邀请按钮点击监听
electronOnMainWindowZoominvitebuttonClicked(apicaller, callback);

# electronOnMainWindowZoomcallEnter

import { electronOnMainWindowZoomcallEnter } from "yach.electron.ipcrenderer";

// zoom视频邀请-被呼叫用户加入会议
electronOnMainWindowZoomcallEnter(apicaller, callback);

# electronOnZoomInitError

import { electronOnZoomInitError } from "yach.electron.ipcrenderer";

// zoom init 失败
electronOnZoomInitError(apicaller, callback);

# electronOnStartCall

import { electronOnStartCall } from "yach.electron.ipcrenderer";

// on start call
electronOnStartCall({ apicaller, callback });

# ipc-message

# electronUnreadOpenWin

import { electronUnreadOpenWin } from "yach.electron.ipcrenderer";

// Unread Open Win
electronUnreadOpenWin(data);

# electronUnreadCloseWin

import { electronUnreadCloseWin } from "yach.electron.ipcrenderer";

// Unread close Win
electronUnreadCloseWin();

# electrongIsreadMsgReadGet

import { electrongIsreadMsgReadGet } from "yach.electron.ipcrenderer";

// Is readMsg Read Get
electrongIsreadMsgReadGet(win, id, idServer, callback);

# electronAgoraSendMessage

import { electronAgoraSendMessage } from "yach.electron.ipcrenderer";

// Agora Send Message
electronAgoraSendMessage(win, data);

# elelctronAgoraClearChannel

import { elelctronAgoraClearChannel } from "yach.electron.ipcrenderer";

// Agora Clear Channel
elelctronAgoraClearChannel(win, data);

# electronInviteSaveMessage

import { electronInviteSaveMessage } from "yach.electron.ipcrenderer";

// Invite Save Message
electronInviteSaveMessage(win, data);

# electronMessageSend

import { electronMessageSend } from "yach.electron.ipcrenderer";

// message send
electronMessageSend(win, data);

# electronUnreadMsg

import { electronUnreadMsg } from "yach.electron.ipcrenderer";

// unread msg
electronUnreadMsg(num, type);

# electronNewMsgComing

import { electronNewMsgComing } from "yach.electron.ipcrenderer";

// new msg coming
electronNewMsgComing(ping);

# electronUpdateUnreadMsgWin

import { electronUpdateUnreadMsgWin } from "yach.electron.ipcrenderer";

// mac tray界面中未读消息展示
electronUpdateUnreadMsgWin(list);

# electronOnClickUnreadList

import { electronOnClickUnreadList } from "yach.electron.ipcrenderer";

// on click unread list
electronOnClickUnreadList(callback);

# electronOnAgoraSendMessage

import { electronOnAgoraSendMessage } from "yach.electron.ipcrenderer";

// zoom视频会议邀请功能-agora 发消息
electronOnAgoraSendMessage({ apicaller, callback });

# electronOnAgoraClearChannel

import { electronOnAgoraClearChannel } from "yach.electron.ipcrenderer";

// zoom视频会议邀请功能-agora 清除频道
electronOnAgoraClearChannel({ apicaller, callback });

# electronOnInviteSaveMessage

import { electronOnInviteSaveMessage } from "yach.electron.ipcrenderer";

// 参会列表发来数据存储
electronOnInviteSaveMessage({ apicaller, callback });

# electronOnMessageSend

import { electronOnMessageSend } from "yach.electron.ipcrenderer";

// on message send
electronOnMessageSend({ apicaller, callback });

# electronOnIsreadMsgReadGet

import { electronOnIsreadMsgReadGet } from "yach.electron.ipcrenderer";

// on is read msg read get
electronOnIsreadMsgReadGet({ apicaller, callback });

# electronSendToIsreadMsgReadRes

import { electronSendToIsreadMsgReadRes } from "yach.electron.ipcrenderer";

// send to is read msg read res
electronSendToIsreadMsgReadRes({ win, data });

# electronSendToEffectMsgNoticeAction

import { electronSendToEffectMsgNoticeAction } from "yach.electron.ipcrenderer";

// SendTo Effect Msg Notice Action
electronSendToEffectMsgNoticeAction({ win, data });

# electronOnEffectMsgNoticeAction

import { electronOnEffectMsgNoticeAction } from "yach.electron.ipcrenderer";

// On Effect Msg Notice Action
electronOnEffectMsgNoticeAction({ apicaller, callback });

# ipc-net

# electronOnOfflineToOnline

import { electronOnOfflineToOnline } from "yach.electron.ipcrenderer";

// on offline to online
electronOnOfflineToOnline(apicaller, callback);

# electronOnlineStatusChanged

import { electronOnlineStatusChanged } from "yach.electron.ipcrenderer";

// online status changed
electronOnlineStatusChanged(status);

# ipc-page

# electronLoadFinish

import { electronLoadFinish } from "yach.electron.ipcrenderer";

// load finish
electronLoadFinish(apicaller, callback);

# electronSinglewebviewGet

import { electronSinglewebviewGet } from "yach.electron.ipcrenderer";

// Single webview Get
electronSinglewebviewGet(data, callback);

# electronChangeSinglewebviewData

import { electronChangeSinglewebviewData } from "yach.electron.ipcrenderer";

// Change Single webview Data
electronChangeSinglewebviewData(apicaller, callback);

# electronWebviewAddTab

import { electronWebviewAddTab } from "yach.electron.ipcrenderer";

// Webview Add Tab
electronWebviewAddTab(apicaller, callback);

# electronWorkbenchAddTab

import { electronWorkbenchAddTab } from "yach.electron.ipcrenderer";

// workbench Add Tab
electronWorkbenchAddTab(apicaller, callback);

# electronCloseWebview

import { electronCloseWebview } from "yach.electron.ipcrenderer";

// Close Webview
electronCloseWebview(apicaller, callback);

# electronWebviewNewTabRes

import { electronWebviewNewTabRes } from "yach.electron.ipcrenderer";

//  Webview New TabRes
electronWebviewNewTabRes(apicaller, callback);
import { electronOpenLink } from "yach.electron.ipcrenderer";

//  open link
electronOpenLink(data);

# electronSinglewebviewOpen

import { electronSinglewebviewOpen } from "yach.electron.ipcrenderer";

// Single webview Open
electronSinglewebviewOpen(data);

# electronWebviewHideMethod

import { electronWebviewHideMethod } from "yach.electron.ipcrenderer";

// Webview Hide Method
electronWebviewHideMethod(data);

# electronSendToCloseWebviewWindow

import { electronSendToCloseWebviewWindow } from "yach.electron.ipcrenderer";

// SendTo Close Webview Window
electronSendToCloseWebviewWindow(win);

# electronSendToNewTab

import { electronSendToNewTab } from "yach.electron.ipcrenderer";

// SendTo New Tab
electronSendToNewTab(win);

# electronSentToWeeklyShare

import { electronSentToWeeklyShare } from "yach.electron.ipcrenderer";

// SendTo weekly share
electronSentToWeeklyShare(win, data, callback);

# electronGetGlobalData

import { electronGetGlobalData } from "yach.electron.ipcrenderer";

// get clobal data
electronGetGlobalData(key);

# electronVersionWindowOpen

import { electronVersionWindowOpen } from "yach.electron.ipcrenderer";

// 打开升级页面
electronVersionWindowOpen({ apicaller, data });

# electronOpenWebView

import { electronOpenWebView } from "yach.electron.ipcrenderer";

// 打开webview页面
electronOpenWebView({ apicaller, data });

# electronAddWebview

import { electronAddWebview } from "yach.electron.ipcrenderer";

// 新增webview tab
electronAddWebview({ apicaller, data });

# electronOpenOnepage

import { electronOpenOnepage } from "yach.electron.ipcrenderer";

// 打开onpage页面
electronOpenOnepage({ apicaller, data });

# electronMainWindowLogout

import { electronMainWindowLogout } from "yach.electron.ipcrenderer";

// 退出登录后清理11的用户信息
electronMainWindowLogout();

# electronOnWeeklyShare

import { electronOnWeeklyShare } from "yach.electron.ipcrenderer";

// on weekly share
electronOnWeeklyShare({ apicaller, callback });

# electronSendToWeeklyShareRes

import { electronSendToWeeklyShareRes } from "yach.electron.ipcrenderer";

// send to weekly share res
electronSendToWeeklyShareRes({ win, data });

# electronSetGlobalData

import { electronSetGlobalData } from "yach.electron.ipcrenderer";

// set global data
electronSetGlobalData({ key, value });

# ipc-panel

# electronOpenUserpanel

import { electronOpenUserpanel } from "yach.electron.ipcrenderer";

// 打开用户信息 弹框
electronOpenUserpanel(data);

# electronUserTokenGet

import { electronUserTokenGet } from "yach.electron.ipcrenderer";

// user token get
electronUserTokenGet(callback);

# electronUserIdGet

import { electronUserIdGet } from "yach.electron.ipcrenderer";

// User Id Get
electronUserIdGet(callback);

# electronUserAddSession

import { electronUserAddSession } from "yach.electron.ipcrenderer";

// User Add Session
electronUserAddSession(apicaller, data, callback);

# electronUserAddOrgWinOpen

import { electronUserAddOrgWinOpen } from "yach.electron.ipcrenderer";

// User Add Org Win Open
electronUserAddOrgWinOpen(apicaller, data, callback);

# electronUseraddComplexWindowOpen

import { electronUseraddComplexWindowOpen } from "yach.electron.ipcrenderer";

// User add Complex Window Open
electronUseraddComplexWindowOpen(apicaller, data, callback);

# electronUseraddGroupWindowOpen

import { electronUseraddGroupWindowOpen } from "yach.electron.ipcrenderer";

// User add Group Window Open
electronUseraddGroupWindowOpen(apicaller, data, callback);

# electronWorkbenchWindowOpen

import { electronWorkbenchWindowOpen } from "yach.electron.ipcrenderer";

// Workbenc hWindow Open
electronWorkbenchWindowOpen(apicaller, data);

# electronslidePanelWorkbenchOpen

import { electronslidePanelWorkbenchOpen } from "yach.electron.ipcrenderer";

// slide Panel Workbench Open
electronslidePanelWorkbenchOpen(apicaller, callback);

# electronReminWindowOpen

import { electronReminWindowOpen } from "yach.electron.ipcrenderer";

// Remin Window Open
electronReminWindowOpen(win, data);

# electronCloseItem

import { electronCloseItem } from "yach.electron.ipcrenderer";

// Close Item
electronCloseItem(apicaller, callback);

# electronSendToUseraddWindowRes

import { electronSendToUseraddWindowRes } from "yach.electron.ipcrenderer";

// SendTo User add WindowRes
electronSendToUseraddWindowRes(win, data);

# electronSessionListGet

import { electronSessionListGet } from "yach.electron.ipcrenderer";

// Session List Get
electronSessionListGet(win, apicaller, callback);

# electronSendToUserpanelGogroup

import { electronSendToUserpanelGogroup } from "yach.electron.ipcrenderer";

// SendTo User panel Gogroup
electronSendToUserpanelGogroup(win, data);

# electronSendToOpenTeamChat

import { electronSendToOpenTeamChat } from "yach.electron.ipcrenderer";

// SendTo Open Team Chat
electronSendToOpenTeamChat(win, data);

# electronSendToOpenSingleChat

import { electronSendToOpenSingleChat } from "yach.electron.ipcrenderer";

// SendTo Open Single Chat
electronSendToOpenSingleChat(win, data);

# electronOpenIsRead

import { electronOpenIsRead } from "yach.electron.ipcrenderer";

// open read win
electronOpenIsRead(data);

# electronCloseIsRead

import { electronCloseIsRead } from "yach.electron.ipcrenderer";

// close read win
electronCloseIsRead(data);

# OnRemindWindowOpen

import { OnRemindWindowOpen } from "yach.electron.ipcrenderer";

// on remind window open
electronOnRemindWindowOpen({ apicaller, callback });

# electronSendToCloseItem

import { electronSendToCloseItem } from "yach.electron.ipcrenderer";

// 关闭呼叫弹窗
electronSendToCloseItem({ win, data });

# electronOnSessionListGet

import { electronOnSessionListGet } from "yach.electron.ipcrenderer";

// on session list get
electronOnSessionListGet({ apicaller, callback });

# electronSendToSessionListRes

import { electronSendToSessionListRes } from "yach.electron.ipcrenderer";

// 发送会话列表
electronSendToSessionListRes({ win, data });

# electronOnSlidepanelLinkOpen

import { electronOnSlidepanelLinkOpen } from "yach.electron.ipcrenderer";

// 打开侧边栏
electronOnSlidepanelLinkOpen({ apicaller, callback });

# electronOpenToast

import { electronOpenToast } from "yach.electron.ipcrenderer";

//公共最上层的toast提示
electronOpenToast({ apicaller, data });

# electronOnOpenTeamChat

import { electronOnOpenTeamChat } from "yach.electron.ipcrenderer";

// on open team chat
electronOnOpenTeamChat({ apicaller, callback });

# electronOnOpenSingleChat

import { electronOnOpenSingleChat } from "yach.electron.ipcrenderer";

// on open single chat
electronOnOpenSingleChat({ apicaller, callback });

# electronOnUserpanelGogroup

import { electronOnUserpanelGogroup } from "yach.electron.ipcrenderer";

// on userpanel go group
electronOnUserpanelGogroup({ apicaller, callback });

# electronOnUserpanelGoUserGroupSetting

import { electronOnUserpanelGoUserGroupSetting } from "yach.electron.ipcrenderer";

// on userpanel go user group setting
electronOnUserpanelGoUserGroupSetting({ apicaller, callback });

# electronOnGuideReport

import { electronOnGuideReport } from "yach.electron.ipcrenderer";

// on guide report
electronOnGuideReport({ apicaller, callback });

# electronSendToUserpanelGoUserGroupSetting

import { electronSendToUserpanelGoUserGroupSetting } from "yach.electron.ipcrenderer";

// send to user panel go user group setting
electronSendToUserpanelGoUserGroupSetting(win, data);

# electronSendToUserpanelShowEndorsement

import { electronSendToUserpanelShowEndorsement } from "yach.electron.ipcrenderer";

// send to user panel show endorsement
electronSendToUserpanelShowEndorsement(win, data);

# electronOnUserpanelShowEndorsement

import { electronOnUserpanelShowEndorsement } from "yach.electron.ipcrenderer";

// on user panel show endorsement
electronOnUserpanelShowEndorsement({ apicaller, callback });

# ipc-proxy

# electronJssdkProxy

import { electronJssdkProxy } from "yach.electron.ipcrenderer";

// Jssdk Proxy
electronJssdkProxy(apicaller, data, callback);

# ipc-screen-shot

# electronScreenShot

import { electronScreenShot } from "yach.electron.ipcrenderer";

// 截屏弹窗
electronScreenShot({ apicaller, callback });

# electronStartScreenCut

import { electronStartScreenCut } from "yach.electron.ipcrenderer";

// 开始截屏
electronStartScreenCut({ apicaller, data, callback });

# electronOnScreenCutRes

import { electronOnScreenCutRes } from "yach.electron.ipcrenderer";

// 监听截屏结果
electronOnScreenCutRes({ apicaller, callback });

# ipc-session

# electronSessionStorageClear

import { electronSessionStorageClear } from "yach.electron.ipcrenderer";

// 监听截屏结果
electronSessionStorageClear({ apicaller, data, callback });

# ipc-systemset

# electronResize

import { electronResize } from "yach.electron.ipcrenderer";

// 设置窗体大小
electronResize(data);

# electronSystemBlur

import { electronSystemBlur } from "yach.electron.ipcrenderer";

// 监听窗口失焦
electronSystemBlur(callback);

# electronRemoveSystemBlur

import { electronRemoveSystemBlur } from "yach.electron.ipcrenderer";

// 移出窗口失焦监听
electronRemoveSystemBlur(callback);

# electronStartUp

import { electronStartUp } from "yach.electron.ipcrenderer";

// 设置是否开机启动
electronStartUp((isStart = false));

# electronSetLocale

import { electronSetLocale } from "yach.electron.ipcrenderer";

// 设置语言
electronSetLocale((lang = "locale"));

# electronRegister

import { electronRegister } from "yach.electron.ipcrenderer";

// 全局快捷键-注册
electronRegister(data);

# electronIsregister

import { electronIsregister } from "yach.electron.ipcrenderer";

// 全局快捷键-是否注册成功
electronIsregister(accelerator);

# electronUnregister

import { electronUnregister } from "yach.electron.ipcrenderer";

// 全局快捷键-注销
electronUnregister(accelerator);

# electronNotify

import { electronNotify } from "yach.electron.ipcrenderer";

// 设置通知内容
electronNotify((type = ""), data);

# electronSetMenu

import { electronSetMenu } from "yach.electron.ipcrenderer";

// 应用内快捷键-设置
electronSetMenu(cmd);

# electronSystemSendTypeChange

import { electronSystemSendTypeChange } from "yach.electron.ipcrenderer";

// System Send Type Change
electronSystemSendTypeChange(win, data);

# electronLogout

import { electronLogout } from "yach.electron.ipcrenderer";

// electron Logout
electronLogout(win, data);

# electronLogoutCloseWindow

import { electronLogoutCloseWindow } from "yach.electron.ipcrenderer";

// Logout close window
electronLogoutCloseWindow(data);

# electronSessionClear

import { electronSessionClear } from "yach.electron.ipcrenderer";

// Session Clear
electronSessionClear();

# electronGetCache

import { electronGetCache } from "yach.electron.ipcrenderer";

// get cache
electronGetCache();

# electronGetCpu

import { electronGetCpu } from "yach.electron.ipcrenderer";

// get cache
electronGetCpu(apicaller, callback);

# electronOpenSystemset

import { electronOpenSystemset } from "yach.electron.ipcrenderer";

// 系统设置-打开
electronOpenSystemset({ apicaller, data });

# electronSystemsetCancellationAll

import { electronSystemsetCancellationAll } from "yach.electron.ipcrenderer";

// 全局快捷键-注销全部
electronSystemsetCancellationAll();

# electronOnElectronLogout

import { electronOnElectronLogout } from "yach.electron.ipcrenderer";

// 系统设置过来的调用退出登录方法
electronOnElectronLogout({ apicaller, callback });

# electronOnSystemTopsearchFocus

import { electronOnSystemTopsearchFocus } from "yach.electron.ipcrenderer";

// on system top search focus
electronOnSystemTopsearchFocus({ apicaller, callback });

# electronOnSystemSendTypeChange

import { electronOnSystemSendTypeChange } from "yach.electron.ipcrenderer";

// on system send type change
electronOnSystemSendTypeChange({ apicaller, callback });

# ipc-upload

# electronFileUpload

import { electronFileUpload } from "yach.electron.ipcrenderer";

// 文件上传
electronFileUpload({
  type,
  apicaller,
  channelid,
  data,
  rescallback,
  progresscallback,
});

# electronClipboardUpload

import { electronClipboardUpload } from "yach.electron.ipcrenderer";

// 剪贴板文件上传
electronClipboardUpload({ apicaller, data, rescallback, progresscallback });

# electronFileUploadDestory

import { electronFileUploadDestory } from "yach.electron.ipcrenderer";

// 取消上传
electronFileUploadDestory(data);

# electronWorkbenchUpload

import { electronWorkbenchUpload } from "yach.electron.ipcrenderer";

// 工作台上传
electronWorkbenchUpload({ apicaller, data, rescallback, progresscallback });

# ipc-version-win

# electronVersionUpdate

import { electronVersionUpdate } from "yach.electron.ipcrenderer";

// version update
electronVersionUpdate(data, callback, progresscallback);

# electronUnzip

import { electronUnzip } from "yach.electron.ipcrenderer";

// unzip
electronUnzip(data, callback);

# electronIncrementInstall

import { electronIncrementInstall } from "yach.electron.ipcrenderer";

// Increment Install
electronIncrementInstall(data, callback);

# electronClientInstall

import { electronClientInstall } from "yach.electron.ipcrenderer";

// Client Install
electronClientInstall(data);

# electronWinClientInstall

import { electronWinClientInstall } from "yach.electron.ipcrenderer";

// Win Client Install
electronWinClientInstall(apicaller, data, callback);

# electronWindowResize

import { electronWindowResize } from "yach.electron.ipcrenderer";

// window resize
electronWindowResize(apicaller, data);

# electronVersionUpdatePause

import { electronVersionUpdatePause } from "yach.electron.ipcrenderer";

// 版本跟新暂停
electronVersionUpdatePause(apicaller, data);

# electronVersionUpdateFiles

import { electronVersionUpdateFiles } from "yach.electron.ipcrenderer";

// electron update dirs
electronVersionUpdateFiles({ apicaller, updatejson }, callback);

# electronRelaunch

import { electronRelaunch } from "yach.electron.ipcrenderer";

// electron Relaunch
electronRelaunch(apicaller, data);

# ipc-window-operation

# show

import { show } from "yach.electron.ipcrenderer";

// 显示窗口
// targetWindow 目标窗口
show(targetWindow);

# hide

import { hide } from "yach.electron.ipcrenderer";

// 隐藏窗口
// targetWindow 目标窗口
hide(targetWindow);

# max

import { max } from "yach.electron.ipcrenderer";

// 最大化窗口
// targetWindow 目标窗口
max(targetWindow);

# min

import { min } from "yach.electron.ipcrenderer";

// 最小化窗口
// targetWindow 目标窗口
min(targetWindow);

# close

import { close } from "yach.electron.ipcrenderer";

// 关闭窗口
// targetWindow 目标窗口
close(targetWindow);

# quit

import { quit } from "yach.electron.ipcrenderer";

// 退出程序
// targetWindow 目标窗口
quit(targetWindow);

# winFocus

import { winFocus } from "yach.electron.ipcrenderer";

// focus
winFocus(win);

# electronBrowserWinFocus

import { electronBrowserWinFocus } from "yach.electron.ipcrenderer";

// browser window focus
electronBrowserWinFocus(apicaller, callbackwin);

# electronBrowserWinBlur

import { electronBrowserWinBlur } from "yach.electron.ipcrenderer";

// browser window blur
electronBrowserWinBlur(apicaller, callbackwin);

# electronMainFocusChangeListen

import { electronMainFocusChangeListen } from "yach.electron.ipcrenderer";

// main focus change listen
electronMainFocusChangeListen(apicaller, callbackwin);

# electronClientPowerChangeListen

import { electronClientPowerChangeListen } from "yach.electron.ipcrenderer";

// client power change listen
electronClientPowerChangeListen(apicaller, callbackwin);

# electronClientPowerGet

import { electronClientPowerGet } from "yach.electron.ipcrenderer";

// client power get
electronClientPowerGet(apicaller, callbackwin);

# electronIsFocus

import { electronIsFocus } from "yach.electron.ipcrenderer";

// electron is focus
electronIsFocus(apicaller, callbackwin);

# electronLangSet

import { electronLangSet } from "yach.electron.ipcrenderer";

// electron language set
electronLangSet(language);

# electronRelaunch

import { electronRelaunch } from "yach.electron.ipcrenderer";

// electron relaunch
electronRelaunch();

# electronOnMainWindowFocusChangeRes

import { electronOnMainWindowFocusChangeRes } from "yach.electron.ipcrenderer";

// On Main Window Focus Change Res
electronOnMainWindowFocusChangeRes(apicaller, callback);

# electronMainWindowLoaded

import { electronMainWindowLoaded } from "yach.electron.ipcrenderer";

// Main Window loaded
electronMainWindowLoaded({ apicaller, data });

# electronCloseOtherWindow

import { electronCloseOtherWindow } from "yach.electron.ipcrenderer";

// close other win
electronCloseOtherWindow(apicaller);

# electronSendToReloadMainWindow

import { electronSendToReloadMainWindow } from "yach.electron.ipcrenderer";

// send to reload main window
electronSendToReloadMainWindow(win);

# electronSystemAppActionDoubleClick

import { electronSystemAppActionDoubleClick } from "yach.electron.ipcrenderer";

// handle default double click action
electronSystemAppActionDoubleClick({ apicaller });

# electronWindowMoveTop

import { electronWindowMoveTop } from "yach.electron.ipcrenderer";

// window move top
electronWindowMoveTop({ apicaller });

# ipc-zhibo

# electronZhiboCheck

import { electronZhiboCheck } from "yach.electron.ipcrenderer";

// zhi bo check
electronZhiboCheck({ apicaller, callback });

# electronZhiboInstall

import { electronZhiboInstall } from "yach.electron.ipcrenderer";

// zhi bo install
electronZhiboInstall({ apicaller, callback });

# version

# 0.1.15.20201015

  1. add user status window open

# 0.1.14.20200925

  1. upade ipc-page , add electronWorkbenchAddTab function for workbench

# 0.1.13.20200924

  1. add electron channel remove listener

# 0.1.12.20200914

  1. add ipc-channel
  2. avoid memory leaks caused by unavailable ipc a. update ipc-upload b. update ipc-download

# 0.1.11.20200903

  1. update ipc-panel
  2. update ipc-window-operation
  3. update ipc-log

# 0.1.10.20200825

  1. update files install
  2. add electronSystemAppActionDoubleClick

# 0.1.9.20200820

Added some modules related to session group and email attachs. Fixed screenshot bugs.

  1. update ipc-page
  2. update ipc-panel
  3. update ipc-screen-shot

# 0.1.8.20200819

  1. update ipc-images
  2. update ipc-message
  3. update ipc-email

# 0.1.7.20200810

  1. add some new functions in some modules
  2. add ipc-debug module
  3. modify electronFileUploadDestory's params in ipc-upload model
  4. add ipc-net module
  5. add ipc-screen-shot module
  6. add ipc-session module
  7. add ipc-zhibo module

# 0.1.6.20200729

  1. update electronNotify's params in ipc-systemset
  2. update readme

# 0.1.5.20200727

  1. add ipc-email
  2. update ipc-file electronCheckFile

# 0.1.3.20200723

  1. update ipc-proxy

# 0.0.6.20200720

  1. ipc-channel-listener
  2. ipc-download
  3. ipc-file
  4. ipc-images
  5. ipc-meeting
  6. ipc-message
  7. ipc-page
  8. ipc-panel
  9. ipc-proxy
  10. ipc-systemset
  11. ipc-upload
  12. ipc-version-win

# 0.0.5.20200717

  1. ipc log add check msg

# 0.0.4.20200705

  1. 更新 readme

# 0.0.3.20200627

  1. ipc window operation

# 0.0.2.20200626

  1. ipc info

# 0.0.1.20200613

  1. init project
  2. electron log add project
foo