Sample Usage

j-Interop provides JIComServer as the embodiment of the actual COM server. This serves as the start point for interoperating with COM.

You can either use a ProgID (well known name for the COM server like "Excel.Application" or "InternetExplorer.Application") or use the CLSID directly (IID of the interface).

Typically, you would always want to use the IDispatch interface (Automation).

//First establish a session. All calls happen within the purview of the Session. //for localhost , you can use "localhost" and "administrator" (since they have universal access) //JISession session = JISession.createSession("localhost","administrator","PASSWORD"); JISession session = JISession.createSession("DOMAIN","USERNAME","PASSWORD"); //Now create the COM server to the target machine, this could either be an IP address or a hostname. JIComServer comServer = new JIComServer(JIProgId.valueOf("Excel.Application"),"127.0.0.1",session); //Instantiate the COM Server IJIComObject excelObject = comServer.createInstance(); //Get a handle to it's IDispatch IJIDispatch dispatch = (IJIDispatch)JIObjectFactory.narrowObject((IJIComObject)excelObject.queryInterface(IJIDispatch.IID)); //call an API JIVariant variant = new JIVariant(Boolean.TRUE); //This will show excel(if yours is not visible then follow FAQ A12). dispatch.put("Visible",variant); //... //when your work is done JISession.destroySession(session); //optional step, the session will be destroyed anyways when the application exits //but good to do when you are working with many COM servers and are done with a few.

For users working with COM servers not supporting Automation, they can work directly with the APIs. They would need to know the operation numbers of the APIs they would be calling on the COM server. These can easily be obtained from the IDL or from the Type Library ("Ole View" for viewing type libraries comes with Microsoft Visual Studio Tools).

The part about obtaining the JIComServer and getting a reference to the COM object is as shown previously, but instead of using IJIDispatch you would be going ahead like this:

//Now QueryInterface for the required interface //In this example "620012E2-69E3-4DC0-B553-AE252524D2F6" is the interface which the user would like to use of the COM server IJIComObject comInterface = comObject.queryInterface("620012E2-69E3-4DC0-B553-AE252524D2F6"); //Set up a call, this following object carries your parameters back and forth between the COM server and the Java App. JICallBuilder callBuilder = new JICallBuilder(); //The same object can be used for many calls, please make sure you reinit before usage/call. callBuilder.reInit(); // set up the obtained operation number, in our case it is 137. callBuilder.setOpnum(137); //This is the input param and they have to be added sequentially and in order. //These are available in the TypeLibrary\IDL, look for [in] params. callBuilder.addInParamAsString("Hello", JIFlags.FLAG_REPRESENTATION_STRING_BSTR); //This is the expected result, you can find out about the return types from the TypeLibrary\IDL as well. //look for [out] params. callBuilder.addOutParamAsObject(new JIString(JIFlags.FLAG_REPRESENTATION_STRING_BSTR),JIFlags.FLAG_NULL); //Execute the call on the obtained interface. Object[] results = comInterface.call(callObject);

Please make sure that you call JISession.destroySession(session) after you are done away with the usage of your session. This will close the sockets to the COM server.

For attaching callbacks , please look at the examples MSInternetExplorer and MSSysInfo.

From MSInternetExplorer

The JILocalCoClass is a representation for a Java server class. Currently, you can implement any IDL of an existing COM server using the JILocalCoClass and pass it's interface pointer instead of the original COM server and it will work fine. Similar mechanism is exploited for call backs.In our case I had to implement DWebBrowserEvents interface.

JILocalCoClass javaComponent = new JILocalCoClass(new JILocalInterfaceDefinition("45B5FC0C-FAC2-42bd-923E-2B221A89E092"),DWebBrowserEvents2.class);

This definition create a Java component with an IID of 45B5FC0C-FAC2-42bd-923E-2B221A89E092... I just made this one up for uniquely classifying this class...you can equate this to a lib identifier of COM IDL. This is required if there are multilple interfaces being implemented in the same Java Class. If you have only one...you can put it's IID here. I just did not do it for showing the user a possiblity. The JILocalCoClass has the option of instantiating the DWebBrowserEvents.class or it could use another ctor to pass an already instantiated object. In latter scenario, the object would be used as target for the events instead of instantiating a new one from DWebBrowserEvents.class.

Now that we have a Java server, we need to define the methods\events it will handle. This is done using the Method descriptors which are themselves described using the Parameter Objects.

JILocalParamsDescriptor propertyChangeObject = new JILocalParamsDescriptor();

This creates a Parameter Object, capable of defining a IN or OUT type for a Method. Like,

propertyChangeObject.addInParamAsType(JIString.class,JIFlags.FLAG_NULL); JILocalMethodDescriptor methodDescriptor = new JILocalMethodDescriptor("PropertyChange",0x70,propertyChangeObject); javaComponent.getInterfaceDefinition().addMethodDescriptor(methodDescriptor);

This declares a method descriptor. The first parameter in the ctor is the API name of the api to implement, the second one is it's OP number.This one can be obtained from the IDL\TypeLib. And the third param is the parameter object describing the input\output types of this method. If you do not want to use this ctor, there is another, which sequentially increments the method numbers starting from 1. The calls below add a new interface IID to this Java server. It simply means that the server supports this interface definition.

ArrayList list = new ArrayList(); list.add("34A715A0-6587-11D0-924A-0020AFC7AC4D"); javaComponent.setSupportedEventInterfaces(list);

This will be the list of all COM interfaces which this Java class supports or implements.

The next call attaches the event handler (our JILocalCoClass) to the actual COM server for recieving events for the interface identified by the IID. There can be many such calls on the same COM server for different IIDs.

identifier = JIObjectFactory.attachEventHandler(ieObject,"34A715A0-6587-11D0-924A-0020AFC7AC4D",JIObjectFactory.buildObject(session,javaComponent));

Now whether you use IJIDispatch or not, events will work regardless of that. The COM object you have to use in the attachEventHandler is the COM Object on which you did the queryInterface for the IJIDispatch.

Examples

Commented examples are located in the "examples" folder of the distribution.