@takeoffmedia/react-native-penthera 0.3.7 → 0.4.0

package/src/hooks/usePenthera/usePenthera.tsx

@@ -4,6 +4,7 @@ import type {
   PentheraState,
   PentheraAction,
   InterfaceDataPlay,
+  AssetError,
 } from './usePenthera.types';
 import {
   deleteMany,
@@ -15,136 +16,161 @@ import {
 } from '../../nativeModules';
 import type { PentheraTypes } from '../../interface/PentheraTypes';
 
-export const usePenthera = create<PentheraState & PentheraAction>((set) => ({
-  assets: [],
-  assetsProgress: {},
-  assetError: {
-    assetId: '',
-    description: '',
-  },
-  assetsPending: [],
-  loadAssets: (assets: PentheraState['assets']) =>
-    set(() => ({
-      assets,
-    })),
-  addAsset: (asset) =>
-    set((state) => ({
-      assets: [...state.assets, asset],
-    })),
-  updateAssetsProgress: (progress) =>
-    set((state) => {
-      return {
-        assetsProgress: {
-          ...state.assetsProgress,
-          ...progress,
-        },
-      };
-    }),
-  updateAssetCompleted: (assetID: string) => {
-    set((state) => {
-      const assets = state.assets.map((item) => {
-        if (item.id === assetID) {
-          return { ...item, isCompleted: true };
-        }
-        return item;
-      });
-      return {
+export const usePenthera = create<PentheraState & PentheraAction>(
+  (set, get) => ({
+    assets: [],
+    assetsProgress: {},
+    assetError: [],
+    assetsPending: [],
+    loadAssets: (assets: PentheraState['assets']) =>
+      set(() => ({
         assets,
-      };
-    });
-  },
-  onGetAllAssets: async () => {
-    try {
-      const assets: PentheraTypes.ItemCatalog[] = await getDownloads('');
-      if (Array.isArray(assets)) {
-        const uniqueAssets = assets.filter(
-          (item, index, self) =>
-            self.findIndex((i) => i.id === item.id) === index
-        );
-        return set(() => ({
-          assets: uniqueAssets,
+      })),
+    addAsset: (asset) =>
+      set((state) => ({
+        assets: [...state.assets, asset],
+      })),
+    updateAssetsProgress: (progress) =>
+      set((state) => {
+        return {
+          assetsProgress: {
+            ...state.assetsProgress,
+            ...progress,
+          },
+        };
+      }),
+    updateAssetCompleted: (assetID: string) => {
+      set((state) => {
+        const assets = state.assets.map((item) => {
+          if (item.id === assetID) {
+            return { ...item, isCompleted: true };
+          }
+          return item;
+        });
+        return {
+          assets,
+        };
+      });
+    },
+    onGetAllAssets: async () => {
+      try {
+        const assets: PentheraTypes.ItemCatalog[] = await getDownloads('');
+        if (Array.isArray(assets)) {
+          const uniqueAssets = assets.filter(
+            (item, index, self) =>
+              self.findIndex((i) => i.id === item.id) === index
+          );
+          return set(() => ({
+            assets: uniqueAssets,
+          }));
+        }
+      } catch (error) {
+        console.log('error in getDownloads', error);
+      }
+    },
+    onDownload: async ({ item, url, drm }) => {
+      try {
+        await download(JSON.stringify({ item, url, drm }));
+        return set((state) => ({
+          assets: [...state.assets, { ...item, id: item.data.mediaId }],
+          assetsPending: state.assetsPending.filter(
+            (asset) => asset.id !== item.data.mediaId
+          ),
         }));
+      } catch (error) {
+        console.error('error: downloadAsset', error);
+      }
+    },
+    deleteMany: async (assetIds: string[]) => {
+      try {
+        const vpids = assetIds.map((assetId) =>
+          get().getVpidByMediaId(assetId)
+        );
+        const response = await deleteMany(vpids);
+        const vpidsDeleted = Object.keys(response).filter(
+          (item) => response[item]
+        );
+        const deleted = vpidsDeleted.map((assetId) =>
+          get().getMediaIdByVpid(assetId)
+        );
+        return set((state) => {
+          const updatedAssetsProgress = { ...state.assetsProgress };
+          deleted.forEach((assetId: string) => {
+            if (state) {
+              delete updatedAssetsProgress[assetId];
+            }
+          });
+          return {
+            assets: state.assets.filter(
+              (asset) => !deleted.includes(asset.id as string)
+            ),
+            assetsProgress: updatedAssetsProgress,
+          };
+        });
+      } catch (error) {
+        console.error('Error: deleteMany', error);
       }
-    } catch (error) {
-      console.log('error in getDownloads', error);
-    }
-  },
-  onDownload: async ({ item, url, drm }) => {
-    try {
-      await download(JSON.stringify({ item, url, drm }));
+    },
+    onPauseDownload: async (assetId: string) => {
+      await pauseDownload(assetId);
+    },
+    onPlayVideo: async (assetId: string) => {
+      try {
+        const vpid = get().getVpidByMediaId(assetId);
+        const response: InterfaceDataPlay = await playAsset(vpid);
+        return response;
+      } catch (error) {
+        console.log('error in onPlayVideo', error);
+        return {};
+      }
+    },
+    setError: (dataError: AssetError) => {
+      return set((state) => {
+        const assetIdExists = state.assetError.some(
+          (error) => error.assetId === dataError.assetId
+        );
+        if (!assetIdExists) {
+          return {
+            assetError: [...state.assetError, { ...dataError }],
+            assetsProgress: {},
+          };
+        }
+        return state;
+      });
+    },
+    removeError: (assetIdToRemove: string) => {
       return set((state) => ({
-        assets: [...state.assets, item],
-        assetError: {
-          assetId: '',
-          description: '',
-        },
+        assetError: state.assetError.filter(
+          (error) => error.assetId !== assetIdToRemove
+        ),
+        assetsProgress: {},
+      }));
+    },
+    setConfigParameters: async (data) => {
+      await configParameters(JSON.stringify(data));
+    },
+    clearAssetProgress: () => {
+      return set(() => ({
+        assetsProgress: {},
+      }));
+    },
+    setAssetPending: (asset: PentheraTypes.ItemCatalog) => {
+      set((state) => ({
+        assetsPending: [...state.assetsPending, asset],
+      }));
+    },
+    removeAssetPending: (assetId: string) => {
+      set((state) => ({
         assetsPending: state.assetsPending.filter(
-          (asset) => asset.id !== item.id
+          (asset) => asset.id !== assetId
         ),
       }));
-    } catch (error) {
-      console.error('error: downloadAsset', error);
-    }
-  },
-  deleteMany: async (assetIds: string[]) => {
-    try {
-      const response = await deleteMany(assetIds);
-      const deleted = Object.keys(response).filter((item) => response[item]);
-
-      return set((state) => {
-        const updatedAssetsProgress = { ...state.assetsProgress };
-        deleted.forEach((assetId: string) => {
-          if (state) {
-            delete updatedAssetsProgress[assetId];
-          }
-        });
-        return {
-          assets: state.assets.filter(
-            (asset) => !deleted.includes(asset.id as string)
-          ),
-          assetsProgress: updatedAssetsProgress,
-        };
-      });
-    } catch (error) {
-      console.error('Error: deleteMany', error);
-    }
-  },
-  onPauseDownload: async (assetId: string) => {
-    await pauseDownload(assetId);
-  },
-  onPlayVideo: async (assetId: string) => {
-    try {
-      const response: InterfaceDataPlay = await playAsset(assetId);
-      return response;
-    } catch (error) {
-      console.log('error in onPlayVideo', error);
-      return {};
-    }
-  },
-  setError: (dataParse) => {
-    return set(() => ({
-      assetError: dataParse,
-      assetsProgress: {},
-    }));
-  },
-  setConfigParameters: async (data) => {
-    await configParameters(JSON.stringify(data));
-  },
-  clearAssetProgress: () => {
-    return set(() => ({
-      assetsProgress: {},
-    }));
-  },
-  setAssetPending: (asset: PentheraTypes.ItemCatalog) => {
-    set((state) => ({
-      assetsPending: [...state.assetsPending, asset],
-    }));
-  },
-  removeAssetPending: (assetId: string) => {
-    set((state) => ({
-      assetsPending: state.assetsPending.filter(
-        (asset) => asset.id !== assetId
-      ),
-    }));
-  },
-}));
+    },
+    getVpidByMediaId: (mediaId: string) =>
+      get().assets.find((item) => item.data.mediaId === mediaId)?.data?.vpid ??
+      '',
+    getMediaIdByVpid: (vpid: string) =>
+      get().assets?.find((item) => item.data.vpid === vpid)?.data?.mediaId ??
+      '',
+  })
+);

package/src/hooks/usePenthera/usePenthera.types.ts

@@ -24,6 +24,13 @@ export type Subtitle = {
   language: string;
 };
 
+export interface InfoVideoPlayer {
+  advisoryClassification: string;
+  advisoryDescription: string;
+  description: string;
+  title: string;
+}
+
 export interface InterfaceDataPlay {
   url?: string;
   license?: string;
@@ -33,12 +40,13 @@ export interface InterfaceDataPlay {
   js?: string;
   css?: string;
   hasZoom?: boolean;
+  infoVideoPlayer?: InfoVideoPlayer;
 }
 
 export type PentheraState = {
   assets: PentheraTypes.ItemCatalog[] | [];
   assetsProgress: AssetProgress | {};
-  assetError: AssetError;
+  assetError: AssetError[] | [];
   assetsPending: PentheraTypes.ItemCatalog[] | [];
 };
 
@@ -69,6 +77,9 @@ export type PentheraAction = {
   updateAssetCompleted: (assetID: string) => void;
   setAssetPending: (assets: PentheraTypes.ItemCatalog) => void;
   removeAssetPending: (assetID: string) => void;
+  removeError: (id: string) => void;
+  getVpidByMediaId: (mediaId: string) => string;
+  getMediaIdByVpid: (vpid: string) => string;
 };
 
 export type Event = {

package/src/hooks/usePenthera/usePentheraInit.tsx

@@ -109,7 +109,6 @@ export function usePentheraInit({
   ]);
 }
 
-
 export function usePentheraInitV2() {
   const [isInitialized, setIsInitialized] = useState(false);
   const updateAssetsProgress = usePenthera(
@@ -164,17 +163,17 @@ export function usePentheraInitV2() {
       }
     };
     const event = eventEmitter.addListener('penthera', sessionConnect);
-    
+
     onGetAllAssets();
 
     return () => {
       event.remove();
-    }
-  }, [isInitialized])
-  
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isInitialized]);
 
   return {
     isInitialized,
-    setIsInitialized
-  }
+    setIsInitialized,
+  };
 }

package/src/interface/PentheraTypes.ts

@@ -11,7 +11,7 @@ export declare namespace PentheraTypes {
     drm: boolean | string;
     thumbnails?: Thumbnails;
     subtitles?: Subtitles;
-    data?: DataItem;
+    data: DataItem;
     isCompleted?: boolean;
     download_percentage?: number;
     isPaused?: boolean;
@@ -53,6 +53,8 @@ export declare namespace PentheraTypes {
     isExpired?: boolean;
     effectiveExpiryDate?: string;
     expiryDate?: string;
+    mediaId: string;
+    vpid: string;
   }
 
   export interface Classification {