JCnfDemo architecture

The following illustration shows the JCnfDemo architecture:

Note: To keep the illustration clear, not all of the links are shown. Conf, Channel, and JCnfDemo implement most of the J*Def interfaces.

The jninmss library uses native code through Java. It provides a link between classes and C structures, and forwards the commands to the Natural Access libraries.

The JCnfDemo consists of the following packages:

A java class, a java interface, and a native wrapper represent each Natural Access service.

The cnfdemo package

The following illustration shows the architecture of the cnfdemo package:

The following table describes the classes:

Cnfdemo package implements interfaces of the jninmss package because Conf and Channel use the jninmss package.

The jninmss package

Java conferencing belongs to the jninmss package. jninmss consists of two files:

• JCnfDef.java

• JCnfApi.java

Because JCnfDef.java implements an interface, java classes should implement JCnfDef.java to use the CNF API.

JCnfDef contains all the constants relative to the CNF API, and all the definitions of classes that wrap the C structures used in the C CNF API.

The following code sample is an extract from the JCnfDef.java file:

public interface JCnfDef
{
// Constants definition
/*------------------------------------------------------------------------
CNF Service ID.  
*/
public static int CNF_SVCID                            = 0x1A;

/*
* Base number for defining other keys
*/
public static int CNF_BASEID                           = 0x001A0000;

// Other constants definition
[...]
// C structures wrapped by java classes:

/* Conference parameters (used in cnfCreateConference)
*/
final public class CNF_CONFERENCE_PARMS
{
// Object size
public int      size;
// Conference creation flags
public int      flags;
// Number of allocated members
public int      allocated_members;
// User value.
public int      user_value;
};

// Other C Structures definition...
[...]
}
 

JCnfApi.java wraps the Natural Conference (CNF) API and contains the definition of the class JCnfAPI. It can also access CnfApi through JCnfApi, forwarding calls to Natural Access.

The following code sample is an extract from the JcnfApi.java file:

public class JCnfApi implements JCnfDef, JCtaDef
{
/**
* jcnfOpenResource native interface wrapper.
*
* @param cta_handles CTA_HANDLE object.
* @param cnf_handles CNF_HANDLES object.
* @param resourcenum Resource number.
* @return int iRet, cnfOpenResource native return value.
*/

public int jcnfOpenResource ( CTA_HANDLES cta_handles ,
                 CNF_HANDLES cnf_handles , int resourcenum )
{
int iRet;
iRet = cnfOpenResource ( cnf_handles , cta_handles.ctahd ,
                resourcenum );
return (iRet);
}

[....]

/////// PRIVATE NATIVE INTERFACE   ...
/**
* cnfOpenResource native interface.
*
* @param cnf_handles CNF_HANDLES object.
* @param ctahd CTA context handle.
* @param resourcenum Resource number.
* @return int iRet, cnfOpenResource native return value.
*/
private native int cnfOpenResource ( CNF_HANDLES cnf_handles , int ctahd ,
                        int resourcenum );

// <<native>> means that the Virtual Machine will call cnfOpenResource
// from C Library jcnfapi

[...]
}
 

The javah program creates a header file from the JcnfApi.java file, called jninmss_JcnfApi.h. This file describes the entry points of the jninmss library.

The JCnfApi library links with cnfapi. It forwards all calls to the C library after transferring data from objects to structures.