Manager Pattern Overview

Overview

MentraOS Cloud uses a Manager pattern to organize functionality within UserSessions. Each manager is responsible for a specific domain of functionality, encapsulating related state, logic, and operations. This pattern promotes separation of concerns, maintainability, and testability.

Architecture

Manager Characteristics

Common Patterns

All managers follow these patterns:

Constructor Pattern

constructor(userSession: UserSession) {
  this.userSession = userSession;
  this.logger = userSession.logger.child({ manager: 'ManagerName' });
  // Initialize manager-specific state
}

Disposal Pattern

dispose(): void {
  // Clear intervals/timeouts
  // Release resources
  // Clear event listeners
  // Reset state
}

Session Reference
- Each manager holds a reference to its parent UserSession
- Allows access to other managers when needed
- Provides context for operations

Manager Categories

1. Hardware Managers

Managers that interface with smart glasses hardware:

MicrophoneManager: Controls microphone state and audio streaming
DisplayManager: Manages display updates with throttling
PhotoManager: Handles photo capture requests
VideoManager: Manages video streaming

2. Processing Managers

Managers that process data streams:

AudioManager: Buffers and routes audio data
TranscriptionManager: Converts speech to text
TranslationManager: Translates text between languages
DashboardManager: Generates dashboard displays

3. Control Managers

Managers that coordinate system behavior:

AppManager: Manages app lifecycle and connections
ManagedStreamingExtension: Handles RTMP streaming

Manager Interactions

Direct Communication

Managers can interact through the UserSession:

// In AudioManager
processAudioData(data: ArrayBuffer) {
  // Process audio...
  
  // Trigger transcription if needed
  if (this.userSession.transcriptionManager.isActive()) {
    this.userSession.transcriptionManager.processAudio(data);
  }
}

Event-Based Communication

Some managers use events for loose coupling:

// In TranscriptionManager
onTranscriptionComplete(text: string) {
  // Emit event that other managers can listen to
  this.emit('transcription', { text, timestamp: Date.now() });
}

Shared State

Managers access shared state through UserSession:

// Check if apps are running
if (this.userSession.runningApps.size > 0) {
  // Perform app-specific logic
}

Lifecycle Management

Initialization

Managers are created when UserSession is instantiated:

// In UserSession constructor
this.appManager = new AppManager(this);
this.audioManager = new AudioManager(this);
this.displayManager = new DisplayManager(this);
// ... other managers

Active Operation

During session lifetime:

Managers respond to incoming messages
Process data streams
Maintain internal state
Coordinate with other managers

Cleanup

When session ends, all managers are disposed:

// In UserSession.dispose()
if (this.appManager) this.appManager.dispose();
if (this.audioManager) this.audioManager.dispose();
// ... dispose all managers

Best Practices

1. Single Responsibility

Each manager should focus on one domain:

✅ AudioManager handles only audio
❌ AudioManager shouldn’t manage display

2. Proper Resource Management

class ExampleManager {
  private intervalId?: Timer;
  
  startProcessing() {
    this.intervalId = setInterval(() => {
      // Process...
    }, 1000);
  }
  
  dispose() {
    if (this.intervalId) {
      clearInterval(this.intervalId);
      this.intervalId = undefined;
    }
  }
}

3. Error Isolation

Errors in one manager shouldn’t crash others:

try {
  await this.performOperation();
} catch (error) {
  this.logger.error('Operation failed:', error);
  // Handle gracefully, don't propagate
}

4. Logging Context

Always use contextual logging:

this.logger = userSession.logger.child({ 
  manager: 'AudioManager',
  userId: userSession.userId 
});

Common Manager Methods

State Queries

isActive(): boolean
getStatus(): ManagerStatus
getCurrentState(): StateObject

Configuration

updateSettings(settings: ManagerSettings): void
setEnabled(enabled: boolean): void

Data Processing

processData(data: DataType): void
handleMessage(message: MessageType): void

Cleanup

dispose(): void
reset(): void
clearBuffers(): void

Threading Considerations

All managers run in the Bun runtime event loop
Long operations should be async or use workers
Avoid blocking operations
Use timers for periodic tasks

Testing Managers

Managers should be testable in isolation:

// Mock UserSession for testing
const mockSession = {
  userId: 'test-user',
  logger: mockLogger,
  websocket: mockWebSocket,
  // ... other required properties
};

const manager = new AudioManager(mockSession);
// Test manager behavior

Performance Guidelines

Buffer Management: Clear old data regularly
Event Throttling: Limit high-frequency events
Resource Pooling: Reuse expensive resources
Lazy Initialization: Create resources only when needed

Manager Documentation

Each manager has detailed documentation:

AppManager - App lifecycle and connections
AudioManager - Audio buffering and routing
DisplayManager - Display updates and throttling
TranscriptionManager - Speech-to-text processing
MicrophoneManager - Microphone state control
PhotoManager - Photo capture handling
VideoManager - Video streaming
DashboardManager - Dashboard generation
TranslationManager - Language translation
ManagedStreamingExtension - RTMP streaming

UserSession Class - Parent container
Session Lifecycle - Manager lifecycle context
Data Flow - How data flows through managers

Getting Started

Cloud Overview

Cloud Architecture

SDK Reference

Development

Overview

Architecture

Manager Characteristics

Common Patterns

Manager Categories

1. Hardware Managers

2. Processing Managers

3. Control Managers

Manager Interactions

Direct Communication

Event-Based Communication

Shared State

Lifecycle Management

Initialization

Active Operation

Cleanup

Best Practices

1. Single Responsibility

2. Proper Resource Management

3. Error Isolation

4. Logging Context

Common Manager Methods

State Queries

Configuration

Data Processing

Cleanup

Threading Considerations

Testing Managers

Performance Guidelines

Manager Documentation

​Overview

​Architecture

​Manager Characteristics

​Common Patterns

​Manager Categories

​1. Hardware Managers

​2. Processing Managers

​3. Control Managers

​Manager Interactions

​Direct Communication

​Event-Based Communication

​Shared State

​Lifecycle Management

​Initialization

​Active Operation

​Cleanup

​Best Practices

​1. Single Responsibility

​2. Proper Resource Management

​3. Error Isolation

​4. Logging Context

​Common Manager Methods

​State Queries

​Configuration

​Data Processing

​Cleanup

​Threading Considerations

​Testing Managers

​Performance Guidelines

​Manager Documentation

​Related Documentation

Overview

Architecture

Manager Characteristics

Common Patterns

Manager Categories

1. Hardware Managers

2. Processing Managers

3. Control Managers

Manager Interactions

Direct Communication

Event-Based Communication

Shared State

Lifecycle Management

Initialization

Active Operation

Cleanup

Best Practices

1. Single Responsibility

2. Proper Resource Management

3. Error Isolation

4. Logging Context

Common Manager Methods

State Queries

Configuration

Data Processing

Cleanup

Threading Considerations

Testing Managers

Performance Guidelines

Manager Documentation

Related Documentation