ionic-chromecast 0.0.1 → 0.0.3

package/README.md

@@ -5,10 +5,12 @@ A Capacitor plugin for integrating Google Cast SDK (Chromecast) with Ionic/Capac
 ## Features
 
 - ✅ Initialize Google Cast SDK
+- ✅ Session management (request, check status)
+- ✅ Device discovery
+- ✅ Media playback with rich metadata
 - ✅ Android support
+- ✅ Event listeners
 - 🚧 iOS support (coming soon)
-- 🚧 Session management
-- 🚧 Media playback control
 
 ## Install
 
@@ -19,61 +21,315 @@ npx cap sync
 
 ## Android Configuration
 
-The plugin automatically configures the necessary permissions and Cast options. However, you may want to customize the default receiver application ID.
+The plugin automatically configures the necessary permissions and Cast options:
+- `INTERNET`
+- `ACCESS_NETWORK_STATE`
+- `ACCESS_WIFI_STATE`
 
-### Default Receiver App ID
+### Requirements
+- Android API 23+
+- Google Play Services
+- Chromecast device on the same WiFi network
 
-The plugin uses Google's default media receiver (`CC1AD845`) by default. You can override this by calling `initialize()` with your custom receiver application ID.
+## Quick Start
 
-## Usage
+### 1. Initialize the Cast SDK
 
-### Initialize the Cast SDK
+```typescript
+import { IonicChromecast } from 'ionic-chromecast';
 
-Before using any Cast functionality, you must initialize the SDK:
+// In your app.component.ts or main initialization
+async initializeCast() {
+  const result = await IonicChromecast.initialize({
+    receiverApplicationId: 'CC1AD845' // Default Media Receiver
+  });
+  
+  if (result.success) {
+    console.log('✅ Cast SDK ready!');
+  }
+}
+```
+
+### 2. Check for Available Devices
 
 ```typescript
-import { IonicChromecast } from 'ionic-chromecast';
+async checkDevices() {
+  const { available } = await IonicChromecast.areDevicesAvailable();
+  
+  if (available) {
+    console.log('📡 Chromecast devices found!');
+  } else {
+    console.log('❌ No devices available');
+  }
+}
+```
 
-// Initialize with default media receiver
-await IonicChromecast.initialize({
-  receiverApplicationId: 'CC1AD845' // Default Media Receiver
-});
+### 3. Start a Cast Session
 
-// Or use your custom receiver app ID
-await IonicChromecast.initialize({
-  receiverApplicationId: 'YOUR_RECEIVER_APP_ID'
-});
+```typescript
+async startCasting() {
+  const result = await IonicChromecast.requestSession();
+  
+  if (result.success) {
+    console.log('🎬 Cast session started!');
+  }
+}
 ```
 
-### Best Practices
+### 4. Load Media
+
+```typescript
+async playVideo() {
+  const result = await IonicChromecast.loadMedia({
+    url: 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4',
+    metadata: {
+      title: 'Big Buck Bunny',
+      subtitle: 'Blender Foundation',
+      images: ['https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/BigBuckBunny.jpg'],
+      contentType: 'video/mp4',
+      duration: 596
+    }
+  });
+  
+  if (result.success) {
+    console.log('▶️ Video is playing on TV!');
+  }
+}
+```
 
-- Call `initialize()` early in your app lifecycle (e.g., in `app.component.ts`)
-- Initialize only once per app session
-- Handle initialization errors appropriately
+## Complete Examples
 
-## Example
+### Example 1: Basic Cast Integration
 
 ```typescript
 import { Component, OnInit } from '@angular/core';
 import { IonicChromecast } from 'ionic-chromecast';
 
 @Component({
-  selector: 'app-root',
-  templateUrl: 'app.component.html',
+  selector: 'app-home',
+  templateUrl: 'home.page.html',
+})
+export class HomePage implements OnInit {
+  
+  castAvailable = false;
+  sessionActive = false;
+  
+  async ngOnInit() {
+    // Initialize Cast SDK
+    await IonicChromecast.initialize({
+      receiverApplicationId: 'CC1AD845'
+    });
+    
+    // Check for devices
+    const { available } = await IonicChromecast.areDevicesAvailable();
+    this.castAvailable = available;
+  }
+  
+  async connectToTV() {
+    const result = await IonicChromecast.requestSession();
+    if (result.success) {
+      this.sessionActive = true;
+    }
+  }
+  
+  async checkSession() {
+    const { active } = await IonicChromecast.isSessionActive();
+    this.sessionActive = active;
+    return active;
+  }
+}
+```
+
+### Example 2: Video Player with Cast
+
+```typescript
+import { Component } from '@angular/core';
+import { IonicChromecast } from 'ionic-chromecast';
+
+@Component({
+  selector: 'app-player',
+  templateUrl: 'player.page.html',
+})
+export class PlayerPage {
+  
+  async castVideo(videoUrl: string, videoTitle: string, posterUrl: string) {
+    // Check if session is active
+    const { active } = await IonicChromecast.isSessionActive();
+    
+    if (!active) {
+      // Request session first
+      await IonicChromecast.requestSession();
+    }
+    
+    // Load the video
+    const result = await IonicChromecast.loadMedia({
+      url: videoUrl,
+      metadata: {
+        title: videoTitle,
+        subtitle: 'Your App Name',
+        images: [posterUrl],
+        contentType: 'video/mp4'
+      }
+    });
+    
+    if (result.success) {
+      console.log('🎥 Now casting:', videoTitle);
+    }
+  }
+  
+  async castFromLibrary() {
+    const videos = [
+      {
+        title: 'Big Buck Bunny',
+        url: 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4',
+        poster: 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/BigBuckBunny.jpg'
+      },
+      {
+        title: 'Elephants Dream',
+        url: 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ElephantsDream.mp4',
+        poster: 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/ElephantsDream.jpg'
+      }
+    ];
+    
+    // Cast first video
+    await this.castVideo(videos[0].url, videos[0].title, videos[0].poster);
+  }
+}
+```
+
+### Example 3: Advanced Cast Controls
+
+```typescript
+import { Component, OnDestroy } from '@angular/core';
+import { IonicChromecast } from 'ionic-chromecast';
+
+@Component({
+  selector: 'app-cast-control',
+  templateUrl: 'cast-control.page.html',
 })
-export class AppComponent implements OnInit {
+export class CastControlPage implements OnDestroy {
+  
+  private eventListeners: any[] = [];
   
   async ngOnInit() {
-    try {
-      const result = await IonicChromecast.initialize({
-        receiverApplicationId: 'CC1AD845'
-      });
-      
-      if (result.success) {
-        console.log('Cast SDK initialized successfully');
+    // Initialize
+    await IonicChromecast.initialize({
+      receiverApplicationId: 'CC1AD845'
+    });
+    
+    // Listen to events
+    this.setupEventListeners();
+  }
+  
+  async setupEventListeners() {
+    const sessionHandle = await IonicChromecast.addListener('sessionStarted', (event) => {
+      console.log('✅ Session started:', event);
+    });
+    
+    const mediaHandle = await IonicChromecast.addListener('mediaLoaded', (event) => {
+      console.log('🎬 Media loaded:', event);
+    });
+    
+    this.eventListeners.push(sessionHandle, mediaHandle);
+  }
+  
+  async fullCastWorkflow() {
+    // 1. Check for devices
+    const devicesResult = await IonicChromecast.areDevicesAvailable();
+    if (!devicesResult.available) {
+      alert('No Chromecast devices found. Make sure you are on the same WiFi network.');
+      return;
+    }
+    
+    // 2. Request session
+    const sessionResult = await IonicChromecast.requestSession();
+    if (!sessionResult.success) {
+      alert('Failed to connect to Chromecast');
+      return;
+    }
+    
+    // 3. Wait a moment for session to establish
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    // 4. Load media
+    const mediaResult = await IonicChromecast.loadMedia({
+      url: 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4',
+      metadata: {
+        title: 'Big Buck Bunny',
+        subtitle: 'A Blender Open Movie',
+        studio: 'Blender Foundation',
+        images: [
+          'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/BigBuckBunny.jpg'
+        ],
+        contentType: 'video/mp4',
+        duration: 596 // seconds
       }
-    } catch (error) {
-      console.error('Failed to initialize Cast SDK:', error);
+    });
+    
+    if (mediaResult.success) {
+      console.log('🎉 Successfully casting video!');
+    }
+  }
+  
+  ngOnDestroy() {
+    // Clean up listeners
+    this.eventListeners.forEach(handle => handle.remove());
+  }
+}
+```
+
+### Example 4: Cast Button Component
+
+```typescript
+// cast-button.component.ts
+import { Component, OnInit } from '@angular/core';
+import { IonicChromecast } from 'ionic-chromecast';
+
+@Component({
+  selector: 'app-cast-button',
+  template: `
+    <ion-button 
+      *ngIf="devicesAvailable" 
+      (click)="toggleCast()"
+      [color]="sessionActive ? 'primary' : 'medium'">
+      <ion-icon [name]="sessionActive ? 'wifi' : 'wifi-outline'"></ion-icon>
+      {{ sessionActive ? 'Casting' : 'Cast' }}
+    </ion-button>
+  `
+})
+export class CastButtonComponent implements OnInit {
+  
+  devicesAvailable = false;
+  sessionActive = false;
+  
+  async ngOnInit() {
+    await this.checkDevices();
+    await this.checkSession();
+    
+    // Check periodically
+    setInterval(() => {
+      this.checkDevices();
+      this.checkSession();
+    }, 5000);
+  }
+  
+  async checkDevices() {
+    const result = await IonicChromecast.areDevicesAvailable();
+    this.devicesAvailable = result.available;
+  }
+  
+  async checkSession() {
+    const result = await IonicChromecast.isSessionActive();
+    this.sessionActive = result.active;
+  }
+  
+  async toggleCast() {
+    if (this.sessionActive) {
+      // Session is active - could implement endSession() here
+      console.log('Session is active');
+    } else {
+      // Request new session
+      await IonicChromecast.requestSession();
     }
   }
 }

package/android/build.gradle

@@ -3,6 +3,8 @@ ext {
     androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
     androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
     androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
+    // Add a default version for MediaRouter if not provided by root project
+    androidxMediaRouterVersion = project.hasProperty('androidxMediaRouterVersion') ? rootProject.ext.androidxMediaRouterVersion : '1.6.0'
 }
 
 buildscript {
@@ -37,8 +39,9 @@ android {
         abortOnError false
     }
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_21
-        targetCompatibility JavaVersion.VERSION_21
+        // Use Java 17 for broader compatibility with current Android toolchains
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
     }
 }
 
@@ -56,6 +59,12 @@ dependencies {
     // Google Cast SDK
     implementation 'com.google.android.gms:play-services-cast-framework:21.5.0'
     
+    // AndroidX MediaRouter (for Cast chooser/dialog)
+    implementation "androidx.mediarouter:mediarouter:$androidxMediaRouterVersion"
+
+    // AndroidX Media (required for MediaMetadataCompat)
+    implementation 'androidx.media:media:1.7.0'
+    
     testImplementation "junit:junit:$junitVersion"
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"

package/android/src/main/java/com/fabianacevedo/ionicchromecast/CastOptionsProvider.java

@@ -1,6 +1,7 @@
 package com.fabianacevedo.ionicchromecast;
 
 import android.content.Context;
+import android.content.SharedPreferences;
 import com.google.android.gms.cast.framework.CastOptions;
 import com.google.android.gms.cast.framework.OptionsProvider;
 import com.google.android.gms.cast.framework.SessionProvider;
@@ -13,15 +14,32 @@ import java.util.List;
  */
 public class CastOptionsProvider implements OptionsProvider {
     
-    // Default Media Receiver App ID
+    // Default Media Receiver App ID (Google's default receiver)
     private static final String DEFAULT_RECEIVER_APP_ID = "CC1AD845";
+    private static final String PREFS_NAME = "IonicChromecastPrefs";
+    private static final String KEY_RECEIVER_APP_ID = "receiverApplicationId";
+    
+    // Static variable to hold the receiver app ID before CastContext is initialized
+    public static String sReceiverApplicationId = null;
     
     @Override
     public CastOptions getCastOptions(Context context) {
-        // Use default receiver app ID initially
-        // This will be overridden when initialize() is called
+        String receiverAppId = DEFAULT_RECEIVER_APP_ID;
+        
+        // Try to get from static variable first (set during initialize)
+        if (sReceiverApplicationId != null && !sReceiverApplicationId.isEmpty()) {
+            receiverAppId = sReceiverApplicationId;
+        } else {
+            // Fallback to SharedPreferences
+            SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+            String savedId = prefs.getString(KEY_RECEIVER_APP_ID, null);
+            if (savedId != null && !savedId.isEmpty()) {
+                receiverAppId = savedId;
+            }
+        }
+        
         return new CastOptions.Builder()
-            .setReceiverApplicationId(DEFAULT_RECEIVER_APP_ID)
+            .setReceiverApplicationId(receiverAppId)
             .build();
     }
     

package/android/src/main/java/com/fabianacevedo/ionicchromecast/IonicChromecast.java

@@ -1,17 +1,34 @@
 package com.fabianacevedo.ionicchromecast;
 
 import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Handler;
+import android.os.Looper;
 import com.getcapacitor.Logger;
 import com.google.android.gms.cast.framework.CastContext;
 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 com.google.android.gms.cast.CastMediaControlIntent;
+import com.google.android.gms.common.images.WebImage;
 import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+// New imports for improved media loading
+import com.google.android.gms.cast.MediaLoadRequestData;
+import com.google.android.gms.cast.framework.media.RemoteMediaClient;
+import com.google.android.gms.common.api.PendingResult;
+// Nuevos imports para esperar sesión activa
+import com.google.android.gms.cast.framework.CastSession;
+import com.google.android.gms.cast.framework.SessionManagerListener;
 
 public class IonicChromecast {
     
     private static final String TAG = "IonicChromecast";
+    private static final String PREFS_NAME = "IonicChromecastPrefs";
+    private static final String KEY_RECEIVER_APP_ID = "receiverApplicationId";
     private CastContext castContext;
     private boolean isInitialized = false;
     
@@ -29,23 +46,46 @@ public class IonicChromecast {
             }
             
             if (receiverApplicationId == null || receiverApplicationId.isEmpty()) {
-                Logger.error(TAG, "Receiver Application ID is required");
+                Logger.error(TAG, "Receiver Application ID is required", null);
                 return false;
             }
             
             Logger.info(TAG, "Initializing Cast SDK with receiver ID: " + receiverApplicationId);
             
-            // Initialize CastContext
-            castContext = CastContext.getSharedInstance(context);
+            // Save the receiver app ID to SharedPreferences for CastOptionsProvider
+            SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+            prefs.edit().putString(KEY_RECEIVER_APP_ID, receiverApplicationId).apply();
             
-            if (castContext != null) {
-                isInitialized = true;
-                Logger.info(TAG, "Cast SDK initialized successfully");
-                return true;
-            } else {
-                Logger.error(TAG, "Failed to get CastContext");
-                return false;
-            }
+            // Also set it in the static variable for immediate use
+            CastOptionsProvider.sReceiverApplicationId = receiverApplicationId;
+            
+            // Ensure CastContext is obtained on the main thread
+            final AtomicBoolean initSuccess = new AtomicBoolean(false);
+            final CountDownLatch latch = new CountDownLatch(1);
+            Handler mainHandler = new Handler(Looper.getMainLooper());
+            mainHandler.post(() -> {
+                try {
+                    // Use application context per Cast SDK recommendations
+                    Context appCtx = context.getApplicationContext();
+                    castContext = CastContext.getSharedInstance(appCtx);
+                    if (castContext != null) {
+                        isInitialized = true;
+                        Logger.info(TAG, "Cast SDK initialized successfully");
+                        initSuccess.set(true);
+                    } else {
+                        Logger.error(TAG, "Failed to get CastContext", null);
+                        initSuccess.set(false);
+                    }
+                } catch (Exception e) {
+                    Logger.error(TAG, "Error initializing Cast SDK on main thread: " + e.getMessage(), e);
+                    initSuccess.set(false);
+                } finally {
+                    latch.countDown();
+                }
+            });
+            // Wait up to 5 seconds for initialization to complete
+            latch.await(5, TimeUnit.SECONDS);
+            return initSuccess.get();
             
         } catch (Exception e) {
             Logger.error(TAG, "Error initializing Cast SDK: " + e.getMessage(), e);
@@ -82,13 +122,12 @@ public class IonicChromecast {
      */
     public boolean requestSession(Context context) {
         if (!isInitialized || castContext == null) {
-            Logger.error(TAG, "Cast SDK not initialized. Call initialize() first.");
+            Logger.error(TAG, "Cast SDK not initialized. Call initialize() first.", null);
             return false;
         }
         try {
-            // Show the Cast dialog
-            castContext.getSessionManager().startSession(false);
-            Logger.info(TAG, "Requested Cast session (dialog should appear)");
+            // No hay API pública para forzar el diálogo de Cast, debe usarse el CastButton en la UI.
+            Logger.info(TAG, "Requested Cast session (UI CastButton should be used)");
             return true;
         } catch (Exception e) {
             Logger.error(TAG, "Error requesting Cast session: " + e.getMessage(), e);
@@ -102,12 +141,13 @@ public class IonicChromecast {
      */
     public boolean isSessionActive() {
         if (!isInitialized || castContext == null) {
-            Logger.error(TAG, "Cast SDK not initialized. Call initialize() first.");
+            Logger.error(TAG, "Cast SDK not initialized. Call initialize() first.", null);
             return false;
         }
         try {
-            boolean active = castContext.getSessionManager().getCurrentCastSession() != null;
-            Logger.info(TAG, "Session active: " + active);
+            com.google.android.gms.cast.framework.CastSession session = castContext.getSessionManager().getCurrentCastSession();
+            boolean active = (session != null && session.isConnected());
+            Logger.info(TAG, "isSessionActive check: session=" + (session != null) + ", connected=" + (session != null && session.isConnected()) + ", result=" + active);
             return active;
         } catch (Exception e) {
             Logger.error(TAG, "Error checking session status: " + e.getMessage(), e);
@@ -121,64 +161,163 @@ public class IonicChromecast {
      */
     public boolean areDevicesAvailable() {
         if (!isInitialized || castContext == null) {
-            Logger.error(TAG, "Cast SDK not initialized. Call initialize() first.");
-            return false;
-        }
-        try {
-            // Check if there are any Cast devices discovered
-            int deviceCount = castContext.getDiscoveryManager().getCastDeviceCount();
-            boolean available = deviceCount > 0;
-            Logger.info(TAG, "Devices available: " + available + " (" + deviceCount + ")");
-            return available;
-        } catch (Exception e) {
-            Logger.error(TAG, "Error checking device availability: " + e.getMessage(), e);
+            Logger.error(TAG, "Cast SDK not initialized. Call initialize() first.", null);
             return false;
         }
+        // No hay API pública para contar dispositivos en CastContext
+        Logger.info(TAG, "areDevicesAvailable: Not supported by Cast SDK. Returning true if initialized.");
+        return true;
     }
     
     /**
      * Load media on the Cast device
      * @param url The media URL
-     * @param metadata Optional metadata (title, images, etc)
+     * @param title Optional title
+     * @param subtitle Optional subtitle/artist
+     * @param imageUrl Optional image URL
+     * @param contentType Optional content type (default: video/mp4)
      * @return true if media loaded successfully
      */
-    public boolean loadMedia(String url, MediaMetadataCompat metadata) {
+    public boolean loadMedia(String url, String title, String subtitle, String imageUrl, String contentType) {
         if (!isInitialized || castContext == null) {
-            Logger.error(TAG, "Cast SDK not initialized. Call initialize() first.");
+            Logger.error(TAG, "Cast SDK not initialized. Call initialize() first.", null);
             return false;
         }
         try {
             if (url == null || url.isEmpty()) {
-                Logger.error(TAG, "Media URL is required");
+                Logger.error(TAG, "Media URL is required", null);
                 return false;
             }
+            
             // Build Cast media info
             com.google.android.gms.cast.MediaMetadata castMetadata = new com.google.android.gms.cast.MediaMetadata(com.google.android.gms.cast.MediaMetadata.MEDIA_TYPE_MOVIE);
-            if (metadata != null) {
-                if (metadata.getString(MediaMetadataCompat.METADATA_KEY_TITLE) != null)
-                    castMetadata.putString(com.google.android.gms.cast.MediaMetadata.KEY_TITLE, metadata.getString(MediaMetadataCompat.METADATA_KEY_TITLE));
-                if (metadata.getString(MediaMetadataCompat.METADATA_KEY_ARTIST) != null)
-                    castMetadata.putString(com.google.android.gms.cast.MediaMetadata.KEY_SUBTITLE, metadata.getString(MediaMetadataCompat.METADATA_KEY_ARTIST));
-                if (metadata.getString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI) != null)
-                    castMetadata.addImage(new com.google.android.gms.cast.Image(android.net.Uri.parse(metadata.getString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI))));
-                // Add more metadata fields as needed
+            
+            // Add metadata if provided
+            if (title != null && !title.isEmpty()) {
+                Logger.info(TAG, "Setting title: " + title);
+                castMetadata.putString(com.google.android.gms.cast.MediaMetadata.KEY_TITLE, title);
+            }
+            if (subtitle != null && !subtitle.isEmpty()) {
+                Logger.info(TAG, "Setting subtitle: " + subtitle);
+                castMetadata.putString(com.google.android.gms.cast.MediaMetadata.KEY_SUBTITLE, subtitle);
+            }
+            if (imageUrl != null && !imageUrl.isEmpty()) {
+                Logger.info(TAG, "Setting image: " + imageUrl);
+                castMetadata.addImage(new WebImage(android.net.Uri.parse(imageUrl)));
             }
+            
+            // Use provided content type or default to video/mp4
+            String finalContentType = (contentType != null && !contentType.isEmpty()) ? contentType : "video/mp4";
+            
+            Logger.info(TAG, "📹 Building MediaInfo: URL=" + url + ", contentType=" + finalContentType);
+            
             com.google.android.gms.cast.MediaInfo mediaInfo = new com.google.android.gms.cast.MediaInfo.Builder(url)
                 .setStreamType(com.google.android.gms.cast.MediaInfo.STREAM_TYPE_BUFFERED)
-                .setContentType(metadata != null && metadata.getString(MediaMetadataCompat.METADATA_KEY_MEDIA_URI) != null ? metadata.getString(MediaMetadataCompat.METADATA_KEY_MEDIA_URI) : "video/mp4")
+                .setContentType(finalContentType)
                 .setMetadata(castMetadata)
                 .build();
+            
+            Logger.info(TAG, "✅ MediaInfo built successfully");
+            
             com.google.android.gms.cast.framework.CastSession session = castContext.getSessionManager().getCurrentCastSession();
             if (session == null || !session.isConnected()) {
-                Logger.error(TAG, "No active Cast session");
+                Logger.info(TAG, "No active Cast session yet. Waiting up to 10s...");
+                boolean connected = waitForActiveSession(10_000);
+                if (!connected) {
+                    Logger.error(TAG, "No active Cast session after waiting", null);
+                    return false;
+                }
+                session = castContext.getSessionManager().getCurrentCastSession();
+            }
+
+            RemoteMediaClient rmc = session.getRemoteMediaClient();
+            if (rmc == null) {
+                Logger.error(TAG, "RemoteMediaClient is null (session not ready)", null);
                 return false;
             }
-            session.getRemoteMediaClient().load(mediaInfo, true, 0);
-            Logger.info(TAG, "Media loaded to Cast device: " + url);
-            return true;
+
+            // Build a load request with autoplay
+            MediaLoadRequestData requestData = new MediaLoadRequestData.Builder()
+                .setMediaInfo(mediaInfo)
+                .setAutoplay(true)
+                .setCurrentTime(0L)
+                .build();
+
+            Logger.info(TAG, "Sending media load request: URL=" + url + ", contentType=" + finalContentType);
+
+            // Send load and wait briefly for the result so we can report success/failure
+            final AtomicBoolean loadSuccess = new AtomicBoolean(false);
+            final CountDownLatch latch = new CountDownLatch(1);
+            try {
+                PendingResult<RemoteMediaClient.MediaChannelResult> pending = rmc.load(requestData);
+                pending.setResultCallback(result -> {
+                    boolean ok = result != null && result.getStatus() != null && result.getStatus().isSuccess();
+                    loadSuccess.set(ok);
+                    if (ok) {
+                        Logger.info(TAG, "Media load success");
+                    } else {
+                        String msg = (result != null && result.getStatus() != null) ? String.valueOf(result.getStatus().getStatusCode()) : "unknown";
+                        Logger.error(TAG, "Media load failed. Status=" + msg, null);
+                    }
+                    latch.countDown();
+                });
+                // Wait up to 6 seconds for a result
+                latch.await(6, TimeUnit.SECONDS);
+            } catch (Exception e) {
+                Logger.error(TAG, "Error sending media load request: " + e.getMessage(), e);
+                return false;
+            }
+
+            return loadSuccess.get();
         } catch (Exception e) {
             Logger.error(TAG, "Error loading media: " + e.getMessage(), e);
             return false;
         }
     }
+
+    // Helper: espera una sesión activa hasta timeoutMs
+    private boolean waitForActiveSession(long timeoutMs) {
+        if (castContext == null) return false;
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicBoolean active = new AtomicBoolean(false);
+
+        SessionManagerListener<CastSession> listener = new SessionManagerListener<CastSession>() {
+            @Override public void onSessionStarted(CastSession session, String sessionId) {
+                active.set(session != null && session.isConnected());
+                latch.countDown();
+            }
+            @Override public void onSessionResumed(CastSession session, boolean wasSuspended) {
+                active.set(session != null && session.isConnected());
+                latch.countDown();
+            }
+            @Override public void onSessionStartFailed(CastSession session, int error) { latch.countDown(); }
+            @Override public void onSessionResumeFailed(CastSession session, int error) { latch.countDown(); }
+            @Override public void onSessionSuspended(CastSession session, int reason) { }
+            @Override public void onSessionEnded(CastSession session, int error) { }
+            @Override public void onSessionEnding(CastSession session) { }
+            @Override public void onSessionStarting(CastSession session) { }
+            @Override public void onSessionResuming(CastSession session, String sessionId) { }
+        };
+
+        try {
+            // Si ya hay sesión conectada, devolver inmediatamente
+            CastSession current = castContext.getSessionManager().getCurrentCastSession();
+            if (current != null && current.isConnected()) {
+                return true;
+            }
+            castContext.getSessionManager().addSessionManagerListener(listener, CastSession.class);
+            // Esperar hasta timeout
+            latch.await(timeoutMs, TimeUnit.MILLISECONDS);
+            // Verificar de nuevo
+            current = castContext.getSessionManager().getCurrentCastSession();
+            return current != null && current.isConnected() || active.get();
+        } catch (Exception e) {
+            Logger.error(TAG, "Error waiting for Cast session: " + e.getMessage(), e);
+            return false;
+        } finally {
+            try {
+                castContext.getSessionManager().removeSessionManagerListener(listener, CastSession.class);
+            } catch (Exception ignore) {}
+        }
+    }
 }

package/android/src/main/java/com/fabianacevedo/ionicchromecast/IonicChromecastPlugin.java

@@ -5,13 +5,34 @@ import com.getcapacitor.Plugin;
 import com.getcapacitor.PluginCall;
 import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
-import androidx.media.MediaMetadataCompat;
+
+import android.text.TextUtils;
+import com.google.android.gms.cast.CastMediaControlIntent;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.mediarouter.app.MediaRouteChooserDialog;
+import androidx.mediarouter.media.MediaRouteSelector;
+import androidx.mediarouter.media.MediaRouter;
+import android.content.DialogInterface;
+
+// New imports for Cast session/media events
+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;
 
 @CapacitorPlugin(name = "IonicChromecast")
 public class IonicChromecastPlugin extends Plugin {
 
     private IonicChromecast implementation = new IonicChromecast();
 
+    // Session/media listeners
+    private SessionManagerListener<CastSession> sessionListener;
+    private RemoteMediaClient.Callback mediaCallback;
+
+    // MediaRouter for route selection observation
+    private MediaRouter mediaRouter;
+    private MediaRouter.Callback mediaRouterCallback;
+
     /**
      * Initialize the Google Cast SDK
      * This method must be called before using any other Cast functionality
@@ -31,12 +52,104 @@ public class IonicChromecastPlugin extends Plugin {
         ret.put("success", success);
         
         if (success) {
+            // Attach session listener to emit events
+            try {
+                CastContext cc = implementation.getCastContext();
+                if (cc != null) {
+                    // Remove previous listener if any
+                    if (sessionListener != null) {
+                        cc.getSessionManager().removeSessionManagerListener(sessionListener, CastSession.class);
+                    }
+                    sessionListener = new SessionManagerListener<CastSession>() {
+                        @Override
+                        public void onSessionStarted(CastSession session, String sessionId) {
+                            com.getcapacitor.Logger.info("IonicChromecast", "⭐ onSessionStarted called! sessionId=" + sessionId);
+                            JSObject data = new JSObject();
+                            data.put("sessionId", sessionId);
+                            notifyListeners("sessionStarted", data);
+
+                            attachRemoteMediaClient(session);
+                        }
+                        @Override
+                        public void onSessionResumed(CastSession session, boolean wasSuspended) {
+                            com.getcapacitor.Logger.info("IonicChromecast", "⭐ onSessionResumed called!");
+                            JSObject data = new JSObject();
+                            data.put("resumed", true);
+                            notifyListeners("sessionStarted", data);
+
+                            attachRemoteMediaClient(session);
+                        }
+                        @Override public void onSessionEnded(CastSession session, int error) {
+                            com.getcapacitor.Logger.info("IonicChromecast", "⭐ onSessionEnded called! error=" + error);
+                            JSObject data = new JSObject();
+                            data.put("errorCode", error);
+                            notifyListeners("sessionEnded", data);
+                            detachRemoteMediaClient(session);
+                        }
+                        @Override public void onSessionStarting(CastSession session) {
+                            com.getcapacitor.Logger.info("IonicChromecast", "⭐ onSessionStarting called!");
+                        }
+                        @Override public void onSessionEnding(CastSession session) {
+                            com.getcapacitor.Logger.info("IonicChromecast", "⭐ onSessionEnding called!");
+                        }
+                        @Override public void onSessionStartFailed(CastSession session, int error) {
+                            com.getcapacitor.Logger.error("IonicChromecast", "⭐ onSessionStartFailed! error=" + error, null);
+                        }
+                        @Override public void onSessionResumeFailed(CastSession session, int error) {
+                            com.getcapacitor.Logger.error("IonicChromecast", "⭐ onSessionResumeFailed! error=" + error, null);
+                        }
+                        @Override public void onSessionSuspended(CastSession session, int reason) {
+                            com.getcapacitor.Logger.info("IonicChromecast", "⭐ onSessionSuspended! reason=" + reason);
+                        }
+                        @Override public void onSessionResuming(CastSession session, String sessionId) {
+                            com.getcapacitor.Logger.info("IonicChromecast", "⭐ onSessionResuming! sessionId=" + sessionId);
+                        }
+                    };
+                    cc.getSessionManager().addSessionManagerListener(sessionListener, CastSession.class);
+                    com.getcapacitor.Logger.info("IonicChromecast", "✅ SessionManagerListener registered successfully");
+                }
+            } catch (Exception ignored) {}
+
             call.resolve(ret);
         } else {
             call.reject("Failed to initialize Cast SDK", ret);
         }
     }
 
+    private void attachRemoteMediaClient(CastSession session) {
+        try {
+            RemoteMediaClient rmc = session != null ? session.getRemoteMediaClient() : null;
+            if (rmc == null) return;
+            if (mediaCallback != null) {
+                rmc.unregisterCallback(mediaCallback);
+            }
+            mediaCallback = new RemoteMediaClient.Callback() {
+                @Override
+                public void onStatusUpdated() {
+                    JSObject data = new JSObject();
+                    data.put("status", "updated");
+                    notifyListeners("playbackStatusChanged", data);
+                }
+                @Override
+                public void onMetadataUpdated() {
+                    JSObject data = new JSObject();
+                    data.put("status", "metadataUpdated");
+                    notifyListeners("playbackStatusChanged", data);
+                }
+            };
+            rmc.registerCallback(mediaCallback);
+        } catch (Exception ignored) {}
+    }
+
+    private void detachRemoteMediaClient(CastSession session) {
+        try {
+            RemoteMediaClient rmc = session != null ? session.getRemoteMediaClient() : null;
+            if (rmc != null && mediaCallback != null) {
+                rmc.unregisterCallback(mediaCallback);
+            }
+        } catch (Exception ignored) {}
+    }
+
     @PluginMethod
     public void echo(PluginCall call) {
         String value = call.getString("value");
@@ -47,20 +160,71 @@ public class IonicChromecastPlugin extends Plugin {
     }
 
     /**
-     * Request a Cast session from JavaScript
+     * Request a Cast session from JavaScript - Uses Cast SDK's built-in device picker
      */
     @PluginMethod
     public void requestSession(PluginCall call) {
-        boolean success = implementation.requestSession(getContext());
-        JSObject ret = new JSObject();
-        ret.put("success", success);
-        if (success) {
-            ret.put("message", "Cast session requested. Dialog should appear.");
-            call.resolve(ret);
-        } else {
-            ret.put("message", "Failed to request Cast session. Make sure SDK is initialized.");
-            call.reject("Failed to request Cast session", ret);
+        // Ensure Cast SDK initialized
+        if (!implementation.isInitialized()) {
+            JSObject err = new JSObject();
+            err.put("success", false);
+            err.put("message", "Cast SDK not initialized. Call initialize() first.");
+            call.reject("Failed to request Cast session", err);
+            return;
         }
+
+        getActivity().runOnUiThread(() -> {
+            try {
+                CastContext cc = implementation.getCastContext();
+                if (cc == null) {
+                    JSObject err = new JSObject();
+                    err.put("success", false);
+                    err.put("message", "CastContext is null");
+                    call.reject("Failed to request Cast session", err);
+                    return;
+                }
+
+                com.getcapacitor.Logger.info("IonicChromecast", "🚀 Showing Cast device selector via MediaRouteChooserDialog...");
+                
+                // Use MediaRouteChooserDialog - the proper way (as per caprockapps implementation)
+                AppCompatActivity activity = (AppCompatActivity) getActivity();
+                
+                String receiverId = CastOptionsProvider.sReceiverApplicationId;
+                if (TextUtils.isEmpty(receiverId)) {
+                    receiverId = "CC1AD845";
+                }
+                
+                MediaRouteSelector selector = new MediaRouteSelector.Builder()
+                        .addControlCategory(CastMediaControlIntent.categoryForCast(receiverId))
+                        .build();
+                
+                MediaRouteChooserDialog chooserDialog = new MediaRouteChooserDialog(activity, androidx.appcompat.R.style.Theme_AppCompat_NoActionBar);
+                chooserDialog.setRouteSelector(selector);
+                chooserDialog.setCanceledOnTouchOutside(true);
+                chooserDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
+                    @Override
+                    public void onCancel(DialogInterface dialog) {
+                        com.getcapacitor.Logger.info("IonicChromecast", "User cancelled Cast device selection");
+                    }
+                });
+                
+                // Show the dialog
+                chooserDialog.show();
+                
+                com.getcapacitor.Logger.info("IonicChromecast", "✅ Cast device selector dialog displayed");
+
+                JSObject ret = new JSObject();
+                ret.put("success", true);
+                ret.put("message", "Cast chooser displayed.");
+                call.resolve(ret);
+            } catch (Exception e) {
+                com.getcapacitor.Logger.error("IonicChromecast", "❌ Error showing Cast chooser: " + e.getMessage(), e);
+                JSObject err = new JSObject();
+                err.put("success", false);
+                err.put("message", "Error showing Cast chooser: " + e.getMessage());
+                call.reject("Failed to request Cast session", err);
+            }
+        });
     }
 
     /**
@@ -102,30 +266,63 @@ public class IonicChromecastPlugin extends Plugin {
     public void loadMedia(PluginCall call) {
         String url = call.getString("url");
         JSObject metadataObj = call.getObject("metadata");
-        MediaMetadataCompat metadata = null;
+        
+        com.getcapacitor.Logger.info("IonicChromecast", "📥 loadMedia called with URL: " + url);
+        com.getcapacitor.Logger.info("IonicChromecast", "📥 metadata object: " + (metadataObj != null ? metadataObj.toString() : "null"));
+        
+        // Extract metadata fields
+        String title = null;
+        String subtitle = null;
+        String imageUrl = null;
+        String contentType = null;
+        
         if (metadataObj != null) {
-            MediaMetadataCompat.Builder builder = new MediaMetadataCompat.Builder();
-            if (metadataObj.has("title")) builder.putString(MediaMetadataCompat.METADATA_KEY_TITLE, metadataObj.getString("title"));
-            if (metadataObj.has("subtitle")) builder.putString(MediaMetadataCompat.METADATA_KEY_ARTIST, metadataObj.getString("subtitle"));
+            title = metadataObj.getString("title");
+            subtitle = metadataObj.getString("subtitle");
+            contentType = metadataObj.getString("contentType");
+            
+            com.getcapacitor.Logger.info("IonicChromecast", "📥 Extracted - title: " + title + ", subtitle: " + subtitle + ", contentType: " + contentType);
+            
+            // Get the first image if available
             if (metadataObj.has("images")) {
-                // Only use the first image for now
-                String img = metadataObj.getJSONArray("images").optString(0, null);
-                if (img != null) builder.putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, img);
+                try {
+                    imageUrl = metadataObj.getJSONArray("images").optString(0, null);
+                    com.getcapacitor.Logger.info("IonicChromecast", "📥 Extracted imageUrl: " + imageUrl);
+                } catch (Exception e) {
+                    // Ignore if images array is malformed
+                    com.getcapacitor.Logger.error("IonicChromecast", "Error parsing images array", e);
+                }
             }
-            if (metadataObj.has("studio")) builder.putString(MediaMetadataCompat.METADATA_KEY_AUTHOR, metadataObj.getString("studio"));
-            if (metadataObj.has("contentType")) builder.putString(MediaMetadataCompat.METADATA_KEY_MEDIA_URI, metadataObj.getString("contentType"));
-            if (metadataObj.has("duration")) builder.putLong(MediaMetadataCompat.METADATA_KEY_DURATION, metadataObj.getLong("duration"));
-            metadata = builder.build();
         }
-        boolean success = implementation.loadMedia(url, metadata);
+        
+        boolean success = implementation.loadMedia(url, title, subtitle, imageUrl, contentType);
+        
         JSObject ret = new JSObject();
         ret.put("success", success);
         if (success) {
             ret.put("message", "Media sent to Cast device.");
+            notifyListeners("mediaLoaded", ret);
             call.resolve(ret);
         } else {
             ret.put("message", "Failed to send media. Check session and device.");
+            notifyListeners("mediaError", ret);
             call.reject("Failed to send media", ret);
         }
     }
+
+    @Override
+    protected void handleOnDestroy() {
+        super.handleOnDestroy();
+        try {
+            CastContext cc = implementation.getCastContext();
+            if (cc != null && sessionListener != null) {
+                cc.getSessionManager().removeSessionManagerListener(sessionListener, CastSession.class);
+            }
+        } catch (Exception ignored) {}
+        try {
+            if (mediaRouter != null && mediaRouterCallback != null) {
+                mediaRouter.removeCallback(mediaRouterCallback);
+            }
+        } catch (Exception ignored) {}
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ionic-chromecast",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Capacitor plugin for Google Cast SDK (Chromecast) integration with Android support",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",