Require explicit annotation for Workflow and Activity interfaces. about sdk-java HOT 3 CLOSED

public interface Base {
    void foo();
}

// Defines MyActivity1_bar and MyActivity1_foo activity types
@ActivityInterface
public interface MyActivity1 extends Base {
    void bar();
}

// Defines MyActivity2_foo activity type
@ActivityInterface
public interface MyActivity2 extends Base {
}

public class MyActivityImpl1 implements MyActivity1, Runnable {
    public void foo() {
        // activity impl
    }
    
    public void bar() {
        // activity impl
    }
    
    public void run() {
        // this is not activity method as Runnable is not an activity
    }
}

public class MyActivityImpl2 implements MyActivity2 {
    public void foo() {
        // activity impl
    }
}

worker.registerActivitiesImplementations(new MyActivityImpl1(), new MyActivityImpl2());


public interface MyWorkflow {
    @WorkflowMethod
    void execute();
}

public class MyWorkflowImpl implements MyWorklfow {
    MyActivity1 a = Workflow.newActivityStub(MyActivity1.class);
    MyActivity2 b = Workflow.newActivityStub(MyActivity2.class);
    // The following is going to fail at runtime as Runnable is not annotated with @ActivityInterface
    Runnable invalid = Workflow.newActivityStub(Runnable.class); 
    // The following is going to fail at runtime as Base is not annotated with @ActivityInterface
    Base invalid2 = Workflow.newActivityStub(Base.class); 

    // This is fine as both MyActivity1 and MyActivity2 extend Base
    Base[] all = new Base[] {a, b};
    
    public void execute() {
        a.bar(); 
        for(Base b:all) {
            b.foo();
        }
    }
}

@ActivityInterface
public interface MyActivity {
    void foo();
}

public class MyActivityImpl1 implements MyActivity, Runnable {
    // This is registered as MyActivity_foo activity name with the worker
    // This is exactly the current behavior
    public void foo() {
        // whatever
    }
    // This is not an activity method
    public void run() {
        //whatever
    }
}

@ActivityImplementation(type="MyActivity2")
public class MyActivityImpl2 implements MyActivity {
    // This is registered as MyActivity2_foo activity name with the worker
    public void foo() {
        // whatever
    }

}

worker.registerActivitiesImplementations(new MyActivityImpl1(), new MyActivityImpl2());


@WorkflowInterface
public interface MyWorkflow {
    @WorkflowMethod
    void execute();
}

public class MyWorkflowImpl implements MyWorklfow {

    MyActivity a1 = Workflow.newActivityStub(MyActivity.class);
    MyActivity a2 = Workflow.newActivityStub(MyActivity.class, "MyActivity2");
    // This is not valid as Runnable is not annotated with @ActivityInterface
    Runnable invalid = Workflow.newActivityStub(Runnable.class, "foo");
    MyActivity[] activities = new MyActivity[] {a1, a2};
    
    public void execute() {
        a1.foo(); // calls MyActivity_foo
        a2.foo(); // calls MyActivity2_foo
        for(MyActivity a: activities) {
           a.foo();  // Ends up calling MyActivity_foo and MyActivity2_foo activity names.
        }
    }
}