unified-video-framework 1.0.0

package/packages/android/src/main/java/com/unifiedvideo/player/cast/CastManager.java

@@ -0,0 +1,141 @@
+package com.unifiedvideo.player.cast;
+
+import android.net.Uri;
+import android.util.Log;
+
+import com.google.android.gms.cast.MediaInfo;
+import com.google.android.gms.cast.MediaLoadRequestData;
+import com.google.android.gms.cast.MediaMetadata;
+import com.google.android.gms.cast.framework.CastContext;
+import com.google.android.gms.cast.framework.CastSession;
+import com.google.android.gms.cast.framework.SessionManagerListener;
+import com.google.android.gms.cast.framework.media.RemoteMediaClient;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Minimal Cast manager to load media on a remote receiver.
+ * Host app is expected to provide a Cast button via CastButtonFactory.
+ */
+public class CastManager {
+    private static final String TAG = "UVF-CastManager";
+
+    private final CastContext castContext;
+
+    public CastManager() {
+        this.castContext = CastContext.getSharedInstance();
+    }
+
+    public boolean hasSession() {
+        CastSession session = castContext.getSessionManager().getCurrentCastSession();
+        return session != null && session.isConnected();
+    }
+
+    public void startCasting(String url, String contentType, String title, List<SubtitleItem> subtitles, String activeSubtitleLabel) {
+        try {
+            CastSession session = castContext.getSessionManager().getCurrentCastSession();
+            if (session == null) {
+                Log.w(TAG, "No Cast session available");
+                return;
+            }
+            RemoteMediaClient rmc = session.getRemoteMediaClient();
+            if (rmc == null) {
+                Log.w(TAG, "RemoteMediaClient is null");
+                return;
+            }
+
+            MediaMetadata md = new MediaMetadata(MediaMetadata.MEDIA_TYPE_MOVIE);
+            md.putString(MediaMetadata.KEY_TITLE, title != null ? title : "Unified Player");
+
+            MediaInfo.Builder mediaInfo = new MediaInfo.Builder(url)
+                    .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED)
+                    .setContentType(contentType)
+                    .setMetadata(md);
+
+            // Subtitles
+            if (subtitles != null && !subtitles.isEmpty()) {
+                List<com.google.android.gms.cast.media.Track> tracks = new ArrayList<>();
+                long nextId = 1;
+                Long activeId = null;
+                for (SubtitleItem sub : subtitles) {
+                    com.google.android.gms.cast.media.Track t =
+                            new com.google.android.gms.cast.media.Track.Builder(nextId, com.google.android.gms.cast.media.Track.TYPE_TEXT)
+                                    .setSubtype(com.google.android.gms.cast.media.Track.SUBTYPE_SUBTITLES)
+                                    .setContentId(sub.url)
+                                    .setContentType(sub.contentType != null ? sub.contentType : inferSubtitleContentType(sub.url))
+                                    .setLanguage(sub.language)
+                                    .setName(sub.label != null ? sub.label : sub.language)
+                                    .build();
+                    if (sub.label != null && sub.label.equalsIgnoreCase(activeSubtitleLabel)) {
+                        activeId = nextId;
+                    }
+                    tracks.add(t);
+                    nextId++;
+                }
+                mediaInfo.setMediaTracks(tracks);
+
+                MediaLoadRequestData.Builder load = new MediaLoadRequestData.Builder()
+                        .setMediaInfo(mediaInfo.build())
+                        .setAutoplay(true);
+                if (activeId != null) {
+                    List<Long> activeTrackIds = new ArrayList<>();
+                    activeTrackIds.add(activeId);
+                    load.setActiveTrackIds(activeTrackIds);
+                }
+                rmc.load(load.build());
+            } else {
+                rmc.load(new MediaLoadRequestData.Builder()
+                        .setMediaInfo(mediaInfo.build())
+                        .setAutoplay(true)
+                        .build());
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Cast load failed", e);
+        }
+    }
+
+    public void stopCasting() {
+        try {
+            CastSession session = castContext.getSessionManager().getCurrentCastSession();
+            if (session != null) {
+                RemoteMediaClient rmc = session.getRemoteMediaClient();
+                if (rmc != null) {
+                    rmc.stop();
+                }
+                castContext.getSessionManager().endCurrentSession(true);
+            }
+        } catch (Exception ignored) {}
+    }
+
+    public void addSessionManagerListener(SessionManagerListener<CastSession> listener) {
+        try { castContext.getSessionManager().addSessionManagerListener(listener, CastSession.class); } catch (Exception ignored) {}
+    }
+
+    public void removeSessionManagerListener(SessionManagerListener<CastSession> listener) {
+        try { castContext.getSessionManager().removeSessionManagerListener(listener, CastSession.class); } catch (Exception ignored) {}
+    }
+
+    private String inferSubtitleContentType(String url) {
+        String u = url != null ? url.toLowerCase() : "";
+        if (u.endsWith(".vtt")) return "text/vtt";
+        if (u.endsWith(".srt")) return "application/x-subrip";
+        if (u.endsWith(".ttml") || u.endsWith(".dfxp") || u.endsWith(".xml")) return "application/ttml+xml";
+        return "text/vtt";
+    }
+
+    public static class SubtitleItem {
+        public final String url;
+        public final String language;
+        public final String label;
+        public final String contentType;
+
+        public SubtitleItem(String url, String language, String label, String contentType) {
+            this.url = url;
+            this.language = language;
+            this.label = label;
+            this.contentType = contentType;
+        }
+    }
+}
+

package/packages/android/src/main/java/com/unifiedvideo/player/cast/CastOptionsProvider.java

@@ -0,0 +1,29 @@
+package com.unifiedvideo.player.cast;
+
+import android.content.Context;
+
+import com.google.android.gms.cast.framework.CastOptions;
+import com.google.android.gms.cast.framework.OptionsProvider;
+import com.google.android.gms.cast.framework.SessionProvider;
+
+import java.util.List;
+
+/**
+ * Provides CastOptions to the Cast framework. Referenced from AndroidManifest.
+ */
+public class CastOptionsProvider implements OptionsProvider {
+    @Override
+    public CastOptions getCastOptions(Context context) {
+        // Use default media receiver; apps can replace via setter in CastManager
+        String receiverAppId = com.google.android.gms.cast.framework.media.CastMediaOptions.DEFAULT_MEDIA_RECEIVER_APPLICATION_ID;
+        return new CastOptions.Builder()
+                .setReceiverApplicationId(receiverAppId)
+                .build();
+    }
+
+    @Override
+    public List<SessionProvider> getAdditionalSessionProviders(Context context) {
+        return null;
+    }
+}
+

package/packages/android/src/main/java/com/unifiedvideo/player/overlay/WatermarkOverlayView.java

@@ -0,0 +1,88 @@
+package com.unifiedvideo.player.overlay;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.LinearGradient;
+import android.graphics.Paint;
+import android.graphics.Shader;
+import android.util.AttributeSet;
+import android.view.View;
+
+import java.util.Random;
+
+/**
+ * Semi-random moving watermark overlay similar to web watermark.
+ */
+public class WatermarkOverlayView extends View {
+    private final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    private final Random random = new Random();
+
+    private int colorStart = 0xFFFF0000; // #ff0000
+    private int colorEnd = 0xFFFF4D4F;   // #ff4d4f
+    private float alpha = 0.3f;
+
+    private String text = "PREMIUM";
+    private float x = 50;
+    private float y = 80;
+
+    public WatermarkOverlayView(Context context) {
+        super(context);
+        init();
+    }
+
+    public WatermarkOverlayView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public WatermarkOverlayView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init();
+    }
+
+    private void init() {
+        paint.setTextSize(42f);
+        paint.setStyle(Paint.Style.FILL);
+        setClickable(false);
+        setFocusable(false);
+    }
+
+    public void setAccentColors(int startColor, int endColor) {
+        this.colorStart = startColor;
+        this.colorEnd = endColor;
+        invalidate();
+    }
+
+    public void setAlphaFactor(float alphaFactor) {
+        this.alpha = Math.max(0f, Math.min(1f, alphaFactor));
+        invalidate();
+    }
+
+    public void setText(String text) {
+        this.text = text;
+        invalidate();
+    }
+
+    /** Move watermark to a random position and redraw. */
+    public void randomize() {
+        int w = getWidth();
+        int h = getHeight();
+        if (w <= 0 || h <= 0) return;
+        float margin = 20f;
+        x = margin + random.nextFloat() * Math.max(1f, (w - margin * 2 - 200));
+        y = margin + random.nextFloat() * Math.max(1f, (h - margin * 2 - 60));
+        invalidate();
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        int w = getWidth();
+        Shader shader = new LinearGradient(0, 0, w, 0, colorStart, colorEnd, Shader.TileMode.CLAMP);
+        paint.setShader(shader);
+        paint.setAlpha((int) (alpha * 255));
+        String content = text + " • " + System.currentTimeMillis() % 100000;
+        canvas.drawText(content, x, y, paint);
+    }
+}
+

package/packages/android/src/main/java/com/unifiedvideo/player/pip/PipActionReceiver.java

@@ -0,0 +1,33 @@
+package com.unifiedvideo.player.pip;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+import com.google.android.exoplayer2.ExoPlayer;
+import com.unifiedvideo.player.services.PlayerHolder;
+
+/**
+ * Receives PiP action intents to control playback.
+ */
+public class PipActionReceiver extends BroadcastReceiver {
+    public static final String ACTION_PLAY = "com.unifiedvideo.player.ACTION_PLAY";
+    public static final String ACTION_PAUSE = "com.unifiedvideo.player.ACTION_PAUSE";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (intent == null || intent.getAction() == null) return;
+        ExoPlayer player = PlayerHolder.getPlayer();
+        if (player == null) return;
+        switch (intent.getAction()) {
+            case ACTION_PLAY:
+                try { player.play(); } catch (Exception e) { Log.w("PipAction", "play failed", e); }
+                break;
+            case ACTION_PAUSE:
+                try { player.pause(); } catch (Exception e) { Log.w("PipAction", "pause failed", e); }
+                break;
+        }
+    }
+}
+

package/packages/android/src/main/java/com/unifiedvideo/player/services/PlaybackService.java

@@ -0,0 +1,110 @@
+package com.unifiedvideo.player.services;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.IBinder;
+
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationCompat;
+import androidx.media.app.NotificationCompat.MediaStyle;
+import android.support.v4.media.session.MediaSessionCompat;
+import android.support.v4.media.session.PlaybackStateCompat;
+
+import com.google.android.exoplayer2.ExoPlayer;
+
+/**
+ * Foreground service for background playback. Minimal implementation.
+ */
+public class PlaybackService extends Service {
+    private static final String CHANNEL_ID = "uvf_playback";
+    private static final int NOTIFICATION_ID = 1001;
+
+    private MediaSessionCompat mediaSession;
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        mediaSession = new MediaSessionCompat(this, "UVF-Player");
+        mediaSession.setActive(true);
+        createChannel();
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        startForeground(NOTIFICATION_ID, buildNotification());
+        return START_STICKY;
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        if (mediaSession != null) {
+            mediaSession.setActive(false);
+            mediaSession.release();
+        }
+    }
+
+    private Notification buildNotification() {
+        ExoPlayer player = PlayerHolder.getPlayer();
+        boolean isPlaying = player != null && player.isPlaying();
+
+        PlaybackStateCompat state = new PlaybackStateCompat.Builder()
+                .setActions(PlaybackStateCompat.ACTION_PLAY_PAUSE | PlaybackStateCompat.ACTION_PLAY | PlaybackStateCompat.ACTION_PAUSE)
+                .setState(isPlaying ? PlaybackStateCompat.STATE_PLAYING : PlaybackStateCompat.STATE_PAUSED, player != null ? player.getCurrentPosition() : 0, 1.0f)
+                .build();
+        mediaSession.setPlaybackState(state);
+
+        PendingIntent playIntent = PendingIntent.getBroadcast(this, 100,
+                new Intent("com.unifiedvideo.player.ACTION_PLAY"), Build.VERSION.SDK_INT >= 31 ? PendingIntent.FLAG_MUTABLE : 0);
+        PendingIntent pauseIntent = PendingIntent.getBroadcast(this, 101,
+                new Intent("com.unifiedvideo.player.ACTION_PAUSE"), Build.VERSION.SDK_INT >= 31 ? PendingIntent.FLAG_MUTABLE : 0);
+
+        NotificationCompat.Action playAction = new NotificationCompat.Action(android.R.drawable.ic_media_play, "Play", playIntent);
+        NotificationCompat.Action pauseAction = new NotificationCompat.Action(android.R.drawable.ic_media_pause, "Pause", pauseIntent);
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
+                .setSmallIcon(android.R.drawable.ic_media_play)
+                .setContentTitle("Playing video")
+                .setContentText("Unified Video Player")
+                .setOngoing(isPlaying)
+                .addAction(isPlaying ? pauseAction : playAction)
+                .setStyle(new MediaStyle().setMediaSession(mediaSession.getSessionToken()).setShowActionsInCompactView(0));
+
+        return builder.build();
+    }
+
+    private void createChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "Playback", NotificationManager.IMPORTANCE_LOW);
+            NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+            nm.createNotificationChannel(channel);
+        }
+    }
+
+    // Static helpers
+    public static void start(Context ctx) {
+        Intent i = new Intent(ctx, PlaybackService.class);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            ctx.startForegroundService(i);
+        } else {
+            ctx.startService(i);
+        }
+    }
+
+    public static void stop(Context ctx) {
+        ctx.stopService(new Intent(ctx, PlaybackService.class));
+    }
+}
+

package/packages/android/src/main/java/com/unifiedvideo/player/services/PlayerHolder.java

@@ -0,0 +1,19 @@
+package com.unifiedvideo.player.services;
+
+import com.google.android.exoplayer2.ExoPlayer;
+
+/**
+ * Holds a reference to the current ExoPlayer for background service and PiP actions.
+ */
+public class PlayerHolder {
+    private static volatile ExoPlayer player;
+
+    public static void setPlayer(ExoPlayer p) {
+        player = p;
+    }
+
+    public static ExoPlayer getPlayer() {
+        return player;
+    }
+}
+

package/packages/core/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@unified-video/core",
+  "version": "1.0.0",
+  "description": "Core interfaces and factory for Unified Video Framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "watch": "tsc -p tsconfig.json --watch",
+    "clean": "rm -rf dist",
+    "test": "jest",
+    "lint": "eslint src --ext .ts,.tsx"
+  },
+  "keywords": [
+    "video",
+    "player",
+    "framework",
+    "core",
+    "interfaces"
+  ],
+  "author": "Your Company",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "typescript": "^4.9.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}