@linanw/homebridge-mijia-remote-camera 0.1.2 → 0.2.0

package/lib/matter-media.mjs

@@ -0,0 +1,296 @@
+import { RTCPeerConnection, MediaStreamTrack, RTCRtpCodecParameters } from 'werift';
+import { createSocket } from 'node:dgram';
+import { spawn } from 'node:child_process';
+import { request as httpRequest } from 'node:http';
+
+const fault = reason => Object.assign(new Error(reason), { reason });
+const integer = (value, fallback, min, max) => Number.isInteger(value) && value >= min && value <= max ? value : fallback;
+const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+const timer = (callback, ms) => { const value = setTimeout(callback, ms); value.unref(); return value; };
+const isRtp = bytes => Buffer.isBuffer(bytes) && bytes.length >= 12 && bytes.length <= 2048 && (bytes[0] >> 6) === 2;
+function localUrl(value, paths) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== 'http:' || !['127.0.0.1', '[::1]'].includes(url.hostname) || url.username || url.password
+      || url.search || url.hash || !paths.includes(url.pathname) || !/^\d+$/.test(url.port) || +url.port < 1024 || +url.port > 65535) throw 0;
+    return url.href;
+  } catch { throw fault('source_invalid'); }
+}
+function audioSource(value, talk = false) {
+  const url = localUrl(value?.url, talk ? ['/talk.pcm', '/talk.ogg'] : ['/audio.wav', '/audio.ogg']);
+  const format = url.endsWith('.pcm') ? 's16le' : url.endsWith('.ogg') ? 'ogg' : 'wav';
+  if ((value.format && value.format !== format) || ![8000, 16000, 24000, 48000].includes(value.sampleRate) || ![1, 2].includes(value.channels)
+    || (talk && (format === 's16le' ? value.sampleRate !== 8000 || value.channels !== 1 : value.sampleRate !== 48000 || value.channels !== 2))) throw fault('audio_source_invalid');
+  return { url, format, sampleRate: value.sampleRate, channels: value.channels };
+}
+function sdp(value) {
+  if (typeof value !== 'string' || value.length > 65536 || !value.startsWith('v=0') || !value.includes('a=fingerprint:') || !value.includes('a=ice-ufrag:')) throw fault('invalid_sdp');
+  return value;
+}
+function jpegSize(data) {
+  if (data.length < 10 || data[0] !== 0xff || data[1] !== 0xd8) throw fault('snapshot_invalid');
+  for (let offset = 2; offset + 4 <= data.length;) {
+    if (data[offset++] !== 0xff) throw fault('snapshot_invalid');
+    while (offset < data.length && data[offset] === 0xff) offset++;
+    if (offset + 3 > data.length) break;
+    const marker = data[offset++];
+    if (marker === 0xd9 || marker === 0xda) break;
+    if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd8)) continue;
+    const length = data.readUInt16BE(offset);
+    if (length < 2 || offset + length > data.length) break;
+    if ([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf].includes(marker) && length >= 8) {
+      const height = data.readUInt16BE(offset + 3), width = data.readUInt16BE(offset + 5);
+      if (width && height && width <= 4096 && height <= 4096) return { width, height };
+      break;
+    }
+    offset += length;
+  }
+  throw fault('snapshot_invalid');
+}
+function codecConfig() {
+  return { video: [new RTCRtpCodecParameters({ mimeType: 'video/H264', clockRate: 90000, payloadType: 96,
+    parameters: 'level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f',
+    rtcpFeedback: [{ type: 'nack' }, { type: 'nack', parameter: 'pli' }] })],
+  audio: [new RTCRtpCodecParameters({ mimeType: 'audio/opus', clockRate: 48000, channels: 2, payloadType: 111,
+    parameters: 'minptime=10;useinbandfec=1;stereo=0;sprop-stereo=0' })] };
+}
+
+/** Packet-oriented WebRTC transport. The bundled FFmpeg owns media coding; only
+ * loopback UDP carries clear RTP. ICE, DTLS, SRTP and retransmission use werift. */
+export class MatterMedia {
+  constructor({ runtime, ffmpegPath, config = {}, snapshotDelegate, spawnProcess = spawn, connectTimeoutMs = 20000, mediaTimeoutMs = 15000 } = {}) {
+    this.runtime = runtime; this.ffmpegPath = ffmpegPath || runtime?.ffmpegPath || config.ffmpegPath || 'ffmpeg';
+    this.config = config; this.snapshotDelegate = snapshotDelegate; this.spawnProcess = spawnProcess;
+    this.connectTimeoutMs = connectTimeoutMs; this.mediaTimeoutMs = mediaTimeoutMs;
+    this.microphoneMuted = config.enableAudio === false; this.speakerMuted = config.enableAudio === false || config.enableTalkback === false;
+    this.microphoneVolume = 100; this.speakerVolume = 100; this.closed = false; this.session = undefined;
+    this.counters = { sessions: 0, failures: 0, videoPackets: 0, audioPackets: 0, talkPackets: 0, talkBytes: 0, state: 'idle' };
+  }
+  status() { return { ...this.counters, active: Boolean(this.session), microphoneMuted: this.microphoneMuted, speakerMuted: this.speakerMuted }; }
+  emit(session, state) {
+    this.counters.state = state;
+    try { session.onState?.(state); } catch {}
+  }
+  alive(session) { return this.session === session && !session.closed && !this.closed; }
+  fail(session, reason = 'media_unavailable') {
+    if (!this.alive(session)) return;
+    this.counters.failures++; this.counters.lastFailure = reason; this.emit(session, 'failed'); void this.closeSession(session.id);
+  }
+  async createSession({ id, offer, video, audio, onCandidate, onState, iceServers, iceTransportPolicy } = {}) {
+    if (this.closed) throw fault('closed');
+    if (this.session) throw fault('session_busy');
+    if (iceTransportPolicy !== undefined && iceTransportPolicy !== 'all') throw fault('relay_unavailable');
+    if (iceServers !== undefined && (!Array.isArray(iceServers) || iceServers.length)) throw fault('ice_servers_unsupported');
+    if ((typeof id !== 'string' && typeof id !== 'number') || !String(id).length || String(id).length > 160 || (!video && !audio)) throw fault('invalid_session');
+    if ((video && (typeof video !== 'object' || (video.codec !== undefined && video.codec !== 'h264')))
+      || (audio && (typeof audio !== 'object' || (audio.codec !== undefined && audio.codec !== 'opus')))) throw fault('unsupported_codec');
+    if (offer !== undefined) sdp(offer);
+    const codecs = codecConfig();
+    const peer = new RTCPeerConnection({ codecs, bundlePolicy: 'max-bundle', iceServers: [], iceUseTcp: false,
+      iceAdditionalHostAddresses: this.config.matterLoopbackIce === true ? ['127.0.0.1'] : undefined });
+    const session = { id, peer, onCandidate, onState, sockets: new Set(), jobs: new Set(), candidateCount: 0,
+      video: video ? { width: integer(video.width, 640, 2, 1280), height: integer(video.height, 360, 2, 720),
+        frameRate: integer(video.frameRate, 15, 1, 30), bitRate: integer(video.bitRate, 512000, 64000, 2000000),
+        keyFrameInterval: integer(video.keyFrameInterval, 1000, 200, 4000) } : undefined,
+      audio: audio && this.config.enableAudio !== false ? { channels: 1, bitRate: integer(audio.bitRate, 24000, 16000, 64000) } : undefined };
+    if (!session.video && !session.audio) { await peer.close(); throw fault('audio_disabled'); }
+    this.session = session; this.counters.sessions++; this.emit(session, 'connecting');
+    session.connectTimer = timer(() => this.fail(session, 'webrtc_timeout'), this.connectTimeoutMs);
+    session.lifeTimer = timer(() => this.closeSession(id), 30 * 60 * 1000);
+    peer.onIceCandidate.subscribe(candidate => {
+      if (!candidate || !this.alive(session) || session.candidateCount++ >= 128) return;
+      try { onCandidate?.({ candidate: candidate.candidate, sdpMid: candidate.sdpMid ?? undefined, sdpMLineIndex: candidate.sdpMLineIndex ?? undefined }); } catch {}
+    });
+    peer.connectionStateChange.subscribe(state => {
+      if (!this.alive(session)) return;
+      if (state === 'connected') {
+        clearTimeout(session.connectTimer); clearTimeout(session.disconnectTimer); this.emit(session, 'connected');
+        if (!session.started) { session.started = true; void this.startMedia(session).catch(() => this.fail(session)); }
+      } else if (state === 'failed' || state === 'closed') this.fail(session, 'webrtc_failed');
+      else if (state === 'disconnected') { clearTimeout(session.disconnectTimer); session.disconnectTimer = timer(() => this.fail(session, 'webrtc_disconnected'), 5000); }
+    });
+    peer.onTrack.subscribe(track => {
+      if (track.kind === 'audio') track.onReceiveRtp.subscribe(packet => this.receiveTalk(session, packet));
+    });
+    try {
+      if (offer !== undefined) await peer.setRemoteDescription({ type: 'offer', sdp: offer });
+      for (const [kind, enabled] of [['video', session.video], ['audio', session.audio]]) {
+        if (!enabled) continue;
+        const track = new MediaStreamTrack({ kind, codec: codecs[kind][0] }); session[`${kind}Track`] = track;
+        const existing = offer !== undefined ? peer.getTransceivers().find(t => t.kind === kind && !t.stopped) : undefined;
+        const direction = kind === 'audio' && this.config.enableTalkback !== false ? 'sendrecv' : 'sendonly';
+        if (existing) { await existing.sender.replaceTrack(track); existing.direction = direction; session[`${kind}Sender`] = existing.sender; }
+        else if (offer === undefined) session[`${kind}Sender`] = peer.addTransceiver(track, { direction }).sender;
+        else throw fault('media_not_offered');
+      }
+      await peer.setLocalDescription(offer !== undefined ? await peer.createAnswer() : await peer.createOffer());
+      if (!this.alive(session)) throw fault('session_closed');
+      return offer !== undefined ? { answer: peer.localDescription.sdp } : { offer: peer.localDescription.sdp };
+    } catch (error) { await this.closeSession(id); throw fault(error?.reason === 'media_not_offered' ? 'media_not_offered' : 'negotiation_failed'); }
+  }
+  getSession(id) { const session = this.session; if (!session || session.id !== id || session.closed) throw fault('unknown_session'); return session; }
+  async provideAnswer(id, value) {
+    const session = this.getSession(id); sdp(value);
+    if (session.peer.signalingState !== 'have-local-offer') throw fault('invalid_session_state');
+    try { await session.peer.setRemoteDescription({ type: 'answer', sdp: value }); } catch { this.fail(session, 'negotiation_failed'); throw fault('negotiation_failed'); }
+  }
+  async addCandidates(id, candidates) {
+    const session = this.getSession(id);
+    if (!Array.isArray(candidates) || candidates.length > 32 || (session.remoteCandidates || 0) + candidates.length > 128) throw fault('invalid_candidates');
+    for (const value of candidates) {
+      if (!value || typeof value.candidate !== 'string' || value.candidate.length > 2048
+        || (value.candidate && !value.candidate.startsWith('candidate:')) || (value.sdpMid != null && typeof value.sdpMid !== 'string')) throw fault('invalid_candidates');
+      try { await session.peer.addIceCandidate({ candidate: value.candidate, sdpMid: value.sdpMid ?? undefined, sdpMLineIndex: value.sdpMLineIndex ?? value.sdpmLineIndex }); }
+      catch { throw fault('invalid_candidates'); }
+    }
+    session.remoteCandidates = (session.remoteCandidates || 0) + candidates.length;
+  }
+  async socket(session) {
+    const socket = createSocket('udp4'); session.sockets.add(socket);
+    socket.on('error', () => this.fail(session, 'udp_error'));
+    await new Promise((resolve, reject) => { socket.once('error', reject); socket.bind(0, '127.0.0.1', resolve); });
+    if (!this.alive(session)) { socket.close(); throw fault('session_closed'); }
+    return socket;
+  }
+  job(session, args, failure = true) {
+    let child;
+    try { child = this.spawnProcess(this.ffmpegPath, ['-hide_banner', '-nostdin', '-loglevel', 'error', ...args], { stdio: ['pipe', 'pipe', 'pipe'] }); }
+    catch { throw fault('ffmpeg_unavailable'); }
+    session.jobs.add(child); child.stdin?.on('error', () => {}); child.stdout?.on('error', () => {});
+    child.stderr?.on('data', () => {}); child.on('error', () => { if (failure) this.fail(session, 'ffmpeg_unavailable'); });
+    child.once('close', () => { session.jobs.delete(child); if (failure && this.alive(session) && !child.intentionalStop) this.fail(session, 'ffmpeg_exit'); });
+    return child;
+  }
+  kill(session, child) {
+    if (!child) return; child.intentionalStop = true; session.jobs.delete(child);
+    try { child.kill('SIGTERM'); } catch {}
+    timer(() => { if (child.exitCode === null && child.signalCode === null) { try { child.kill('SIGKILL'); } catch {} } }, 1500);
+  }
+  async startMedia(session) {
+    if (!this.alive(session)) return;
+    if ((session.video && !session.videoSender.codec) || (session.audio && !session.audioSender.codec)) throw fault('codec_unavailable');
+    if (session.video) {
+      const source = localUrl(await this.runtime.ensureReady({ timeoutMs: 5000 }), ['/cam.ts']);
+      if (!this.alive(session)) return;
+      const socket = await this.socket(session), v = session.video;
+      session.videoDeadline = timer(() => this.fail(session, 'video_timeout'), this.mediaTimeoutMs);
+      socket.on('message', bytes => { if (!this.alive(session) || !isRtp(bytes) || (bytes[1] & 0x7f) !== 96) return; clearTimeout(session.videoDeadline); this.counters.videoPackets++; session.videoTrack.writeRtp(bytes); });
+      this.job(session, ['-rw_timeout', '8000000', '-analyzeduration', '1000000', '-probesize', '2000000', '-f', 'mpegts', '-i', source,
+        '-map', '0:v:0', '-an', '-sn', '-dn', '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-profile:v', 'baseline', '-level:v', '3.1',
+        '-preset', 'ultrafast', '-tune', 'zerolatency', '-threads', '2', '-vf', `scale=${v.width}:${v.height}:force_original_aspect_ratio=decrease,scale=trunc(iw/2)*2:trunc(ih/2)*2,pad=${v.width}:${v.height}:(ow-iw)/2:(oh-ih)/2`,
+        '-r', String(v.frameRate), '-b:v', String(v.bitRate), '-maxrate', String(v.bitRate), '-bufsize', String(v.bitRate * 2),
+        '-g', String(Math.max(1, Math.round(v.frameRate * v.keyFrameInterval / 1000))), '-bf', '0', '-x264-params', 'repeat-headers=1',
+        '-payload_type', '96', '-f', 'rtp', `rtp://127.0.0.1:${socket.address().port}?pkt_size=1200`]);
+    }
+    if (session.audio) void this.startAudio(session);
+  }
+  async startAudio(session) {
+    if (!this.alive(session) || this.microphoneMuted || session.audioChild || session.audioStarting || !session.audio) return;
+    const generation = session.audioGeneration || 0; session.audioStarting = true;
+    try {
+      const value = await this.runtime.audioSource?.();
+      if (!this.alive(session) || this.microphoneMuted || generation !== (session.audioGeneration || 0)) return;
+      if (!value) { this.pollAudio(session, 2000); return; }
+      const source = audioSource(value), socket = await this.socket(session); session.audioSocket = socket;
+      if (!this.alive(session) || this.microphoneMuted || generation !== (session.audioGeneration || 0)) {
+        session.sockets.delete(socket); try { socket.close(); } catch {} return;
+      }
+      session.audioSender.replaceRTP({ sequenceNumber: 0, timestamp: 0 }, true, 960);
+      socket.on('message', bytes => { if (this.alive(session) && !this.microphoneMuted && generation === (session.audioGeneration || 0) && isRtp(bytes) && (bytes[1] & 0x7f) === 111) { this.counters.audioPackets++; session.audioTrack.writeRtp(bytes); } });
+      session.audioChild = this.job(session, ['-rw_timeout', '8000000', '-f', source.format, '-i', source.url, '-map', '0:a:0', '-vn', '-sn', '-dn',
+        '-af', `volume=${this.microphoneVolume / 100}`, '-c:a', 'libopus', '-ar', '48000', '-ac', '1', '-application', 'lowdelay', '-frame_duration', '20',
+        '-b:a', String(session.audio.bitRate), '-payload_type', '111', '-f', 'rtp', `rtp://127.0.0.1:${socket.address().port}?pkt_size=1200`], false);
+      const child = session.audioChild;
+      child.on('error', () => this.restartAudio(session)); child.once('close', () => { if (session.audioChild === child) this.restartAudio(session); });
+    } catch { if (this.alive(session)) this.pollAudio(session, 2000); }
+    finally {
+      session.audioStarting = false;
+      if (this.alive(session) && !this.microphoneMuted && !session.audioChild && !session.audioPoll)
+        this.pollAudio(session, 500);
+    }
+  }
+  pollAudio(session, ms) {
+    clearTimeout(session.audioPoll);
+    session.audioPoll = timer(() => { session.audioPoll = undefined; void this.startAudio(session); }, ms);
+  }
+  stopAudio(session) {
+    session.audioGeneration = (session.audioGeneration || 0) + 1; clearTimeout(session.audioPoll); session.audioPoll = undefined;
+    this.kill(session, session.audioChild); session.audioChild = undefined;
+    if (session.audioSocket) { session.sockets.delete(session.audioSocket); try { session.audioSocket.close(); } catch {} session.audioSocket = undefined; }
+  }
+  restartAudio(session) { this.stopAudio(session); if (this.alive(session) && !this.microphoneMuted) this.pollAudio(session, 500); }
+  receiveTalk(session, packet) {
+    if (!this.alive(session) || this.speakerMuted || !session.audio || this.config.enableTalkback === false) return;
+    this.counters.talkPackets++;
+    if (!session.talk) { session.talk = { queue: [], size: 0, closed: false }; void this.startTalk(session, session.talk); }
+    const talk = session.talk; clearTimeout(talk.idleTimer); talk.idleTimer = timer(() => this.stopTalk(session), 2500);
+    const copy = packet.clone(); copy.header.extensions = []; copy.header.payloadType = 111;
+    const bytes = copy.serialize();
+    if (talk.ready && talk.socket) talk.socket.send(bytes, talk.port, '127.0.0.1', () => {});
+    else if (talk.size + bytes.length <= 65536) { talk.queue.push(bytes); talk.size += bytes.length; }
+    else this.stopTalk(session);
+  }
+  async startTalk(session, talk) {
+    try {
+      const value = await this.runtime.talkSource?.(); if (!value) throw fault('talkback_unavailable');
+      const source = audioSource(value, true); if (!this.alive(session) || talk.closed || this.speakerMuted) return;
+      const reservation = await this.socket(session); talk.port = reservation.address().port;
+      session.sockets.delete(reservation); await new Promise(resolve => reservation.close(resolve));
+      talk.socket = await this.socket(session);
+      if (talk.closed || this.speakerMuted) { session.sockets.delete(talk.socket); talk.socket.close(); return; }
+      const description = `v=0\r\no=- 0 0 IN IP4 127.0.0.1\r\ns=Talk\r\nc=IN IP4 127.0.0.1\r\nt=0 0\r\nm=audio ${talk.port} RTP/AVP 111\r\na=rtpmap:111 opus/48000/2\r\n`;
+      const output = source.format === 's16le' ? ['-c:a', 'pcm_s16le', '-ar', '8000', '-ac', '1', '-f', 's16le']
+        : ['-c:a', 'libopus', '-application', 'lowdelay', '-frame_duration', '40', '-ar', '48000', '-ac', '2', '-f', 'ogg', '-page_duration', '40000'];
+      talk.child = this.job(session, ['-protocol_whitelist', 'file,pipe,udp,rtp', '-analyzeduration', '0', '-probesize', '32768', '-f', 'sdp', '-i', 'pipe:0',
+        '-map', '0:a:0', '-vn', '-sn', '-dn', '-af', `volume=${this.speakerVolume / 100}`, ...output, 'pipe:1'], false);
+      talk.child.stdin.end(description);
+      talk.post = httpRequest(source.url, { method: 'POST', headers: { 'Content-Type': source.format === 'ogg' ? 'audio/ogg' : 'application/octet-stream' } }, response => {
+        if (response.statusCode !== 200) this.stopTalk(session, talk); response.resume();
+      });
+      talk.post.on('error', () => this.stopTalk(session, talk)); talk.post.setTimeout(10000, () => this.stopTalk(session, talk));
+      talk.child.stdout.on('data', bytes => {
+        if (talk.closed || !this.alive(session) || this.speakerMuted) return;
+        if (talk.post.writableLength > 262144) { this.stopTalk(session, talk); return; }
+        this.counters.talkBytes += bytes.length;
+        if (!talk.post.write(bytes)) { talk.child.stdout.pause(); talk.post.once('drain', () => { if (!talk.closed) talk.child.stdout.resume(); }); }
+      });
+      talk.child.on('error', () => this.stopTalk(session, talk)); talk.child.once('close', () => { if (!talk.closed) this.stopTalk(session, talk); });
+      talk.readyTimer = timer(() => {
+        if (!this.alive(session) || talk.closed || this.speakerMuted) return;
+        talk.ready = true; for (const bytes of talk.queue) talk.socket.send(bytes, talk.port, '127.0.0.1', () => {});
+        talk.queue.length = 0; talk.size = 0;
+      }, 200);
+    } catch { this.stopTalk(session, talk); }
+  }
+  stopTalk(session, expected) {
+    const talk = session.talk; if (!talk || (expected && expected !== talk)) return; session.talk = undefined; talk.closed = true;
+    clearTimeout(talk.idleTimer); clearTimeout(talk.readyTimer); talk.queue.length = 0; talk.size = 0;
+    this.kill(session, talk.child); talk.post?.end(); timer(() => talk.post?.destroy(), 300);
+    if (talk.socket) { session.sockets.delete(talk.socket); try { talk.socket.close(); } catch {} }
+  }
+  setMicrophoneMuted(value) { this.microphoneMuted = value === true || this.config.enableAudio === false; if (this.session) { this.stopAudio(this.session); if (!this.microphoneMuted && this.session.started) void this.startAudio(this.session); } }
+  setSpeakerMuted(value) { this.speakerMuted = value === true || this.config.enableAudio === false || this.config.enableTalkback === false; if (this.session) this.stopTalk(this.session); }
+  setMicrophoneVolume(value) { this.microphoneVolume = clamp(integer(value, 100, 0, 100), 0, 100); if (this.session) this.restartAudio(this.session); }
+  setSpeakerVolume(value) { this.speakerVolume = clamp(integer(value, 100, 0, 100), 0, 100); if (this.session) this.stopTalk(this.session); }
+  async snapshot({ width = 320, height = 180 } = {}) {
+    if (this.closed) throw fault('closed');
+    width = integer(width, 320, 2, 1280); height = integer(height, 180, 2, 720);
+    if (!this.snapshotDelegate?.handleSnapshotRequest) throw fault('snapshot_unavailable');
+    const data = await new Promise((resolve, reject) => this.snapshotDelegate.handleSnapshotRequest({ width, height }, (error, data) => error ? reject(fault('snapshot_unavailable')) : resolve(data)));
+    if (!Buffer.isBuffer(data) || data.length > 8 * 1024 * 1024) throw fault('snapshot_invalid');
+    return { data, ...jpegSize(data) };
+  }
+  async closeSession(id) {
+    const session = this.session; if (!session || session.id !== id || session.closed) return;
+    session.closed = true; this.session = undefined;
+    for (const name of ['connectTimer', 'disconnectTimer', 'lifeTimer', 'videoDeadline']) clearTimeout(session[name]);
+    this.stopAudio(session); this.stopTalk(session);
+    for (const child of [...session.jobs]) this.kill(session, child);
+    for (const socket of session.sockets) { try { socket.close(); } catch {} } session.sockets.clear();
+    session.videoTrack?.stop(); session.audioTrack?.stop();
+    try { await session.peer.close(); } catch {}
+    this.emit(session, 'closed');
+  }
+  async close() { this.closed = true; if (this.session) await this.closeSession(this.session.id); }
+}
+export const createMatterMedia = options => new MatterMedia(options);

package/lib/matter-service.mjs

@@ -0,0 +1,117 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+
+import { safeMatterStatus } from './matter-diagnostics.mjs';
+export { safeMatterStatus } from './matter-diagnostics.mjs';
+const REASONS = new Set(['matter_disabled', 'matter_not_ready', 'matter_start_failed', 'matter_port_in_use',
+  'matter_configuration_invalid', 'matter_pairing_unavailable', 'matter_window_failed', 'matter_closed']);
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const bounded = (value, fallback, min, max) => Number.isInteger(value) && value >= min && value <= max ? value : fallback;
+const failure = reason => Object.assign(new Error(REASONS.has(reason) ? reason : 'matter_start_failed'), {
+  reason: REASONS.has(reason) ? reason : 'matter_start_failed',
+});
+
+/** Optional Matter endpoint. Its failure never prevents the existing HomeKit accessory from starting. */
+export class MatterService {
+  constructor({ runtime, delegate, config = {}, storagePath, name, serialNumber, deviceFactory, mediaFactory } = {}) {
+    this.runtime = runtime; this.delegate = delegate; this.config = config;
+    this.storagePath = storagePath; this.name = name; this.serialNumber = serialNumber;
+    this.deviceFactory = deviceFactory; this.mediaFactory = mediaFactory;
+    this.enabled = config.enableMatter === true; this.state = this.enabled ? 'stopped' : 'disabled';
+    this.reason = this.enabled ? undefined : 'matter_disabled'; this.closed = false;
+  }
+  status() {
+    let raw = {}, media;
+    try { raw = this.device?.status?.() ?? {}; } catch {}
+    try { media = this.media?.status?.(); } catch {}
+    return safeMatterStatus({ ...raw, enabled: this.enabled, running: this.state === 'ready' && raw.running === true,
+      state: this.state, reason: this.reason, media });
+  }
+  start() {
+    if (this.closed) return Promise.reject(failure('matter_closed'));
+    if (!this.enabled) return Promise.resolve(this.status());
+    if (this.starting) return this.starting;
+    if (this.state === 'ready') return Promise.resolve(this.status());
+    this.starting = this._start().finally(() => { this.starting = undefined; });
+    return this.starting;
+  }
+  async _start() {
+    this.state = 'starting'; this.reason = undefined;
+    try {
+      const port = this.config.matterPort ?? 5540;
+      const networkInterface = this.config.matterInterface ?? 'eth0';
+      if (!Number.isInteger(port) || port < 1024 || port > 65535 || typeof networkInterface !== 'string'
+        || !/^[A-Za-z0-9_.:-]{1,40}$/.test(networkInterface) || typeof this.storagePath !== 'string')
+        throw failure('matter_configuration_invalid');
+      const createMedia = this.mediaFactory ?? (await import('./matter-media.mjs')).createMatterMedia;
+      if (this.closed) throw failure('matter_closed');
+      this.media = await createMedia({ runtime: this.runtime, ffmpegPath: this.runtime.ffmpegPath,
+        config: this.config, snapshotDelegate: this.delegate });
+      const createDevice = this.deviceFactory ?? (await import('./matter-device.mjs')).createMatterDevice;
+      if (this.closed) throw failure('matter_closed');
+      const selected = this.runtime.selected?.();
+      const serialNumber = this.serialNumber || `MiCam-${createHash('sha256').update(String(selected?.deviceId || '')).digest('hex').slice(0, 16)}`;
+      this.device = await createDevice({ storagePath: path.resolve(this.storagePath), name: this.name,
+        serialNumber, networkInterface, port, runtime: this.runtime, media: this.media,
+        config: { width: bounded(this.config.maxWidth, 640, 160, 1280) & ~1,
+          height: bounded(this.config.maxHeight, 360, 120, 720) & ~1,
+          frameRate: bounded(this.config.maxFPS, 12, 1, 25),
+          bitRate: bounded(this.config.maxBitrate, 700, 100, 2000) * 1000,
+          maxStreams: 1, enableAudio: this.config.enableAudio !== false,
+          enableTalkback: this.config.enableAudio !== false && this.config.enableTalkback !== false,
+          nightVision: this.config.enableNightVision !== false
+            && ['chuangmi.camera.061a01', 'chuangmi.camera.061a03'].includes(selected?.model) } });
+      if (this.closed) throw failure('matter_closed');
+      await this.device.start();
+      if (this.closed) throw failure('matter_closed');
+      this.state = 'ready';
+      this.statusListener = value => {
+        if (value?.ready !== true) void Promise.resolve().then(() => this.device?.closeSessions?.()).catch(() => {});
+      };
+      this.runtime.on?.('status', this.statusListener);
+      return this.status();
+    } catch (error) {
+      await this._release();
+      this.device = this.media = undefined;
+      const reason = REASONS.has(error?.reason) ? error.reason
+        : error?.code === 'EADDRINUSE' ? 'matter_port_in_use' : 'matter_start_failed';
+      this.state = this.closed ? 'stopped' : 'failed'; this.reason = reason;
+      throw failure(reason);
+    }
+  }
+  pairing() {
+    if (!this.enabled) throw failure('matter_disabled');
+    if (this.closed || this.state !== 'ready' || !this.device) throw failure('matter_not_ready');
+    const value = this.device.pairing();
+    if (!object(value) || typeof value.manualPairingCode !== 'string' || !/^(?:\d{11}|\d{21})$/.test(value.manualPairingCode)
+      || typeof value.qrPairingCode !== 'string' || !/^MT:[0-9A-Z.:-]{10,250}$/.test(value.qrPairingCode))
+      throw failure('matter_pairing_unavailable');
+    return { manualPairingCode: value.manualPairingCode, qrPairingCode: value.qrPairingCode };
+  }
+  async openCommissioningWindow() {
+    if (!this.enabled) throw failure('matter_disabled');
+    if (this.closed || this.state !== 'ready' || !this.device) throw failure('matter_not_ready');
+    try { await this.device.openCommissioningWindow(); return this.status(); }
+    catch { throw failure('matter_window_failed'); }
+  }
+  async closeCommissioningWindow() {
+    if (!this.enabled) throw failure('matter_disabled');
+    if (this.closed || this.state !== 'ready' || !this.device?.closeCommissioningWindow) throw failure('matter_not_ready');
+    try { await this.device.closeCommissioningWindow(); return this.status(); }
+    catch { throw failure('matter_window_failed'); }
+  }
+  async _release() {
+    if (this.statusListener) this.runtime.off?.('status', this.statusListener);
+    this.statusListener = undefined;
+    for (const value of [this.device, this.media]) { try { await value?.close?.(); } catch {} }
+  }
+  close() {
+    if (this.closing) return this.closing;
+    this.closed = true;
+    return this.closing = (async () => {
+      await this.starting?.catch(() => {});
+      await this._release();
+      this.device = this.media = undefined; this.state = 'stopped';
+    })();
+  }
+}

package/lib/platform.mjs

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { MijiaCameraDelegate } from './camera.mjs';
 import { configureNightVision } from './night-vision.mjs';
+import { MatterService } from './matter-service.mjs';
 
 export const PLUGIN_NAME = '@linanw/homebridge-mijia-remote-camera';
 export const PLATFORM_NAME = 'MijiaRemoteCamera';
@@ -12,12 +13,13 @@ const label = value => typeof value === 'string' && value.trim()
   ? value.replace(/[\x00-\x1f\x7f]/g, ' ').slice(0, 64).trim() : '米家摄像头';
 
 export class MijiaRemoteCameraPlatform {
-  constructor(log, config, api, { runtimeFactory, delegateFactory } = {}) {
+  constructor(log, config, api, { runtimeFactory, delegateFactory, matterServiceFactory } = {}) {
     this.log = log;
     this.config = config || {};
     this.api = api;
     this.runtimeFactory = runtimeFactory;
     this.delegateFactory = delegateFactory || (options => new MijiaCameraDelegate(options));
+    this.matterServiceFactory = matterServiceFactory || (options => new MatterService(options));
     this.refreshQueue = Promise.resolve();
     this.stopping = false;
     api.on('didFinishLaunching', () => {
@@ -41,6 +43,15 @@ export class MijiaRemoteCameraPlatform {
       config: this.config, log: this.log,
     });
     this.runtime.mediaDiagnostics = () => this.delegate?.getMediaDiagnostics?.();
+    this.runtime.matterStatus = () => this.matter?.status?.() ?? { enabled: this.config.enableMatter === true,
+      running: false, state: this.config.enableMatter === true ? 'stopped' : 'disabled' };
+    const matterOperation = method => async () => {
+      if (!this.matter) throw Object.assign(new Error('matter_not_ready'), { reason: 'matter_not_ready' });
+      return this.matter[method]();
+    };
+    this.runtime.matterPairing = matterOperation('pairing');
+    this.runtime.matterOpenWindow = matterOperation('openCommissioningWindow');
+    this.runtime.matterCloseWindow = matterOperation('closeCommissioningWindow');
     if (this.stopping) { await this.runtime.stop(); await this.runtime.close?.(); return; }
     this.selectionListener = () => {
       this.refreshQueue = this.refreshQueue.then(() => this.refresh()).catch(() => {
@@ -54,15 +65,18 @@ export class MijiaRemoteCameraPlatform {
   async refresh() {
     if (this.stopping) return;
     const selected = await this.runtime.selected();
+    if (this.stopping) return;
     if (!selected || !numeric(selected.deviceId) || !numeric(selected.homeId) || !numeric(selected.homeOwner)) {
       this.delegate?.shutdown();
       this.nightVision?.shutdown?.();
+      await this.matter?.close?.();
       this.log.info('请打开插件设置，登录米家并选择家庭和摄像头。');
       return;
     }
     if (this.deviceId && this.deviceId !== selected.deviceId) {
       this.delegate?.shutdown();
       this.nightVision?.shutdown?.();
+      await this.matter?.close?.();
       this.log.info('已保存新的摄像头选择，请重启 Homebridge 使配件变更生效。');
       return;
     }
@@ -81,7 +95,7 @@ export class MijiaRemoteCameraPlatform {
       ?.setCharacteristic(this.api.hap.Characteristic.Manufacturer, 'Xiaomi')
       .setCharacteristic(this.api.hap.Characteristic.Model, label(selected.model || '米家远程摄像头'))
       .setCharacteristic(this.api.hap.Characteristic.SerialNumber, `MiCam-${opaqueId}`)
-      .setCharacteristic(this.api.hap.Characteristic.FirmwareRevision, '0.1.2');
+      .setCharacteristic(this.api.hap.Characteristic.FirmwareRevision, '0.2.0');
     this.delegate = this.delegateFactory({ api: this.api, log: this.log, runtime: this.runtime,
       config: this.config, ffmpegPath: this.runtime.ffmpegPath });
     accessory.configureController(this.delegate.controller);
@@ -93,6 +107,12 @@ export class MijiaRemoteCameraPlatform {
     this.accessory = accessory;
     this.deviceId = selected.deviceId;
     this.log.info('米家摄像头已发布，请在 Apple 家庭中添加此配件。');
+    this.matter = this.matterServiceFactory({ runtime: this.runtime, delegate: this.delegate, config: this.config,
+      storagePath: path.join(this.api.user.storagePath(), 'mijia-remote-camera'), name,
+      serialNumber: `MiCam-${opaqueId}` });
+    this.matterStart = Promise.resolve().then(() => this.stopping ? undefined : this.matter.start()).catch(() => {
+      this.log.warn('Matter 摄像头未能启动，请在插件设置中查看 Matter 状态。');
+    });
   }
 
   async shutdown() {
@@ -101,7 +121,7 @@ export class MijiaRemoteCameraPlatform {
     this.delegate?.shutdown();
     this.nightVision?.shutdown?.();
     this.runtime?.off?.('selection', this.selectionListener);
-    await this.runtime?.stop?.();
+    await Promise.allSettled([this.matter?.close?.(), this.runtime?.stop?.()]);
     await this.runtime?.close?.();
   }
 }

package/lib/rpc.mjs

@@ -4,7 +4,7 @@ import { createHash } from 'node:crypto';
 import { join, resolve } from 'node:path';
 import { StringDecoder } from 'node:string_decoder';
 
-const METHODS = new Set(['status', 'homes', 'devices', 'select', 'pause', 'resume', 'auth.start', 'auth.status', 'auth.cancel', 'night.get', 'night.set']);
+const METHODS = new Set(['status', 'homes', 'devices', 'select', 'pause', 'resume', 'auth.start', 'auth.status', 'auth.cancel', 'night.get', 'night.set', 'matter.pairing', 'matter.openWindow', 'matter.closeWindow']);
 const MAX_REQUEST = 32768;
 const MAX_RESPONSE = 1048576;
 const REASONS = new Set(['operation_failed', 'invalid_request', 'response_too_large', 'invalid_response', 'plugin_not_running',
@@ -16,7 +16,9 @@ const REASONS = new Set(['operation_failed', 'invalid_request', 'response_too_la
   'runtime_unavailable', 'query_timeout', 'query_cancelled', 'invalid_backend_response', 'storage_failed', 'auth_in_progress',
   'invalid_region', 'unsafe_url', 'network_error', 'request_timeout', 'unexpected_response', 'login_expired', 'login_cancelled',
   'login_not_approved', 'incomplete_session', 'credentials_write_failed', 'unknown_login',
-  'night_vision_unsupported', 'night_vision_unavailable', 'night_vision_rejected', 'night_vision_not_applied', 'night_vision_timeout']);
+  'night_vision_unsupported', 'night_vision_unavailable', 'night_vision_rejected', 'night_vision_not_applied', 'night_vision_timeout',
+  'matter_disabled', 'matter_not_ready', 'matter_start_failed', 'matter_port_in_use', 'matter_configuration_invalid',
+  'matter_pairing_unavailable', 'matter_window_failed', 'matter_closed']);
 
 export function socketPath(storagePath) {
   const normal = join(resolve(storagePath), 'control.sock');

package/lib/runtime-factory.mjs

@@ -50,8 +50,12 @@ export async function attachServices(runtime, auth, storagePath) {
       if (method === 'status') {
         const status = runtime.status();
         const media = runtime.mediaDiagnostics?.();
-        return media ? { ...status, media } : status;
+        const matter = runtime.matterStatus?.();
+        return { ...status, ...(media ? { media } : {}), ...(matter ? { matter } : {}) };
       }
+      if (method === 'matter.pairing') return runtime.matterPairing?.() ?? Promise.reject(failure('matter_not_ready'));
+      if (method === 'matter.openWindow') return runtime.matterOpenWindow?.() ?? Promise.reject(failure('matter_not_ready'));
+      if (method === 'matter.closeWindow') return runtime.matterCloseWindow?.() ?? Promise.reject(failure('matter_not_ready'));
       if (authorizing && ['homes', 'devices', 'select', 'resume', 'night.get', 'night.set'].includes(method)) throw failure('auth_in_progress');
       if (method === 'night.get') return runtime.getNightVision();
       if (method === 'night.set') return runtime.setNightVision(payload.mode);