Feat/VideoDeepLinks for Player and MetaDetails + send more events

stremio-core-kotlin/src/commonMain/rust/env/env.rs

@@ -20,6 +20,7 @@ use stremio_core::{
     analytics::Analytics,
     models::{ctx::Ctx, streaming_server::StreamingServer},
     runtime::{msg::Event, Env, EnvError, EnvFuture, EnvFutureExt, TryEnvFuture},
+    types::api::AuthRequest,
 };
 
 use crate::{
@@ -113,35 +114,63 @@ impl AndroidEnv {
     }
     pub fn emit_to_analytics(event: &AndroidEvent, model: &AndroidModel, path: &str) {
         let (name, data) = match event {
-            AndroidEvent::CoreEvent(Event::PlayerPlaying { load_time, context }) => (
-                "playerPlaying".to_owned(),
-                json!({
-                    "loadTime": load_time,
-                    "player": context
-                }),
-            ),
-            AndroidEvent::CoreEvent(Event::PlayerStopped { context }) => {
-                ("playerStopped".to_owned(), json!({ "player": context }))
-            }
-            AndroidEvent::CoreEvent(Event::PlayerEnded {
-                context,
-                is_binge_enabled,
-                is_playing_next_video,
-            }) => (
-                "playerEnded".to_owned(),
-                json!({
-                   "player": context,
-                   "isBingeEnabled": is_binge_enabled,
-                   "isPlayingNextVideo": is_playing_next_video
-                }),
-            ),
-            AndroidEvent::CoreEvent(Event::TraktPlaying { context }) => {
-                ("traktPlaying".to_owned(), json!({ "player": context }))
-            }
-            AndroidEvent::CoreEvent(Event::TraktPaused { context }) => {
-                ("traktPaused".to_owned(), json!({ "player": context }))
-            }
-            _ => return,
+            AndroidEvent::CoreEvent(core_event) => match core_event {
+                Event::UserAuthenticated { auth_request } => (
+                    "login".to_owned(),
+                    json!({
+                        "type": match auth_request {
+                            AuthRequest::Login { facebook, .. } if *facebook => "facebook",
+                            AuthRequest::Login { .. } => "login",
+                            AuthRequest::Facebook { .. } => "authWithFacebook",
+                            AuthRequest::LoginWithToken { .. } => "loginWithToken",
+                            AuthRequest::Register { .. } => "register",
+                        },
+                    }),
+                ),
+                Event::AddonInstalled { transport_url, id } => (
+                    "installAddon".to_owned(),
+                    json!({
+                        "addonTransportUrl": transport_url,
+                        "addonID": id
+                    }),
+                ),
+                Event::AddonUninstalled { transport_url, id } => (
+                    "removeAddon".to_owned(),
+                    json!({
+                        "addonTransportUrl": transport_url,
+                        "addonID": id
+                    }),
+                ),
+                Event::PlayerPlaying { load_time, context } => (
+                    "playerPlaying".to_owned(),
+                    json!({
+                        "loadTime": load_time,
+                        "player": context
+                    }),
+                ),
+                Event::PlayerStopped { context } => {
+                    ("playerStopped".to_owned(), json!({ "player": context }))
+                }
+                Event::PlayerEnded {
+                    context,
+                    is_binge_enabled,
+                    is_playing_next_video,
+                } => (
+                    "playerEnded".to_owned(),
+                    json!({
+                       "player": context,
+                       "isBingeEnabled": is_binge_enabled,
+                       "isPlayingNextVideo": is_playing_next_video
+                    }),
+                ),
+                Event::TraktPlaying { context } => {
+                    ("traktPlaying".to_owned(), json!({ "player": context }))
+                }
+                Event::TraktPaused { context } => {
+                    ("traktPaused".to_owned(), json!({ "player": context }))
+                }
+                _ => return,
+            },
         };
         ANALYTICS.emit(name, data, &model.ctx, &model.streaming_server, path);
     }

stremio-core-kotlin/src/commonMain/rust/model/model.rs

@@ -164,7 +164,7 @@ impl AndroidModel {
                 .encode_to_vec(),
             AndroidModelField::MetaDetails => self
                 .meta_details
-                .to_protobuf::<AndroidEnv>(&self.ctx)
+                .to_protobuf::<AndroidEnv>(&(&self.ctx, &self.streaming_server))
                 .encode_to_vec(),
             AndroidModelField::AddonDetails => self
                 .addon_details
@@ -176,7 +176,7 @@ impl AndroidModel {
                 .encode_to_vec(),
             AndroidModelField::Player => self
                 .player
-                .to_protobuf::<AndroidEnv>(&self.ctx)
+                .to_protobuf::<AndroidEnv>(&(&self.ctx, &self.streaming_server))
                 .encode_to_vec(),
 
             // guard against new fields  being added to the CSharp model

stremio-core-protobuf/proto/stremio/core/types/video.proto

@@ -18,9 +18,28 @@ message Video {
   required bool upcoming = 8;
   required bool watched = 9;
   required bool current_video = 10;
+  // Watch progress percentage
+  optional double progress = 11;
+  // scheduled: bool,
+
+  required VideoDeepLinks deep_links = 12;
 
   message SeriesInfo {
     required int64 season = 1;
     required int64 episode = 2;
   }
+}
+
+message VideoDeepLinks {
+  required string meta_details_videos = 1;
+  required string meta_details_streams = 2;
+  // pub player: Option<String>,
+  // pub external_player: Option<ExternalPlayerLink>,
+  optional string player = 3;
+  required ExternalPlayerLink external_player = 4;
+
+  message ExternalPlayerLink {
+    optional string download = 1;
+    optional string streaming = 2;
+  }
 }

stremio-core-protobuf/src/bridge/loadable.rs

@@ -7,7 +7,7 @@ use stremio_core::{
         common::{Loadable, ResourceError},
         ctx::{Ctx, CtxError},
         link::LinkError,
-        streaming_server::PlaybackDevice,
+        streaming_server::{PlaybackDevice, StreamingServer},
     },
     runtime::EnvError,
     types::{
@@ -53,6 +53,8 @@ impl
     ToProtobuf<
         models::loadable_meta_item::Content,
         (
+            &Ctx,
+            &StreamingServer,
             Option<&LibraryItem>,
             Option<&WatchedBitField>,
             Option<&String>,
@@ -62,17 +64,26 @@ impl
 {
     fn to_protobuf<E: stremio_core::runtime::Env + 'static>(
         &self,
-        (library_item, watched, addon_name, meta_request): &(
+        (ctx, streaming_server, library_item, watched, addon_name, meta_request): &(
+            &Ctx,
+            &StreamingServer,
             Option<&LibraryItem>,
             Option<&WatchedBitField>,
             Option<&String>,
             &ResourceRequest,
         ),
     ) -> models::loadable_meta_item::Content {
         match &self {
-            Loadable::Ready(ready) => models::loadable_meta_item::Content::Ready(
-                ready.to_protobuf::<E>(&(*library_item, *watched, *addon_name, *meta_request)),
-            ),
+            Loadable::Ready(ready) => {
+                models::loadable_meta_item::Content::Ready(ready.to_protobuf::<E>(&(
+                    *ctx,
+                    *streaming_server,
+                    *library_item,
+                    *watched,
+                    *addon_name,
+                    *meta_request,
+                )))
+            }
             Loadable::Err(error) => models::loadable_meta_item::Content::Error(models::Error {
                 message: error.to_string(),
             }),

stremio-core-protobuf/src/bridge/resource_loadable.rs

@@ -6,6 +6,7 @@ use stremio_core::{
     models::{
         common::{DescriptorLoadable, ResourceLoadable},
         ctx::Ctx,
+        streaming_server::StreamingServer,
     },
     types::{
         addon::{Descriptor, ResourceRequest},
@@ -60,18 +61,33 @@ impl ToProtobuf<models::LoadablePage, Ctx> for ResourceLoadable<Vec<MetaItemPrev
     }
 }
 
-impl ToProtobuf<models::LoadableMetaItem, (&Ctx, Option<&LibraryItem>, Option<&WatchedBitField>)>
-    for &ResourceLoadable<MetaItem>
+impl
+    ToProtobuf<
+        models::LoadableMetaItem,
+        (
+            &Ctx,
+            &StreamingServer,
+            Option<&LibraryItem>,
+            Option<&WatchedBitField>,
+        ),
+    > for &ResourceLoadable<MetaItem>
 {
     fn to_protobuf<E: stremio_core::runtime::Env + 'static>(
         &self,
-        (ctx, library_item, watched): &(&Ctx, Option<&LibraryItem>, Option<&WatchedBitField>),
+        (ctx, streming_server, library_item, watched): &(
+            &Ctx,
+            &StreamingServer,
+            Option<&LibraryItem>,
+            Option<&WatchedBitField>,
+        ),
     ) -> models::LoadableMetaItem {
         let addon_name = get_addon_name(ctx, &self.request.base);
         models::LoadableMetaItem {
             title: addon_name.to_string(),
             request: self.request.to_protobuf::<E>(&()),
             content: self.content.to_protobuf::<E>(&(
+                *ctx,
+                *streming_server,
                 *library_item,
                 *watched,
                 Some(&addon_name),