Add option to log sleep mode events to VRCX's game log

* log sleep mode change to vrcx (1)

* log sleep mode change to vrcx (2)

* make requested changes

* Various improvements to VRCX logging

* Add contribution

---------

Co-authored-by: Raphii <iam@raphii.co>

Author: sofoxe1

src-core/Cargo.lock

@@ -40,6 +40,7 @@ md5 = "0.8.0"
 mime = "0.3.17"
 mime_guess = "2.0.5"
 nalgebra = "0.33.2"
+named_pipe = "0.4.1"
 oyasumivr-shared = { path = "../src-shared-rust", version = '*' }
 oyasumivr_macros = { path = "./macros" }
 prost = "0.13.5"

src-core/Cargo.toml

@@ -20,6 +20,7 @@ mod system_tray;
 mod telemetry;
 mod utils;
 mod vrc_log_parser;
+mod vrcx;
 
 use std::{mem, sync::atomic::Ordering};
 
@@ -420,5 +421,6 @@ fn configure_command_handlers() -> impl Fn(tauri::ipc::Invoke) -> bool {
         grpc::commands::get_core_grpc_port,
         grpc::commands::get_core_grpc_web_port,
         telemetry::commands::set_telemetry_enabled,
+        vrcx::commands::vrcx_log,
     ]
 }

src-core/src/main.rs

@@ -0,0 +1,33 @@
+use log::debug;
+
+use crate::vrcx::*;
+
+#[tauri::command]
+#[oyasumivr_macros::command_profiling]
+pub async fn vrcx_log(msg: String) -> bool {
+    let sender = &mut VRCX_NORITICATION_SENDER.lock().unwrap();
+    if sender.sender.is_none() && sender.connect().is_err() {
+        debug!("[VRCX] failed to connect to VRCX");
+        return false;
+    }
+    if let Err(err) = sender.send_msg(msg.clone()) {
+        match err {
+            VrcxNotificationSenderError::NotConnected => {
+                if sender.connect().is_err() {
+                    debug!("[VRCX] failed to connect to VRCX");
+                    return false;
+                }
+                if sender.send_msg(msg).is_err() {
+                    debug!("[VRCX] failed to send message to VRCX");
+                    return false;
+                }
+            }
+            VrcxNotificationSenderError::SendFailed(_) => {
+                debug!("[VRCX] failed to send message to VRCX");
+                return false;
+            }
+            VrcxNotificationSenderError::UnableToConnect(_) => unreachable!(),
+        };
+    }
+    return true;
+}

src-core/src/vrcx/commands.rs

@@ -0,0 +1,88 @@
+#![allow(dead_code)]
+pub mod commands;
+pub mod models;
+use models::*;
+use std::{
+    env,
+    io::Write,
+    sync::{LazyLock, Mutex},
+    time::Duration,
+};
+
+use log::warn;
+use named_pipe::PipeClient;
+pub static VRCX_NORITICATION_SENDER: LazyLock<Mutex<NotificationSender>> =
+    LazyLock::new(Mutex::default);
+#[derive(Default)]
+pub struct NotificationSender {
+    sender: Option<PipeClient>,
+}
+
+impl NotificationSender {
+
+    pub fn connect(&mut self) -> Result<(), VrcxNotificationSenderError> {
+        let mut sender = PipeClient::connect_ms(
+            get_pipe_path(),
+            Duration::from_millis(10).as_millis() as u32,
+        )
+        .map_err(VrcxNotificationSenderError::UnableToConnect)?;
+        sender.set_write_timeout(Some(Duration::from_millis(100)));
+        sender.set_read_timeout(Some(Duration::from_millis(100)));
+        self.sender = Some(sender);
+        Ok(())
+    }
+
+    pub fn send_msg(&mut self, msg: String) -> Result<(), VrcxNotificationSenderError> {
+        if let Some(sender) = &mut self.sender {
+            let msg = VrcxMsg {
+                type_: EventType::VrcxMessage,
+                msg_type: Some(MessageType::External),
+                data: Some(msg),
+                notify: false,
+                user_id: None,
+                display_name: Some("OyasumiVR".to_string()),
+            };
+            if let Err(err) =
+                sender.write(format!("{}\0", serde_json::to_string(&msg).unwrap()).as_bytes())
+            {
+                match err.kind() {
+                    std::io::ErrorKind::BrokenPipe => {
+                        self.sender = None;
+                        return Err(VrcxNotificationSenderError::NotConnected);
+                    }
+                    _ => return Err(VrcxNotificationSenderError::SendFailed(err)),
+                };
+            }
+            Ok(())
+        } else {
+            Err(VrcxNotificationSenderError::NotConnected)
+        }
+    }
+
+}
+pub fn init() {
+    //try to connect
+    VRCX_NORITICATION_SENDER.lock().unwrap().connect().ok();
+}
+
+fn get_pipe_path() -> String {
+    let username_env_name = {
+        if cfg!(target_os = "windows") {
+            "username".to_string()
+        } else {
+            "USER".to_string()
+        }
+    };
+    let hash = env::var(&username_env_name)
+        .unwrap_or_else(|err| {
+            warn!(
+                "[Core] failed getting '{}' enviroment variable: {:?}",
+                username_env_name, err
+            );
+            "".to_string()
+        })
+        .chars()
+        .map(|x| x as u32)
+        .sum::<u32>();
+    format!("\\\\.\\pipe\\vrcx-ipc-{}", hash)
+}

src-core/src/vrcx/mod.rs

@@ -0,0 +1,40 @@
+use serde::Serialize;
+pub enum VrcxNotificationSenderError {
+    UnableToConnect(std::io::Error),
+    SendFailed(std::io::Error),
+    NotConnected,
+}
+#[derive(Serialize, Debug)]
+pub enum EventType {
+    OnEvent,
+    OnOperationResponse,
+    OnOperationRequest,
+    VRCEvent,
+    Event7List,
+    VrcxMessage,
+    Ping,
+    MsgPing,
+    LaunchCommand,
+    VRCXLaunch,
+}
+#[derive(Serialize, Debug)]
+pub enum MessageType {
+    CustomTag,
+    ClearCustomTag,
+    Noty,
+    External,
+}
+#[derive(Serialize, Debug)]
+pub struct VrcxMsg {
+    #[serde(rename = "type")]
+    pub type_: EventType,
+    #[serde(rename = "MsgType")]
+    pub msg_type: Option<MessageType>,
+    #[serde(rename = "Data")]
+    pub data: Option<String>,
+    #[serde(rename = "UserId")]
+    pub user_id: Option<String>,
+    #[serde(rename = "DisplayName")]
+    pub display_name: Option<String>,
+    pub notify: bool,
+}

src-core/src/vrcx/models.rs

@@ -260,6 +260,7 @@ import { LighthouseForceStatePopoverComponent } from './components/lighthouse-fo
 import { OyasumiVRSteamVRDevicePowerAutomationsService } from './services/power-automations/oyasumivr-steamvr-device-power-automations.service';
 import { SleepDevicePowerAutomationsService } from './services/power-automations/sleep-device-power-automations.service';
 import { TurnOffDevicesWhenChargingAutomationService } from './services/power-automations/turn-off-devices-when-charging-automation.service';
+import { VRCXService } from './services/vrcx.service';
 
 [
   localeEN,
@@ -489,6 +490,7 @@ export class AppModule {
     private hotkeyService: HotkeyService,
     private hotkeyHandlerService: HotkeyHandlerService,
     private discordService: DiscordService,
+    private vrcxService: VRCXService,
     private mqttService: MqttService,
     private mqttDiscoveryService: MqttDiscoveryService,
     private mqttIntegrationService: MqttIntegrationService,
@@ -646,6 +648,8 @@ export class AppModule {
             await this.logInit('Initializing Steam', this.steamService.init()),
             // Initialize Discord support
             await this.logInit('Initializing Discord', this.discordService.init()),
+            // Initialize VRCX support
+            await this.logInit('Initializing VRCX', this.vrcxService.init()),
             // Initialize IPC
             await this.logInit('Initializing IPC', this.ipcService.init()).then(async () => {
               await this.logInit('Initializing overlay services', this.overlayService.init());

src-ui/app/app.module.ts

@@ -59,8 +59,12 @@ export interface AppSettings {
   bigscreenBeyondMaxBrightness: number; // User limit
   bigscreenBeyondUnsafeBrightness: boolean; // Allow brightness above 150%
   bigscreenBeyondBrightnessFanSafety: boolean; // Force fan to 100% if brightness is above 100%
+  // VRCX
+  vrcxLogsEnabled: VRCXEventLogType[];
 }
 
+export type VRCXEventLogType = 'SleepMode';
+
 export type DiscordActivityMode = 'ENABLED' | 'ONLY_ASLEEP' | 'DISABLED';
 
 export type QuitWithSteamVRMode = 'DISABLED' | 'IMMEDIATELY' | 'AFTERDELAY';
@@ -143,6 +147,8 @@ export const APP_SETTINGS_DEFAULT: AppSettings = {
   bigscreenBeyondMaxBrightness: 150,
   bigscreenBeyondUnsafeBrightness: false,
   bigscreenBeyondBrightnessFanSafety: true,
+  // VRCX
+  vrcxLogsEnabled: ['SleepMode'],
 };
 
 export type ExecutableReferenceStatus =

src-ui/app/models/settings.ts

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import { SleepService } from './sleep.service';
+import { distinctUntilChanged, skip } from 'rxjs';
+import { invoke } from '@tauri-apps/api/core';
+import { TranslateService } from '@ngx-translate/core';
+import { SleepPreparationService } from './sleep-preparation.service';
+import { AppSettingsService } from './app-settings.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class VRCXService {
+  constructor(
+    private sleep: SleepService,
+    private sleepPreparation: SleepPreparationService,
+    private translate: TranslateService,
+    private appSettingsService: AppSettingsService
+  ) {}
+
+  async init() {
+    // Log sleep mode to VRCX
+    this.sleep.mode.pipe(skip(1), distinctUntilChanged()).subscribe(async (sleepMode) => {
+      if (this.appSettingsService.settingsSync.vrcxLogsEnabled.includes('SleepMode')) {
+        await invoke<boolean>('vrcx_log', {
+          msg: this.translate.instant(
+            `settings.integrations.vrcx.logs.${sleepMode ? 'onSleepEnable' : 'onSleepDisable'}`
+          ),
+        });
+      }
+    });
+    // Log sleep preparation to VRCX
+    this.sleepPreparation.onSleepPreparation.subscribe(async () => {
+      if (this.appSettingsService.settingsSync.vrcxLogsEnabled.includes('SleepMode')) {
+        await invoke<boolean>('vrcx_log', {
+          msg: this.translate.instant('settings.integrations.vrcx.logs.onSleepPreparation'),
+        });
+      }
+    });
+  }
+}

src-ui/app/services/vrcx.service.ts

@@ -65,6 +65,12 @@
             <span translate>about.contributionType.programming</span></span
           >
         </div>
+        <div class="contributor-list-entry">
+          <span
+            ><a href="https://github.com/sofoxe1" target="_blank">sofoxe1</a> |
+            <span translate>about.contributionType.programming</span></span
+          >
+        </div>
         <div class="contributor-list-entry">
           <span>spaecd | <span translate>about.contributionType.soundFx</span></span>
         </div>