antonlyap/ffmpeg-kit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

replace execute callback with session specific complete callbacks, fixes #197

Browse Source
This commit is contained in:
Taner Sener 2021-12-25 12:30:33 +00:00
parent ea9f267ce6
commit adfce89fc1
4 changed files with 461 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
react-native/android/src/main/java/com/arthenica/ffmpegkit/reactnative/FFmpegKitReactNativeModule.java
View File

@ -111,7 +111,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
// EVENTS // EVENTS
public static final String EVENT_LOG_CALLBACK_EVENT = "FFmpegKitLogCallbackEvent"; public static final String EVENT_LOG_CALLBACK_EVENT = "FFmpegKitLogCallbackEvent";
public static final String EVENT_STATISTICS_CALLBACK_EVENT = "FFmpegKitStatisticsCallbackEvent"; 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 // REQUEST CODES
public static final int READABLE_REQUEST_CODE = 10000; public static final int READABLE_REQUEST_CODE = 10000;
@ -165,9 +165,19 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
} }
protected void registerGlobalCallbacks(final ReactApplicationContext reactContext) { protected void registerGlobalCallbacks(final ReactApplicationContext reactContext) {
FFmpegKitConfig.enableExecuteCallback(session -> { FFmpegKitConfig.enableFFmpegSessionCompleteCallback(session -> {
final DeviceEventManagerModule.RCTDeviceEventEmitter jsModule = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class); 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 -> { FFmpegKitConfig.enableLogCallback(log -> {
@ -359,7 +369,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
if (session == null) { if (session == null) {
promise.reject("SESSION_NOT_FOUND", "Session not found."); promise.reject("SESSION_NOT_FOUND", "Session not found.");
} else { } else {
if (session instanceof FFmpegSession) { if (session.isFFmpeg()) {
final int timeout; final int timeout;
if (isValidPositiveNumber(waitTimeout)) { if (isValidPositiveNumber(waitTimeout)) {
timeout = waitTimeout.intValue(); timeout = waitTimeout.intValue();
@ -384,7 +394,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
if (session == null) { if (session == null) {
promise.reject("SESSION_NOT_FOUND", "Session not found."); promise.reject("SESSION_NOT_FOUND", "Session not found.");
} else { } else {
if (session instanceof FFmpegSession) { if (session.isFFmpeg()) {
final List<Statistics> statistics = ((FFmpegSession) session).getStatistics(); final List<Statistics> statistics = ((FFmpegSession) session).getStatistics();
promise.resolve(toStatisticsArray(statistics)); promise.resolve(toStatisticsArray(statistics));
} else { } else {
@ -580,7 +590,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
if (session == null) { if (session == null) {
promise.reject("SESSION_NOT_FOUND", "Session not found."); promise.reject("SESSION_NOT_FOUND", "Session not found.");
} else { } else {
if (session instanceof FFmpegSession) { if (session.isFFmpeg()) {
final FFmpegSessionExecuteTask ffmpegSessionExecuteTask = new FFmpegSessionExecuteTask((FFmpegSession) session, promise); final FFmpegSessionExecuteTask ffmpegSessionExecuteTask = new FFmpegSessionExecuteTask((FFmpegSession) session, promise);
asyncExecutorService.submit(ffmpegSessionExecuteTask); asyncExecutorService.submit(ffmpegSessionExecuteTask);
} else { } else {
@ -599,7 +609,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
if (session == null) { if (session == null) {
promise.reject("SESSION_NOT_FOUND", "Session not found."); promise.reject("SESSION_NOT_FOUND", "Session not found.");
} else { } else {
if (session instanceof FFprobeSession) { if (session.isFFprobe()) {
final FFprobeSessionExecuteTask ffprobeSessionExecuteTask = new FFprobeSessionExecuteTask((FFprobeSession) session, promise); final FFprobeSessionExecuteTask ffprobeSessionExecuteTask = new FFprobeSessionExecuteTask((FFprobeSession) session, promise);
asyncExecutorService.submit(ffprobeSessionExecuteTask); asyncExecutorService.submit(ffprobeSessionExecuteTask);
} else { } else {
@ -618,7 +628,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
if (session == null) { if (session == null) {
promise.reject("SESSION_NOT_FOUND", "Session not found."); promise.reject("SESSION_NOT_FOUND", "Session not found.");
} else { } else {
if (session instanceof MediaInformationSession) { if (session.isMediaInformation()) {
final int timeout; final int timeout;
if (isValidPositiveNumber(waitTimeout)) { if (isValidPositiveNumber(waitTimeout)) {
timeout = waitTimeout.intValue(); timeout = waitTimeout.intValue();
@ -643,7 +653,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
if (session == null) { if (session == null) {
promise.reject("SESSION_NOT_FOUND", "Session not found."); promise.reject("SESSION_NOT_FOUND", "Session not found.");
} else { } else {
if (session instanceof FFmpegSession) { if (session.isFFmpeg()) {
FFmpegKitConfig.asyncFFmpegExecute((FFmpegSession) session); FFmpegKitConfig.asyncFFmpegExecute((FFmpegSession) session);
promise.resolve(null); promise.resolve(null);
} else { } else {
@ -662,7 +672,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
if (session == null) { if (session == null) {
promise.reject("SESSION_NOT_FOUND", "Session not found."); promise.reject("SESSION_NOT_FOUND", "Session not found.");
} else { } else {
if (session instanceof FFprobeSession) { if (session.isFFprobe()) {
FFmpegKitConfig.asyncFFprobeExecute((FFprobeSession) session); FFmpegKitConfig.asyncFFprobeExecute((FFprobeSession) session);
promise.resolve(null); promise.resolve(null);
} else { } else {
@ -681,7 +691,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
if (session == null) { if (session == null) {
promise.reject("SESSION_NOT_FOUND", "Session not found."); promise.reject("SESSION_NOT_FOUND", "Session not found.");
} else { } else {
if (session instanceof MediaInformationSession) { if (session.isMediaInformation()) {
final int timeout; final int timeout;
if (isValidPositiveNumber(waitTimeout)) { if (isValidPositiveNumber(waitTimeout)) {
timeout = waitTimeout.intValue(); timeout = waitTimeout.intValue();
@ -932,7 +942,12 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
@ReactMethod @ReactMethod
public void getFFprobeSessions(final Promise promise) { 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 // Packages
@ -980,7 +995,7 @@ public class FFmpegKitReactNativeModule extends ReactContextBaseJavaModule imple
sessionMap.putString(KEY_SESSION_COMMAND, session.getCommand()); sessionMap.putString(KEY_SESSION_COMMAND, session.getCommand());
if (session.isFFprobe()) { if (session.isFFprobe()) {
if (session instanceof MediaInformationSession) { if (session.isMediaInformation()) {
final MediaInformationSession mediaInformationSession = (MediaInformationSession) session; final MediaInformationSession mediaInformationSession = (MediaInformationSession) session;
final MediaInformation mediaInformation = mediaInformationSession.getMediaInformation(); final MediaInformation mediaInformation = mediaInformationSession.getMediaInformation();
if (mediaInformation != null) { if (mediaInformation != null) {

48
react-native/ios/FFmpegKitReactNativeModule.m
View File

@ -61,7 +61,7 @@ static int const SESSION_TYPE_MEDIA_INFORMATION = 3;
// EVENTS // EVENTS
static NSString *const EVENT_LOG_CALLBACK_EVENT = @"FFmpegKitLogCallbackEvent"; static NSString *const EVENT_LOG_CALLBACK_EVENT = @"FFmpegKitLogCallbackEvent";
static NSString *const EVENT_STATISTICS_CALLBACK_EVENT = @"FFmpegKitStatisticsCallbackEvent"; 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; extern int const AbstractSessionDefaultTimeoutForAsynchronousMessagesInTransmit;
@ -91,15 +91,25 @@ RCT_EXPORT_MODULE(FFmpegKitReactNativeModule);
[array addObject:EVENT_LOG_CALLBACK_EVENT]; [array addObject:EVENT_LOG_CALLBACK_EVENT];
[array addObject:EVENT_STATISTICS_CALLBACK_EVENT]; [array addObject:EVENT_STATISTICS_CALLBACK_EVENT];
[array addObject:EVENT_EXECUTE_CALLBACK_EVENT]; [array addObject:EVENT_COMPLETE_CALLBACK_EVENT];
return array; return array;
} }
- (void)registerGlobalCallbacks { - (void)registerGlobalCallbacks {
[FFmpegKitConfig enableExecuteCallback:^(id<Session> session){ [FFmpegKitConfig enableFFmpegSessionCompleteCallback:^(FFmpegSession* session){
NSDictionary *dictionary = [FFmpegKitReactNativeModule toSessionDictionary: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){ [FFmpegKitConfig enableLogCallback: ^(Log* log){
@ -234,7 +244,7 @@ RCT_EXPORT_METHOD(getArch:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRe
// FFmpegSession // FFmpegSession
RCT_EXPORT_METHOD(ffmpegSession:(NSArray*)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) { 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]); resolve([FFmpegKitReactNativeModule toSessionDictionary:session]);
} }
@ -243,7 +253,7 @@ RCT_EXPORT_METHOD(ffmpegSessionGetAllStatistics:(int)sessionId withTimeout:(int)
if (session == nil) { if (session == nil) {
reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); reject(@"SESSION_NOT_FOUND", @"Session not found.", nil);
} else { } else {
if ([session isMemberOfClass:[FFmpegSession class]]) { if ([session isFFmpeg]) {
int timeout; int timeout;
if ([FFmpegKitReactNativeModule isValidPositiveNumber:waitTimeout]) { if ([FFmpegKitReactNativeModule isValidPositiveNumber:waitTimeout]) {
timeout = waitTimeout; timeout = waitTimeout;
@ -263,7 +273,7 @@ RCT_EXPORT_METHOD(ffmpegSessionGetStatistics:(int)sessionId resolver:(RCTPromise
if (session == nil) { if (session == nil) {
reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); reject(@"SESSION_NOT_FOUND", @"Session not found.", nil);
} else { } else {
if ([session isMemberOfClass:[FFmpegSession class]]) { if ([session isFFmpeg]) {
NSArray* statistics = [(FFmpegSession*)session getStatistics]; NSArray* statistics = [(FFmpegSession*)session getStatistics];
resolve([FFmpegKitReactNativeModule toStatisticsArray:statistics]); resolve([FFmpegKitReactNativeModule toStatisticsArray:statistics]);
} else { } else {
@ -275,14 +285,14 @@ RCT_EXPORT_METHOD(ffmpegSessionGetStatistics:(int)sessionId resolver:(RCTPromise
// FFprobeSession // FFprobeSession
RCT_EXPORT_METHOD(ffprobeSession:(NSArray*)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) { 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]); resolve([FFmpegKitReactNativeModule toSessionDictionary:session]);
} }
// MediaInformationSession // MediaInformationSession
RCT_EXPORT_METHOD(mediaInformationSession:(NSArray*)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) { 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]); resolve([FFmpegKitReactNativeModule toSessionDictionary:session]);
} }
@ -409,7 +419,7 @@ RCT_EXPORT_METHOD(ffmpegSessionExecute:(int)sessionId resolver:(RCTPromiseResolv
if (session == nil) { if (session == nil) {
reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); reject(@"SESSION_NOT_FOUND", @"Session not found.", nil);
} else { } else {
if ([session isMemberOfClass:[FFmpegSession class]]) { if ([session isFFmpeg]) {
dispatch_async(asyncDispatchQueue, ^{ dispatch_async(asyncDispatchQueue, ^{
[FFmpegKitConfig ffmpegExecute:(FFmpegSession*)session]; [FFmpegKitConfig ffmpegExecute:(FFmpegSession*)session];
resolve(nil); resolve(nil);
@ -425,7 +435,7 @@ RCT_EXPORT_METHOD(ffprobeSessionExecute:(int)sessionId resolver:(RCTPromiseResol
if (session == nil) { if (session == nil) {
reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); reject(@"SESSION_NOT_FOUND", @"Session not found.", nil);
} else { } else {
if ([session isMemberOfClass:[FFprobeSession class]]) { if ([session isFFprobe]) {
dispatch_async(asyncDispatchQueue, ^{ dispatch_async(asyncDispatchQueue, ^{
[FFmpegKitConfig ffprobeExecute:(FFprobeSession*)session]; [FFmpegKitConfig ffprobeExecute:(FFprobeSession*)session];
resolve(nil); resolve(nil);
@ -441,7 +451,7 @@ RCT_EXPORT_METHOD(mediaInformationSessionExecute:(int)sessionId withTimeout:(int
if (session == nil) { if (session == nil) {
reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); reject(@"SESSION_NOT_FOUND", @"Session not found.", nil);
} else { } else {
if ([session isMemberOfClass:[MediaInformationSession class]]) { if ([session isMediaInformation]) {
int timeout; int timeout;
if ([FFmpegKitReactNativeModule isValidPositiveNumber:waitTimeout]) { if ([FFmpegKitReactNativeModule isValidPositiveNumber:waitTimeout]) {
timeout = waitTimeout; timeout = waitTimeout;
@ -462,7 +472,7 @@ RCT_EXPORT_METHOD(asyncFFmpegSessionExecute:(int)sessionId resolver:(RCTPromiseR
if (session == nil) { if (session == nil) {
reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); reject(@"SESSION_NOT_FOUND", @"Session not found.", nil);
} else { } else {
if ([session isMemberOfClass:[FFmpegSession class]]) { if ([session isFFmpeg]) {
[FFmpegKitConfig asyncFFmpegExecute:(FFmpegSession*)session]; [FFmpegKitConfig asyncFFmpegExecute:(FFmpegSession*)session];
resolve(nil); resolve(nil);
} else { } else {
@ -476,7 +486,7 @@ RCT_EXPORT_METHOD(asyncFFprobeSessionExecute:(int)sessionId resolver:(RCTPromise
if (session == nil) { if (session == nil) {
reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); reject(@"SESSION_NOT_FOUND", @"Session not found.", nil);
} else { } else {
if ([session isMemberOfClass:[FFprobeSession class]]) { if ([session isFFprobe]) {
[FFmpegKitConfig asyncFFprobeExecute:(FFprobeSession*)session]; [FFmpegKitConfig asyncFFprobeExecute:(FFprobeSession*)session];
resolve(nil); resolve(nil);
} else { } else {
@ -490,7 +500,7 @@ RCT_EXPORT_METHOD(asyncMediaInformationSessionExecute:(int)sessionId withTimeout
if (session == nil) { if (session == nil) {
reject(@"SESSION_NOT_FOUND", @"Session not found.", nil); reject(@"SESSION_NOT_FOUND", @"Session not found.", nil);
} else { } else {
if ([session isMemberOfClass:[MediaInformationSession class]]) { if ([session isMediaInformation]) {
int timeout; int timeout;
if ([FFmpegKitReactNativeModule isValidPositiveNumber:waitTimeout]) { if ([FFmpegKitReactNativeModule isValidPositiveNumber:waitTimeout]) {
timeout = waitTimeout; timeout = waitTimeout;
@ -652,7 +662,11 @@ RCT_EXPORT_METHOD(getFFmpegSessions:(RCTPromiseResolveBlock)resolve rejecter:(RC
// FFprobeKit // FFprobeKit
RCT_EXPORT_METHOD(getFFprobeSessions:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) { 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 // Packages
@ -695,7 +709,7 @@ RCT_EXPORT_METHOD(getExternalLibraries:(RCTPromiseResolveBlock)resolve rejecter:
dictionary[KEY_SESSION_COMMAND] = [session getCommand]; dictionary[KEY_SESSION_COMMAND] = [session getCommand];
if ([session isFFprobe]) { if ([session isFFprobe]) {
if ([(AbstractSession*)session isMemberOfClass:[MediaInformationSession class]]) { if ([session isMediaInformation]) {
MediaInformationSession *mediaInformationSession = (MediaInformationSession*)session; MediaInformationSession *mediaInformationSession = (MediaInformationSession*)session;
dictionary[KEY_SESSION_MEDIA_INFORMATION] = [FFmpegKitReactNativeModule toMediaInformationDictionary:[mediaInformationSession getMediaInformation]]; dictionary[KEY_SESSION_MEDIA_INFORMATION] = [FFmpegKitReactNativeModule toMediaInformationDictionary:[mediaInformationSession getMediaInformation]];
dictionary[KEY_SESSION_TYPE] = [NSNumber numberWithInt:SESSION_TYPE_MEDIA_INFORMATION]; dictionary[KEY_SESSION_TYPE] = [NSNumber numberWithInt:SESSION_TYPE_MEDIA_INFORMATION];

86
react-native/src/index.d.ts vendored
View File

@ -16,8 +16,6 @@ declare module 'ffmpeg-kit-react-native' {
static createMediaInformationSessionFromMap(sessionMap: { [key: string]: any }): MediaInformationSession; static createMediaInformationSessionFromMap(sessionMap: { [key: string]: any }): MediaInformationSession;
getExecuteCallback(): ExecuteCallback;
getLogCallback(): LogCallback; getLogCallback(): LogCallback;
getSessionId(): number; getSessionId(): number;
@ -58,6 +56,8 @@ declare module 'ffmpeg-kit-react-native' {
isFFprobe(): boolean; isFFprobe(): boolean;
isMediaInformation(): boolean;
cancel(): Promise<void>; cancel(): Promise<void>;
} }
@ -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 { export class FFmpegKit {
static execute(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise<FFmpegSession>; static execute(command: string, completeCallback?: FFmpegSessionCompleteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise<FFmpegSession>;
static executeWithArguments(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise<FFmpegSession>; static executeWithArguments(commandArguments: string[], completeCallback?: FFmpegSessionCompleteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise<FFmpegSession>;
static executeAsync(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise<FFmpegSession>; static executeAsync(command: string, completeCallback?: FFmpegSessionCompleteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise<FFmpegSession>;
static executeWithArgumentsAsync(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise<FFmpegSession>; static executeWithArgumentsAsync(commandArguments: string[], completeCallback?: FFmpegSessionCompleteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback): Promise<FFmpegSession>;
static cancel(sessionId?: number): Promise<void>; static cancel(sessionId?: number): Promise<void>;
@ -132,7 +134,17 @@ declare module 'ffmpeg-kit-react-native' {
static enableStatisticsCallback(statisticsCallback: StatisticsCallback): void; 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; static getLogLevel(): Level;
@ -152,6 +164,12 @@ declare module 'ffmpeg-kit-react-native' {
static clearSessions(): Promise<void>; static clearSessions(): Promise<void>;
static getFFmpegSessions(): Promise<FFmpegSession[]>;
static getFFprobeSessions(): Promise<FFprobeSession[]>;
static getMediaInformationSessions(): Promise<MediaInformationSession[]>;
static getSessionsByState(state): Promise<Session[]>; static getSessionsByState(state): Promise<Session[]>;
static getLogRedirectionStrategy(): LogRedirectionStrategy; static getLogRedirectionStrategy(): LogRedirectionStrategy;
@ -192,12 +210,14 @@ declare module 'ffmpeg-kit-react-native' {
constructor(); constructor();
static create(argumentsArray: Array<string>, executeCallback?: ExecuteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback, logRedirectionStrategy?: LogRedirectionStrategy): Promise<FFmpegSession>; static create(argumentsArray: Array<string>, completeCallback?: FFmpegSessionCompleteCallback, logCallback?: LogCallback, statisticsCallback?: StatisticsCallback, logRedirectionStrategy?: LogRedirectionStrategy): Promise<FFmpegSession>;
static fromMap(sessionMap: { [key: string]: any }): FFmpegSession; static fromMap(sessionMap: { [key: string]: any }): FFmpegSession;
getStatisticsCallback(): StatisticsCallback; getStatisticsCallback(): StatisticsCallback;
getCompleteCallback(): FFmpegSessionCompleteCallback;
getAllStatistics(waitTimeout?: number): Promise<Array<Statistics>>; getAllStatistics(waitTimeout?: number): Promise<Array<Statistics>>;
getStatistics(): Promise<Array<Statistics>>; getStatistics(): Promise<Array<Statistics>>;
@ -208,31 +228,35 @@ declare module 'ffmpeg-kit-react-native' {
isFFprobe(): boolean; isFFprobe(): boolean;
isMediaInformation(): boolean;
} }
export class FFprobeKit { export class FFprobeKit {
static execute(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback): Promise<FFprobeSession>; static execute(command: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback): Promise<FFprobeSession>;
static executeWithArguments(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback): Promise<FFprobeSession>; static executeWithArguments(commandArguments: string[], completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback): Promise<FFprobeSession>;
static executeAsync(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback): Promise<FFprobeSession>; static executeAsync(command: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback): Promise<FFprobeSession>;
static executeWithArgumentsAsync(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback): Promise<FFprobeSession>; static executeWithArgumentsAsync(commandArguments: string[], completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback): Promise<FFprobeSession>;
static getMediaInformation(path: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>; static getMediaInformation(path: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>;
static getMediaInformationFromCommand(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>; static getMediaInformationFromCommand(command: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>;
static getMediaInformationFromCommandArguments(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>; static getMediaInformationFromCommandArguments(commandArguments: string[], completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>;
static getMediaInformationAsync(path: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>; static getMediaInformationAsync(path: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>;
static getMediaInformationFromCommandAsync(command: string, executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>; static getMediaInformationFromCommandAsync(command: string, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>;
static getMediaInformationFromCommandArgumentsAsync(commandArguments: string[], executeCallback?: ExecuteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>; static getMediaInformationFromCommandArgumentsAsync(commandArguments: string[], completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, waitTimeout?: number): Promise<MediaInformationSession>;
static listSessions(): Promise<FFprobeSession[]>; static listFFprobeSessions(): Promise<FFprobeSession[]>;
static listMediaInformationSessions(): Promise<MediaInformationSession[]>;
} }
@ -240,14 +264,18 @@ declare module 'ffmpeg-kit-react-native' {
constructor(); constructor();
static create(argumentsArray: Array<string>, executeCallback?: ExecuteCallback, logCallback?: LogCallback, logRedirectionStrategy?: LogRedirectionStrategy): Promise<FFprobeSession>; static create(argumentsArray: Array<string>, completeCallback?: FFprobeSessionCompleteCallback, logCallback?: LogCallback, logRedirectionStrategy?: LogRedirectionStrategy): Promise<FFprobeSession>;
static fromMap(sessionMap: { [key: string]: any }): FFprobeSession; static fromMap(sessionMap: { [key: string]: any }): FFprobeSession;
getCompleteCallback(): FFprobeSessionCompleteCallback;
isFFmpeg(): boolean; isFFmpeg(): boolean;
isFFprobe(): boolean; isFFprobe(): boolean;
isMediaInformation(): boolean;
} }
export class Level { 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(); constructor();
static create(argumentsArray: Array<string>, executeCallback?: ExecuteCallback, logCallback?: LogCallback): Promise<MediaInformationSession>; static create(argumentsArray: Array<string>, completeCallback?: MediaInformationSessionCompleteCallback, logCallback?: LogCallback): Promise<MediaInformationSession>;
static fromMap(sessionMap: { [key: string]: any }): MediaInformationSession; static fromMap(sessionMap: { [key: string]: any }): MediaInformationSession;
@ -353,6 +381,14 @@ declare module 'ffmpeg-kit-react-native' {
setMediaInformation(mediaInformation: MediaInformation): void; setMediaInformation(mediaInformation: MediaInformation): void;
getCompleteCallback(): MediaInformationSessionCompleteCallback;
isFFmpeg(): boolean;
isFFprobe(): boolean;
isMediaInformation(): boolean;
} }
export class Packages { export class Packages {
@ -387,8 +423,6 @@ declare module 'ffmpeg-kit-react-native' {
export interface Session { export interface Session {
getExecuteCallback(): ExecuteCallback;
getLogCallback(): LogCallback; getLogCallback(): LogCallback;
getSessionId(): number; getSessionId(): number;
@ -429,6 +463,8 @@ declare module 'ffmpeg-kit-react-native' {
isFFprobe(): boolean; isFFprobe(): boolean;
isMediaInformation(): boolean;
cancel(): Promise<void>; cancel(): Promise<void>;
} }

452
react-native/src/index.js vendored
View File

@ -2,14 +2,16 @@ import {NativeEventEmitter, NativeModules} from 'react-native';
const {FFmpegKitReactNativeModule} = NativeModules; const {FFmpegKitReactNativeModule} = NativeModules;
const executeCallbackMap = new Map() const ffmpegSessionCompleteCallbackMap = new Map()
const ffprobeSessionCompleteCallbackMap = new Map()
const mediaInformationSessionCompleteCallbackMap = new Map()
const logCallbackMap = new Map() const logCallbackMap = new Map()
const statisticsCallbackMap = new Map() const statisticsCallbackMap = new Map()
const logRedirectionStrategyMap = new Map() const logRedirectionStrategyMap = new Map()
const eventLogCallbackEvent = "FFmpegKitLogCallbackEvent"; const eventLogCallbackEvent = "FFmpegKitLogCallbackEvent";
const eventStatisticsCallbackEvent = "FFmpegKitStatisticsCallbackEvent"; const eventStatisticsCallbackEvent = "FFmpegKitStatisticsCallbackEvent";
const eventExecuteCallbackEvent = "FFmpegKitExecuteCallbackEvent"; const eventCompleteCallbackEvent = "FFmpegKitCompleteCallbackEvent";
export const LogRedirectionStrategy = { export const LogRedirectionStrategy = {
ALWAYS_PRINT_LOGS: 0, ALWAYS_PRINT_LOGS: 0,
@ -59,17 +61,9 @@ class FFmpegKitReactNativeEventEmitter extends NativeEventEmitter {
export class Session { export class Session {
/** /**
* Returns the session specific execute callback function. * Returns the session specific log callback.
* *
* @return session specific execute callback function * @return session specific log callback
*/
getExecuteCallback() {
}
/**
* Returns the session specific log callback function.
*
* @return session specific log callback function
*/ */
getLogCallback() { getLogCallback() {
} }
@ -245,6 +239,14 @@ export class Session {
isFFprobe() { isFFprobe() {
} }
/**
* Returns whether it is a <code>MediaInformation</code> session or not.
*
* @return true if it is a <code>MediaInformation</code> session, false otherwise
*/
isMediaInformation() {
}
/** /**
* Cancels running the session. * Cancels running the session.
*/ */
@ -254,8 +256,8 @@ export class Session {
} }
/** /**
* Abstract session implementation which includes common features shared by <code>FFmpeg</code> * Abstract session implementation which includes common features shared by <code>FFmpeg</code>,
* and <code>FFprobe</code> sessions. * <code>FFprobe</code> and <code>MediaInformation</code> sessions.
*/ */
export class AbstractSession extends Session { 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 * @return session specific log callback
*/
getExecuteCallback() {
return FFmpegKitFactory.getExecuteCallback(this.getSessionId())
}
/**
* Returns the session specific log callback function.
*
* @return session specific log callback function
*/ */
getLogCallback() { getLogCallback() {
return FFmpegKitFactory.getLogCallback(this.getSessionId()) return FFmpegKitFactory.getLogCallback(this.getSessionId())
@ -666,6 +659,15 @@ export class AbstractSession extends Session {
return false; return false;
} }
/**
* Returns whether it is a <code>MediaInformation</code> session or not.
*
* @return true if it is a <code>MediaInformation</code> session, false otherwise
*/
isMediaInformation() {
return false;
}
/** /**
* Cancels running the session. * 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. * into arguments. You can use single or double quote characters to specify arguments inside your command.
* *
* @param command FFmpeg 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 logCallback callback that will receive logs
* @param statisticsCallback callback that will receive statistics * @param statisticsCallback callback that will receive statistics
* @return FFmpeg session created for this execution * @return FFmpeg session created for this execution
*/ */
static async execute(command, executeCallback, logCallback, statisticsCallback) { static async execute(command, completeCallback, logCallback, statisticsCallback) {
return FFmpegKit.executeWithArguments(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback, statisticsCallback); return FFmpegKit.executeWithArguments(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback, statisticsCallback);
} }
/** /**
* <p>Synchronously executes FFmpeg with arguments provided. * <p>Synchronously executes FFmpeg with arguments provided.
* *
* @param commandArguments FFmpeg command options/arguments as string array * @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 logCallback callback that will receive logs
* @param statisticsCallback callback that will receive statistics * @param statisticsCallback callback that will receive statistics
* @return FFmpeg session created for this execution * @return FFmpeg session created for this execution
*/ */
static async executeWithArguments(commandArguments, executeCallback, logCallback, statisticsCallback) { static async executeWithArguments(commandArguments, completeCallback, logCallback, statisticsCallback) {
let session = await FFmpegSession.create(commandArguments, executeCallback, logCallback, statisticsCallback); let session = await FFmpegSession.create(commandArguments, completeCallback, logCallback, statisticsCallback);
await FFmpegKitConfig.ffmpegExecute(session); 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. * into arguments. You can use single or double quote characters to specify arguments inside your command.
* *
* <p>Note that this method returns immediately and does not wait the execution to complete. You must use an * <p>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 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 logCallback callback that will receive logs
* @param statisticsCallback callback that will receive statistics * @param statisticsCallback callback that will receive statistics
* @return FFmpeg session created for this execution * @return FFmpeg session created for this execution
*/ */
static async executeAsync(command, executeCallback, logCallback, statisticsCallback) { static async executeAsync(command, completeCallback, logCallback, statisticsCallback) {
return FFmpegKit.executeWithArgumentsAsync(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback, statisticsCallback); return FFmpegKit.executeWithArgumentsAsync(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback, statisticsCallback);
} }
/** /**
* <p>Starts an asynchronous FFmpeg execution with arguments provided. * <p>Starts an asynchronous FFmpeg execution with arguments provided.
* *
* <p>Note that this method returns immediately and does not wait the execution to complete. You must use an * <p>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 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 logCallback callback that will receive logs
* @param statisticsCallback callback that will receive statistics * @param statisticsCallback callback that will receive statistics
* @return FFmpeg session created for this execution * @return FFmpeg session created for this execution
*/ */
static async executeWithArgumentsAsync(commandArguments, executeCallback, logCallback, statisticsCallback) { static async executeWithArgumentsAsync(commandArguments, completeCallback, logCallback, statisticsCallback) {
let session = await FFmpegSession.create(commandArguments, executeCallback, logCallback, statisticsCallback); let session = await FFmpegSession.create(commandArguments, completeCallback, logCallback, statisticsCallback);
await FFmpegKitConfig.asyncFFmpegExecute(session); await FFmpegKitConfig.asyncFFmpegExecute(session);
@ -773,7 +775,7 @@ export class FFmpegKit {
/** /**
* <p>Cancels the session specified with <code>sessionId</code>. * <p>Cancels the session specified with <code>sessionId</code>.
* *
* <p>This function does not wait for termination to complete and returns immediately. * <p>This method does not wait for termination to complete and returns immediately.
* *
* @param sessionId id of the session that will be cancelled * @param sessionId id of the session that will be cancelled
*/ */
@ -1019,7 +1021,7 @@ export class FFmpegKitConfig {
* <p>Starts an asynchronous FFmpeg execution for the given session. * <p>Starts an asynchronous FFmpeg execution for the given session.
* *
* <p>Note that this method returns immediately and does not wait the execution to complete. You must use an * <p>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 * @param ffmpegSession FFmpeg session which includes command options/arguments
*/ */
@ -1033,7 +1035,7 @@ export class FFmpegKitConfig {
* <p>Starts an asynchronous FFprobe execution for the given session. * <p>Starts an asynchronous FFprobe execution for the given session.
* *
* <p>Note that this method returns immediately and does not wait the execution to complete. You must use an * <p>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 * @param ffprobeSession FFprobe session which includes command options/arguments
*/ */
@ -1047,7 +1049,7 @@ export class FFmpegKitConfig {
* <p>Starts an asynchronous FFprobe execution for the given media information session. * <p>Starts an asynchronous FFprobe execution for the given media information session.
* *
* <p>Note that this method returns immediately and does not wait the execution to complete. You must use an * <p>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 mediaInformationSession media information session which includes command options/arguments
* @param waitTimeout max time to wait until media information is transmitted * @param waitTimeout max time to wait until media information is transmitted
@ -1059,9 +1061,9 @@ export class FFmpegKitConfig {
} }
/** /**
* <p>Sets a global callback function to redirect FFmpeg/FFprobe logs. * <p>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 * callback
*/ */
static enableLogCallback(logCallback) { static enableLogCallback(logCallback) {
@ -1069,9 +1071,9 @@ export class FFmpegKitConfig {
} }
/** /**
* <p>Sets a global callback function to redirect FFmpeg statistics. * <p>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 * defined callback
*/ */
static enableStatisticsCallback(statisticsCallback) { static enableStatisticsCallback(statisticsCallback) {
@ -1079,13 +1081,58 @@ export class FFmpegKitConfig {
} }
/** /**
* <p>Sets a global callback function to receive execution results. * <p>Sets a global FFmpegSessionCompleteCallback to receive execution results for FFmpeg sessions.
* *
* @param executeCallback execute callback function or undefined to disable a previously * @param ffmpegSessionCompleteCallback complete callback or undefined to disable a previously defined callback
* defined callback
*/ */
static enableExecuteCallback(executeCallback) { static enableFFmpegSessionCompleteCallback(ffmpegSessionCompleteCallback) {
FFmpegKitFactory.setGlobalExecuteCallback(executeCallback); FFmpegKitFactory.setGlobalFFmpegSessionCompleteCallback(ffmpegSessionCompleteCallback);
}
/**
* <p>Returns the global FFmpegSessionCompleteCallback set.
*
* @return global FFmpegSessionCompleteCallback or undefined if it is not set
*/
static getFFmpegSessionCompleteCallback() {
return FFmpegKitFactory.getGlobalFFmpegSessionCompleteCallback();
}
/**
* <p>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);
}
/**
* <p>Returns the global FFprobeSessionCompleteCallback set.
*
* @return global FFprobeSessionCompleteCallback or undefined if it is not set
*/
static getFFprobeSessionCompleteCallback() {
return FFmpegKitFactory.getGlobalFFprobeSessionCompleteCallback();
}
/**
* <p>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);
}
/**
* <p>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(); return FFmpegKitReactNativeModule.clearSessions();
} }
/**
* <p>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);
}
/**
* <p>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);
}
/**
* <p>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);
}
/** /**
* <p>Returns sessions that have the given state. * <p>Returns sessions that have the given state.
* *
@ -1475,9 +1558,11 @@ export class FFmpegKitConfig {
class FFmpegKitFactory { class FFmpegKitFactory {
static #ffmpegSessionCompleteCallback = undefined;
static #ffprobeSessionCompleteCallback = undefined;
static #mediaInformationSessionCompleteCallback = undefined;
static #logCallback = undefined; static #logCallback = undefined;
static #statisticsCallback = undefined; static #statisticsCallback = undefined;
static #executeCallback = undefined;
static #activeLogLevel = undefined; static #activeLogLevel = undefined;
static mapToStatistics(statisticsMap) { static mapToStatistics(statisticsMap) {
@ -1560,22 +1645,58 @@ class FFmpegKitFactory {
this.#statisticsCallback = statisticsCallback; this.#statisticsCallback = statisticsCallback;
} }
static getExecuteCallback(sessionId) { static getFFmpegSessionCompleteCallback(sessionId) {
return executeCallbackMap.get(sessionId); return ffmpegSessionCompleteCallbackMap.get(sessionId);
} }
static setExecuteCallback(sessionId, executeCallback) { static setFFmpegSessionCompleteCallback(sessionId, completeCallback) {
if (executeCallback !== undefined) { if (completeCallback !== undefined) {
executeCallbackMap.set(sessionId, executeCallback); ffmpegSessionCompleteCallbackMap.set(sessionId, completeCallback);
} }
} }
static getGlobalExecuteCallback() { static getGlobalFFmpegSessionCompleteCallback() {
return this.#executeCallback; return this.#ffmpegSessionCompleteCallback;
} }
static setGlobalExecuteCallback(executeCallback) { static setGlobalFFmpegSessionCompleteCallback(completeCallback) {
this.#executeCallback = executeCallback; this.#ffmpegSessionCompleteCallback = completeCallback;
}
static getFFprobeSessionCompleteCallback(sessionId) {
return ffprobeSessionCompleteCallbackMap.get(sessionId);
}
static setFFprobeSessionCompleteCallback(sessionId, completeCallback) {
if (completeCallback !== undefined) {
ffprobeSessionCompleteCallbackMap.set(sessionId, completeCallback);
}
}
static getGlobalFFprobeSessionCompleteCallback() {
return this.#ffprobeSessionCompleteCallback;
}
static setGlobalFFprobeSessionCompleteCallback(completeCallback) {
this.#ffprobeSessionCompleteCallback = completeCallback;
}
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) { static setLogLevel(logLevel) {
@ -1631,7 +1752,7 @@ class FFmpegKitInitializer {
// NOTIFY SESSION CALLBACK DEFINED // NOTIFY SESSION CALLBACK DEFINED
activeLogCallback(log); activeLogCallback(log);
} catch (err) { } 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 // NOTIFY GLOBAL CALLBACK DEFINED
globalLogCallbackFunction(log); globalLogCallbackFunction(log);
} catch (err) { } 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 // NOTIFY SESSION CALLBACK DEFINED
activeStatisticsCallback(statistics); activeStatisticsCallback(statistics);
} catch (err) { } catch (err) {
console.log("Exception thrown inside session StatisticsCallback block.", err.stack); console.log("Exception thrown inside session statistics callback.", err.stack);
} }
} }
@ -1707,35 +1828,61 @@ class FFmpegKitInitializer {
// NOTIFY GLOBAL CALLBACK DEFINED // NOTIFY GLOBAL CALLBACK DEFINED
globalStatisticsCallbackFunction(statistics); globalStatisticsCallbackFunction(statistics);
} catch (err) { } 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) { static processCompleteCallbackEvent(event) {
if (event !== undefined) {
let sessionId = event.sessionId; let sessionId = event.sessionId;
FFmpegKitConfig.getSession(sessionId).then(session => { FFmpegKitConfig.getSession(sessionId).then(session => {
if (session.getExecuteCallback() !== undefined) { if (session !== undefined) {
if (session.getCompleteCallback() !== undefined) {
try { try {
// NOTIFY SESSION CALLBACK DEFINED // NOTIFY SESSION CALLBACK DEFINED
session.getExecuteCallback()(session); session.getCompleteCallback()(session);
} catch (err) { } catch (err) {
console.log("Exception thrown inside session ExecuteCallback block.", err.stack); console.log("Exception thrown inside session complete callback.", err.stack);
} }
} }
let globalExecuteCallbackFunction = FFmpegKitFactory.getGlobalExecuteCallback(); if (session.isFFmpeg()) {
if (globalExecuteCallbackFunction !== undefined) { let globalFFmpegSessionCompleteCallback = FFmpegKitFactory.getGlobalFFmpegSessionCompleteCallback();
if (globalFFmpegSessionCompleteCallback !== undefined) {
try { try {
// NOTIFY GLOBAL CALLBACK DEFINED // NOTIFY GLOBAL CALLBACK DEFINED
globalExecuteCallbackFunction(session); globalFFmpegSessionCompleteCallback(session);
} catch (err) { } catch (err) {
console.log("Exception thrown inside global ExecuteCallback block.", err.stack); 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);
}
}
} }
} }
}); });
} }
}
static async initialize() { static async initialize() {
if (this.#initialized) { if (this.#initialized) {
@ -1748,7 +1895,7 @@ class FFmpegKitInitializer {
this.#eventEmitter.addListener(eventLogCallbackEvent, FFmpegKitInitializer.processLogCallbackEvent); this.#eventEmitter.addListener(eventLogCallbackEvent, FFmpegKitInitializer.processLogCallbackEvent);
this.#eventEmitter.addListener(eventStatisticsCallbackEvent, FFmpegKitInitializer.processStatisticsCallbackEvent); this.#eventEmitter.addListener(eventStatisticsCallbackEvent, FFmpegKitInitializer.processStatisticsCallbackEvent);
this.#eventEmitter.addListener(eventExecuteCallbackEvent, FFmpegKitInitializer.processExecuteCallbackEvent); this.#eventEmitter.addListener(eventCompleteCallbackEvent, FFmpegKitInitializer.processCompleteCallbackEvent);
FFmpegKitFactory.setLogLevel(await FFmpegKitReactNativeModule.getLogLevel()); FFmpegKitFactory.setLogLevel(await FFmpegKitReactNativeModule.getLogLevel());
const version = FFmpegKitFactory.getVersion(); const version = FFmpegKitFactory.getVersion();
@ -1779,17 +1926,17 @@ export class FFmpegSession extends AbstractSession {
* Creates a new FFmpeg session. * Creates a new FFmpeg session.
* *
* @param argumentsArray FFmpeg command arguments * @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 logCallback callback that will receive logs
* @param statisticsCallback callback that will receive statistics * @param statisticsCallback callback that will receive statistics
* @param logRedirectionStrategy defines how logs will be redirected * @param logRedirectionStrategy defines how logs will be redirected
* @returns FFmpeg session created * @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 session = await AbstractSession.createFFmpegSession(argumentsArray, logRedirectionStrategy);
const sessionId = session.getSessionId(); const sessionId = session.getSessionId();
FFmpegKitFactory.setExecuteCallback(sessionId, executeCallback); FFmpegKitFactory.setFFmpegSessionCompleteCallback(sessionId, completeCallback);
FFmpegKitFactory.setLogCallback(sessionId, logCallback); FFmpegKitFactory.setLogCallback(sessionId, logCallback);
FFmpegKitFactory.setStatisticsCallback(sessionId, statisticsCallback); 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() { getStatisticsCallback() {
return FFmpegKitFactory.getStatisticsCallback(this.getSessionId()); 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 * 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. * 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; 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. * into arguments. You can use single or double quote characters to specify arguments inside your command.
* *
* @param command FFprobe 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 * @param logCallback callback that will receive logs
* @return FFprobe session created for this execution * @return FFprobe session created for this execution
*/ */
static async execute(command, executeCallback, logCallback) { static async execute(command, completeCallback, logCallback) {
return FFprobeKit.executeWithArguments(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback); return FFprobeKit.executeWithArguments(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback);
} }
/** /**
* <p>Synchronously executes FFprobe with arguments provided. * <p>Synchronously executes FFprobe with arguments provided.
* *
* @param commandArguments FFprobe command options/arguments as string array * @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 * @param logCallback callback that will receive logs
* @return FFprobe session created for this execution * @return FFprobe session created for this execution
*/ */
static async executeWithArguments(commandArguments, executeCallback, logCallback) { static async executeWithArguments(commandArguments, completeCallback, logCallback) {
let session = await FFprobeSession.create(commandArguments, executeCallback, logCallback); let session = await FFprobeSession.create(commandArguments, completeCallback, logCallback);
await FFmpegKitConfig.ffprobeExecute(session); 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. * into arguments. You can use single or double quote characters to specify arguments inside your command.
* *
* <p>Note that this method returns immediately and does not wait the execution to complete. You must use an * <p>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 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 * @param logCallback callback that will receive logs
* @return FFprobe session created for this execution * @return FFprobe session created for this execution
*/ */
static async executeAsync(command, executeCallback, logCallback) { static async executeAsync(command, completeCallback, logCallback) {
return FFprobeKit.executeWithArgumentsAsync(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback); return FFprobeKit.executeWithArgumentsAsync(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback);
} }
/** /**
* <p>Starts an asynchronous FFprobe execution with arguments provided. * <p>Starts an asynchronous FFprobe execution with arguments provided.
* *
* <p>Note that this method returns immediately and does not wait the execution to complete. You must use an * <p>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 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 * @param logCallback callback that will receive logs
* @return FFprobe session created for this execution * @return FFprobe session created for this execution
*/ */
static async executeWithArgumentsAsync(commandArguments, executeCallback, logCallback) { static async executeWithArgumentsAsync(commandArguments, completeCallback, logCallback) {
let session = await FFprobeSession.create(commandArguments, executeCallback, logCallback); let session = await FFprobeSession.create(commandArguments, completeCallback, logCallback);
await FFmpegKitConfig.asyncFFprobeExecute(session); await FFmpegKitConfig.asyncFFprobeExecute(session);
@ -1942,14 +2102,14 @@ export class FFprobeKit {
* <p>Extracts media information for the file specified with path. * <p>Extracts media information for the file specified with path.
* *
* @param path path or uri of a media file * @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 logCallback callback that will receive logs
* @param waitTimeout max time to wait until media information is transmitted * @param waitTimeout max time to wait until media information is transmitted
* @return media information session created for this execution * @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]; 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. * 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 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 logCallback callback that will receive logs
* @param waitTimeout max time to wait until media information is transmitted * @param waitTimeout max time to wait until media information is transmitted
* @return media information session created for this execution * @return media information session created for this execution
*/ */
static async getMediaInformationFromCommand(command, executeCallback, logCallback, waitTimeout) { static async getMediaInformationFromCommand(command, completeCallback, logCallback, waitTimeout) {
return FFprobeKit.getMediaInformationFromCommandArguments(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback, waitTimeout); return FFprobeKit.getMediaInformationFromCommandArguments(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback, waitTimeout);
} }
/** /**
@ -1972,13 +2132,13 @@ export class FFprobeKit {
* from it. * from it.
* *
* @param commandArguments FFprobe command arguments that prints media information for a file in JSON format * @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 logCallback callback that will receive logs
* @param waitTimeout max time to wait until media information is transmitted * @param waitTimeout max time to wait until media information is transmitted
* @return media information session created for this execution * @return media information session created for this execution
*/ */
static async getMediaInformationFromCommandArguments(commandArguments, executeCallback, logCallback, waitTimeout) { static async getMediaInformationFromCommandArguments(commandArguments, completeCallback, logCallback, waitTimeout) {
let session = await MediaInformationSession.create(commandArguments, executeCallback, logCallback); let session = await MediaInformationSession.create(commandArguments, completeCallback, logCallback);
await FFmpegKitConfig.getMediaInformationExecute(session, waitTimeout); await FFmpegKitConfig.getMediaInformationExecute(session, waitTimeout);
@ -1989,17 +2149,17 @@ export class FFprobeKit {
* <p>Starts an asynchronous FFprobe execution to extract the media information for the specified file. * <p>Starts an asynchronous FFprobe execution to extract the media information for the specified file.
* *
* <p>Note that this method returns immediately and does not wait the execution to complete. You must use an * <p>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 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 logCallback callback that will receive logs
* @param waitTimeout max time to wait until media information is transmitted * @param waitTimeout max time to wait until media information is transmitted
* @return media information session created for this execution * @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]; 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. * this method must generate the output in JSON format in order to successfully extract media information from it.
* *
* <p>Note that this method returns immediately and does not wait the execution to complete. You must use an * <p>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 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 logCallback callback that will receive logs
* @param waitTimeout max time to wait until media information is transmitted * @param waitTimeout max time to wait until media information is transmitted
* @return media information session created for this execution * @return media information session created for this execution
*/ */
static async getMediaInformationFromCommandAsync(command, executeCallback, logCallback, waitTimeout) { static async getMediaInformationFromCommandAsync(command, completeCallback, logCallback, waitTimeout) {
return FFprobeKit.getMediaInformationFromCommandArgumentsAsync(FFmpegKitConfig.parseArguments(command), executeCallback, logCallback, waitTimeout); return FFprobeKit.getMediaInformationFromCommandArgumentsAsync(FFmpegKitConfig.parseArguments(command), completeCallback, logCallback, waitTimeout);
} }
/** /**
@ -2025,16 +2185,16 @@ export class FFprobeKit {
* from it. * from it.
* *
* <p>Note that this method returns immediately and does not wait the execution to complete. You must use an * <p>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 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 logCallback callback that will receive logs
* @param waitTimeout max time to wait until media information is transmitted * @param waitTimeout max time to wait until media information is transmitted
* @return media information session created for this execution * @return media information session created for this execution
*/ */
static async getMediaInformationFromCommandArgumentsAsync(commandArguments, executeCallback, logCallback, waitTimeout) { static async getMediaInformationFromCommandArgumentsAsync(commandArguments, completeCallback, logCallback, waitTimeout) {
let session = await MediaInformationSession.create(commandArguments, executeCallback, logCallback); let session = await MediaInformationSession.create(commandArguments, completeCallback, logCallback);
await FFmpegKitConfig.asyncGetMediaInformationExecute(session, waitTimeout); await FFmpegKitConfig.asyncGetMediaInformationExecute(session, waitTimeout);
@ -2046,13 +2206,25 @@ export class FFprobeKit {
* *
* @return all FFprobe sessions in the session history * @return all FFprobe sessions in the session history
*/ */
static async listSessions() { static async listFFprobeSessions() {
await FFmpegKitConfig.init(); await FFmpegKitConfig.init();
const sessionArray = await FFmpegKitReactNativeModule.getFFprobeSessions(); const sessionArray = await FFmpegKitReactNativeModule.getFFprobeSessions();
return sessionArray.map(FFmpegKitFactory.mapToSession); return sessionArray.map(FFmpegKitFactory.mapToSession);
} }
/**
* <p>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. * Creates a new FFprobe session.
* *
* @param argumentsArray FFprobe command arguments * @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 logCallback callback that will receive logs
* @param logRedirectionStrategy defines how logs will be redirected * @param logRedirectionStrategy defines how logs will be redirected
* @returns FFprobe session created * @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 session = await AbstractSession.createFFprobeSession(argumentsArray, logRedirectionStrategy);
const sessionId = session.getSessionId(); const sessionId = session.getSessionId();
FFmpegKitFactory.setExecuteCallback(sessionId, executeCallback); FFmpegKitFactory.setFFprobeSessionCompleteCallback(sessionId, completeCallback);
FFmpegKitFactory.setLogCallback(sessionId, logCallback); FFmpegKitFactory.setLogCallback(sessionId, logCallback);
return session; return session;
@ -2096,6 +2268,15 @@ export class FFprobeSession extends AbstractSession {
return AbstractSession.createFFprobeSessionFromMap(sessionMap); return AbstractSession.createFFprobeSessionFromMap(sessionMap);
} }
/**
* Returns the session specific complete callback.
*
* @return session specific complete callback
*/
getCompleteCallback() {
return FFmpegKitFactory.getFFprobeSessionCompleteCallback(this.getSessionId());
}
isFFmpeg() { isFFmpeg() {
return false; return false;
} }
@ -2104,6 +2285,10 @@ export class FFprobeSession extends AbstractSession {
return true; return true;
} }
isMediaInformation() {
return false;
}
} }
/** /**
@ -2469,7 +2654,7 @@ export class MediaInformationJsonParser {
* <p>A custom FFprobe session, which produces a <code>MediaInformation</code> object using the * <p>A custom FFprobe session, which produces a <code>MediaInformation</code> object using the
* FFprobe output. * FFprobe output.
*/ */
export class MediaInformationSession extends FFprobeSession { export class MediaInformationSession extends AbstractSession {
#mediaInformation; #mediaInformation;
/** /**
@ -2483,15 +2668,15 @@ export class MediaInformationSession extends FFprobeSession {
* Creates a new MediaInformationSession session. * Creates a new MediaInformationSession session.
* *
* @param argumentsArray FFprobe command arguments * @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 logCallback callback that will receive logs
* @returns MediaInformationSession session created * @returns MediaInformationSession session created
*/ */
static async create(argumentsArray, executeCallback, logCallback) { static async create(argumentsArray, completeCallback, logCallback) {
const session = await AbstractSession.createMediaInformationSession(argumentsArray); const session = await AbstractSession.createMediaInformationSession(argumentsArray);
const sessionId = session.getSessionId(); const sessionId = session.getSessionId();
FFmpegKitFactory.setExecuteCallback(sessionId, executeCallback); FFmpegKitFactory.setMediaInformationSessionCompleteCallback(sessionId, completeCallback);
FFmpegKitFactory.setLogCallback(sessionId, logCallback); FFmpegKitFactory.setLogCallback(sessionId, logCallback);
return session; return session;
@ -2526,6 +2711,27 @@ export class MediaInformationSession extends FFprobeSession {
this.#mediaInformation = mediaInformation; 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;
}
} }
/** /**