BowlerAbstractDevice.java

Go to the documentation of this file.

/*******************************************************************************
 * Copyright 2010 Neuron Robotics, LLC
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/
package com.neuronrobotics.sdk.common;
 
import java.util.ArrayList;
 
import com.neuronrobotics.sdk.commands.bcs.core.PingCommand;
import com.neuronrobotics.sdk.commands.neuronrobotics.dyio.InfoFirmwareRevisionCommand;
 
// TODO: Auto-generated Javadoc
public abstract class BowlerAbstractDevice implements IBowlerDatagramListener {
    
    private boolean keepAlive = true;
    
    private boolean disconnecting = false;
    
    private long lastPacketTime=0;
    
    private BowlerAbstractConnection connection=null;
    private MACAddress address = new MACAddress(MACAddress.BROADCAST);
    
    private ArrayList<IDeviceConnectionEventListener> disconnectListeners = new ArrayList<IDeviceConnectionEventListener> ();
    
    private String scriptingName = "device";
    
    
    public boolean isAvailable() throws InvalidConnectionException{
        return getConnection().isConnected()&&disconnecting==false;
    }
 
    
    protected void fireDisconnectEvent() {
        ArrayList<IDeviceConnectionEventListener> disconnectListeners2 = getDisconnectListeners();
        for (int i = 0; i < disconnectListeners2.size(); i++) {
            IDeviceConnectionEventListener l = disconnectListeners2.get(i);
            l.onDisconnect(this);
        }
    }
    
    protected void fireConnectEvent() {
        ArrayList<IDeviceConnectionEventListener> disconnectListeners2 = getDisconnectListeners();
        for (int i = 0; i < disconnectListeners2.size(); i++) {
            IDeviceConnectionEventListener l = disconnectListeners2.get(i);
            l.onConnect(this);
        }
    }
    
    public void addConnectionEventListener(final IDeviceConnectionEventListener l ) {
        if(!getDisconnectListeners().contains(l)) {
            getDisconnectListeners().add(l);
        }
//      System.err.println(getScriptingName()+" Adding listener "+l.getClass());
//      l.trace.printStackTrace();
//      new Exception().printStackTrace();
        BowlerAbstractDevice bad = this;
        if(connection !=null)
        connection.addConnectionEventListener(new IConnectionEventListener() {
            
            @Override
            public void onDisconnect(BowlerAbstractConnection source) {
                
                l.onDisconnect(bad);
            }
            
            @Override
            public void onConnect(BowlerAbstractConnection source) {
                // TODO Auto-generated method stub
                l.onConnect(bad);
            }
        });
    }
    
    public void removeConnectionEventListener(IDeviceConnectionEventListener l ) {
        if(getDisconnectListeners().contains(l)) {
            getDisconnectListeners().remove(l);
        }
 
    }
    
 
    
    public void setConnection(BowlerAbstractConnection connection) {
        setThreadedUpstreamPackets(false);
        if(connection == null) {
            throw new NullPointerException("Can not use a NULL connection.");
        }
        BowlerAbstractDevice bad = this;
        for(int i=0;i<getDisconnectListeners().size();i++) {
            final int index = i;
            connection.addConnectionEventListener(new IConnectionEventListener() {
                
                @Override
                public void onDisconnect(BowlerAbstractConnection source) {
                    getDisconnectListeners().get(index).onDisconnect(bad);
                }
                
                @Override
                public void onConnect(BowlerAbstractConnection source) {
                    // TODO Auto-generated method stub
                    getDisconnectListeners().get(index).onConnect(bad);
                }
            });
        }
        this.connection = connection;
        connection.addDatagramListener(this);
    }
    
    public boolean connect() throws InvalidConnectionException {
        
        if (connection == null) {
            throw new InvalidConnectionException("Null Connection");
        }
        if(!connection.isConnected()) {
            if(!connection.connect()) {
                return false;
            }else {
                //startHeartBeat();
            }
        }
        
        return this.isAvailable();
    }
    
    public void disconnect() {
        disconnecting=true;
        if (connection != null) {
            if(connection.isConnected()){
                Log.info("Disconnecting Bowler Device");
                connection.disconnect();
            }
        }
    }
    
    public BowlerAbstractConnection getConnection() {
        return connection;
    }
    
    public void setAddress(MACAddress address) {
        if(!address.isValid()) {
            throw new InvalidMACAddressException();
        }
        this.address = address;
    }
    
    public MACAddress getAddress() {
        //System.out.println();
        return address;
    }
    
//  /**
//   * Send a sendable to the connection.
//   *
//   * @param sendable the sendable
//   * @return the syncronous response
//   */
//  public BowlerDatagram send(ISendable sendable) {
//      setLastPacketTime(System.currentTimeMillis());
//      return connection.send(sendable, getAddress());
//  }
    
 
    public BowlerDatagram send(BowlerAbstractCommand command) throws NoConnectionAvailableException, InvalidResponseException { 
        return send(command,1);
    }
    
    public BowlerDatagram send(BowlerAbstractCommand command, int retry) throws NoConnectionAvailableException, InvalidResponseException {
        
        return connection.send(command,getAddress(), retry);
    }
    
    public Object [] send(String namespace,BowlerMethod method, String rpcString, Object[] arguments, int retry) throws DeviceConnectionException{
        return connection.send(getAddress(),namespace, method, rpcString, arguments, retry);
    }
    
    public Object [] send(String namespace,BowlerMethod method, String rpcString, Object[] arguments) throws DeviceConnectionException{
        return send(namespace, method, rpcString, arguments, 5);
    }
        
    public boolean ping() {
        return ping(false);
    }
    
    public boolean ping(boolean switchParser) {
        return connection.ping(getAddress(),switchParser);
    }
    public ArrayList<ByteList> getRevisions(){
        ArrayList<ByteList> list = new ArrayList<ByteList>();
        try {
            BowlerDatagram b = send(new InfoFirmwareRevisionCommand(),5);
            Log.debug("FW info:\n"+b);
            for(int i=0;i<(b.getData().size()/3);i++){
                list.add(new ByteList(b.getData().getBytes((i*3),3)));
            }
        } catch (InvalidResponseException e) {
            Log.error("Invalid response from Firmware rev request");
            
        } catch (NoConnectionAvailableException e) {
            Log.error("No connection is available.");
        }
        return list;
    }
    
    public ArrayList<String>  getNamespaces(){
        return connection.getNamespaces(getAddress());  
    }
    
    public boolean hasNamespace(String string) {
        return connection.hasNamespace(string,getAddress());
    }
    
    public void startHeartBeat(){
        getConnection().startHeartBeat();
    }
    
    public void startHeartBeat(long msHeartBeatTime){
        getConnection().startHeartBeat(msHeartBeatTime);
    }
    
    public void stopHeartBeat(){
        getConnection().stopHeartBeat();
    }
 
    
    public void setThreadedUpstreamPackets(boolean up){
        if(connection != null){
            connection.setThreadedUpstreamPackets(up);
        }
    }
    
    public ArrayList<RpcEncapsulation> getRpcList(String namespace) {
        return connection.getRpcList(namespace,getAddress());
    }
    
    public void loadRpcList() {
         ArrayList<String> names = getNamespaces();
         
         for (String s:names){
             System.out.println(getRpcList(s));
         }
         
    }
    @Deprecated
    public void onAllResponse(BowlerDatagram data){
        // this is here to prevent the breaking of an interface, 
    }
    
    public boolean isKeepAlive() {
        return keepAlive;
    }
    
    public void setKeepAlive(boolean keepAlive) {
        this.keepAlive = keepAlive;
    }
 
 
    public long getLastPacketTime() {
        return lastPacketTime;
    }
 
 
    public void setLastPacketTime(long lastPacketTime) {
        this.lastPacketTime = lastPacketTime;
    }
 
 
    public String getScriptingName() {
        return scriptingName;
    }
 
 
    public void setScriptingName(String scriptingName) {
        this.scriptingName = scriptingName;
    }
 
 
    public ArrayList<IDeviceConnectionEventListener> getDisconnectListeners() {
        return disconnectListeners;
    }
 
    
}