amazon-ivs-react-native-player 1.0.0

package/src/__tests__/index.test.tsx

@@ -0,0 +1,226 @@
+import { render, fireEvent } from '@testing-library/react-native';
+import React from 'react';
+import { UIManager } from 'react-native';
+import type { IVSPlayerRef } from '../types';
+
+import IVSPlayer from '../IVSPlayer';
+
+const URL =
+  'https://fcc3ddae59ed.us-west-2.playback.live-video.net/api/video/v1/us-west-2.893648527354.channel.DmumNckWFTqz.m3u8';
+
+jest.mock('react-native', () => {
+  const RN = jest.requireActual('react-native');
+
+  RN.UIManager.getViewManagerConfig = (name: string) => {
+    if (name === 'AmazonIvs') {
+      return {
+        Commands: {
+          play: 1,
+          pause: 2,
+          seekTo: 3,
+        },
+      };
+    }
+    return {};
+  };
+
+  return RN;
+});
+
+const testCallbackPassing = async (
+  name: string,
+  nativeEvent?: any,
+  result?: any
+) => {
+  const mockFn = jest.fn();
+
+  const { findByTestId } = render(
+    <IVSPlayer streamUrl={URL} {...{ [name]: mockFn }} />
+  );
+  const nativePlayer = await findByTestId('IVSPlayer');
+
+  fireEvent(
+    nativePlayer,
+    name,
+    nativeEvent
+      ? {
+          nativeEvent,
+        }
+      : undefined
+  );
+  expect(mockFn).toHaveBeenCalledWith(result);
+};
+
+test('Renders the native component', async () => {
+  const { findByTestId } = render(<IVSPlayer />);
+  const nativePlayer = await findByTestId('IVSPlayer');
+
+  expect(nativePlayer).toBeDefined();
+});
+
+test('Passing onDurationChange down works correctly', async () => {
+  await testCallbackPassing('onDurationChange', { duration: 1 }, 1);
+});
+
+test('Passing onSeek down works correctly', async () => {
+  await testCallbackPassing('onSeek', { position: 1 }, 1);
+});
+
+test('Passing onData down works correctly', async () => {
+  await testCallbackPassing(
+    'onData',
+    { playerData: { sessionId: 1 } },
+    { sessionId: 1 }
+  );
+});
+
+test('Passing onVideoStatistics down works correctly', async () => {
+  await testCallbackPassing(
+    'onVideoStatistics',
+    { videoData: { duration: 1 } },
+    { duration: 1 }
+  );
+});
+
+test('Passing onPlayerStateChange down works correctly', async () => {
+  await testCallbackPassing('onPlayerStateChange', { state: 1 }, 1);
+});
+
+test('Passing onQualityChange down works correctly', async () => {
+  await testCallbackPassing(
+    'onQualityChange',
+    { quality: { bitrate: 1 } },
+    { bitrate: 1 }
+  );
+});
+
+test('Passing onRebuffering down works correctly', async () => {
+  await testCallbackPassing('onRebuffering');
+});
+
+test('Passing onLoadStart down works correctly', async () => {
+  await testCallbackPassing('onLoadStart');
+});
+
+test('Passing onLoad down works correctly', async () => {
+  await testCallbackPassing('onLoad', { duration: 1 }, 1);
+});
+
+test('Passing onLiveLatencyChange down works correctly', async () => {
+  await testCallbackPassing('onLiveLatencyChange', { liveLatency: 1 }, 1);
+});
+
+test('Passing onTextCue down works correctly', async () => {
+  await testCallbackPassing(
+    'onTextCue',
+    { textCue: { text: 'text' } },
+    { text: 'text' }
+  );
+});
+
+test('Passing onTextMetadataCue down works correctly', async () => {
+  await testCallbackPassing(
+    'onTextMetadataCue',
+    { textMetadataCue: { text: 'text' } },
+    { text: 'text' }
+  );
+});
+
+test('Passing onProgress down works correctly', async () => {
+  await testCallbackPassing('onProgress', { position: 1 }, 1);
+});
+
+test('Passing onError down works correctly', async () => {
+  await testCallbackPassing('onError', { error: 'err' }, 'err');
+});
+
+test('Passing onTimePoint down works correctly', async () => {
+  await testCallbackPassing('onTimePoint', { position: 1 }, 1);
+});
+
+test('Player will autoplay without any props', async () => {
+  const mockCommandFn = jest.fn();
+  UIManager.dispatchViewManagerCommand = mockCommandFn;
+
+  render(<IVSPlayer streamUrl={URL} />);
+
+  expect(mockCommandFn).toHaveBeenCalled();
+
+  // Checking if the second argument of the function is the "play" command
+  expect(mockCommandFn.mock.calls[0][1]).toEqual(1);
+});
+
+test('Paused set to false wont play the video', async () => {
+  const mockCommandFn = jest.fn();
+  UIManager.dispatchViewManagerCommand = mockCommandFn;
+
+  render(<IVSPlayer streamUrl={URL} paused />);
+
+  expect(mockCommandFn).toHaveBeenCalled();
+
+  // Checking if the second argument of the function is the "pause" command
+  expect(mockCommandFn.mock.calls[0][1]).toEqual(2);
+});
+
+test('Using pause on ref calls pause on native component', async () => {
+  const mockCommandFn = jest.fn();
+  const ref = React.createRef<IVSPlayerRef>();
+
+  render(<IVSPlayer streamUrl={URL} ref={ref} />);
+
+  UIManager.dispatchViewManagerCommand = mockCommandFn;
+  ref.current?.pause();
+
+  expect(mockCommandFn).toHaveBeenCalled();
+
+  // Checking if the second argument of the function is the "pause" command
+  expect(mockCommandFn.mock.calls[0][1]).toEqual(2);
+});
+
+test('Using play on ref calls play on native component', async () => {
+  const mockCommandFn = jest.fn();
+  const ref = React.createRef<IVSPlayerRef>();
+
+  render(<IVSPlayer streamUrl={URL} ref={ref} />);
+
+  UIManager.dispatchViewManagerCommand = mockCommandFn;
+  ref.current?.pause();
+  ref.current?.play();
+
+  expect(mockCommandFn).toHaveBeenCalledTimes(2);
+
+  // Checking if the second argument of the function is the "play" command
+  expect(mockCommandFn.mock.calls[1][1]).toEqual(1);
+});
+
+test('Using seekTo on ref calls seekTo on native component', async () => {
+  const mockCommandFn = jest.fn();
+  const ref = React.createRef<IVSPlayerRef>();
+
+  render(<IVSPlayer streamUrl={URL} ref={ref} />);
+
+  UIManager.dispatchViewManagerCommand = mockCommandFn;
+  ref.current?.seekTo(10);
+
+  expect(mockCommandFn).toHaveBeenCalled();
+
+  // Checking if the second argument of the function is the "play" command
+  expect(mockCommandFn.mock.calls[0][1]).toEqual(3);
+
+  // Checking if the value we pass down is proper
+  expect(mockCommandFn.mock.calls[0][2]).toEqual([10]);
+});
+
+test('Autoplay when onLoad', async () => {
+  const mockCommandFn = jest.fn();
+
+  const { findByTestId } = render(<IVSPlayer streamUrl={URL} />);
+  UIManager.dispatchViewManagerCommand = mockCommandFn;
+  const nativePlayer = await findByTestId('IVSPlayer');
+  fireEvent(nativePlayer, 'onLoad', { nativeEvent: { duration: 10 } });
+
+  expect(mockCommandFn).toHaveBeenCalled();
+
+  // Checking if the second argument of the function is the "play" command
+  expect(mockCommandFn.mock.calls[0][1]).toEqual(1);
+});

package/src/enums.js.flow

@@ -0,0 +1,21 @@
+/**
+ * Flowtype definitions for enums
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.13.0
+ * @flow
+ */
+
+declare export var LogLevel: {|
+  +IVSLogLevelDebug: 0, // 0
+  +IVSLogLevelInfo: 1, // 1
+  +IVSLogLevelWarning: 2, // 2
+  +IVSLogLevelError: 3, // 3
+|};
+
+declare export var PlayerState: {|
+  +Idle: 0, // 0
+  +Ready: 1, // 1
+  +Buffering: 2, // 2
+  +Playing: 3, // 3
+  +Ended: 4, // 4
+|};

package/src/enums.ts

@@ -0,0 +1,14 @@
+export enum LogLevel {
+  IVSLogLevelDebug,
+  IVSLogLevelInfo,
+  IVSLogLevelWarning,
+  IVSLogLevelError,
+}
+
+export enum PlayerState {
+  Idle = 'Idle',
+  Ready = 'Ready',
+  Buffering = 'Buffering',
+  Playing = 'Playing',
+  Ended = 'Ended',
+}

package/src/index.js.flow

@@ -0,0 +1,11 @@
+/**
+ * Flowtype definitions for index
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.13.0
+ * @flow
+ */
+
+declare export * from './enums'
+declare export * from './types'
+import IVSPlayer from './IVSPlayer';
+declare export default typeof IVSPlayer;

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './enums';
+export * from './types';
+import IVSPlayer from './IVSPlayer';
+
+export default IVSPlayer;

package/src/types.js.flow

@@ -0,0 +1,44 @@
+/**
+ * Flowtype definitions for types
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.13.0
+ * @flow
+ */
+
+export type Quality = {|
+  name: string,
+  codecs: string,
+  bitrate: number,
+  framerate: number,
+  width: number,
+  height: number,
+|};
+export type PlayerData = {|
+  qualities: Quality[],
+  version: string,
+  sessionId: string,
+|};
+export type VideoData = {|
+  bitrate: number,
+  duration: number | null,
+  framesDecoded: number | null,
+  framesDropped: number | null,
+|};
+export type TextCue = {|
+  type: string,
+  line: number,
+  size: number,
+  position: number,
+  text: string,
+  textAlignment: string,
+|};
+export type TextMetadataCue = {|
+  type: string,
+  text: string,
+  textDescription: string,
+|};
+export type IVSPlayerRef = {|
+  play: () => void,
+  pause: () => void,
+  seekTo: (position: number) => void,
+|};

package/src/types.ts

@@ -0,0 +1,42 @@
+export type Quality = {
+  name: string;
+  codecs: string;
+  bitrate: number;
+  framerate: number;
+  width: number;
+  height: number;
+};
+
+export type PlayerData = {
+  qualities: Quality[];
+  version: string;
+  sessionId: string;
+};
+
+export type VideoData = {
+  bitrate: number;
+  duration: number | null;
+  framesDecoded: number | null;
+  framesDropped: number | null;
+};
+
+export type TextCue = {
+  type: string;
+  line: number;
+  size: number;
+  position: number;
+  text: string;
+  textAlignment: string;
+};
+
+export type TextMetadataCue = {
+  type: string;
+  text: string;
+  textDescription: string;
+};
+
+export type IVSPlayerRef = {
+  play: () => void;
+  pause: () => void;
+  seekTo: (position: number) => void;
+};