pocketstation 1.0.1

Source-aware desktop audio Session SDK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Control-plane source generation tracking for explicit rediscovery.

use std::collections::{HashMap, HashSet};

use super::{CaptureSource, SourceGeneration, SourceState, StableSourceId};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SourceGenerationTransition {
    Disappeared {
        stable_id: StableSourceId,
        generation: SourceGeneration,
    },
    Reappeared {
        stable_id: StableSourceId,
        previous_generation: SourceGeneration,
        generation: SourceGeneration,
    },
}

#[derive(Debug, Clone, Copy)]
struct SourceGenerationState {
    generation: SourceGeneration,
    available: bool,
}

/// Assigns source generations across complete discovery snapshots.
///
/// This registry never reconnects capture. Reappearance still requires a new
/// Session after explicit rediscovery.
#[derive(Debug, Default)]
pub struct SourceLifecycleRegistry {
    entries: HashMap<StableSourceId, SourceGenerationState>,
}

impl SourceLifecycleRegistry {
    pub fn observe_complete_snapshot(
        &mut self,
        sources: &[CaptureSource],
    ) -> Vec<SourceGenerationTransition> {
        let present_ids = sources
            .iter()
            .filter(|source| source.state != SourceState::Unavailable)
            .map(|source| source.stable_id.clone())
            .collect::<HashSet<_>>();
        let mut transitions = Vec::new();

        for (stable_id, state) in &mut self.entries {
            if state.available && !present_ids.contains(stable_id) {
                state.available = false;
                transitions.push(SourceGenerationTransition::Disappeared {
                    stable_id: stable_id.clone(),
                    generation: state.generation,
                });
            }
        }

        for stable_id in present_ids {
            match self.entries.get_mut(&stable_id) {
                Some(state) if !state.available => {
                    let previous_generation = state.generation;
                    state.generation = state.generation.next();
                    state.available = true;
                    transitions.push(SourceGenerationTransition::Reappeared {
                        stable_id,
                        previous_generation,
                        generation: state.generation,
                    });
                }
                Some(_) => {}
                None => {
                    self.entries.insert(
                        stable_id,
                        SourceGenerationState {
                            generation: SourceGeneration::INITIAL,
                            available: true,
                        },
                    );
                }
            }
        }
        transitions
    }

    pub fn generation(&self, stable_id: &StableSourceId) -> Option<SourceGeneration> {
        self.entries.get(stable_id).map(|state| state.generation)
    }
}