diff --git a/spine-flutter/example/lib/main.dart b/spine-flutter/example/lib/main.dart
index ce80fc6f6..bd61c399c 100644
--- a/spine-flutter/example/lib/main.dart
+++ b/spine-flutter/example/lib/main.dart
@@ -78,6 +78,11 @@ class AnimationStateEvents extends StatelessWidget {
       controller.animationState?.addAnimation(0, "run", true, 2)?.setListener((event) {
         print("Run animation event ${event.type}");
       });
+      controller.animationState?.setListener((event) {
+        if (event.type == EventType.Event) {
+          print("User event: { intValue: ${event.event?.getIntValue()}, floatValue: intValue: ${event.event?.getFloatValue()}, stringValue: ${event.event?.getStringValue()} }");
+        }
+      });
     });
 
     return Scaffold(
diff --git a/spine-flutter/lib/spine_flutter.dart b/spine-flutter/lib/spine_flutter.dart
index 4cdc61065..6870d2e0d 100644
--- a/spine-flutter/lib/spine_flutter.dart
+++ b/spine-flutter/lib/spine_flutter.dart
@@ -709,7 +709,7 @@ class TrackEntry {
     return _bindings.spine_track_entry_get_track_complete(_entry);
   }
 
-  void setListener(AnimationStateListener listener) {
+  void setListener(AnimationStateListener? listener) {
     _state._setTrackEntryListener(_entry, listener);
   }
 }
@@ -723,10 +723,45 @@ enum EventType {
   Event
 }
 
+class EventData {
+  final spine_event_data _data;
+
+  EventData(this._data);
+}
+
 class Event {
   final spine_event _event;
 
   Event(this._event);
+
+  EventData getData() {
+    return EventData(_bindings.spine_event_get_data(_event));
+  }
+
+  double getTime() {
+    return _bindings.spine_event_get_time(_event);
+  }
+
+  int getIntValue() {
+    return _bindings.spine_event_get_int_value(_event);
+  }
+
+  double getFloatValue() {
+    return _bindings.spine_event_get_float_value(_event);
+  }
+
+  String getStringValue() {
+    final Pointer<Utf8> value = _bindings.spine_event_get_string_value(_event).cast();
+    return value.toDartString();
+  }
+
+  double getVolume() {
+    return _bindings.spine_event_get_volume(_event);
+  }
+
+  double getBalance() {
+    return _bindings.spine_event_get_balance(_event);
+  }
 }
 
 class AnimationStateEvent {
@@ -747,8 +782,9 @@ class AnimationState {
 
   AnimationState(this._state, this._events): _trackEntryListeners = {};
 
-  void _setTrackEntryListener(spine_track_entry entry, AnimationStateListener listener) {
-    _trackEntryListeners[entry] = listener;
+  void _setTrackEntryListener(spine_track_entry entry, AnimationStateListener? listener) {
+    if (listener == null) _trackEntryListeners.remove(entry);
+    else _trackEntryListeners[entry] = listener;
   }
 
   /// Increments the track entry times, setting queued animations as current if needed
@@ -886,6 +922,10 @@ class AnimationState {
   void setTimeScale(double timeScale) {
     _bindings.spine_animation_state_set_time_scale(_state, timeScale);
   }
+
+  void setListener(AnimationStateListener? listener) {
+    _stateListener = listener;
+  }
 }
 
 class SkeletonDrawable {
diff --git a/spine-flutter/lib/spine_flutter_bindings_generated.dart b/spine-flutter/lib/spine_flutter_bindings_generated.dart
index 29782f409..f54614df8 100644
--- a/spine-flutter/lib/spine_flutter_bindings_generated.dart
+++ b/spine-flutter/lib/spine_flutter_bindings_generated.dart
@@ -1934,6 +1934,104 @@ class SpineFlutterBindings {
           'spine_skeleton_set_scale_y');
   late final _spine_skeleton_set_scale_y = _spine_skeleton_set_scale_yPtr
       .asFunction<void Function(spine_skeleton, double)>();
+
+  spine_event_data spine_event_get_data(
+    spine_event event,
+  ) {
+    return _spine_event_get_data(
+      event,
+    );
+  }
+
+  late final _spine_event_get_dataPtr =
+      _lookup<ffi.NativeFunction<spine_event_data Function(spine_event)>>(
+          'spine_event_get_data');
+  late final _spine_event_get_data = _spine_event_get_dataPtr
+      .asFunction<spine_event_data Function(spine_event)>();
+
+  double spine_event_get_time(
+    spine_event event,
+  ) {
+    return _spine_event_get_time(
+      event,
+    );
+  }
+
+  late final _spine_event_get_timePtr =
+      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
+          'spine_event_get_time');
+  late final _spine_event_get_time =
+      _spine_event_get_timePtr.asFunction<double Function(spine_event)>();
+
+  int spine_event_get_int_value(
+    spine_event event,
+  ) {
+    return _spine_event_get_int_value(
+      event,
+    );
+  }
+
+  late final _spine_event_get_int_valuePtr =
+      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_event)>>(
+          'spine_event_get_int_value');
+  late final _spine_event_get_int_value =
+      _spine_event_get_int_valuePtr.asFunction<int Function(spine_event)>();
+
+  double spine_event_get_float_value(
+    spine_event event,
+  ) {
+    return _spine_event_get_float_value(
+      event,
+    );
+  }
+
+  late final _spine_event_get_float_valuePtr =
+      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
+          'spine_event_get_float_value');
+  late final _spine_event_get_float_value = _spine_event_get_float_valuePtr
+      .asFunction<double Function(spine_event)>();
+
+  ffi.Pointer<ffi.Int8> spine_event_get_string_value(
+    spine_event event,
+  ) {
+    return _spine_event_get_string_value(
+      event,
+    );
+  }
+
+  late final _spine_event_get_string_valuePtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Int8> Function(spine_event)>>(
+          'spine_event_get_string_value');
+  late final _spine_event_get_string_value = _spine_event_get_string_valuePtr
+      .asFunction<ffi.Pointer<ffi.Int8> Function(spine_event)>();
+
+  double spine_event_get_volume(
+    spine_event event,
+  ) {
+    return _spine_event_get_volume(
+      event,
+    );
+  }
+
+  late final _spine_event_get_volumePtr =
+      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
+          'spine_event_get_volume');
+  late final _spine_event_get_volume =
+      _spine_event_get_volumePtr.asFunction<double Function(spine_event)>();
+
+  double spine_event_get_balance(
+    spine_event event,
+  ) {
+    return _spine_event_get_balance(
+      event,
+    );
+  }
+
+  late final _spine_event_get_balancePtr =
+      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
+          'spine_event_get_balance');
+  late final _spine_event_get_balance =
+      _spine_event_get_balancePtr.asFunction<double Function(spine_event)>();
 }
 
 class spine_atlas extends ffi.Struct {
@@ -2055,3 +2153,4 @@ typedef spine_attachment = ffi.Pointer<ffi.Void>;
 typedef spine_ik_constraint = ffi.Pointer<ffi.Void>;
 typedef spine_transform_constraint = ffi.Pointer<ffi.Void>;
 typedef spine_path_constraint = ffi.Pointer<ffi.Void>;
+typedef spine_event_data = ffi.Pointer<ffi.Void>;
diff --git a/spine-flutter/src/spine_flutter.cpp b/spine-flutter/src/spine_flutter.cpp
index e288484f2..fd270434c 100644
--- a/spine-flutter/src/spine_flutter.cpp
+++ b/spine-flutter/src/spine_flutter.cpp
@@ -375,7 +375,7 @@ FFI_PLUGIN_EXPORT spine_event spine_animation_state_events_get_event(spine_anima
     if (events == nullptr) return nullptr;
     EventListener *_events = (EventListener*)events;
     if (index >= _events->events.size()) return nullptr;
-    return (spine_track_entry)_events->events[index].entry;
+    return (spine_track_entry)_events->events[index].event;
 }
 
 FFI_PLUGIN_EXPORT void spine_animation_state_events_reset(spine_animation_state_events events) {
@@ -925,4 +925,46 @@ FFI_PLUGIN_EXPORT void spine_skeleton_set_scale_y(spine_skeleton skeleton, float
     if (skeleton == nullptr) return;
     Skeleton *_skeleton = (Skeleton*)skeleton;
     _skeleton->setScaleY(scaleY);
+}
+
+FFI_PLUGIN_EXPORT spine_event_data spine_event_get_data(spine_event event) {
+    if (event == nullptr) return nullptr;
+    Event *_event = (Event*)event;
+    return (spine_event_data)&_event->getData();
+}
+
+FFI_PLUGIN_EXPORT float spine_event_get_time(spine_event event) {
+    if (event == nullptr) return 0;
+    Event *_event = (Event*)event;
+    return _event->getTime();
+}
+
+FFI_PLUGIN_EXPORT int spine_event_get_int_value(spine_event event) {
+    if (event == nullptr) return 0;
+    Event *_event = (Event*)event;
+    return _event->getIntValue();
+}
+
+FFI_PLUGIN_EXPORT float spine_event_get_float_value(spine_event event) {
+    if (event == nullptr) return 0;
+    Event *_event = (Event*)event;
+    return _event->getFloatValue();
+}
+
+FFI_PLUGIN_EXPORT const char* spine_event_get_string_value(spine_event event) {
+    if (event == nullptr) return nullptr;
+    Event *_event = (Event*)event;
+    return _event->getStringValue().buffer();
+}
+
+FFI_PLUGIN_EXPORT float spine_event_get_volume(spine_event event) {
+    if (event == nullptr) return 0;
+    Event *_event = (Event*)event;
+    return _event->getVolume();
+}
+
+FFI_PLUGIN_EXPORT float spine_event_get_balance(spine_event event) {
+    if (event == nullptr) return 0;
+    Event *_event = (Event*)event;
+    return _event->getBalance();
 }
\ No newline at end of file
diff --git a/spine-flutter/src/spine_flutter.h b/spine-flutter/src/spine_flutter.h
index 125ee089d..b637efb04 100644
--- a/spine-flutter/src/spine_flutter.h
+++ b/spine-flutter/src/spine_flutter.h
@@ -231,4 +231,12 @@ FFI_PLUGIN_EXPORT void spine_skeleton_set_y(spine_skeleton skeleton, float y);
 FFI_PLUGIN_EXPORT float spine_skeleton_get_scale_x(spine_skeleton skeleton);
 FFI_PLUGIN_EXPORT void spine_skeleton_set_scale_x(spine_skeleton skeleton, float scaleX);
 FFI_PLUGIN_EXPORT float spine_skeleton_get_scale_y(spine_skeleton skeleton);
-FFI_PLUGIN_EXPORT void spine_skeleton_set_scale_y(spine_skeleton skeleton, float scaleY);
\ No newline at end of file
+FFI_PLUGIN_EXPORT void spine_skeleton_set_scale_y(spine_skeleton skeleton, float scaleY);
+
+FFI_PLUGIN_EXPORT spine_event_data spine_event_get_data(spine_event event);
+FFI_PLUGIN_EXPORT float spine_event_get_time(spine_event event);
+FFI_PLUGIN_EXPORT int spine_event_get_int_value(spine_event event);
+FFI_PLUGIN_EXPORT float spine_event_get_float_value(spine_event event);
+FFI_PLUGIN_EXPORT const char* spine_event_get_string_value(spine_event event);
+FFI_PLUGIN_EXPORT float spine_event_get_volume(spine_event event);
+FFI_PLUGIN_EXPORT float spine_event_get_balance(spine_event event);
\ No newline at end of file