--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivity/com.nokia.tcf/src/com/nokia/tcf/impl/TCAPIConnection.java Fri Apr 03 23:33:03 2009 +0100
@@ -0,0 +1,1025 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+/**
+ *
+ */
+package com.nokia.tcf.impl;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.text.MessageFormat;
+
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.osgi.service.datalocation.Location;
+
+import com.nokia.tcf.api.ITCAPIConnection;
+import com.nokia.tcf.api.ITCConnection;
+import com.nokia.tcf.api.ITCErrorListener;
+import com.nokia.tcf.api.ITCMessage;
+import com.nokia.tcf.api.ITCRealSerialConnection;
+import com.nokia.tcf.api.ITCRealTCPConnection;
+import com.nokia.tcf.api.ITCVirtualSerialConnection;
+import com.nokia.tcf.api.TCFClassFactory;
+import com.nokia.tcf.api.ITCMessageIds;
+import com.nokia.tcf.api.ITCMessageInputStream;
+import com.nokia.tcf.api.ITCMessageOptions;
+import com.nokia.tcf.api.ITCVersion;
+import com.nokia.tcf.Activator;
+import com.nokia.tcf.api.TCErrorConstants;
+
+public class TCAPIConnection implements ITCAPIConnection {
+
+ static {
+ Activator plugin = Activator.getDefault();
+ IPath path = null;
+ String dePath = null;
+ if (plugin != null)
+ path = plugin.getDebuggerPath();
+ if (path != null)
+ dePath = path.toOSString();
+ if (dePath == null) {
+ System.loadLibrary("TCFClient");
+ } else {
+ try{
+ System.load(dePath + java.io.File.separator + "TCFClient.dll");
+ } catch (UnsatisfiedLinkError e) {
+ // if Carbide DLL is not found in DE,
+ // try to load one from the plugin itself
+ System.loadLibrary("TCFClient");
+ }
+ }
+ }
+ private TCErrorListenerList<ITCErrorListener> errorListenerList;
+ private ITCCookie cookie; // this client's handle to native
+ private ITCMessageIds messageIds; // this client's message ids
+ private TCMessageInputStream inputStream; // this client's message input stream (not using message file)
+ protected ITCMessageOptions messageOptions; // this client's message options
+ private TCFMonitorThread monitorThread; // the client's native monitor
+ public boolean stopTCFMonitorThread; // stream monitor start/stop flag
+ protected IStatus statusOK;
+ protected ITCConnection connection; // the client's connection
+
+ public ITCConnection getConnection() {
+ return this.connection;
+ }
+ public ITCMessageOptions getMessageOptions() {
+ return this.messageOptions;
+ }
+ /**
+ * Only constructor - fields are created using the public methods
+ */
+ public TCAPIConnection() {
+ super();
+ this.errorListenerList = new TCErrorListenerList<ITCErrorListener>();
+ this.errorListenerList.clear();
+ this.connection = null;
+ IStatus status = new Status(Status.OK, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_NONE, "OK", null);
+ statusOK = status;
+ this.cookie = new TCCookie(-1, status, false, false);
+ this.inputStream = null;
+ this.messageIds = null;
+ this.messageOptions = null;
+ this.monitorThread = null;
+ this.stopTCFMonitorThread = false;
+ }
+
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#addErrorListener(com.nokia.tcf.api.ITCErrorListener)
+ */
+ public IStatus addErrorListener(ITCErrorListener inErrorListener) {
+ IStatus status = statusOK;
+ try {
+ errorListenerList.add(inErrorListener);
+ } catch (NullPointerException e) {
+ int err = (int)TCErrorConstants.TCAPI_ERR_ERRLISTENER_NULL;
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, err, TCErrorConstants.getErrorMessage(err), e);
+ }
+// System.out.printf("addErrorListener status = %s\n", status.getMessage());
+ return status;
+ }
+
+ private IStatus checkConnected() {
+ IStatus status = statusOK;
+ if (this.connection == null || this.cookie.isConnected() == false) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MEDIA_NOT_OPEN,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MEDIA_NOT_OPEN), null);
+ }
+ return status;
+ }
+ protected IStatus checkDecodeFormat(String decodeFormat) {
+ IStatus status = statusOK;
+ return status;
+ }
+ protected IStatus checkConnectionType(ITCConnection inConnection) {
+ IStatus status = statusOK;
+ int type = inConnection.getConnectionType();
+ if (type == ITCConnection.MEDIA_VIRTUALSERIAL) {
+ ITCVirtualSerialConnection c = (ITCVirtualSerialConnection)inConnection;
+ String p = c.getComPort();
+ if (p == null) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_MEDIA_DATA,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_MEDIA_DATA), null);
+ }
+ } else if (type == ITCConnection.MEDIA_REALTCP) {
+ ITCRealTCPConnection c = (ITCRealTCPConnection)inConnection;
+ String ip = c.getIpAddress();
+ String p = c.getPort();
+ if (ip == null || p == null) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_MEDIA_DATA,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_MEDIA_DATA), null);
+ }
+ } else if (type == ITCConnection.MEDIA_REALSERIAL) {
+ ITCRealSerialConnection c = (ITCRealSerialConnection)inConnection;
+ long err = checkRealSerialSettings(c);
+ if (err != TCErrorConstants.TCAPI_ERR_NONE) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)err, TCErrorConstants.getErrorMessage(err), null);
+ }
+ } else {
+ // Add other connection types here
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_UNKNOWN_MEDIA_TYPE,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_UNKNOWN_MEDIA_TYPE), null);
+ }
+
+ return status;
+ }
+ private IStatus checkConnection(ITCConnection inConnection) {
+ IStatus status = statusOK;
+ if (this.cookie.isConnected()) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_ALREADY_CONNECTED,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_ALREADY_CONNECTED), null);
+ }
+ if (inConnection == null) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_CONNECTION_SPEC,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_CONNECTION_SPEC), null);
+ }
+ if (status.isOK()) {
+ String decodeFormat = inConnection.getDecodeFormat();
+ status = checkDecodeFormat(decodeFormat);
+ }
+ if (status.isOK()) {
+ long retryI = inConnection.getRetryInterval();
+ long retryT = inConnection.getRetryTimeout();
+ if (retryI == 0 || retryT == 0 || retryI > retryT) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_INVALID_RETRY_PERIODS,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_INVALID_RETRY_PERIODS), null);
+ }
+ }
+
+ if (status.isOK()) {
+ status = checkConnectionType(inConnection);
+ }
+
+ return status;
+ }
+ private long checkRealSerialSettings(ITCRealSerialConnection c) {
+ String[] setting = new String[6];
+ setting[0] = c.getBaudRate();
+ setting[1] = c.getComPort();
+ setting[2] = c.getDataBits();
+ setting[3] = c.getFlowControl();
+ setting[4] = c.getParity();
+ setting[5] = c.getStopBits();
+ for (int i = 0; i < 6; i++) {
+ if (setting[i] == null) {
+ return TCErrorConstants.TCAPI_ERR_MISSING_MEDIA_DATA;
+ }
+ }
+ if ((setting[2] != ITCRealSerialConnection.DATABITS_4) && (setting[2] != ITCRealSerialConnection.DATABITS_5) && (setting[2] != ITCRealSerialConnection.DATABITS_6) &&
+ (setting[2] != ITCRealSerialConnection.DATABITS_7) && (setting[2] != ITCRealSerialConnection.DATABITS_8)) {
+ return TCErrorConstants.TCAPI_ERR_COMM_INVALID_DATABITS;
+ }
+ if ((setting[3] != ITCRealSerialConnection.FLOWCONTROL_HW) && (setting[3] != ITCRealSerialConnection.FLOWCONTROL_NONE) && (setting[3] != ITCRealSerialConnection.FLOWCONTROL_SW)) {
+ return TCErrorConstants.TCAPI_ERR_COMM_INVALID_FLOWCONTROL;
+ }
+ if ((setting[4] != ITCRealSerialConnection.PARITY_EVEN) && (setting[4] != ITCRealSerialConnection.PARITY_NONE) && (setting[4] != ITCRealSerialConnection.PARITY_ODD)) {
+ return TCErrorConstants.TCAPI_ERR_COMM_INVALID_PARITY;
+ }
+ if ((setting[5] != ITCRealSerialConnection.STOPBITS_1) && (setting[5] != ITCRealSerialConnection.STOPBITS_1_5) && (setting[5] != ITCRealSerialConnection.STOPBITS_2)) {
+ return TCErrorConstants.TCAPI_ERR_COMM_INVALID_STOPBITS;
+ }
+
+ return TCErrorConstants.TCAPI_ERR_NONE;
+ }
+ private IStatus checkMessage(ITCMessage inMessage) {
+ IStatus status = statusOK;
+
+ if (inMessage == null) {
+ // inMessage cannot be null
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE), null);
+ } else if (inMessage.size() == 0) {
+ // bytes to send may be 0 if we're doing the header (header is the message)
+ if (this.messageOptions.getMessageEncodeFormat() == ITCMessageOptions.ENCODE_NO_FORMAT) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE), null);
+ }
+ }
+ if (status.isOK()) {
+ // check options
+ if (inMessage.isUseMyMessageId()) {
+ if (this.messageOptions.getMessageEncodeFormat() == ITCMessageOptions.ENCODE_NO_FORMAT) {
+ // use my id, but don't encode = error
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MESSAGE_OPTIONS_CONFLICT,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MESSAGE_OPTIONS_CONFLICT), null);
+ } else {
+ // use my id, and encode = OK
+ }
+ } else {
+ if (this.messageOptions.getMessageEncodeFormat() == ITCMessageOptions.ENCODE_NO_FORMAT) {
+ // don't use my id, and don't encode = OK
+ } else {
+ // don't use my id, but encode = warning (we'll go ahead send this message raw)
+ status = new Status(Status.WARNING, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MESSAGE_OPTIONS_CONFLICT,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MESSAGE_OPTIONS_CONFLICT), null);
+ }
+ }
+ }
+ return status;
+ }
+ private IStatus checkMessageIds(ITCMessageIds inMessageIds) {
+ IStatus status = statusOK;
+
+ if (inMessageIds == null || inMessageIds.size() == 0) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_NO_MESSAGESIDS_REGISTERED,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_NO_MESSAGESIDS_REGISTERED), null);
+ }
+ if (status.isOK()) {
+ if (inMessageIds.size() > 256) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MESSAGEID_MAXIMUM,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MESSAGEID_MAXIMUM), null);
+ }
+ }
+ return status;
+ }
+
+
+ private IStatus checkMessageOptions(ITCMessageOptions inMessageOptions) {
+ IStatus status = statusOK;
+
+ if (inMessageOptions == null) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE_OPTIONS,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_MISSING_MESSAGE_OPTIONS), null);
+ }
+// if (status.isOK()) {
+// long option = inMessageOptions.getMessageDestination();
+// String file = inMessageOptions.getMessageFile().toOSString();
+// if (option == ITCMessageOptions.DESTINATION_CLIENTFILE) {
+// status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_FEATURE_NOT_IMPLEMENTED,
+// TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_FEATURE_NOT_IMPLEMENTED), null);
+// }
+// }
+
+ if (status.isOK()) {
+ long option = inMessageOptions.getMessageEncodeFormat();
+ switch ((int)option) {
+ case (int)ITCMessageOptions.ENCODE_NO_FORMAT:
+ case (int)ITCMessageOptions.ENCODE_FORMAT:
+ case (int)ITCMessageOptions.ENCODE_TRK_FORMAT:
+ break;
+ default:
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_INVALID_ENCODE_FORMAT,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_INVALID_ENCODE_FORMAT), null);
+ }
+ }
+ if (status.isOK()) {
+ long option = inMessageOptions.getUnWrapFormat();
+ switch ((int)option) {
+ case (int)ITCMessageOptions.UNWRAP_DELETE_HEADERS:
+ case (int)ITCMessageOptions.UNWRAP_LEAVE_HEADERS:
+ break;
+ default:
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_INVALID_MESSAGE_UNWRAP_OPTION,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_INVALID_MESSAGE_UNWRAP_OPTION), null);
+ }
+ }
+
+ if (status.isOK()) {
+ long bufferSize = inMessageOptions.getInputStreamSize();
+ if (bufferSize <= 0) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_INVALID_STREAM_BUFFER_SIZE,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_INVALID_STREAM_BUFFER_SIZE), null);
+ }
+ }
+
+ return status;
+ }
+
+ protected IStatus checkConnectOptions(ITCConnection inConnection,
+ ITCMessageOptions inMessageOptions, ITCMessageIds inMessageIds) {
+
+ IStatus status = statusOK;
+
+ status = checkConnection(inConnection);
+
+ if (status.isOK()) {
+ status = checkMessageOptions(inMessageOptions);
+ }
+ if (status.isOK()) {
+ status = checkMessageIds(inMessageIds);
+ }
+ return status;
+ }
+ protected IStatus finishConnect(int type, String[] settings,
+ ITCConnection inConnection, ITCMessageOptions inMessageOptions, ITCMessageIds inMessageIds) {
+ IStatus status = statusOK;
+ // connect
+ long[] clientId = new long[1];
+ clientId[0] = -1;
+ long[] options = new long[3];
+ options[0] = inConnection.getRetryInterval(); // connection options
+ options[1] = inConnection.getRetryTimeout();
+ options[2] = 0;
+ long[] moptions = new long[2];
+ moptions[0] = inMessageOptions.getUnWrapFormat();
+ moptions[1] = inMessageOptions.getOSTVersion();
+ String filePath = null;
+ if (inMessageOptions.getMessageDestination() == ITCMessageOptions.DESTINATION_CLIENTFILE) {
+ filePath = inMessageOptions.getMessageFile().toOSString();
+ try {
+ ensureWritableFile(filePath);
+ } catch (IOException e) {
+ String msg = e.getMessage();
+ long err = TCErrorConstants.TCAPI_ERR_CREATE_FILE;
+ String tcErr = String.format("%s OSError: %s", TCErrorConstants.getErrorMessage(err), msg);
+ status = new Status(IStatus.ERROR, Activator.PLUGIN_ID,
+ (int)TCErrorConstants.TCAPI_ERR_CREATE_FILE, tcErr, e);
+ }
+ }
+
+ try {
+ long ret = nativeConnect(type, options, settings, moptions, filePath, clientId);
+ if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
+ this.cookie.setClientId(clientId[0]);
+ this.cookie.setConnected(true);
+ this.connection = inConnection;
+ this.messageOptions = inMessageOptions;
+ } else {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ } catch (Exception e) {
+ // exception is thrown ONLY when err = TCAPI_ERR_WHILE_CONFIGURING_MEDIA from native
+ // and the message is the OS error generated
+ String msg = e.getMessage();
+ long ret = TCErrorConstants.TCAPI_ERR_WHILE_CONFIGURING_MEDIA;
+ String tcErr = String.format("%s OSError: %s", TCErrorConstants.getErrorMessage(ret), msg);
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, tcErr, null);
+ }
+ // send message ids to capture
+ if (status.isOK()) {
+ int number = (int)inMessageIds.size();
+ byte[] ids = new byte[number];
+ for (int i = 0; i < number; i++) {
+ ids[i] = inMessageIds.getMessageIds().get(i);
+ }
+ long ret = nativeSetMessageIds(this.cookie.getClientId(), ids);
+ if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
+ this.messageIds = inMessageIds;
+ } else {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ }
+ // setup input stream
+ if (status.isOK() && inMessageOptions.getMessageDestination() == ITCMessageOptions.DESTINATION_INPUTSTREAM) {
+ inputStream = new TCMessageInputStream(this,
+ inMessageOptions.getInputStreamSize(),
+ cookie.getClientId());
+ try {
+ inputStream.open();
+ } catch (IOException e) {
+ // stream didn't open
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, e.getMessage(), e);
+ e.printStackTrace();
+ }
+ }
+ // create error monitor
+ if (status.isOK()) {
+ String monitorName = String.format("TCFMonitor%d", this.cookie.getClientId());
+ monitorThread = new TCFMonitorThread(this, monitorName);
+ stopTCFMonitorThread = false;
+ monitorThread.start();
+ }
+
+ // start capture
+ if (status.isOK()) {
+ long ret = nativeStart(this.cookie.getClientId());
+ if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
+ this.cookie.setMessageProcessing(true);
+ } else {
+ // error in starting capture
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ }
+ if (!status.isOK()) {
+ // an error occurred along the way - unravel what we've done
+ if (this.cookie.isMessageProcessing()) {
+ long ret = nativeStop(this.cookie.getClientId());
+ // ignore error
+ this.cookie.setMessageProcessing(false);
+ }
+ if (this.monitorThread != null) {
+ this.stopTCFMonitorThread = true;
+ try {
+ this.monitorThread.join();
+ } catch (InterruptedException e) {
+ }
+ this.monitorThread = null;
+ }
+ if (this.inputStream != null && this.inputStream.isOpen()) {
+ try {
+ this.inputStream.close();
+ } catch (IOException e) {
+ }
+ this.inputStream = null;
+ }
+ if (this.cookie.isConnected()) {
+ long ret = nativeDisconnect(this.getClientId());
+ this.cookie.setConnected(false);
+ this.cookie.setClientId(-1);
+ }
+ }
+ return status;
+ }
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#connect(com.nokia.tcf.api.ITCConnection, com.nokia.tcf.api.ITCMessageOptions, com.nokia.tcf.api.ITCMessageIds)
+ */
+ public IStatus connect(ITCConnection inConnection,
+ ITCMessageOptions inMessageOptions, ITCMessageIds inMessageIds) {
+
+ IStatus status = checkConnectOptions(inConnection, inMessageOptions, inMessageIds);
+ String[] settings = null;
+ int type = 0;
+
+ // do connect
+ if (status.isOK()) {
+ settings = null;
+ type = inConnection.getConnectionType();
+ switch(type) {
+ case ITCConnection.MEDIA_REALTCP: {
+ settings = new String[3];
+ ITCRealTCPConnection t = (ITCRealTCPConnection)inConnection;
+ settings[0] = t.getIpAddress();
+ settings[1] = t.getPort();
+ settings[2] = t.getDecodeFormat().toLowerCase();
+ break;
+ }
+ case ITCConnection.MEDIA_VIRTUALSERIAL: {
+ settings = new String[2];
+ ITCVirtualSerialConnection s = (ITCVirtualSerialConnection)inConnection;
+ settings[0] = s.getComPort();
+ settings[1] = s.getDecodeFormat().toLowerCase();
+ break;
+ }
+ case ITCConnection.MEDIA_REALSERIAL: {
+ settings = new String[7];
+ ITCRealSerialConnection s = (ITCRealSerialConnection)inConnection;
+ settings[0] = s.getComPort();
+ settings[1] = s.getBaudRate();
+ settings[2] = s.getDataBits();
+ settings[3] = s.getParity();
+ settings[4] = s.getStopBits();
+ settings[5] = s.getFlowControl();
+ settings[6] = s.getDecodeFormat().toLowerCase();
+ break;
+ }
+ case ITCConnection.MEDIA_USB: {
+ settings = new String[1];
+ break;
+ }
+ default:
+ // Add other connection types here - error already checked in checkConnection()
+ break;
+ }
+ }
+ return finishConnect(type, settings, inConnection, inMessageOptions, inMessageIds);
+ }
+ private void ensureWritableFile(String filePath) throws IOException {
+ // ensure file path points to a writable regular file
+ IPath path = new Path(filePath);
+ File file = path.toFile();
+ if (!file.exists()) {
+ file.createNewFile();
+ }
+ else { // file exists
+ if (file.isDirectory()) {
+ throw new IOException(MessageFormat.format("Path is a directory: {0}", filePath));
+ }
+ else if (!file.canWrite()) {
+ throw new IOException(MessageFormat.format("File exists and is not writable: {0}", filePath));
+ }
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#connect(com.nokia.tcf.api.ITCMessageOptions, com.nokia.tcf.api.ITCMessageIds)
+ */
+ public IStatus connect(ITCMessageOptions inMessageOptions, ITCMessageIds inMessageIds) {
+ // not currently implemented or tested
+ long ret = TCErrorConstants.TCAPI_ERR_FEATURE_NOT_IMPLEMENTED;
+ IStatus status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ return status;
+ }
+
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#disconnect()
+ */
+ public IStatus disconnect() {
+ IStatus status = statusOK;
+
+ IStatus connectStatus = checkConnected();
+ // ignore error
+ if (connectStatus.isOK()) {
+ if (this.cookie.isMessageProcessing()) {
+ long ret = nativeStop(this.cookie.getClientId());
+ this.cookie.setMessageProcessing(false);
+ if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
+ status = new Status(IStatus.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ }
+ if (this.monitorThread != null) {
+ this.stopTCFMonitorThread = true;
+ this.monitorThread.stop = true;
+ try {
+ this.monitorThread.join();
+ } catch (InterruptedException e) {
+ }
+ this.monitorThread = null;
+ }
+ if (this.inputStream != null && this.inputStream.isOpen()) {
+ try {
+ this.inputStream.close();
+ } catch (IOException e) {
+ }
+ this.inputStream = null;
+ }
+ if (this.cookie.isConnected()) {
+ long ret = nativeDisconnect(this.cookie.getClientId());
+ if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
+ this.cookie.setConnected(false);
+ this.cookie.setClientId(-1);
+ } else {
+ // error from nativeDisconnect
+ status = new Status(Status.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ }
+ }
+ return status;
+ }
+
+ // private methods
+ /**
+ * This is called from TCFMonitorThread to send errors to registered listeners
+ */
+ public void fireErrorListeners(long errorCode, String errorString) {
+ int s = this.errorListenerList.size();
+// System.out.printf("fireErrorListeners s = %d\n", s);
+ for (int i = 0; i < s; i++) {
+ ITCErrorListener e = (ITCErrorListener)this.errorListenerList.get(i);
+ if (e != null) {
+ int errorStatus = Status.ERROR;
+ if (errorCode == TCErrorConstants.TCAPI_INFO_COMM_RECONNECTED)
+ errorStatus = Status.INFO;
+ IStatus status = new Status(errorStatus, Activator.PLUGIN_ID, (int)errorCode, errorString, null);
+ e.errorOccurred(status);
+ }
+ }
+ }
+
+ public long getClientId() {
+ return this.cookie.getClientId();
+ }
+
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#getConnections()
+ */
+ public ITCConnection[] getConnections() {
+ IStatus status = statusOK;
+ ITCConnection[] connections = null;
+ long numberConnections = 0;
+ long[] number = new long[1];
+ long ret = nativeGetNumberConnections(number);
+ if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
+ numberConnections = number[0];
+ } else {
+ // error processing from nativeGetNumberConnections
+ status = new Status(Status.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ if (numberConnections > 0)
+ {
+ connections = new ITCConnection[(int)numberConnections];
+ for (int inIndex = 0; inIndex < numberConnections; inIndex++)
+ {
+ int[] type = new int[1];
+ ret = nativeGetTypeOfConnection(inIndex, type);
+ switch ((int)type[0]) {
+ case (int)ITCConnection.MEDIA_VIRTUALSERIAL: {
+ ITCVirtualSerialConnection outConnection = (ITCVirtualSerialConnection)TCFClassFactory.createITCVirtualSerialConnection(null);
+ int[] outType = new int[1];
+ long[] outOptions = new long[3];
+ String[] outSettings = new String[1];
+ ret = nativeGetConnectionSettings(inIndex, outType, outOptions, outSettings);
+ if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
+ outConnection.setConnectionType(outType[0]);
+ outConnection.setRetryInterval(outOptions[0]);
+ outConnection.setRetryTimeout(outOptions[1]);
+ outConnection.setDecodeFormat(convertDecodeFormat(outOptions[2]));
+ outConnection.setComPort(outSettings[0]);
+
+ connections[inIndex] = outConnection;
+ } else {
+ // error processing from nativeGetConnectionSettings
+ status = new Status(Status.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ break;
+ }
+ case (int)ITCConnection.MEDIA_REALTCP: {
+ ITCRealTCPConnection outConnection = (ITCRealTCPConnection)TCFClassFactory.createITCRealTCPConnection(null, null);
+ int[] outType = new int[1];
+ long[] outOptions = new long[3];
+ String[] outSettings = new String[2];
+ ret = nativeGetConnectionSettings(inIndex, outType, outOptions, outSettings);
+ if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
+ outConnection.setConnectionType(outType[0]);
+ outConnection.setRetryInterval(outOptions[0]);
+ outConnection.setRetryTimeout(outOptions[1]);
+ outConnection.setDecodeFormat(convertDecodeFormat(outOptions[2]));
+ outConnection.setIpAddress(outSettings[0]);
+ outConnection.setPort(outSettings[1]);
+
+ connections[inIndex] = outConnection;
+ } else {
+ // error processing from nativeGetConnectionSettings
+ status = new Status(Status.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ break;
+ }
+ case (int)ITCConnection.MEDIA_REALSERIAL: {
+ ITCRealSerialConnection outConnection = (ITCRealSerialConnection)TCFClassFactory.createITCRealSerialConnection(null);
+ int[] outType = new int[1];
+ long[] outOptions = new long[6];
+ String[] outSettings = new String[6];
+ ret = nativeGetConnectionSettings(inIndex, outType, outOptions, outSettings);
+ if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
+ outConnection.setConnectionType(outType[0]);
+ outConnection.setRetryInterval(outOptions[0]);
+ outConnection.setRetryTimeout(outOptions[1]);
+ outConnection.setDecodeFormat(convertDecodeFormat(outOptions[2]));
+ outConnection.setComPort(outSettings[0]);
+ outConnection.setBaudRate(outSettings[1]);
+ outConnection.setDataBits(outSettings[2]);
+ outConnection.setParity(outSettings[3]);
+ outConnection.setStopBits(outSettings[4]);
+ outConnection.setFlowControl(outSettings[5]);
+
+ connections[inIndex] = outConnection;
+ } else {
+ // error processing from nativeGetConnectionSettings
+ status = new Status(Status.ERROR,Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ break;
+ }
+ case (int)ITCConnection.MEDIA_USB: {
+ break;
+ }
+ default:
+ // Add other connection types here
+ break;
+ }
+ }
+ }
+ return connections;
+ }
+
+ protected String convertDecodeFormat(long decodeFormat) {
+ if (decodeFormat == 1) {
+ return "platsim";
+ }
+ if (decodeFormat == 2) {
+ return "ost";
+ }
+ if (decodeFormat == 3) {
+ return "rawtrk";
+ }
+ return "ost";
+ }
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#getInputStream()
+ */
+ public ITCMessageInputStream getInputStream() {
+ return this.inputStream;
+ }
+
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#getVersions()
+ */
+ public ITCVersion[] getVersions() {
+ IStatus status = statusOK;
+ ITCVersion[] versions = null;
+ status = checkConnected();
+ if (status.isOK()) {
+ // we're connected call native
+ long numberVersions = nativeGetNumberVersionEntities(this.cookie.getClientId());
+ if (numberVersions > 0) {
+ versions = new TCVersion[(int)numberVersions];
+ String[] versStrings = new String[(int)numberVersions];
+ long numberGotten = nativeGetVersion(this.cookie.getClientId(), numberVersions, versStrings);
+ for (int i = 0; i < numberGotten; i++) {
+ versions[i] = new TCVersion(versStrings[i]);
+ }
+ }
+ }
+ return versions;
+ }
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#removeErrorListener(com.nokia.tcf.api.ITCErrorListener)
+ */
+ public IStatus removeErrorListener(ITCErrorListener inErrorListener) {
+ IStatus status = statusOK;
+// System.out.printf("removeErrorListener\n");
+ this.errorListenerList.remove(inErrorListener);
+ return status;
+ }
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#sendMessage(com.nokia.tcf.api.ITCMessage)
+ */
+ public IStatus sendMessage(ITCMessage inMessage) {
+ IStatus status = statusOK;
+ status = checkConnected();
+ if (status.isOK()) {
+ // we are connected are we processing?
+ if (this.cookie.isMessageProcessing()) {
+ // we are running, check message
+ status = checkMessage(inMessage);
+ if (status.getSeverity() != Status.ERROR) {
+ // Status.OK or Status.WARNING (still attempt to send on warning)
+ // Encode if option is set
+
+ long[] formattingOptions = new long[5];
+ formattingOptions[0] = 0;
+ formattingOptions[1] = messageOptions.getMessageEncodeFormat();
+ formattingOptions[2] = messageOptions.getOSTVersion();
+ formattingOptions[3] = inMessage.getMyMessageId();
+ formattingOptions[4] = (inMessage.isUseMyMessageId() == true) ? 1 : 0;
+ String[] settings = new String[1];
+ settings[0] = connection.getDecodeFormat().toLowerCase();
+ try {
+ long ret = TCErrorConstants.TCAPI_ERR_NONE;
+ if (inMessage == null) { // OK if we're just sending a header
+ ret = nativeSendMessage(this.cookie.getClientId(), formattingOptions, settings, null);
+ } else {
+ ret = nativeSendMessage(this.cookie.getClientId(), formattingOptions, settings, inMessage.getMessage());
+ }
+ if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ } catch (Exception e) {
+ // exception is thrown ONLY when err = TCAPI_ERR_COMM_ERROR from native
+ // message is OS Error
+ String msg = e.getMessage();
+ long ret = TCErrorConstants.TCAPI_ERR_COMM_ERROR;
+ String tcErr = String.format("%s OSError: %s", TCErrorConstants.getErrorMessage(ret), msg);
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, tcErr, null);
+ }
+ }
+ } else {
+ // we are stopped
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_ROUTING_STOPPED,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_ROUTING_STOPPED), null);
+ }
+ }
+ return status;
+ }
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#setTCMessageIds(com.nokia.tcf.api.ITCMessageIds)
+ */
+ public IStatus setTCMessageIds(ITCMessageIds inMessageIds) {
+ IStatus status = statusOK;
+ status = checkMessageIds(inMessageIds);
+ if (status.isOK()) {
+ // input is OK
+ status = checkConnected();
+ if (status.isOK()) {
+ // connected
+ if (this.cookie.isMessageProcessing()) {
+ // must be stopped to set new IDs
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)TCErrorConstants.TCAPI_ERR_ROUTING_IN_PROGRESS,
+ TCErrorConstants.getErrorMessage(TCErrorConstants.TCAPI_ERR_ROUTING_IN_PROGRESS), null);
+ }
+ }
+ }
+ if (status.isOK()) {
+ // everything OK, so we can save our IDs and register them
+ this.messageIds = inMessageIds;
+ int size = (int)inMessageIds.size();
+ byte[] messageids = new byte[size];
+ for (int i = 0; i < size; i++) {
+ messageids[0] = inMessageIds.getMessageIds().get(i);
+ }
+ long ret = nativeSetMessageIds(this.cookie.getClientId(), messageids);
+ if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret,
+ TCErrorConstants.getErrorMessage(ret), null);
+ }
+ }
+ return status;
+ }
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#start()
+ */
+ public IStatus start() {
+ IStatus status = statusOK;
+ // check connected
+ status = checkConnected();
+ if (status.isOK()) {
+ if (this.cookie.isMessageProcessing() == false) {
+ // call native
+ long ret = nativeStart(this.cookie.getClientId());
+ if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
+ this.cookie.setMessageProcessing(true);
+ } else {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ }
+ }
+
+ return status;
+ }
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#stop()
+ */
+ public IStatus stop() {
+ IStatus status = statusOK;
+ status = checkConnected();
+ if (status.isOK()) {
+ if (this.cookie.isMessageProcessing()) {
+ long ret = nativeStop(this.cookie.getClientId());
+ if (ret == TCErrorConstants.TCAPI_ERR_NONE) {
+ this.cookie.setMessageProcessing(false);
+ } else {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ }
+ }
+ return status;
+ }
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#testConnection()
+ */
+ public IStatus testConnection() {
+ IStatus status = statusOK;
+ status = checkConnected();
+ if (status.isOK()) {
+ long ret = nativeTestConnection(this.cookie.getClientId());
+ if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)(ret), TCErrorConstants.getErrorMessage((int)ret), null);
+ }
+ }
+ return status;
+ }
+ protected IStatus doTestConnection(int type, String[] settings, ITCConnection inConnection) {
+ IStatus status = statusOK;
+ // test connection
+ long[] options = new long[3];
+ options[0] = inConnection.getRetryInterval(); // connection options
+ options[1] = inConnection.getRetryTimeout();
+ options[2] = 0;
+ long ret = nativeTestConnection(type, options, settings);
+ if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ return status;
+ }
+ /* (non-Javadoc)
+ * @see com.nokia.tcf.api.ITCAPIConnection#testConnection(com.nokia.tcf.api.ITCConnection)
+ */
+ public IStatus testConnection(ITCConnection inConnection) {
+ IStatus status = statusOK;
+ String[] settings = null;
+ int type = inConnection.getConnectionType();
+ switch(type) {
+ case ITCConnection.MEDIA_REALSERIAL:
+ {
+ settings = new String[7];
+ ITCRealSerialConnection s = (ITCRealSerialConnection)inConnection;
+ settings[0] = s.getComPort();
+ settings[1] = s.getBaudRate();
+ settings[2] = s.getDataBits();
+ settings[3] = s.getParity();
+ settings[4] = s.getStopBits();
+ settings[5] = s.getFlowControl();
+ settings[6] = s.getDecodeFormat().toLowerCase();
+ }
+ break;
+ case ITCConnection.MEDIA_REALTCP:
+ {
+ settings = new String[3];
+ ITCRealTCPConnection s = (ITCRealTCPConnection)inConnection;
+ settings[0] = s.getIpAddress();
+ settings[1] = s.getPort();
+ settings[2] = s.getDecodeFormat().toLowerCase();
+ }
+ break;
+ case ITCConnection.MEDIA_USB:
+ {
+ settings = new String[1];
+ }
+ break;
+ case ITCConnection.MEDIA_VIRTUALSERIAL:
+ {
+ settings = new String[2];
+ ITCVirtualSerialConnection s = (ITCVirtualSerialConnection)inConnection;
+ settings[0] = s.getComPort();
+ settings[1] = s.getDecodeFormat().toLowerCase();
+ }
+ break;
+ default:
+ long err = TCErrorConstants.TCAPI_ERR_MEDIA_NOT_SUPPORTED;
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)err, TCErrorConstants.getErrorMessage((int)err), null);
+ break;
+ }
+
+ if (status.isOK()) {
+ status = doTestConnection(type, settings, inConnection);
+/* // test connection
+ long[] options = new long[3];
+ options[0] = inConnection.getRetryInterval(); // connection options
+ options[1] = inConnection.getRetryTimeout();
+ options[2] = inConnection.getDecodeFormat();
+ long ret = nativeTestConnection(type, options, settings);
+ if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
+ status = new Status(Status.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ } */
+ }
+ return status;
+ }
+ public IStatus clearMessageFile() {
+ IStatus status = statusOK;
+ IStatus connStatus = checkConnected();
+ if (connStatus.isOK()) {
+ if (messageOptions.getMessageDestination() == ITCMessageOptions.DESTINATION_CLIENTFILE) {
+ if (messageOptions.getMessageFile() != null) {
+ long ret = nativeClearFile(cookie.getClientId());
+ if (ret != TCErrorConstants.TCAPI_ERR_NONE) {
+ status = new Status(IStatus.ERROR, Activator.PLUGIN_ID, (int)ret, TCErrorConstants.getErrorMessage(ret), null);
+ }
+ }
+ }
+ }
+ return status;
+ }
+
+ // natives
+ // connect/disconnect
+ private native long nativeConnect(int inType, long[] inOptions, String[] inSettings, long[] inMessageOptions, String inFilePath, long[] outClientId);
+ private native long nativeDisconnect(long inClientId);
+ // connections
+ protected native long nativeGetNumberConnections(long[] outNumber);
+ protected native long nativeGetTypeOfConnection(long inIndex, int[] outType);
+ protected native long nativeGetConnectionSettings(long inIndex, int[] outType, long[] outOptions, String[] outSettings);
+ // port handling errors
+ public native boolean nativePollError(long inClienId, int[] outErrorCode, boolean[] outHasOSErrorCode, long[] outOSErrorCode);
+ // versions
+ private native long nativeGetNumberVersionEntities(long inClientId);
+ private native long nativeGetVersion(long inClientId, long inNumToGet, String[] outVersion);
+ // input stream
+ public native long nativePollInputStream(long inClientId, long[] outNumberTotalMessages);
+ public native long nativePollInputStream2(long inClientId, long inNumberMessagesToPeek, long[] outNumberMessagesPeeked, long[] outNumberBytesPeeked);
+ public native long nativeGetInputStreamMessageBytes(long inClientId, long inNumberMessagesToPeek, long[] outNumberBytesPerMessage);
+ public native long nativeReadInputStream(long inClientId, long inNumberMessagesToRead, long[] outNumberMessagesRead, long[] outNumberBytesRead, long inNumberMaxBytes, byte[] outMessages);
+ public native long nativeOpenInputStream(long inClientId, String inBaseFilePath, long inInputStreamSize, boolean inOverFlowToFile);
+ public native long nativeCloseInputStream(long inClientId);
+ // message file
+ private native long nativeClearFile(long inClientId);
+ // send message
+ private native long nativeSendMessage(long inClientId, long[] inFormattingOptions, String[] inSettings, byte[] inMessage);
+ // register message IDs
+ private native long nativeSetMessageIds(long inClientId, byte[] inMessageIds);
+ // start/stop processing
+ private native long nativeStart(long inClientId);
+ private native long nativeStop(long inClientId);
+ // test connections
+ private native long nativeTestConnection(int inType, long[] inOptions, String[] inSettings);
+ private native long nativeTestConnection(long inClientId);
+ // start/stop server - done from plugin activator start/stop methods
+ public native long nativeStartServer();
+ public native long nativeStopServer();
+}