How to link the task execution in my Gradle plugin to the output file of another plugin?

I'm trying to write a plugin for Gradle that would perform some actions with the file result of performing another task (defined in another plugin - java-library-distribution). I can easily get the file I need via this.getProject().getTasks().getByName("distZip").getOutputs().getFiles().getSingleFile() in my task class.

But with this approach, my task will be executed every time, regardless of whether the file has changed in the higher-level task.

I annotated the getter method as an @InputFile. But unfortunately Gradle still doesn't mark the issue as UP-TO-DATE.

public class YcfPlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
        project.getExtensions().create("ycf", YcfPluginExtension.class);
        project.getPluginManager().apply("java-library-distribution");

        project.getTasks().register("ycfCreateVersion", YcfTaskCreateVersion.class);
    }
}

abstract class YcfTask extends DefaultTask {
    public static final String TASK_GROUP = "Some Description";
    YcfPluginExtension ycfExtension = this.getProject().getExtensions().getByType(YcfPluginExtension.class);
    Logger logger = this.getProject().getLogger();

    public YcfTask() {
        this.setGroup(TASK_GROUP);   
    }
}

public class YcfTaskCreateVersion extends YcfTask {
    private File fi;

    public YcfTaskCreateVersion() {
        this.setDescription("Some description");
        this.dependsOn(this.getProject().getTasks().getByName("distZip"));

    }

    @InputFile
    public File getFi() {
        return this.getProject().getTasks().getByName("distZip").getOutputs().getFiles().getSingleFile();
    }
    @TaskAction
    public void run() {
        byte[] bytes = Files.readAllBytes(getFi().toPath());
        //..do something with file content
    }
}

There are some misconceptions in your current approach:

1. The @InputFile annotation should be used on a getter method. A getter method is not just a method that starts with the prefix get. Usually it is a method that returns the value of a (private) field. In your example there is a field called fi, so the respective getter method getFi should just return the value of this field. By the way, in your current code, the field fi is not used at all.

2. It is good that you know what value should be used as an input of your task (getProject().getTasks().getByName("distZip").getOutputs().getFiles().getSingleFile()), but this should not be a part of the task type implementation. Instead, task types should be as configurable as possible. You may then create and configure one instance of this task type in your plugin code:

   public class YcfTaskCreateVersion extends YcfTask {
       private File fi;
   
       @InputFile
       public File getFi() {
           return fi;
       }
   
       public void setFi(File fi) {
           this.fi = fi;
       }
   
       @TaskAction
       public void run() {
           // ...
       }
   }
   
   public class YcfPlugin implements Plugin<Project> {
       @Override
       public void apply(Project project) {
           // ...
   
           YcfTaskCreateVersion createVersionTask = project.getTasks()
               .register("ycfCreateVersion", YcfTaskCreateVersion.class);
           createVersionTask.setFi(project.getTasks().getByName("distZip")
               .getOutputs().getFiles().getSingleFile());
       }
   }
   

3. Sadly, the code above won't work, because at the time the task is created (when the plugin is applied), the outputs of the task distZip (and maybe even the task) won't be available. But that is not a big problem, because Gradle supports this use case. You can change the type of your field to Object, so that not only objects of type File may be passed in. Whether a file (or something that may be converted to a file) was passed, will be checked when the task executes.

   public class YcfTaskCreateVersion extends YcfTask {
       private Object fi;
   
       @InputFile
       public Object getFi() {
           return fi;
       }
   
       public void setFi(Object fi) {
           this.fi = fi;
       }
   
       @TaskAction
       public void run() {
           File file = getProject().files(fi).getSingleFile();
           // do something with file
       }
   }
   

   There is a cool thing about this setup: You may pass the task distZip directly and Gradle will automatically extract the file outputs. It will even detect that you are using the outputs of a task as inputs of another task, so Gradle will automatically setup a task dependency between the two tasks and you don't have to use dependsOn anymore:

   createVersionTask.setFi(project.getTasks().getByName("distZip"));
   

4. Lets check the Gradle documentation on task outcomes. There is a section on UP-TO-DATE:

   > Task’s outputs did not change.
   > - Task has outputs and inputs and they have not changed. See Incremental Builds.
   > - Task has actions, but the task tells Gradle it did not change its outputs.
   > - Task has no actions and some dependencies, but all of the dependencies are up-to-date, skipped or from cache. See also Lifecycle Tasks.
   > - Task has no actions and no dependencies.

   As you can see, your task needs to define outputs to be considered up-to-date. You can define output files in the same way as input files (field, getter with @OutputFile and setter). They should be configurable and default to a file inside the build directory. Alternatively you may use onlyIf to implement a custom check whether the task should be run. If the predicate inside onlyIf returns false, the task will be SKIPPED.