Ability to execute parameterized method in extension package without creating dependency

Question

This answer: Managed Package Integration without Extensions or Dependencies is now 4 years old and I was curious if it is still the only way to accomplish the following goal:

1. Main Package
2. Extension Package - May or May Not be installed along with the main package
3. In main package need to determine if Extension is installed
4. If installed run method in extension package passing in parameters
5. No dependency can be created as the extension is not required but if present it must run at a specified point

So basically need to check if extension is installed and if so run a parameterized method without creating dependencies.

System.Type does not allow for the execution of methods or the passing of parameters AFAIK. I do not see any other way to accomplish this.

Granted, the previous answer is still applicable and does not consume much CPU time at all. Just curious if it is still the only and preferred way of doing this.

In the simplest form the following is what I currently have:

Main Package (Batch Apex)

System.Type apiMethod = Type.forName('ns', 'Class.Method');
If(apiMethod != null){
  Object apiCall = JSON.deserialize(
          '{"param1":null,"param2":"12345"}',
          apiMethod
  );
}

Extension Package

global class{
        global Id param1 {get;set;}
        global string param2 {get;set;}

        global method(){
            if(string.isBlank(param2) || param1 == null)
                throw new ex_Exception('Invalid Parameters');

            secondMethod(param1,param2);
        }
    }

    global static void secondMethod(Id param1, String param2) {
       ..Do something...
    }


}

Please ignore naming conventions as for illustration only. This works and does not create a dependency in either package.

Answer 1

You would use an Interface. In the base package, declare your interfaces as global, so they can be accessed in the extension package. Then, you can use Type.forName as usual.

Base Package

global interface DoSomething {
    void doSomething(Object param1, object param2);
}

...

Type externalType = Type.forName('ExtensionClass','extns');
if(externalType != null) {
    DoSomething data = (DoSomething)externalType.newInstance();
    data.doSomething(param1, param2);
}

Extension Package

global class ExtensionClass implements basens.DoSomething {
    global void doSomething(Object param1, Object param2) {
        // Do stuff here
    }
}