diff --git a/react-native/android/src/main/java/com/arthenica/ffmpegkit/reactnative/FFmpegKitReactNativeModule.java b/react-native/android/src/main/java/com/arthenica/ffmpegkit/reactnative/FFmpegKitReactNativeModule.java index 13c8fdb..6f12fdd 100644 --- a/react-native/android/src/main/java/com/arthenica/ffmpegkit/reactnative/FFmpegKitReactNativeModule.java +++ b/react-native/android/src/main/java/com/arthenica/ffmpegkit/reactnative/FFmpegKitReactNativeModule.java @@ -111,7 +111,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple // EVENTS public static final String EVENT_LOG_CALLBACK_EVENT = "FFmpegKitLogCallbackEvent"; public static final String EVENT_STATISTICS_CALLBACK_EVENT = "FFmpegKitStatisticsCallbackEvent"; - public static final String EVENT_EXECUTE_CALLBACK_EVENT = "FFmpegKitExecuteCallbackEvent"; + public static final String EVENT_COMPLETE_CALLBACK_EVENT = "FFmpegKitCompleteCallbackEvent"; // REQUEST CODES public static final int READABLE_REQUEST_CODE = 10000; @@ -165,9 +165,19 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple } protected void registerGlobalCallbacks(final ReactApplicationContext reactContext) { - FFmpegKitConfig.enableExecuteCallback(session -> { + FFmpegKitConfig.enableFFmpegSessionCompleteCallback(session -> { final DeviceEventManagerModule.RCTDeviceEventEmitter jsModule = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class); - jsModule.emit(EVENT_EXECUTE_CALLBACK_EVENT, toMap(session)); + jsModule.emit(EVENT_COMPLETE_CALLBACK_EVENT, toMap(session)); + }); + + FFmpegKitConfig.enableFFprobeSessionCompleteCallback(session -> { + final DeviceEventManagerModule.RCTDeviceEventEmitter jsModule = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class); + jsModule.emit(EVENT_COMPLETE_CALLBACK_EVENT, toMap(session)); + }); + + FFmpegKitConfig.enableMediaInformationSessionCompleteCallback(session -> { + final DeviceEventManagerModule.RCTDeviceEventEmitter jsModule = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class); + jsModule.emit(EVENT_COMPLETE_CALLBACK_EVENT, toMap(session)); }); FFmpegKitConfig.enableLogCallback(log -> { @@ -359,7 +369,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple if (session == null) { promise.reject("SESSION_NOT_FOUND", "Session not found."); } else { - if (session instanceof FFmpegSession) { + if (session.isFFmpeg()) { final int timeout; if (isValidPositiveNumber(waitTimeout)) { timeout = waitTimeout.intValue(); @@ -384,7 +394,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple if (session == null) { promise.reject("SESSION_NOT_FOUND", "Session not found."); } else { - if (session instanceof FFmpegSession) { + if (session.isFFmpeg()) { final List statistics = ((FFmpegSession) session).getStatistics(); promise.resolve(toStatisticsArray(statistics)); } else { @@ -580,7 +590,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple if (session == null) { promise.reject("SESSION_NOT_FOUND", "Session not found."); } else { - if (session instanceof FFmpegSession) { + if (session.isFFmpeg()) { final FFmpegSessionExecuteTask ffmpegSessionExecuteTask = new FFmpegSessionExecuteTask((FFmpegSession) session, promise); asyncExecutorService.submit(ffmpegSessionExecuteTask); } else { @@ -599,7 +609,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple if (session == null) { promise.reject("SESSION_NOT_FOUND", "Session not found."); } else { - if (session instanceof FFprobeSession) { + if (session.isFFprobe()) { final FFprobeSessionExecuteTask ffprobeSessionExecuteTask = new FFprobeSessionExecuteTask((FFprobeSession) session, promise); asyncExecutorService.submit(ffprobeSessionExecuteTask); } else { @@ -618,7 +628,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple if (session == null) { promise.reject("SESSION_NOT_FOUND", "Session not found."); } else { - if (session instanceof MediaInformationSession) { + if (session.isMediaInformation()) { final int timeout; if (isValidPositiveNumber(waitTimeout)) { timeout = waitTimeout.intValue(); @@ -643,7 +653,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple if (session == null) { promise.reject("SESSION_NOT_FOUND", "Session not found."); } else { - if (session instanceof FFmpegSession) { + if (session.isFFmpeg()) { FFmpegKitConfig.asyncFFmpegExecute((FFmpegSession) session); promise.resolve(null); } else { @@ -662,7 +672,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple if (session == null) { promise.reject("SESSION_NOT_FOUND", "Session not found."); } else { - if (session instanceof FFprobeSession) { + if (session.isFFprobe()) { FFmpegKitConfig.asyncFFprobeExecute((FFprobeSession) session); promise.resolve(null); } else { @@ -681,7 +691,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple if (session == null) { promise.reject("SESSION_NOT_FOUND", "Session not found."); } else { - if (session instanceof MediaInformationSession) { + if (session.isMediaInformation()) { final int timeout; if (isValidPositiveNumber(waitTimeout)) { timeout = waitTimeout.intValue(); @@ -932,7 +942,12 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple @ReactMethod public void getFFprobeSessions(final Promise promise) { - promise.resolve(toSessionArray(FFprobeKit.listSessions())); + promise.resolve(toSessionArray(FFprobeKit.listFFprobeSessions())); + } + + @ReactMethod + public void getMediaInformationSessions(final Promise promise) { + promise.resolve(toSessionArray(FFprobeKit.listMediaInformationSessions())); } // Packages @@ -980,7 +995,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple sessionMap.putString(KEY_SESSION_COMMAND, session.getCommand()); if (session.isFFprobe()) { - if (session instanceof MediaInformationSession) { + if (session.isMediaInformation()) { final MediaInformationSession mediaInformationSession = (MediaInformationSession) session; final MediaInformation mediaInformation = mediaInformationSession.getMediaInformation(); if (mediaInformation != null) { diff --git a/react-native/ios/FFmpegKitReactNativeModule.m b/react-native/ios/FFmpegKitReactNativeModule.m index 00edb26..839175c 100644 --- a/react-native/ios/FFmpegKitReactNativeModule.m +++ b/react-native/ios/FFmpegKitReactNativeModule.m @@ -61,7 +61,7 @@ static int const SESSION_TYPE_MEDIA_INFORMATION = 3; // EVENTS static NSString *const EVENT_LOG_CALLBACK_EVENT = @"FFmpegKitLogCallbackEvent"; static NSString *const EVENT_STATISTICS_CALLBACK_EVENT = @"FFmpegKitStatisticsCallbackEvent"; -static NSString *const EVENT_EXECUTE_CALLBACK_EVENT = @"FFmpegKitExecuteCallbackEvent"; +static NSString *const EVENT_COMPLETE_CALLBACK_EVENT = @"FFmpegKitCompleteCallbackEvent"; extern int const AbstractSessionDefaultTimeoutForAsynchronousMessagesInTransmit; @@ -91,15 +91,25 @@ RCT_EXPORT_MODULE(FFmpegKitReactNativeModule); [array addObject:EVENT_LOG_CALLBACK_EVENT]; [array addObject:EVENT_STATISTICS_CALLBACK_EVENT]; - [array addObject:EVENT_EXECUTE_CALLBACK_EVENT]; + [array addObject:EVENT_COMPLETE_CALLBACK_EVENT]; return array; } - (void)registerGlobalCallbacks { - [FFmpegKitConfig enableExecuteCallback:^(id session){ + [FFmpegKitConfig enableFFmpegSessionCompleteCallback:^(FFmpegSession* session){ NSDictionary *dictionary = [FFmpegKitReactNativeModule toSessionDictionary:session]; - [self sendEventWithName:EVENT_EXECUTE_CALLBACK_EVENT body:dictionary]; + [self sendEventWithName:EVENT_COMPLETE_CALLBACK_EVENT body:dictionary]; + }]; + + [FFmpegKitConfig enableFFprobeSessionCompleteCallback:^(FFprobeSession* session){ + NSDictionary *dictionary = [FFmpegKitReactNativeModule toSessionDictionary:session]; + [self sendEventWithName:EVENT_COMPLETE_CALLBACK_EVENT body:dictionary]; + }]; + + [FFmpegKitConfig enableMediaInformationSessionCompleteCallback:^(MediaInformationSession* session){ + NSDictionary *dictionary = [FFmpegKitReactNativeModule toSessionDictionary:session]; + [self sendEventWithName:EVENT_COMPLETE_CALLBACK_EVENT body:dictionary]; }]; [FFmpegKitConfig enableLogCallback: ^(Log* log){ @@ -234,7 +244,7 @@ RCT_EXPORT_METHOD(getArch:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRe // FFmpegSession RCT_EXPORT_METHOD(ffmpegSession:(NSArray*)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) { - FFmpegSession* session = [[FFmpegSession alloc] init:arguments withExecuteCallback:nil withLogCallback:nil withStatisticsCallback:nil withLogRedirectionStrategy:LogRedirectionStrategyNeverPrintLogs]; + FFmpegSession* session = [[FFmpegSession alloc] init:arguments withCompleteCallback:nil withLogCallback:nil withStatisticsCallback:nil withLogRedirectionStrategy:LogRedirectionStrategyNeverPrintLogs]; resolve([FFmpegKitReactNativeModule toSessionDictionary:session]); } @@ -243,7 +253,7 @@ RCT_EXPORT_METHOD(ffmpegSessionGetAllStatistics:(int)sessionId withTimeout:(int) if (session == nil) { reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); } else { - if ([session isMemberOfClass:[FFmpegSession class]]) { + if ([session isFFmpeg]) { int timeout; if ([FFmpegKitReactNativeModule isValidPositiveNumber:waitTimeout]) { timeout = waitTimeout; @@ -263,7 +273,7 @@ RCT_EXPORT_METHOD(ffmpegSessionGetStatistics:(int)sessionId resolver:(RCTPromise if (session == nil) { reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); } else { - if ([session isMemberOfClass:[FFmpegSession class]]) { + if ([session isFFmpeg]) { NSArray* statistics = [(FFmpegSession*)session getStatistics]; resolve([FFmpegKitReactNativeModule toStatisticsArray:statistics]); } else { @@ -275,14 +285,14 @@ RCT_EXPORT_METHOD(ffmpegSessionGetStatistics:(int)sessionId resolver:(RCTPromise // FFprobeSession RCT_EXPORT_METHOD(ffprobeSession:(NSArray*)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) { - FFprobeSession* session = [[FFprobeSession alloc] init:arguments withExecuteCallback:nil withLogCallback:nil withLogRedirectionStrategy:LogRedirectionStrategyNeverPrintLogs]; + FFprobeSession* session = [[FFprobeSession alloc] init:arguments withCompleteCallback:nil withLogCallback:nil withLogRedirectionStrategy:LogRedirectionStrategyNeverPrintLogs]; resolve([FFmpegKitReactNativeModule toSessionDictionary:session]); } // MediaInformationSession RCT_EXPORT_METHOD(mediaInformationSession:(NSArray*)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) { - MediaInformationSession* session = [[MediaInformationSession alloc] init:arguments withExecuteCallback:nil withLogCallback:nil]; + MediaInformationSession* session = [[MediaInformationSession alloc] init:arguments withCompleteCallback:nil withLogCallback:nil]; resolve([FFmpegKitReactNativeModule toSessionDictionary:session]); } @@ -409,7 +419,7 @@ RCT_EXPORT_METHOD(ffmpegSessionExecute:(int)sessionId resolver:(RCTPromiseResolv if (session == nil) { reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); } else { - if ([session isMemberOfClass:[FFmpegSession class]]) { + if ([session isFFmpeg]) { dispatch_async(asyncDispatchQueue, ^{ [FFmpegKitConfig ffmpegExecute:(FFmpegSession*)session]; resolve(nil); @@ -425,7 +435,7 @@ RCT_EXPORT_METHOD(ffprobeSessionExecute:(int)sessionId resolver:(RCTPromiseResol if (session == nil) { reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); } else { - if ([session isMemberOfClass:[FFprobeSession class]]) { + if ([session isFFprobe]) { dispatch_async(asyncDispatchQueue, ^{ [FFmpegKitConfig ffprobeExecute:(FFprobeSession*)session]; resolve(nil); @@ -441,7 +451,7 @@ RCT_EXPORT_METHOD(mediaInformationSessionExecute:(int)sessionId withTimeout:(int if (session == nil) { reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); } else { - if ([session isMemberOfClass:[MediaInformationSession class]]) { + if ([session isMediaInformation]) { int timeout; if ([FFmpegKitReactNativeModule isValidPositiveNumber:waitTimeout]) { timeout = waitTimeout; @@ -462,7 +472,7 @@ RCT_EXPORT_METHOD(asyncFFmpegSessionExecute:(int)sessionId resolver:(RCTPromiseR if (session == nil) { reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); } else { - if ([session isMemberOfClass:[FFmpegSession class]]) { + if ([session isFFmpeg]) { [FFmpegKitConfig asyncFFmpegExecute:(FFmpegSession*)session]; resolve(nil); } else { @@ -476,7 +486,7 @@ RCT_EXPORT_METHOD(asyncFFprobeSessionExecute:(int)sessionId resolver:(RCTPromise if (session == nil) { reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); } else { - if ([session isMemberOfClass:[FFprobeSession class]]) { + if ([session isFFprobe]) { [FFmpegKitConfig asyncFFprobeExecute:(FFprobeSession*)session]; resolve(nil); } else { @@ -490,7 +500,7 @@ RCT_EXPORT_METHOD(asyncMediaInformationSessionExecute:(int)sessionId withTimeout if (session == nil) { reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); } else { - if ([session isMemberOfClass:[MediaInformationSession class]]) { + if ([session isMediaInformation]) { int timeout; if ([FFmpegKitReactNativeModule isValidPositiveNumber:waitTimeout]) { timeout = waitTimeout; @@ -652,7 +662,11 @@ RCT_EXPORT_METHOD(getFFmpegSessions:(RCTPromiseResolveBlock)resolve rejecter:(RC // FFprobeKit RCT_EXPORT_METHOD(getFFprobeSessions:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) { - resolve([FFmpegKitReactNativeModule toSessionArray:[FFprobeKit listSessions]]); + resolve([FFmpegKitReactNativeModule toSessionArray:[FFprobeKit listFFprobeSessions]]); +} + +RCT_EXPORT_METHOD(getMediaInformationSessions:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) { + resolve([FFmpegKitReactNativeModule toSessionArray:[FFprobeKit listMediaInformationSessions]]); } // Packages @@ -695,7 +709,7 @@ RCT_EXPORT_METHOD(getExternalLibraries:(RCTPromiseResolveBlock)resolve rejecter: dictionary[KEY_SESSION_COMMAND] = [session getCommand]; if ([session isFFprobe]) { - if ([(AbstractSession*)session isMemberOfClass:[MediaInformationSession class]]) { + if ([session isMediaInformation]) { MediaInformationSession *mediaInformationSession = (MediaInformationSession*)session; dictionary[KEY_SESSION_MEDIA_INFORMATION] = [FFmpegKitReactNativeModule toMediaInformationDictionary:[mediaInformationSession getMediaInformation]]; dictionary[KEY_SESSION_TYPE] = [NSNumber numberWithInt:SESSION_TYPE_MEDIA_INFORMATION]; diff --git a/react-native/src/index.d.ts b/react-native/src/index.d.ts index 039bc24..d856480 100644 --- a/react-native/src/index.d.ts +++ b/react-native/src/index.d.ts @@ -16,8 +16,6 @@ declare module 'ffmpeg-kit-react-native' { static createMediaInformationSessionFromMap(sessionMap: { [key: string]: any }): MediaInformationSession; - getExecuteCallback(): ExecuteCallback; - getLogCallback(): LogCallback; getSessionId(): number; @@ -58,6 +56,8 @@ declare module 'ffmpeg-kit-react-native' { isFFprobe(): boolean; + isMediaInformation(): boolean; + cancel(): Promise; } @@ -68,17 +68,19 @@ declare module 'ffmpeg-kit-react-native' { } - export type ExecuteCallback = (session: Session) => void; + export type FFmpegSessionCompleteCallback = (session: FFmpegSession) => void; + export type FFprobeSessionCompleteCallback = (session: FFprobeSession) => void; + export type MediaInformationSessionCompleteCallback = (session: MediaInformationSession) => void; export class FFmpegKit { - static execute(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise; + static execute(command: string, completeCallback?: FFmpegSessionCompleteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise; - static executeWithArguments(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise; + static executeWithArguments(commandArguments: string[], completeCallback?: FFmpegSessionCompleteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise; - static executeAsync(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise; + static executeAsync(command: string, completeCallback?: FFmpegSessionCompleteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise; - static executeWithArgumentsAsync(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise; + static executeWithArgumentsAsync(commandArguments: string[], completeCallback?: FFmpegSessionCompleteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise; static cancel(sessionId?: number): Promise; @@ -132,7 +134,17 @@ declare module 'ffmpeg-kit-react-native' { static enableStatisticsCallback(statisticsCallback: StatisticsCallback): void; - static enableExecuteCallback(executeCallback: ExecuteCallback): void; + static enableFFmpegSessionCompleteCallback(completeCallback: FFmpegSessionCompleteCallback): void; + + static getFFmpegSessionCompleteCallback(): FFmpegSessionCompleteCallback; + + static enableFFprobeSessionCompleteCallback(completeCallback: FFprobeSessionCompleteCallback): void; + + static getFFprobeSessionCompleteCallback(): FFprobeSessionCompleteCallback; + + static enableMediaInformationSessionCompleteCallback(completeCallback: MediaInformationSessionCompleteCallback): void; + + static getMediaInformationSessionCompleteCallback(): MediaInformationSessionCompleteCallback; static getLogLevel(): Level; @@ -152,6 +164,12 @@ declare module 'ffmpeg-kit-react-native' { static clearSessions(): Promise; + static getFFmpegSessions(): Promise; + + static getFFprobeSessions(): Promise; + + static getMediaInformationSessions(): Promise; + static getSessionsByState(state): Promise; static getLogRedirectionStrategy(): LogRedirectionStrategy; @@ -192,12 +210,14 @@ declare module 'ffmpeg-kit-react-native' { constructor(); - static create(argumentsArray: Array, executeCallback?: ExecuteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback, logRedirectionStrategy?: LogRedirectionStrategy): Promise; + static create(argumentsArray: Array, completeCallback?: FFmpegSessionCompleteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback, logRedirectionStrategy?: LogRedirectionStrategy): Promise; static fromMap(sessionMap: { [key: string]: any }): FFmpegSession; getStatisticsCallback(): StatisticsCallback; + getCompleteCallback(): FFmpegSessionCompleteCallback; + getAllStatistics(waitTimeout?: number): Promise>; getStatistics(): Promise>; @@ -208,31 +228,35 @@ declare module 'ffmpeg-kit-react-native' { isFFprobe(): boolean; + isMediaInformation(): boolean; + } export class FFprobeKit { - static execute(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback): Promise; + static execute(command: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback): Promise; - static executeWithArguments(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback): Promise; + static executeWithArguments(commandArguments: string[], completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback): Promise; - static executeAsync(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback): Promise; + static executeAsync(command: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback): Promise; - static executeWithArgumentsAsync(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback): Promise; + static executeWithArgumentsAsync(commandArguments: string[], completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback): Promise; - static getMediaInformation(path: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; + static getMediaInformation(path: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; - static getMediaInformationFromCommand(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; + static getMediaInformationFromCommand(command: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; - static getMediaInformationFromCommandArguments(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; + static getMediaInformationFromCommandArguments(commandArguments: string[], completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; - static getMediaInformationAsync(path: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; + static getMediaInformationAsync(path: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; - static getMediaInformationFromCommandAsync(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; + static getMediaInformationFromCommandAsync(command: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; - static getMediaInformationFromCommandArgumentsAsync(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; + static getMediaInformationFromCommandArgumentsAsync(commandArguments: string[], completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise; - static listSessions(): Promise; + static listFFprobeSessions(): Promise; + + static listMediaInformationSessions(): Promise; } @@ -240,14 +264,18 @@ declare module 'ffmpeg-kit-react-native' { constructor(); - static create(argumentsArray: Array, executeCallback?: ExecuteCallback, logCallback?: LogCallback, logRedirectionStrategy?: LogRedirectionStrategy): Promise; + static create(argumentsArray: Array, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, logRedirectionStrategy?: LogRedirectionStrategy): Promise; static fromMap(sessionMap: { [key: string]: any }): FFprobeSession; + getCompleteCallback(): FFprobeSessionCompleteCallback; + isFFmpeg(): boolean; isFFprobe(): boolean; + isMediaInformation(): boolean; + } export class Level { @@ -341,11 +369,11 @@ declare module 'ffmpeg-kit-react-native' { } - export class MediaInformationSession extends FFprobeSession { + export class MediaInformationSession extends AbstractSession implements Session { constructor(); - static create(argumentsArray: Array, executeCallback?: ExecuteCallback, logCallback?: LogCallback): Promise; + static create(argumentsArray: Array, completeCallback?: MediaInformationSessionCompleteCallback, logCallback?: LogCallback): Promise; static fromMap(sessionMap: { [key: string]: any }): MediaInformationSession; @@ -353,6 +381,14 @@ declare module 'ffmpeg-kit-react-native' { setMediaInformation(mediaInformation: MediaInformation): void; + getCompleteCallback(): MediaInformationSessionCompleteCallback; + + isFFmpeg(): boolean; + + isFFprobe(): boolean; + + isMediaInformation(): boolean; + } export class Packages { @@ -387,8 +423,6 @@ declare module 'ffmpeg-kit-react-native' { export interface Session { - getExecuteCallback(): ExecuteCallback; - getLogCallback(): LogCallback; getSessionId(): number; @@ -429,6 +463,8 @@ declare module 'ffmpeg-kit-react-native' { isFFprobe(): boolean; + isMediaInformation(): boolean; + cancel(): Promise; } diff --git a/react-native/src/index.js b/react-native/src/index.js index 432037e..958221f 100644 --- a/react-native/src/index.js +++ b/react-native/src/index.js @@ -2,14 +2,16 @@ import {NativeEventEmitter, NativeModules} from 'react-native'; const {FFmpegKitReactNativeModule} = NativeModules; -const executeCallbackMap = new Map() +const ffmpegSessionCompleteCallbackMap = new Map() +const ffprobeSessionCompleteCallbackMap = new Map() +const mediaInformationSessionCompleteCallbackMap = new Map() const logCallbackMap = new Map() const statisticsCallbackMap = new Map() const logRedirectionStrategyMap = new Map() const eventLogCallbackEvent = "FFmpegKitLogCallbackEvent"; const eventStatisticsCallbackEvent = "FFmpegKitStatisticsCallbackEvent"; -const eventExecuteCallbackEvent = "FFmpegKitExecuteCallbackEvent"; +const eventCompleteCallbackEvent = "FFmpegKitCompleteCallbackEvent"; export const LogRedirectionStrategy = { ALWAYS_PRINT_LOGS: 0, @@ -59,17 +61,9 @@ class FFmpegKitReactNativeEventEmitter extends NativeEventEmitter { export class Session { /** - * Returns the session specific execute callback function. + * Returns the session specific log callback. * - * @return session specific execute callback function - */ - getExecuteCallback() { - } - - /** - * Returns the session specific log callback function. - * - * @return session specific log callback function + * @return session specific log callback */ getLogCallback() { } @@ -245,6 +239,14 @@ export class Session { isFFprobe() { } + /** + * Returns whether it is a MediaInformation session or not. + * + * @return true if it is a MediaInformation session, false otherwise + */ + isMediaInformation() { + } + /** * Cancels running the session. */ @@ -254,8 +256,8 @@ export class Session { } /** - * Abstract session implementation which includes common features shared by FFmpeg - * and FFprobe sessions. + * Abstract session implementation which includes common features shared by FFmpeg, + * FFprobe and MediaInformation sessions. */ export class AbstractSession extends Session { @@ -445,18 +447,9 @@ export class AbstractSession extends Session { } /** - * Returns the session specific execute callback function. + * Returns the session specific log callback. * - * @return session specific execute callback function - */ - getExecuteCallback() { - return FFmpegKitFactory.getExecuteCallback(this.getSessionId()) - } - - /** - * Returns the session specific log callback function. - * - * @return session specific log callback function + * @return session specific log callback */ getLogCallback() { return FFmpegKitFactory.getLogCallback(this.getSessionId()) @@ -666,6 +659,15 @@ export class AbstractSession extends Session { return false; } + /** + * Returns whether it is a MediaInformation session or not. + * + * @return true if it is a MediaInformation session, false otherwise + */ + isMediaInformation() { + return false; + } + /** * Cancels running the session. */ @@ -707,26 +709,26 @@ export class FFmpegKit { * into arguments. You can use single or double quote characters to specify arguments inside your command. * * @param command FFmpeg command - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @param statisticsCallback callback that will receive statistics * @return FFmpeg session created for this execution */ - static async execute(command, executeCallback, logCallback, statisticsCallback) { - return FFmpegKit.executeWithArguments(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback, statisticsCallback); + static async execute(command, completeCallback, logCallback, statisticsCallback) { + return FFmpegKit.executeWithArguments(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback, statisticsCallback); } /** *

Synchronously executes FFmpeg with arguments provided. * * @param commandArguments FFmpeg command options/arguments as string array - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @param statisticsCallback callback that will receive statistics * @return FFmpeg session created for this execution */ - static async executeWithArguments(commandArguments, executeCallback, logCallback, statisticsCallback) { - let session = await FFmpegSession.create(commandArguments, executeCallback, logCallback, statisticsCallback); + static async executeWithArguments(commandArguments, completeCallback, logCallback, statisticsCallback) { + let session = await FFmpegSession.create(commandArguments, completeCallback, logCallback, statisticsCallback); await FFmpegKitConfig.ffmpegExecute(session); @@ -738,32 +740,32 @@ export class FFmpegKit { * into arguments. You can use single or double quote characters to specify arguments inside your command. * *

Note that this method returns immediately and does not wait the execution to complete. You must use an - * ExecuteCallback if you want to be notified about the result. + * FFmpegSessionCompleteCallback if you want to be notified about the result. * * @param command FFmpeg command - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @param statisticsCallback callback that will receive statistics * @return FFmpeg session created for this execution */ - static async executeAsync(command, executeCallback, logCallback, statisticsCallback) { - return FFmpegKit.executeWithArgumentsAsync(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback, statisticsCallback); + static async executeAsync(command, completeCallback, logCallback, statisticsCallback) { + return FFmpegKit.executeWithArgumentsAsync(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback, statisticsCallback); } /** *

Starts an asynchronous FFmpeg execution with arguments provided. * *

Note that this method returns immediately and does not wait the execution to complete. You must use an - * ExecuteCallback if you want to be notified about the result. + * FFmpegSessionCompleteCallback if you want to be notified about the result. * * @param commandArguments FFmpeg command options/arguments as string array - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @param statisticsCallback callback that will receive statistics * @return FFmpeg session created for this execution */ - static async executeWithArgumentsAsync(commandArguments, executeCallback, logCallback, statisticsCallback) { - let session = await FFmpegSession.create(commandArguments, executeCallback, logCallback, statisticsCallback); + static async executeWithArgumentsAsync(commandArguments, completeCallback, logCallback, statisticsCallback) { + let session = await FFmpegSession.create(commandArguments, completeCallback, logCallback, statisticsCallback); await FFmpegKitConfig.asyncFFmpegExecute(session); @@ -773,7 +775,7 @@ export class FFmpegKit { /** *

Cancels the session specified with sessionId. * - *

This function does not wait for termination to complete and returns immediately. + *

This method does not wait for termination to complete and returns immediately. * * @param sessionId id of the session that will be cancelled */ @@ -1019,7 +1021,7 @@ export class FFmpegKitConfig { *

Starts an asynchronous FFmpeg execution for the given session. * *

Note that this method returns immediately and does not wait the execution to complete. You must use an - * ExecuteCallback if you want to be notified about the result. + * FFmpegSessionCompleteCallback if you want to be notified about the result. * * @param ffmpegSession FFmpeg session which includes command options/arguments */ @@ -1033,7 +1035,7 @@ export class FFmpegKitConfig { *

Starts an asynchronous FFprobe execution for the given session. * *

Note that this method returns immediately and does not wait the execution to complete. You must use an - * ExecuteCallback if you want to be notified about the result. + * FFprobeSessionCompleteCallback if you want to be notified about the result. * * @param ffprobeSession FFprobe session which includes command options/arguments */ @@ -1047,7 +1049,7 @@ export class FFmpegKitConfig { *

Starts an asynchronous FFprobe execution for the given media information session. * *

Note that this method returns immediately and does not wait the execution to complete. You must use an - * ExecuteCallback if you want to be notified about the result. + * MediaInformationSessionCompleteCallback if you want to be notified about the result. * * @param mediaInformationSession media information session which includes command options/arguments * @param waitTimeout max time to wait until media information is transmitted @@ -1059,9 +1061,9 @@ export class FFmpegKitConfig { } /** - *

Sets a global callback function to redirect FFmpeg/FFprobe logs. + *

Sets a global callback to redirect FFmpeg/FFprobe logs. * - * @param logCallback log callback function or undefined to disable a previously defined + * @param logCallback log callback or undefined to disable a previously defined * callback */ static enableLogCallback(logCallback) { @@ -1069,9 +1071,9 @@ export class FFmpegKitConfig { } /** - *

Sets a global callback function to redirect FFmpeg statistics. + *

Sets a global callback to redirect FFmpeg statistics. * - * @param statisticsCallback statistics callback function or undefined to disable a previously + * @param statisticsCallback statistics callback or undefined to disable a previously * defined callback */ static enableStatisticsCallback(statisticsCallback) { @@ -1079,13 +1081,58 @@ export class FFmpegKitConfig { } /** - *

Sets a global callback function to receive execution results. + *

Sets a global FFmpegSessionCompleteCallback to receive execution results for FFmpeg sessions. + * + * @param ffmpegSessionCompleteCallback complete callback or undefined to disable a previously defined callback + */ + static enableFFmpegSessionCompleteCallback(ffmpegSessionCompleteCallback) { + FFmpegKitFactory.setGlobalFFmpegSessionCompleteCallback(ffmpegSessionCompleteCallback); + } + + /** + *

Returns the global FFmpegSessionCompleteCallback set. + * + * @return global FFmpegSessionCompleteCallback or undefined if it is not set + */ + static getFFmpegSessionCompleteCallback() { + return FFmpegKitFactory.getGlobalFFmpegSessionCompleteCallback(); + } + + /** + *

Sets a global FFprobeSessionCompleteCallback to receive execution results for FFprobe sessions. + * + * @param ffprobeSessionCompleteCallback complete callback or undefined to disable a previously defined callback + */ + static enableFFprobeSessionCompleteCallback(ffprobeSessionCompleteCallback) { + FFmpegKitFactory.setGlobalFFprobeSessionCompleteCallback(ffprobeSessionCompleteCallback); + } + + /** + *

Returns the global FFprobeSessionCompleteCallback set. * - * @param executeCallback execute callback function or undefined to disable a previously - * defined callback + * @return global FFprobeSessionCompleteCallback or undefined if it is not set */ - static enableExecuteCallback(executeCallback) { - FFmpegKitFactory.setGlobalExecuteCallback(executeCallback); + static getFFprobeSessionCompleteCallback() { + return FFmpegKitFactory.getGlobalFFprobeSessionCompleteCallback(); + } + + /** + *

Sets a global MediaInformationSessionCompleteCallback to receive execution results for MediaInformation sessions. + * + * @param mediaInformationSessionCompleteCallback complete callback or undefined to disable a previously defined + * callback + */ + static enableMediaInformationSessionCompleteCallback(mediaInformationSessionCompleteCallback) { + FFmpegKitFactory.setGlobalMediaInformationSessionCompleteCallback(mediaInformationSessionCompleteCallback); + } + + /** + *

Returns the global MediaInformationSessionCompleteCallback set. + * + * @return global MediaInformationSessionCompleteCallback or undefined if it is not set + */ + static getMediaInformationSessionCompleteCallback() { + return FFmpegKitFactory.getGlobalMediaInformationSessionCompleteCallback(); } /** @@ -1195,6 +1242,42 @@ export class FFmpegKitConfig { return FFmpegKitReactNativeModule.clearSessions(); } + /** + *

Returns all FFmpeg sessions in the session history. + * + * @return all FFmpeg sessions in the session history + */ + static async getFFmpegSessions() { + await FFmpegKitConfig.init(); + + const sessionArray = await FFmpegKitReactNativeModule.getFFmpegSessions(); + return sessionArray.map(FFmpegKitFactory.mapToSession); + } + + /** + *

Returns all FFprobe sessions in the session history. + * + * @return all FFprobe sessions in the session history + */ + static async getFFprobeSessions() { + await FFmpegKitConfig.init(); + + const sessionArray = await FFmpegKitReactNativeModule.getFFprobeSessions(); + return sessionArray.map(FFmpegKitFactory.mapToSession); + } + + /** + *

Returns all MediaInformation sessions in the session history. + * + * @return all MediaInformation sessions in the session history + */ + static async getMediaInformationSessions() { + await FFmpegKitConfig.init(); + + const sessionArray = await FFmpegKitReactNativeModule.getMediaInformationSessions(); + return sessionArray.map(FFmpegKitFactory.mapToSession); + } + /** *

Returns sessions that have the given state. * @@ -1475,9 +1558,11 @@ export class FFmpegKitConfig { class FFmpegKitFactory { + static #ffmpegSessionCompleteCallback = undefined; + static #ffprobeSessionCompleteCallback = undefined; + static #mediaInformationSessionCompleteCallback = undefined; static #logCallback = undefined; static #statisticsCallback = undefined; - static #executeCallback = undefined; static #activeLogLevel = undefined; static mapToStatistics(statisticsMap) { @@ -1560,22 +1645,58 @@ class FFmpegKitFactory { this.#statisticsCallback = statisticsCallback; } - static getExecuteCallback(sessionId) { - return executeCallbackMap.get(sessionId); + static getFFmpegSessionCompleteCallback(sessionId) { + return ffmpegSessionCompleteCallbackMap.get(sessionId); + } + + static setFFmpegSessionCompleteCallback(sessionId, completeCallback) { + if (completeCallback !== undefined) { + ffmpegSessionCompleteCallbackMap.set(sessionId, completeCallback); + } + } + + static getGlobalFFmpegSessionCompleteCallback() { + return this.#ffmpegSessionCompleteCallback; + } + + static setGlobalFFmpegSessionCompleteCallback(completeCallback) { + this.#ffmpegSessionCompleteCallback = completeCallback; + } + + static getFFprobeSessionCompleteCallback(sessionId) { + return ffprobeSessionCompleteCallbackMap.get(sessionId); } - static setExecuteCallback(sessionId, executeCallback) { - if (executeCallback !== undefined) { - executeCallbackMap.set(sessionId, executeCallback); + static setFFprobeSessionCompleteCallback(sessionId, completeCallback) { + if (completeCallback !== undefined) { + ffprobeSessionCompleteCallbackMap.set(sessionId, completeCallback); } } - static getGlobalExecuteCallback() { - return this.#executeCallback; + static getGlobalFFprobeSessionCompleteCallback() { + return this.#ffprobeSessionCompleteCallback; + } + + static setGlobalFFprobeSessionCompleteCallback(completeCallback) { + this.#ffprobeSessionCompleteCallback = completeCallback; } - static setGlobalExecuteCallback(executeCallback) { - this.#executeCallback = executeCallback; + static getMediaInformationSessionCompleteCallback(sessionId) { + return mediaInformationSessionCompleteCallbackMap.get(sessionId); + } + + static setMediaInformationSessionCompleteCallback(sessionId, completeCallback) { + if (completeCallback !== undefined) { + mediaInformationSessionCompleteCallbackMap.set(sessionId, completeCallback); + } + } + + static getGlobalMediaInformationSessionCompleteCallback() { + return this.#mediaInformationSessionCompleteCallback; + } + + static setGlobalMediaInformationSessionCompleteCallback(completeCallback) { + this.#mediaInformationSessionCompleteCallback = completeCallback; } static setLogLevel(logLevel) { @@ -1631,7 +1752,7 @@ class FFmpegKitInitializer { // NOTIFY SESSION CALLBACK DEFINED activeLogCallback(log); } catch (err) { - console.log("Exception thrown inside session LogCallback block.", err.stack); + console.log("Exception thrown inside session log callback.", err.stack); } } @@ -1643,7 +1764,7 @@ class FFmpegKitInitializer { // NOTIFY GLOBAL CALLBACK DEFINED globalLogCallbackFunction(log); } catch (err) { - console.log("Exception thrown inside global LogCallback block.", err.stack); + console.log("Exception thrown inside global log callback.", err.stack); } } @@ -1697,7 +1818,7 @@ class FFmpegKitInitializer { // NOTIFY SESSION CALLBACK DEFINED activeStatisticsCallback(statistics); } catch (err) { - console.log("Exception thrown inside session StatisticsCallback block.", err.stack); + console.log("Exception thrown inside session statistics callback.", err.stack); } } @@ -1707,34 +1828,60 @@ class FFmpegKitInitializer { // NOTIFY GLOBAL CALLBACK DEFINED globalStatisticsCallbackFunction(statistics); } catch (err) { - console.log("Exception thrown inside global StatisticsCallback block.", err.stack); + console.log("Exception thrown inside global statistics callback.", err.stack); } } } - static processExecuteCallbackEvent(event) { - let sessionId = event.sessionId; - - FFmpegKitConfig.getSession(sessionId).then(session => { - if (session.getExecuteCallback() !== undefined) { - try { - // NOTIFY SESSION CALLBACK DEFINED - session.getExecuteCallback()(session); - } catch (err) { - console.log("Exception thrown inside session ExecuteCallback block.", err.stack); + static processCompleteCallbackEvent(event) { + if (event !== undefined) { + let sessionId = event.sessionId; + + FFmpegKitConfig.getSession(sessionId).then(session => { + if (session !== undefined) { + if (session.getCompleteCallback() !== undefined) { + try { + // NOTIFY SESSION CALLBACK DEFINED + session.getCompleteCallback()(session); + } catch (err) { + console.log("Exception thrown inside session complete callback.", err.stack); + } + } + + if (session.isFFmpeg()) { + let globalFFmpegSessionCompleteCallback = FFmpegKitFactory.getGlobalFFmpegSessionCompleteCallback(); + if (globalFFmpegSessionCompleteCallback !== undefined) { + try { + // NOTIFY GLOBAL CALLBACK DEFINED + globalFFmpegSessionCompleteCallback(session); + } catch (err) { + console.log("Exception thrown inside global complete callback.", err.stack); + } + } + } else if (session.isFFprobe()) { + let globalFFprobeSessionCompleteCallback = FFmpegKitFactory.getGlobalFFprobeSessionCompleteCallback(); + if (globalFFprobeSessionCompleteCallback !== undefined) { + try { + // NOTIFY GLOBAL CALLBACK DEFINED + globalFFprobeSessionCompleteCallback(session); + } catch (err) { + console.log("Exception thrown inside global complete callback.", err.stack); + } + } + } else if (session.isMediaInformation()) { + let globalMediaInformationSessionCompleteCallback = FFmpegKitFactory.getGlobalMediaInformationSessionCompleteCallback(); + if (globalMediaInformationSessionCompleteCallback !== undefined) { + try { + // NOTIFY GLOBAL CALLBACK DEFINED + globalMediaInformationSessionCompleteCallback(session); + } catch (err) { + console.log("Exception thrown inside global complete callback.", err.stack); + } + } + } } - } - - let globalExecuteCallbackFunction = FFmpegKitFactory.getGlobalExecuteCallback(); - if (globalExecuteCallbackFunction !== undefined) { - try { - // NOTIFY GLOBAL CALLBACK DEFINED - globalExecuteCallbackFunction(session); - } catch (err) { - console.log("Exception thrown inside global ExecuteCallback block.", err.stack); - } - } - }); + }); + } } static async initialize() { @@ -1748,7 +1895,7 @@ class FFmpegKitInitializer { this.#eventEmitter.addListener(eventLogCallbackEvent, FFmpegKitInitializer.processLogCallbackEvent); this.#eventEmitter.addListener(eventStatisticsCallbackEvent, FFmpegKitInitializer.processStatisticsCallbackEvent); - this.#eventEmitter.addListener(eventExecuteCallbackEvent, FFmpegKitInitializer.processExecuteCallbackEvent); + this.#eventEmitter.addListener(eventCompleteCallbackEvent, FFmpegKitInitializer.processCompleteCallbackEvent); FFmpegKitFactory.setLogLevel(await FFmpegKitReactNativeModule.getLogLevel()); const version = FFmpegKitFactory.getVersion(); @@ -1779,17 +1926,17 @@ export class FFmpegSession extends AbstractSession { * Creates a new FFmpeg session. * * @param argumentsArray FFmpeg command arguments - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @param statisticsCallback callback that will receive statistics * @param logRedirectionStrategy defines how logs will be redirected * @returns FFmpeg session created */ - static async create(argumentsArray, executeCallback, logCallback, statisticsCallback, logRedirectionStrategy) { + static async create(argumentsArray, completeCallback, logCallback, statisticsCallback, logRedirectionStrategy) { const session = await AbstractSession.createFFmpegSession(argumentsArray, logRedirectionStrategy); const sessionId = session.getSessionId(); - FFmpegKitFactory.setExecuteCallback(sessionId, executeCallback); + FFmpegKitFactory.setFFmpegSessionCompleteCallback(sessionId, completeCallback); FFmpegKitFactory.setLogCallback(sessionId, logCallback); FFmpegKitFactory.setStatisticsCallback(sessionId, statisticsCallback); @@ -1807,14 +1954,23 @@ export class FFmpegSession extends AbstractSession { } /** - * Returns the session specific statistics callback function. + * Returns the session specific statistics callback. * - * @return session specific statistics callback function + * @return session specific statistics callback */ getStatisticsCallback() { return FFmpegKitFactory.getStatisticsCallback(this.getSessionId()); } + /** + * Returns the session specific complete callback. + * + * @return session specific complete callback + */ + getCompleteCallback() { + return FFmpegKitFactory.getFFmpegSessionCompleteCallback(this.getSessionId()); + } + /** * Returns all statistics entries generated for this session. If there are asynchronous * messages that are not delivered yet, this method waits for them until the given timeout. @@ -1867,6 +2023,10 @@ export class FFmpegSession extends AbstractSession { return false; } + isMediaInformation() { + return false; + } + } /** @@ -1879,24 +2039,24 @@ export class FFprobeKit { * into arguments. You can use single or double quote characters to specify arguments inside your command. * * @param command FFprobe command - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @return FFprobe session created for this execution */ - static async execute(command, executeCallback, logCallback) { - return FFprobeKit.executeWithArguments(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback); + static async execute(command, completeCallback, logCallback) { + return FFprobeKit.executeWithArguments(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback); } /** *

Synchronously executes FFprobe with arguments provided. * * @param commandArguments FFprobe command options/arguments as string array - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @return FFprobe session created for this execution */ - static async executeWithArguments(commandArguments, executeCallback, logCallback) { - let session = await FFprobeSession.create(commandArguments, executeCallback, logCallback); + static async executeWithArguments(commandArguments, completeCallback, logCallback) { + let session = await FFprobeSession.create(commandArguments, completeCallback, logCallback); await FFmpegKitConfig.ffprobeExecute(session); @@ -1908,30 +2068,30 @@ export class FFprobeKit { * into arguments. You can use single or double quote characters to specify arguments inside your command. * *

Note that this method returns immediately and does not wait the execution to complete. You must use an - * ExecuteCallback if you want to be notified about the result. + * FFprobeSessionCompleteCallback if you want to be notified about the result. * * @param command FFprobe command - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @return FFprobe session created for this execution */ - static async executeAsync(command, executeCallback, logCallback) { - return FFprobeKit.executeWithArgumentsAsync(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback); + static async executeAsync(command, completeCallback, logCallback) { + return FFprobeKit.executeWithArgumentsAsync(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback); } /** *

Starts an asynchronous FFprobe execution with arguments provided. * *

Note that this method returns immediately and does not wait the execution to complete. You must use an - * ExecuteCallback if you want to be notified about the result. + * FFprobeSessionCompleteCallback if you want to be notified about the result. * * @param commandArguments FFprobe command options/arguments as string array - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @return FFprobe session created for this execution */ - static async executeWithArgumentsAsync(commandArguments, executeCallback, logCallback) { - let session = await FFprobeSession.create(commandArguments, executeCallback, logCallback); + static async executeWithArgumentsAsync(commandArguments, completeCallback, logCallback) { + let session = await FFprobeSession.create(commandArguments, completeCallback, logCallback); await FFmpegKitConfig.asyncFFprobeExecute(session); @@ -1942,14 +2102,14 @@ export class FFprobeKit { *

Extracts media information for the file specified with path. * * @param path path or uri of a media file - * @param executeCallback callback that will be notified when execution is completed + * @param completeCallback callback that will be notified when execution has completed * @param logCallback callback that will receive logs * @param waitTimeout max time to wait until media information is transmitted * @return media information session created for this execution */ - static async getMediaInformation(path, executeCallback, logCallback, waitTimeout) { + static async getMediaInformation(path, completeCallback, logCallback, waitTimeout) { const commandArguments = ["-v", "error", "-hide_banner", "-print_format", "json", "-show_format", "-show_streams", "-show_chapters", "-i", path]; - return FFprobeKit.getMediaInformationFromCommandArguments(commandArguments, executeCallback, logCallback, waitTimeout); + return FFprobeKit.getMediaInformationFromCommandArguments(commandArguments, completeCallback, logCallback, waitTimeout); } /** @@ -1957,13 +2117,13 @@ export class FFprobeKit { * this method must generate the output in JSON format in order to successfully extract media information from it. * * @param command FFprobe command that prints media information for a file in JSON format - * @param executeCallback callback that will be notified when execution is completed + * @param completeCallback callback that will be notified when execution has completed * @param logCallback callback that will receive logs * @param waitTimeout max time to wait until media information is transmitted * @return media information session created for this execution */ - static async getMediaInformationFromCommand(command, executeCallback, logCallback, waitTimeout) { - return FFprobeKit.getMediaInformationFromCommandArguments(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback, waitTimeout); + static async getMediaInformationFromCommand(command, completeCallback, logCallback, waitTimeout) { + return FFprobeKit.getMediaInformationFromCommandArguments(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback, waitTimeout); } /** @@ -1972,13 +2132,13 @@ export class FFprobeKit { * from it. * * @param commandArguments FFprobe command arguments that prints media information for a file in JSON format - * @param executeCallback callback that will be notified when execution is completed + * @param completeCallback callback that will be notified when execution has completed * @param logCallback callback that will receive logs * @param waitTimeout max time to wait until media information is transmitted * @return media information session created for this execution */ - static async getMediaInformationFromCommandArguments(commandArguments, executeCallback, logCallback, waitTimeout) { - let session = await MediaInformationSession.create(commandArguments, executeCallback, logCallback); + static async getMediaInformationFromCommandArguments(commandArguments, completeCallback, logCallback, waitTimeout) { + let session = await MediaInformationSession.create(commandArguments, completeCallback, logCallback); await FFmpegKitConfig.getMediaInformationExecute(session, waitTimeout); @@ -1989,17 +2149,17 @@ export class FFprobeKit { *

Starts an asynchronous FFprobe execution to extract the media information for the specified file. * *

Note that this method returns immediately and does not wait the execution to complete. You must use an - * ExecuteCallback if you want to be notified about the result. + * MediaInformationSessionCompleteCallback if you want to be notified about the result. * * @param path path or uri of a media file - * @param executeCallback callback that will be notified when execution is completed + * @param completeCallback callback that will be notified when execution has completed * @param logCallback callback that will receive logs * @param waitTimeout max time to wait until media information is transmitted * @return media information session created for this execution */ - static async getMediaInformationAsync(path, executeCallback, logCallback, waitTimeout) { + static async getMediaInformationAsync(path, completeCallback, logCallback, waitTimeout) { const commandArguments = ["-v", "error", "-hide_banner", "-print_format", "json", "-show_format", "-show_streams", "-show_chapters", "-i", path]; - return FFprobeKit.getMediaInformationFromCommandArgumentsAsync(commandArguments, executeCallback, logCallback, waitTimeout); + return FFprobeKit.getMediaInformationFromCommandArgumentsAsync(commandArguments, completeCallback, logCallback, waitTimeout); } /** @@ -2007,16 +2167,16 @@ export class FFprobeKit { * this method must generate the output in JSON format in order to successfully extract media information from it. * *

Note that this method returns immediately and does not wait the execution to complete. You must use an - * ExecuteCallback if you want to be notified about the result. + * MediaInformationSessionCompleteCallback if you want to be notified about the result. * * @param command FFprobe command that prints media information for a file in JSON format - * @param executeCallback callback that will be notified when execution is completed + * @param completeCallback callback that will be notified when execution has completed * @param logCallback callback that will receive logs * @param waitTimeout max time to wait until media information is transmitted * @return media information session created for this execution */ - static async getMediaInformationFromCommandAsync(command, executeCallback, logCallback, waitTimeout) { - return FFprobeKit.getMediaInformationFromCommandArgumentsAsync(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback, waitTimeout); + static async getMediaInformationFromCommandAsync(command, completeCallback, logCallback, waitTimeout) { + return FFprobeKit.getMediaInformationFromCommandArgumentsAsync(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback, waitTimeout); } /** @@ -2025,16 +2185,16 @@ export class FFprobeKit { * from it. * *

Note that this method returns immediately and does not wait the execution to complete. You must use an - * ExecuteCallback if you want to be notified about the result. + * MediaInformationSessionCompleteCallback if you want to be notified about the result. * * @param commandArguments FFprobe command arguments that prints media information for a file in JSON format - * @param executeCallback callback that will be notified when execution is completed + * @param completeCallback callback that will be notified when execution has completed * @param logCallback callback that will receive logs * @param waitTimeout max time to wait until media information is transmitted * @return media information session created for this execution */ - static async getMediaInformationFromCommandArgumentsAsync(commandArguments, executeCallback, logCallback, waitTimeout) { - let session = await MediaInformationSession.create(commandArguments, executeCallback, logCallback); + static async getMediaInformationFromCommandArgumentsAsync(commandArguments, completeCallback, logCallback, waitTimeout) { + let session = await MediaInformationSession.create(commandArguments, completeCallback, logCallback); await FFmpegKitConfig.asyncGetMediaInformationExecute(session, waitTimeout); @@ -2046,13 +2206,25 @@ export class FFprobeKit { * * @return all FFprobe sessions in the session history */ - static async listSessions() { + static async listFFprobeSessions() { await FFmpegKitConfig.init(); const sessionArray = await FFmpegKitReactNativeModule.getFFprobeSessions(); return sessionArray.map(FFmpegKitFactory.mapToSession); } + /** + *

Lists all MediaInformation sessions in the session history. + * + * @return all MediaInformation sessions in the session history + */ + static async listMediaInformationSessions() { + await FFmpegKitConfig.init(); + + const sessionArray = await FFmpegKitReactNativeModule.getMediaInformationSessions(); + return sessionArray.map(FFmpegKitFactory.mapToSession); + } + } /** @@ -2071,16 +2243,16 @@ export class FFprobeSession extends AbstractSession { * Creates a new FFprobe session. * * @param argumentsArray FFprobe command arguments - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @param logRedirectionStrategy defines how logs will be redirected * @returns FFprobe session created */ - static async create(argumentsArray, executeCallback, logCallback, logRedirectionStrategy) { + static async create(argumentsArray, completeCallback, logCallback, logRedirectionStrategy) { const session = await AbstractSession.createFFprobeSession(argumentsArray, logRedirectionStrategy); const sessionId = session.getSessionId(); - FFmpegKitFactory.setExecuteCallback(sessionId, executeCallback); + FFmpegKitFactory.setFFprobeSessionCompleteCallback(sessionId, completeCallback); FFmpegKitFactory.setLogCallback(sessionId, logCallback); return session; @@ -2096,6 +2268,15 @@ export class FFprobeSession extends AbstractSession { return AbstractSession.createFFprobeSessionFromMap(sessionMap); } + /** + * Returns the session specific complete callback. + * + * @return session specific complete callback + */ + getCompleteCallback() { + return FFmpegKitFactory.getFFprobeSessionCompleteCallback(this.getSessionId()); + } + isFFmpeg() { return false; } @@ -2104,6 +2285,10 @@ export class FFprobeSession extends AbstractSession { return true; } + isMediaInformation() { + return false; + } + } /** @@ -2469,7 +2654,7 @@ export class MediaInformationJsonParser { *

A custom FFprobe session, which produces a MediaInformation object using the * FFprobe output. */ -export class MediaInformationSession extends FFprobeSession { +export class MediaInformationSession extends AbstractSession { #mediaInformation; /** @@ -2483,15 +2668,15 @@ export class MediaInformationSession extends FFprobeSession { * Creates a new MediaInformationSession session. * * @param argumentsArray FFprobe command arguments - * @param executeCallback callback that will be called when the execution is completed + * @param completeCallback callback that will be called when the execution has completed * @param logCallback callback that will receive logs * @returns MediaInformationSession session created */ - static async create(argumentsArray, executeCallback, logCallback) { + static async create(argumentsArray, completeCallback, logCallback) { const session = await AbstractSession.createMediaInformationSession(argumentsArray); const sessionId = session.getSessionId(); - FFmpegKitFactory.setExecuteCallback(sessionId, executeCallback); + FFmpegKitFactory.setMediaInformationSessionCompleteCallback(sessionId, completeCallback); FFmpegKitFactory.setLogCallback(sessionId, logCallback); return session; @@ -2526,6 +2711,27 @@ export class MediaInformationSession extends FFprobeSession { this.#mediaInformation = mediaInformation; } + /** + * Returns the session specific complete callback. + * + * @return session specific complete callback + */ + getCompleteCallback() { + return FFmpegKitFactory.getMediaInformationSessionCompleteCallback(this.getSessionId()); + } + + isFFmpeg() { + return false; + } + + isFFprobe() { + return false; + } + + isMediaInformation() { + return true; + } + } /**