Pros of NewPipe

• Ad-free and open-source YouTube client with additional features like background playback and downloads
• Lightweight and doesn't require Google Services Framework
• Supports multiple streaming services beyond YouTube (e.g., SoundCloud, PeerTube)

Cons of NewPipe

• Limited to streaming services; doesn't support local media playback
• May experience occasional issues with YouTube API changes
• Lacks Chromecast support and some advanced playback features

Code Comparison

NewPipe (Java):

@Override
protected void onLoadFinished() {
    if (currentInfo == null) {
        return;
    }
    super.onLoadFinished();
    // ...
}

VLC-Android (Kotlin):

override fun onLoadFinished() {
    super.onLoadFinished()
    if (currentMedia == null) return
    // ...
}

Both projects use similar event-driven architectures, but NewPipe focuses on streaming services while VLC-Android is a more comprehensive media player. NewPipe's codebase is primarily in Java, while VLC-Android uses a mix of Kotlin and C++. VLC-Android offers broader codec support and local media playback, making it more versatile for general media consumption. However, NewPipe excels in providing a YouTube-like experience without ads or tracking, appealing to privacy-conscious users.

Pros of ExoPlayer

• More lightweight and focused on Android-specific media playback
• Easier integration with other Google services and APIs
• More frequent updates and active development

Cons of ExoPlayer

• Limited codec support compared to VLC's extensive library
• Less cross-platform compatibility
• Steeper learning curve for developers new to Android media frameworks

Code Comparison

ExoPlayer

SimpleExoPlayer player = new SimpleExoPlayer.Builder(context).build();
MediaItem mediaItem = MediaItem.fromUri(videoUri);
player.setMediaItem(mediaItem);
player.prepare();
player.play();

VLC-Android

LibVLC libVLC = new LibVLC(context);
MediaPlayer mediaPlayer = new MediaPlayer(libVLC);
IVLCVout vout = mediaPlayer.getVLCVout();
vout.setVideoView(videoView);
mediaPlayer.setMedia(new Media(libVLC, videoUri));
mediaPlayer.play();

Both examples demonstrate basic video playback setup. ExoPlayer's API is more streamlined, while VLC-Android offers more granular control over playback components.

ExoPlayer is better suited for projects focused solely on Android, especially those integrating with other Google services. VLC-Android, on the other hand, provides broader codec support and cross-platform compatibility, making it ideal for projects requiring extensive media format support or multi-platform development.

Pros of Jellyfin Android

• Open-source media streaming client with a focus on personal media libraries
• Supports a wide range of media formats and codecs
• Integrates with Jellyfin server for a seamless media streaming experience

Cons of Jellyfin Android

• More limited in terms of local playback options compared to VLC
• Requires a Jellyfin server setup for full functionality
• Less mature project with potentially fewer contributors

Code Comparison

VLC Android:

public class VLCApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        MediaParsingService.Companion.getMediaLibrary().init(this);
    }
}

Jellyfin Android:

class JellyfinApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        AppPreferences.init(this)
        initializeWebView()
    }
}

Both applications extend the Android Application class and initialize their respective media libraries or preferences in the onCreate method. VLC Android uses Java, while Jellyfin Android is written in Kotlin, reflecting more modern Android development practices.

Pros of mpv-android

• Lightweight and minimalistic interface
• Better support for advanced video playback features
• More customizable through Lua scripting

Cons of mpv-android

• Smaller user base and community support
• Less comprehensive media library management features
• Fewer built-in codecs and formats supported out-of-the-box

Code Comparison

mpv-android:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    MPVLib.create(this)
    setContentView(R.layout.player)
    // ... more initialization code
}

vlc-android:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.player);
    mService = VLCInstance.getService();
    // ... more initialization code
}

Both projects use similar initialization patterns, but mpv-android uses Kotlin while vlc-android uses Java. The mpv-android codebase tends to be more concise due to Kotlin's features, while vlc-android has a more extensive codebase with additional features and compatibility layers.

mpv-android focuses on a streamlined video playback experience, making it ideal for users who prioritize performance and customization. vlc-android offers a more comprehensive media player solution with broader format support and media library management, catering to a wider range of use cases.

Pros of Player

• Lightweight and minimalist design, focusing on core video playback features
• Faster startup time and lower resource usage
• More frequent updates and active development

Cons of Player

• Limited codec support compared to VLC's extensive library
• Fewer advanced features and customization options
• Smaller community and less documentation

Code Comparison

Player (Kotlin):

override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
    binding = FragmentPlayerBinding.inflate(inflater, container, false)
    return binding.root
}

VLC-Android (Java):

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View v = inflater.inflate(R.layout.player, container, false);
    mSurfaceView = v.findViewById(R.id.player_surface);
    mSurfaceFrame = v.findViewById(R.id.player_surface_frame);
    return v;
}

Player uses Kotlin and view binding, resulting in more concise code. VLC-Android uses Java and traditional findViewById, which is more verbose but potentially more familiar to some developers.

Both projects follow similar architectural patterns for their player implementations, but Player's codebase is generally more modern and streamlined due to its focus on simplicity and use of Kotlin.