@neoskola/auto-play 0.2.18 → 0.3.1

package/nitrogen/generated/ios/swift/HybridNowPlayingTemplateSpec_cxx.swift

@@ -184,4 +184,118 @@ open class HybridNowPlayingTemplateSpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func playAudio(templateId: std.string, url: std.string, startFrom: Double) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.playAudio(templateId: String(templateId), url: String(url), startFrom: startFrom)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func pauseAudio(templateId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.pauseAudio(templateId: String(templateId))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func resumeAudio(templateId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.resumeAudio(templateId: String(templateId))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func seekForward(templateId: std.string, seconds: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.seekForward(templateId: String(templateId), seconds: seconds)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func seekBackward(templateId: std.string, seconds: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.seekBackward(templateId: String(templateId), seconds: seconds)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func stopAudio(templateId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.stopAudio(templateId: String(templateId))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/ios/swift/NowPlayingTemplateConfig.swift

@@ -19,7 +19,7 @@ public extension NowPlayingTemplateConfig {
   /**
    * Create a new instance of `NowPlayingTemplateConfig`.
    */
-  init(id: String, onWillAppear: ((_ animated: Bool?) -> Void)?, onWillDisappear: ((_ animated: Bool?) -> Void)?, onDidAppear: ((_ animated: Bool?) -> Void)?, onDidDisappear: ((_ animated: Bool?) -> Void)?, onPopped: (() -> Void)?, autoDismissMs: Double?, title: AutoText, subtitle: AutoText?, courseId: String, lessonId: String, image: Variant_GlyphImage_AssetImage?, isPlaying: Bool, onPlay: (() -> Void)?, onPause: (() -> Void)?, onSkipForward: (() -> Void)?, onSkipBackward: (() -> Void)?, onComplete: (() -> Void)?) {
+  init(id: String, onWillAppear: ((_ animated: Bool?) -> Void)?, onWillDisappear: ((_ animated: Bool?) -> Void)?, onDidAppear: ((_ animated: Bool?) -> Void)?, onDidDisappear: ((_ animated: Bool?) -> Void)?, onPopped: (() -> Void)?, autoDismissMs: Double?, title: AutoText, subtitle: AutoText?, courseId: String, lessonId: String, image: Variant_GlyphImage_AssetImage?, isPlaying: Bool, onPlay: (() -> Void)?, onPause: (() -> Void)?, onSkipForward: (() -> Void)?, onSkipBackward: (() -> Void)?, onComplete: (() -> Void)?, onProgressUpdate: ((_ currentTime: Double, _ duration: Double) -> Void)?, onPlaybackFinished: (() -> Void)?) {
     self.init(std.string(id), { () -> bridge.std__optional_std__function_void_std__optional_bool_____animated______ in
       if let __unwrappedValue = onWillAppear {
         return bridge.create_std__optional_std__function_void_std__optional_bool_____animated______({ () -> bridge.Func_void_std__optional_bool_ in
@@ -135,6 +135,24 @@ public extension NowPlayingTemplateConfig {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_std__function_void_double____currentTime_____double____duration______ in
+      if let __unwrappedValue = onProgressUpdate {
+        return bridge.create_std__optional_std__function_void_double____currentTime_____double____duration______({ () -> bridge.Func_void_double_double in
+          let __closureWrapper = Func_void_double_double(__unwrappedValue)
+          return bridge.create_Func_void_double_double(__closureWrapper.toUnsafe())
+        }())
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__function_void____ in
+      if let __unwrappedValue = onPlaybackFinished {
+        return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+          let __closureWrapper = Func_void(__unwrappedValue)
+          return bridge.create_Func_void(__closureWrapper.toUnsafe())
+        }())
+      } else {
+        return .init()
+      }
     }())
   }
 
@@ -613,4 +631,68 @@ public extension NowPlayingTemplateConfig {
       }()
     }
   }
+  
+  var onProgressUpdate: ((_ currentTime: Double, _ duration: Double) -> Void)? {
+    @inline(__always)
+    get {
+      return { () -> ((_ currentTime: Double, _ duration: Double) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_double____currentTime_____double____duration______(self.__onProgressUpdate) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_double____currentTime_____double____duration______(self.__onProgressUpdate)
+          return { () -> (Double, Double) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_double_double(__unwrapped)
+            return { (__currentTime: Double, __duration: Double) -> Void in
+              __wrappedFunction.call(__currentTime, __duration)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__onProgressUpdate = { () -> bridge.std__optional_std__function_void_double____currentTime_____double____duration______ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__function_void_double____currentTime_____double____duration______({ () -> bridge.Func_void_double_double in
+            let __closureWrapper = Func_void_double_double(__unwrappedValue)
+            return bridge.create_Func_void_double_double(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var onPlaybackFinished: (() -> Void)? {
+    @inline(__always)
+    get {
+      return { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(self.__onPlaybackFinished) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(self.__onPlaybackFinished)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__onPlaybackFinished = { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
 }

package/nitrogen/generated/shared/c++/HybridNowPlayingTemplateSpec.cpp

@@ -18,6 +18,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       prototype.registerHybridMethod("updateNowPlayingTemplatePlaybackState", &HybridNowPlayingTemplateSpec::updateNowPlayingTemplatePlaybackState);
       prototype.registerHybridMethod("updateNowPlayingTemplateInfo", &HybridNowPlayingTemplateSpec::updateNowPlayingTemplateInfo);
       prototype.registerHybridMethod("updateNowPlayingTemplateElapsedTime", &HybridNowPlayingTemplateSpec::updateNowPlayingTemplateElapsedTime);
+      prototype.registerHybridMethod("playAudio", &HybridNowPlayingTemplateSpec::playAudio);
+      prototype.registerHybridMethod("pauseAudio", &HybridNowPlayingTemplateSpec::pauseAudio);
+      prototype.registerHybridMethod("resumeAudio", &HybridNowPlayingTemplateSpec::resumeAudio);
+      prototype.registerHybridMethod("seekForward", &HybridNowPlayingTemplateSpec::seekForward);
+      prototype.registerHybridMethod("seekBackward", &HybridNowPlayingTemplateSpec::seekBackward);
+      prototype.registerHybridMethod("stopAudio", &HybridNowPlayingTemplateSpec::stopAudio);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridNowPlayingTemplateSpec.hpp

@@ -55,6 +55,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       virtual std::shared_ptr<Promise<void>> updateNowPlayingTemplatePlaybackState(const std::string& templateId, bool isPlaying) = 0;
       virtual std::shared_ptr<Promise<void>> updateNowPlayingTemplateInfo(const std::string& templateId, const std::string& title, const std::string& subtitle) = 0;
       virtual std::shared_ptr<Promise<void>> updateNowPlayingTemplateElapsedTime(const std::string& templateId, double elapsedTime, double duration) = 0;
+      virtual std::shared_ptr<Promise<bool>> playAudio(const std::string& templateId, const std::string& url, double startFrom) = 0;
+      virtual std::shared_ptr<Promise<void>> pauseAudio(const std::string& templateId) = 0;
+      virtual std::shared_ptr<Promise<void>> resumeAudio(const std::string& templateId) = 0;
+      virtual std::shared_ptr<Promise<void>> seekForward(const std::string& templateId, double seconds) = 0;
+      virtual std::shared_ptr<Promise<void>> seekBackward(const std::string& templateId, double seconds) = 0;
+      virtual std::shared_ptr<Promise<void>> stopAudio(const std::string& templateId) = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/NowPlayingTemplateConfig.hpp

@@ -63,10 +63,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     std::optional<std::function<void()>> onSkipForward     SWIFT_PRIVATE;
     std::optional<std::function<void()>> onSkipBackward     SWIFT_PRIVATE;
     std::optional<std::function<void()>> onComplete     SWIFT_PRIVATE;
+    std::optional<std::function<void(double /* currentTime */, double /* duration */)>> onProgressUpdate     SWIFT_PRIVATE;
+    std::optional<std::function<void()>> onPlaybackFinished     SWIFT_PRIVATE;
 
   public:
     NowPlayingTemplateConfig() = default;
-    explicit NowPlayingTemplateConfig(std::string id, std::optional<std::function<void(std::optional<bool> /* animated */)>> onWillAppear, std::optional<std::function<void(std::optional<bool> /* animated */)>> onWillDisappear, std::optional<std::function<void(std::optional<bool> /* animated */)>> onDidAppear, std::optional<std::function<void(std::optional<bool> /* animated */)>> onDidDisappear, std::optional<std::function<void()>> onPopped, std::optional<double> autoDismissMs, AutoText title, std::optional<AutoText> subtitle, std::string courseId, std::string lessonId, std::optional<std::variant<GlyphImage, AssetImage>> image, bool isPlaying, std::optional<std::function<void()>> onPlay, std::optional<std::function<void()>> onPause, std::optional<std::function<void()>> onSkipForward, std::optional<std::function<void()>> onSkipBackward, std::optional<std::function<void()>> onComplete): id(id), onWillAppear(onWillAppear), onWillDisappear(onWillDisappear), onDidAppear(onDidAppear), onDidDisappear(onDidDisappear), onPopped(onPopped), autoDismissMs(autoDismissMs), title(title), subtitle(subtitle), courseId(courseId), lessonId(lessonId), image(image), isPlaying(isPlaying), onPlay(onPlay), onPause(onPause), onSkipForward(onSkipForward), onSkipBackward(onSkipBackward), onComplete(onComplete) {}
+    explicit NowPlayingTemplateConfig(std::string id, std::optional<std::function<void(std::optional<bool> /* animated */)>> onWillAppear, std::optional<std::function<void(std::optional<bool> /* animated */)>> onWillDisappear, std::optional<std::function<void(std::optional<bool> /* animated */)>> onDidAppear, std::optional<std::function<void(std::optional<bool> /* animated */)>> onDidDisappear, std::optional<std::function<void()>> onPopped, std::optional<double> autoDismissMs, AutoText title, std::optional<AutoText> subtitle, std::string courseId, std::string lessonId, std::optional<std::variant<GlyphImage, AssetImage>> image, bool isPlaying, std::optional<std::function<void()>> onPlay, std::optional<std::function<void()>> onPause, std::optional<std::function<void()>> onSkipForward, std::optional<std::function<void()>> onSkipBackward, std::optional<std::function<void()>> onComplete, std::optional<std::function<void(double /* currentTime */, double /* duration */)>> onProgressUpdate, std::optional<std::function<void()>> onPlaybackFinished): id(id), onWillAppear(onWillAppear), onWillDisappear(onWillDisappear), onDidAppear(onDidAppear), onDidDisappear(onDidDisappear), onPopped(onPopped), autoDismissMs(autoDismissMs), title(title), subtitle(subtitle), courseId(courseId), lessonId(lessonId), image(image), isPlaying(isPlaying), onPlay(onPlay), onPause(onPause), onSkipForward(onSkipForward), onSkipBackward(onSkipBackward), onComplete(onComplete), onProgressUpdate(onProgressUpdate), onPlaybackFinished(onPlaybackFinished) {}
   };
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay
@@ -96,7 +98,9 @@ namespace margelo::nitro {
         JSIConverter<std::optional<std::function<void()>>>::fromJSI(runtime, obj.getProperty(runtime, "onPause")),
         JSIConverter<std::optional<std::function<void()>>>::fromJSI(runtime, obj.getProperty(runtime, "onSkipForward")),
         JSIConverter<std::optional<std::function<void()>>>::fromJSI(runtime, obj.getProperty(runtime, "onSkipBackward")),
-        JSIConverter<std::optional<std::function<void()>>>::fromJSI(runtime, obj.getProperty(runtime, "onComplete"))
+        JSIConverter<std::optional<std::function<void()>>>::fromJSI(runtime, obj.getProperty(runtime, "onComplete")),
+        JSIConverter<std::optional<std::function<void(double, double)>>>::fromJSI(runtime, obj.getProperty(runtime, "onProgressUpdate")),
+        JSIConverter<std::optional<std::function<void()>>>::fromJSI(runtime, obj.getProperty(runtime, "onPlaybackFinished"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::swe::iternio::reactnativeautoplay::NowPlayingTemplateConfig& arg) {
@@ -119,6 +123,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, "onSkipForward", JSIConverter<std::optional<std::function<void()>>>::toJSI(runtime, arg.onSkipForward));
       obj.setProperty(runtime, "onSkipBackward", JSIConverter<std::optional<std::function<void()>>>::toJSI(runtime, arg.onSkipBackward));
       obj.setProperty(runtime, "onComplete", JSIConverter<std::optional<std::function<void()>>>::toJSI(runtime, arg.onComplete));
+      obj.setProperty(runtime, "onProgressUpdate", JSIConverter<std::optional<std::function<void(double, double)>>>::toJSI(runtime, arg.onProgressUpdate));
+      obj.setProperty(runtime, "onPlaybackFinished", JSIConverter<std::optional<std::function<void()>>>::toJSI(runtime, arg.onPlaybackFinished));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -147,6 +153,8 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<std::function<void()>>>::canConvert(runtime, obj.getProperty(runtime, "onSkipForward"))) return false;
       if (!JSIConverter<std::optional<std::function<void()>>>::canConvert(runtime, obj.getProperty(runtime, "onSkipBackward"))) return false;
       if (!JSIConverter<std::optional<std::function<void()>>>::canConvert(runtime, obj.getProperty(runtime, "onComplete"))) return false;
+      if (!JSIConverter<std::optional<std::function<void(double, double)>>>::canConvert(runtime, obj.getProperty(runtime, "onProgressUpdate"))) return false;
+      if (!JSIConverter<std::optional<std::function<void()>>>::canConvert(runtime, obj.getProperty(runtime, "onPlaybackFinished"))) return false;
       return true;
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neoskola/auto-play",
-  "version": "0.2.18",
+  "version": "0.3.1",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",

package/src/specs/NowPlayingTemplate.nitro.ts

@@ -9,4 +9,12 @@ export interface NowPlayingTemplate extends HybridObject<{ android: 'kotlin'; io
   updateNowPlayingTemplatePlaybackState(templateId: string, isPlaying: boolean): Promise<void>;
   updateNowPlayingTemplateInfo(templateId: string, title: string, subtitle: string): Promise<void>;
   updateNowPlayingTemplateElapsedTime(templateId: string, elapsedTime: number, duration: number): Promise<void>;
+
+  // Native audio playback
+  playAudio(templateId: string, url: string, startFrom: number): Promise<boolean>;
+  pauseAudio(templateId: string): Promise<void>;
+  resumeAudio(templateId: string): Promise<void>;
+  seekForward(templateId: string, seconds: number): Promise<void>;
+  seekBackward(templateId: string, seconds: number): Promise<void>;
+  stopAudio(templateId: string): Promise<void>;
 }

package/src/templates/NowPlayingTemplate.ts

@@ -25,6 +25,8 @@ export interface NitroNowPlayingTemplateConfig extends TemplateConfig {
   onSkipForward?: () => void;
   onSkipBackward?: () => void;
   onComplete?: () => void;
+  onProgressUpdate?: (currentTime: number, duration: number) => void;
+  onPlaybackFinished?: () => void;
 }
 
 export type NowPlayingTemplateConfig = Omit<
@@ -63,4 +65,28 @@ export class NowPlayingTemplate extends Template<
   public updateElapsedTime(elapsedTime: number, duration: number) {
     return HybridNowPlayingTemplate.updateNowPlayingTemplateElapsedTime(this.id, elapsedTime, duration);
   }
+
+  public playAudio(url: string, startFrom: number = 0): Promise<boolean> {
+    return HybridNowPlayingTemplate.playAudio(this.id, url, startFrom);
+  }
+
+  public pauseAudio(): Promise<void> {
+    return HybridNowPlayingTemplate.pauseAudio(this.id);
+  }
+
+  public resumeAudio(): Promise<void> {
+    return HybridNowPlayingTemplate.resumeAudio(this.id);
+  }
+
+  public seekForward(seconds: number = 30): Promise<void> {
+    return HybridNowPlayingTemplate.seekForward(this.id, seconds);
+  }
+
+  public seekBackward(seconds: number = 30): Promise<void> {
+    return HybridNowPlayingTemplate.seekBackward(this.id, seconds);
+  }
+
+  public stopAudio(): Promise<void> {
+    return HybridNowPlayingTemplate.stopAudio(this.id);
+  }
 }