[android] Fatal Exception: java.lang.NullPointerException - SpineController.init

[ArtoonHardik]

i have check the null object but it's still getting crash

Fatal Exception: java.lang.NullPointerException: on a null object reference in method ***
at com.esotericsoftware.spine.android.SpineController.init(SpineController.java:156)
at com.esotericsoftware.spine.android.SpineView.lambda$loadFrom$4(SpineView.java:361)
at android.os.Handler.handleCallback(Handler.java:958)
at android.os.Handler.dispatchMessage(Handler.java:99)
at android.os.Looper.loopOnce(Looper.java:230)
at android.os.Looper.loop(Looper.java:319)
at android.app.ActivityThread.main(ActivityThread.java:8919)
at java.lang.reflect.Method.invoke(Method.java)
at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:578)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:1103)

[badlogic]

I'm afraid this is not enough information to help. Please provide us with a minimal project that reproduces the issue.

[ArtoonHardik]

public class SpineAnimationLoader {
    private static final String TAG = "SpineAnimationLoader";
    private static final float DEFAULT_SCALE = 0.8f;

    @Inject
    public SpineAnimationLoader() {
    }

    /**
     * Checks if the SpineView is properly attached and ready for animation loading.
     *
     * @param spineView The view to check
     * @return true if view is attached and has valid context, false otherwise
     */
    private boolean isViewAttached(SpineView spineView) {
        if (spineView == null) {
            Log.e(TAG, "SpineView is null");
            return false;
        }
        if (spineView.getContext() == null) {
            Log.e(TAG, "SpineView context is null");
            return false;
        }
        if (!spineView.isAttachedToWindow()) {
            Log.e(TAG, "SpineView is not attached to window");
            return false;
        }
        return true;
    }

    public void loadSpineAnimation(SpineView spineView, String atlasFileName, String skeletonFileName, String animationName) {
        // Validate SpineView
        if (!isViewAttached(spineView)) {
            return;
        }

        // Validate asset file names
        if (atlasFileName == null || skeletonFileName == null || animationName == null) {
            Log.e(TAG, "Invalid parameters: atlas=" + atlasFileName + ", skeleton=" + skeletonFileName + ", animation=" + animationName);
            return;
        }

        String requestedSignature = buildSignature(atlasFileName, skeletonFileName, animationName);
        SpineTag currentTag = getOrCreateTag(spineView);

        // Skip if already loaded
        if (requestedSignature.equals(currentTag.signature) && getAnimationState(spineView) != null) {
            Log.d(TAG, "Animation already loaded: " + animationName);
            return;
        }

        Runnable loadTask = () -> {
            try {
                // Re-validate view is still attached
                if (!isViewAttached(spineView)) {
                    Log.e(TAG, "SpineView became detached during load");
                    return;
                }

                SpineTag cachedTag = getOrCreateTag(spineView);

                // Check again if already loaded (race condition protection)
                if (requestedSignature.equals(cachedTag.signature) && getAnimationState(spineView) != null) {
                    Log.d(TAG, "Animation loaded by another thread: " + animationName);
                    return;
                }

                // Set content mode before loading
                spineView.setContentMode(ContentMode.FILL);

                // Create controller with initialization callback
                // This callback executes AFTER assets are loaded by SpineView
                SpineController spineController = new SpineController(controller -> {
                    try {
                        if (controller != null && controller.getSkeleton() != null) {
                            controller.getSkeleton().setScale(DEFAULT_SCALE, DEFAULT_SCALE);
                            AnimationState animationState = controller.getAnimationState();
                            if (animationState != null) {
                                animationState.setAnimation(0, animationName, true);
                                Log.d(TAG, "Animation started: " + animationName);
                            } else {
                                Log.e(TAG, "AnimationState is null after loading");
                            }
                        } else {
                            Log.e(TAG, "Controller or Skeleton is null in callback");
                        }
                    } catch (Exception e) {
                        Log.e(TAG, "Error in controller initialization callback: " + e.getMessage(), e);
                    }
                });

                // Set controller before loading assets
                spineView.setController(spineController);

                // Load assets - this triggers controller.init() internally
                // The controller callback above will execute AFTER successful load
                spineView.loadFromAsset(atlasFileName, skeletonFileName);

                // Update tag to track loaded animation
                cachedTag.signature = requestedSignature;
                cachedTag.lastTimeScale = 1f;
                cachedTag.paused = false;
                spineView.setTag(cachedTag);

                Log.d(TAG, "Spine animation load initiated: " + animationName);

            } catch (Exception e) {
                Log.e(TAG, "Error loading spine animation: " + e.getMessage(), e);
            }
        };

        // Execute on main thread
           try {
        if (Looper.myLooper() == Looper.getMainLooper()) {
            loadTask.run();
        } else {
            spineView.post(loadTask);
        }
          } catch (Exception e) {
                Log.e(TAG, "Error resuming spine animation: " + e.getMessage(), e);
            }
    }

    public void clearAnimation(SpineView spineView) {
        if (spineView == null) {
            return;
        }

        Runnable clearTask = () -> {
            try {
                clearAnimationInternal(spineView);
                spineView.setTag(null);
            } catch (Exception e) {
                Log.e(TAG, "Error clearing animation: " + e.getMessage());
            }
        };
        try {
            if (Looper.myLooper() == Looper.getMainLooper()) {
                clearTask.run();
            } else {
                spineView.post(clearTask);
            }
        } catch (Exception e) {
            Log.e(TAG, "Error resuming spine animation: " + e.getMessage(), e);
        }
    }

private void clearAnimationInternal(SpineView spineView) {
      if (spineView == null) {
          return;
      }

      // Clear animation tracks
      try {
          SpineController controller = spineView.getController();
          if (controller != null) {
              try {
                  AnimationState animationState = controller.getAnimationState();
                  if (animationState != null) {
                      animationState.clearTracks();
                      Log.d(TAG, "Cleared animation tracks");
                  }
              } catch (Exception e) {
                  Log.e(TAG, "Error clearing animation tracks: " + e.getMessage());
              }
          }
      } catch (Exception e) {
          Log.e(TAG, "Error accessing controller: " + e.getMessage());
      }

      // Clear spine view animation
      try {
          spineView.clearAnimation();
          Log.d(TAG, "Cleared spine view animation");
      } catch (Exception e) {
          Log.e(TAG, "Error clearing spine view animation: " + e.getMessage());
      }

      // Remove controller reference
      try {
          spineView.setController(null);
          Log.d(TAG, "Removed controller reference");
      } catch (Exception e) {
          Log.e(TAG, "Error removing controller: " + e.getMessage());
      }
  }

  public void pauseAnimation(SpineView spineView) {
      if (spineView == null) {
          return;
      }

      Runnable pauseTask = () -> {
          try {
              AnimationState state = getAnimationState(spineView);
              if (state != null) {
                  SpineTag tag = getOrCreateTag(spineView);
                  if (!tag.paused) {
                      tag.lastTimeScale = state.getTimeScale() == 0f ? 1f : state.getTimeScale();
                      state.setTimeScale(0f);
                      tag.paused = true;
                      spineView.setTag(tag);
                  }
              }
          } catch (Exception e) {
              Log.e(TAG, "Error pausing spine animation: " + e.getMessage(), e);
          }
      };

      try {
          if (Looper.myLooper() == Looper.getMainLooper()) {
              pauseTask.run();
          } else {
              spineView.post(pauseTask);
          }
      } catch (Exception e) {
          Log.e(TAG, "Error resuming spine animation: " + e.getMessage(), e);
      }
  }

  public void resumeAnimation(SpineView spineView) {
      if (spineView == null) {
          return;
      }

      Runnable resumeTask = () -> {
          try {
              AnimationState state = getAnimationState(spineView);
              if (state != null) {
                  SpineTag tag = getOrCreateTag(spineView);
                  state.setTimeScale(tag.paused ? Math.max(tag.lastTimeScale, 1f) : Math.max(state.getTimeScale(), 1f));
                  tag.paused = false;
                  spineView.setTag(tag);
              }
          } catch (Exception e) {
              Log.e(TAG, "Error resuming spine animation: " + e.getMessage(), e);
          }
      };

      try {
          if (Looper.myLooper() == Looper.getMainLooper()) {
              resumeTask.run();
          } else {
              spineView.post(resumeTask);
          }
      } catch (Exception e) {
          Log.e(TAG, "Error resuming spine animation: " + e.getMessage(), e);
      }
  }

  private AnimationState getAnimationState(SpineView spineView) {
      if (spineView == null) {
          return null;
      }

      try {
          SpineController controller = spineView.getController();
          if (controller != null) {
              return controller.getAnimationState();
          }
      } catch (Exception e) {
          Log.e(TAG, "Error retrieving animation state: " + e.getMessage(), e);
      }
      return null;
  }

  private SpineTag getOrCreateTag(SpineView spineView) {
      Object tagObj = spineView.getTag();
      if (tagObj instanceof SpineTag) {
          return (SpineTag) tagObj;
      }
      SpineTag newTag = new SpineTag();
      spineView.setTag(newTag);
      return newTag;
  }

  private String buildSignature(String atlasFileName, String skeletonFileName, String animationName) {
      return atlasFileName + "|" + skeletonFileName + "|" + animationName;
  }


  private static final class SpineTag {
      String signature = "";
      float lastTimeScale = 1f;
      boolean paused = false;
  }
}

above is my sample code and i have used as below
// Load spine animation in background to avoid blocking UI
  @Inject
  SpineAnimationLoader spineAnimationLoader;


      try {
          if (spineAnimationLoader != null && dashBoardBinding != null) {
              try {
                  dashBoardBinding.icFreeVideoImage.post(() -> {
                      try {
                          spineAnimationLoader.loadSpineAnimation(
                                  dashBoardBinding.icFreeVideoImage, "spineAnimation/rewardButton/Dashboard ADS Icon.atlas",
                                  "spineAnimation/rewardButton/Dashboard ADS Icon.json",
                                  "Dashboard ADS Icon"
                          );
                      } catch (Exception e) {
                          Log.e(TAG, "Error resuming spine animation: " + e.getMessage(), e);
                      }
                  });

              } catch (Exception e) {

              }

          }
      } catch (Exception e) {
          Log.e("DashBoard", "Error loading spine animation: ", e);
      }