feat: added music player aplication

[adityacosmos24]

🎵 Music Player Application - Design Patterns Implementation

📋 Overview

This PR introduces a comprehensive Music Player application that demonstrates multiple design patterns in C++. The application provides a complete music playback system with playlist management, multiple playback strategies, and device abstraction.

✨ Features

Core Functionality

• Song Library Management: Create and manage a collection of songs with metadata (title, artist, file path)
• Playlist Management: Create playlists and add/remove songs dynamically
• Multiple Playback Strategies: Sequential, Random, and Custom Queue playback modes
• Device Support: Bluetooth, Wired, and Headphone audio output devices
• Playback Controls: Play, pause, next, previous, and queue management

Demo Scenarios

• Single song playback with pause/resume functionality
• Sequential playlist playback
• Random playlist playback
• Custom queue management with song prioritization
• Previous track navigation

🏗️ Architecture & Design Patterns

1. Singleton Pattern

• MusicPlayerFacade: Central orchestrator for the music player
• MusicPlayerApplication: High-level application controller
• DeviceManager, PlaylistManager, StrategyManager: Resource managers

2. Strategy Pattern

• PlayStrategy interface with concrete implementations:
  • SequentialPlayStrategy: Plays songs in playlist order
  • RandomPlayStrategy: Plays songs in random order
  • CustomQueueStrategy: Allows custom song queuing

3. Adapter Pattern

• IAudioOutputDevice interface with device adapters:
  • BluetoothSpeakerAdapter
  • WiredSpeakerAdapter
  • HeadphonesAdapter

4. Factory Pattern

• DeviceFactory: Creates appropriate audio output device instances based on device type

5. Facade Pattern

• MusicPlayerFacade: Provides simplified interface to complex subsystem of managers and strategies

6. Manager Pattern

• DeviceManager: Handles audio device connections and management
• PlaylistManager: Manages playlist creation and song associations
• StrategyManager: Manages playback strategy selection and instantiation

📁 Project Structure

MusicPlayerApplication/
├── main.cpp / Main.java              # Entry point and demo runner
├── MusicPlayerFacade                 # Facade orchestrator
├── MusicPlayerApplication            # High-level application controller
├── core/
│   └── AudioEngine                   # Playback engine
├── models/
│   ├── Song                          # Song data model
│   └── Playlist                      # Playlist data model
├── strategies/
│   ├── PlayStrategy                  # Strategy interface
│   ├── SequentialPlayStrategy        # Sequential playback
│   ├── RandomPlayStrategy            # Random playback
│   └── CustomQueueStrategy           # Custom queue playback
├── device/
│   ├── IAudioOutputDevice            # Device interface
│   ├── BluetoothSpeakerAdapter       # Bluetooth device adapter
│   ├── WiredSpeakerAdapter           # Wired device adapter
│   └── HeadphonesAdapter             # Headphone adapter
├── managers/
│   ├── DeviceManager                 # Device management
│   ├── PlaylistManager               # Playlist management
│   └── StrategyManager               # Strategy management
├── factories/
│   └── DeviceFactory                 # Device creation factory
└── external/
    ├── BluetoothSpeakerAPI           # External Bluetooth API
    ├── WiredSpeakerAPI               # External Wired API
    └── HeadphonesAPI                 # External Headphone API

🚀 Getting Started

Prerequisites

• C++11 compatible compiler (g++, clang++, MSVC)
• Java 8+ (for Java implementation)

Compilation & Execution

C++ Version

cd "CPP_Mini_Projects/src/Music_Player_Application"
./compile.bat

🎯 Demo Output

The application demonstrates various playback scenarios:

• Single Song Playback: Play/pause individual songs
• Sequential Playback: Play entire playlist in order
• Random Playback: Play playlist songs in random order
• Custom Queue: Queue specific songs for next playback
• Navigation: Previous track functionality

🔧 Technical Highlights

Error Handling

• Comprehensive exception handling for device connection failures
• Validation for playlist operations and song management
• Graceful handling of invalid operations

Extensibility

• Easy addition of new playback strategies
• Simple integration of new audio device types
• Modular design allows independent testing of components

Code Quality

• Clean separation of concerns
• Interface-based design for testability
• Consistent naming conventions and documentation

📊 Design Pattern Benefits

1. Maintainability: Clear separation of concerns makes code easy to modify
2. Extensibility: New strategies and devices can be added without changing existing code
3. Testability: Interface-based design enables easy unit testing
4. Reusability: Components can be reused across different contexts
5. Flexibility: Runtime strategy selection allows dynamic behavior changes

🎵 Sample Usage

// Create application instance
auto app = MusicPlayerApplication::getInstance();

// Add songs to library
app->createSongInLibrary("Song Title", "Artist", "/path/to/song.mp3");

// Create playlist
app->createPlaylist("My Playlist");
app->addSongToPlaylist("My Playlist", "Song Title");

// Connect device and set strategy
app->connectAudioDevice(DeviceType::BLUETOOTH);
app->selectPlayStrategy(PlayStrategyType::SEQUENTIAL);

// Play music
app->loadPlaylist("My Playlist");
app->playAllTracksInPlaylist();

This implementation serves as an excellent example of how multiple design patterns can work together to create a robust, maintainable, and extensible software system.

closess issue- #34