Object Instance with method from ObjectType - no arguments and badNotImplemented

[Siedlerchr]

Hi,

maybe that's a stupid question but I am new to opcua and didn't find anything in the code related to this. I have an ObjectType modeled like in the ExampleNamespace and added a method.
When I now create an instance, I see the method with no arguments in OPCUAExpert and when I try to call it I see BadNotImplemented.

How do I wire the method definition to the instance?
Thanks in advance

   private fun addReaderConnectMethod(readerObjectType: UaObjectTypeNode) {
            val connectMethod = UaMethodNode.build(nodeContext) { builder ->
                builder.setNodeId(NodeId(namespaceIndex, "ReaderObjectType.Connect"))
                    .setBrowseName(QualifiedName(namespaceIndex, "connect"))
                    .setDisplayName(LocalizedText("Connect "))
                    .setDescription(LocalizedText.english("Connect"))
                    .buildAndAdd()

            }

            val inputArguments = arrayOf(
                Argument(
                    /* name = */ "rfidChannel",
                    /* dataType = */ NodeIds.Int32,
                    /* valueRank = */ ValueRanks.Scalar,
                    /* arrayDimensions = */ null,
                    /* description = */ LocalizedText.english("Rfid Channel")
                ),
                Argument(
                    "busAddress",
                    NodeIds.Int32,
                    ValueRanks.Scalar,
                    null,
                    LocalizedText.english("Bus address")
                )
            )
            val outputArguments = arrayOf(
                Argument(
                    "Result",
                    ResultType.TYPE_ID.toNodeIdOrThrow(server.namespaceTable), // DataType
                    ValueRanks.Scalar,  // Single structure, not array
                    null,
                    LocalizedText.english("ResultType structure as output")
                )

            )

            connectMethod.inputArguments = inputArguments
            connectMethod.outputArguments = outputArguments

            connectMethod.invocationHandler = object : AbstractMethodInvocationHandler(connectMethod) {
                override fun getInputArguments() = inputArguments

                override fun getOutputArguments() = outputArguments

                override fun invoke(
                    invocationContext: InvocationContext,
                    inputValues: Array<Variant>
                ): Array<Variant> {

                    if (inputValues.isNotEmpty()) {
        
               // TODO: ... 

                    }
                    return arrayOf()
                }
            }

            connectMethod.addReference(
                Reference(
                    connectMethod.nodeId,
                    ReferenceTypes.HasComponent,
                    readerObjectTypeId.expanded(),
                    Reference.Direction.INVERSE
                )
            )

            readerObjectType.addComponent(connectMethod)

            connectMethod.addReference(
                Reference(
                    connectMethod.nodeId, // Source NodeId
                    NodeIds.HasModellingRule, // Reference Type
                    NodeIds.ModellingRule_Mandatory.expanded(), // Target NodeId
                    Reference.Direction.FORWARD // Direction
                )
            )
        }

Instance creation

   fun createReaderInstance(
            instanceName: String,
            initialId: UShort,
            initialLocation: String,
            readersFolder: UaFolderNode
        ): NodeId {
            val instanceNodeId = NodeId(namespaceIndex, "Reader_${objectIdCounter.incrementAndFetch()}")
            val instanceQualifiedName = QualifiedName(namespaceIndex, instanceName)
            val instanceDisplayName = LocalizedText(instanceName)


            val readerInstance = nodeFactory.createNode(
                instanceNodeId,
                readerObjectTypeId
            ) as UaObjectNode
            readerInstance.browseName = instanceQualifiedName
            readerInstance.displayName = instanceDisplayName

            // Add forward and inverse references from the root folder.
            readersFolder.addOrganizes(readerInstance)
            readerInstance.addReference(
                Reference(
                    readerInstance.nodeId,
                    NodeIds.Organizes,
                    readersFolder.nodeId.expanded(),
                    Reference.Direction.INVERSE
                )
            )

            // Add to the "Readers" folder
            val readersFolder = nodeManager.getNode(readersFolderId).getOrNull() as UaFolderNode

            readersFolder.addReference(
                Reference(
                    readersFolderId, // Source NodeId
                    ReferenceTypes.HasComponent, // Reference Type
                    instanceNodeId.expanded(), // Target NodeId
                    Reference.Direction.FORWARD // Direction
                )
            )

[kevinherron]

Is addReaderConnectMethod called while building the ObjectType Node? i.e. is it part of the type declaration? (it looks like it because you're using HasModellingRule references).

Instead of adding the invocation handler to the method that is part of the type declaration, try adding it to the method instance that is created once you have created an object instance.

e.g.

UaMethodNode connectMethod = readerInstance.getConnectMethod(); // does it have a getConnectMethod? might have to get it some other way...
connectMethod.setInvocationHandler(...);

[Siedlerchr]

Thanks a lot for the quick repoly!
addReaderConnectMethod was called when creating the object Type defintion. I assumed that the method would be somehow autoamtically "inherited" with the input/output argumentss well from the ObjectType.

Adding it to each instance seems to work now.

      val methodNode = readerInstance.findMethodNode(NodeId(namespaceIndex, "ReaderObjectType.Connect"))
            val connectMethod = ConnectMethod(
                methodNode!!, // TODO: check for null 
                methodCallbacks
            )
            methodNode.inputArguments = connectMethod.inputArguments
            methodNode.outputArguments = connectMethod.outputArguments
            methodNode.invocationHandler = connectMethod

[kevinherron]

I think the problem is that invocation handlers need to have a reference to the actual object and method instance nodes, not a reference to the type declaration nodes that you would get by only defining it on the declaration.

[Siedlerchr]

Seems logical in case you want to modify the behavior on each Instance. I now switched it to adding it only to the concrete instance and interestingly, it still shows up in the ObjectType....

[kevinherron]

What do you mean by "it still shows up in the ObjectType"? What shows up?

The ObjectType should have a reference to a Method when you browse the address space. There are no "MethodType" Nodes, so the standard Method Node does double duty - you'll find them as part of the type declaration, as well as on the instance.

You just don't need to try to install an invocation handler on it in this case.