source: proiecte/ptvs/src/vnsim/applications/vitp/CarRunningVITP.java @ 31

/************************************************************************************
 * Copyright (C) 2008 by Politehnica University of Bucharest and Rutgers University
 * All rights reserved.
 * Refer to LICENSE for terms and conditions of use.
 ***********************************************************************************/
package vnsim.applications.vitp;


import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.util.TreeMap;
import java.util.Vector;

import vnsim.applications.trafficview.SimulatedCarInfo;
import vnsim.applications.vitp.peer.Peer;
import vnsim.applications.vitp.routing.RoutingModule;
import vnsim.applications.vitp.routing.RoutingPacket;
import vnsim.applications.vitp.services.MessageProcessServices;
import vnsim.applications.vitp.ui.UserInterface;
import vnsim.applications.vitp.utils.MessageIndexModule;
import vnsim.core.Communicator;
import vnsim.map.object.Globals;
import vnsim.vehicular.routePlan.infrastructureRouted.InfrastructureReply;
import vnsim.vehicular.simulator.Location;
import vnsim.vehicular.simulator.RouteSegment;





public class CarRunningVITP extends SimulatedCarInfo {

        public Peer p;

        public RoutingModule r;

        private MessageIndexModule mim;

        private UserInterface ui;

        private MessageProcessServices mps;

        public TreeMap<Integer, byte[]> messagesToSend = new TreeMap<Integer, byte[]>();

        public TreeMap<Integer, RouteSegment> periodicalBroadcasts = new TreeMap<Integer, RouteSegment>();

        public boolean isInformed = false;

        public Vector<Integer> sentTypes = new Vector<Integer>();

        public CarRunningVITP(int vehicleId, byte lane, double speed,
                        short roadIdx, short pointIdx, byte direction, double offset) 
        {
                super(vehicleId, lane, speed, roadIdx, pointIdx, direction, offset);
                p = new Peer();
                r = new RoutingModule();
                mim = new MessageIndexModule();
                ui = new UserInterface();
                mps = new MessageProcessServices(this);

                r.attachModules(this, mim, p);
                p.attachModules(r, mps, ui);
                ui.attachModules(p);

        }

        public void broadcastRoadPacket(String toSend) 
        {
                // System.out.println("car Vitp sending"+toSend);
                int t = scheduleSingleSendEvent(Globals.MESSAGE_PROCESSING_TIME, null);

                try {
                        this.messagesToSend.put(t, toSend.getBytes());
                        this.sentTypes.add(new Integer(t));
                } catch (Exception ex) {
                        System.out.println("EXCEPTION CarRunningVITP Broadcast packet:"
                                        + ex.toString());
                        ex.printStackTrace();
                }

        }

        public void onReceive(byte[] bytesReceived, Serializable m, Communicator sender) {
                if (!isEquipped || bytesReceived == null)
                        return;
                // is it a VITP packet?
                byte header = bytesReceived[0];
                byte[] message = null;
                switch (header) {
//              case Globals.PROT_NEIGHBOR_DISCOVERY:
//                      // ByteBuffer bb = ByteBuffer.wrap(bytesReceived, 1,
//                      // bytesReceived.length-1);
//                      SimulatedCarInfo sc = new SimulatedCarInfo();
//                      byte[] message = new byte[bytesReceived.length - 1];
//                      for (int i = 0; i < message.length; i++) {
//                              message[i] = bytesReceived[i + 1];
//                      }
//                      sc.wrap(message);
//                      boolean added = false;
//                      for (int i = 0; i < neighbors.size(); i++)
//                              if ((neighbors.get(i)).getVehicleId() == sc.getVehicleId()) {
//                                      synchronized (neighbors) {
//                                              neighbors.set(i, sc);
//                                              // System.out.println("Insert "+dc.getVehicleId() +" at
//                                              // "+i);
//                                              added = true;
//                                      }
//                                      break;
//                              }
//                      if (!added)
//                              synchronized (neighbors) {
//                                      neighbors.add(sc);
//                                      // System.out.println("Insert "+dc.getVehicleId() +" at
//                                      // "+(Globals.neighbors.size()-1));
//                              }
//                      break;
                case Globals.VITP_PROT:
                        // System.out.println("I AM :"+vehicleId+"; RECEIVED VITP!");
                        message = new byte[bytesReceived.length - 1];
                        for (int i = 0; i < message.length; i++) {
                                message[i] = bytesReceived[i + 1];
                        }
                        try {
                                ObjectInputStream ois = new ObjectInputStream(
                                                new ByteArrayInputStream(message));
                                RoutingPacket rp = (RoutingPacket) ois.readObject();

                                r.postMessageFromBelow(rp);

                        } catch (Exception ex) {
                                System.out.println("EXCEPTION CarRunningVITP:" + ex.toString());
                                ex.printStackTrace();
                                return;
                        }
                        break;
                case Globals.ROAD_PLANNING_PROT:
                        message = new byte[bytesReceived.length - 1];
                        for (int i = 0; i < message.length; i++) {
                                message[i] = bytesReceived[i + 1];
                        }
                        (new InfrastructureReply(new String(message),this.getRealPos())).analizeMessage();
                        
                //      System.out.println("Received a packet back");
                        break;
                default:
                        super.onReceive(bytesReceived, m, sender);
                        break;
                }
        }

        public byte[] prepareMessage(int messageType) {

                if (!isEquipped)
                        return null;
                ByteBuffer bb = ByteBuffer.allocate(28);
                if (messageType == STANDARD_MESSAGE_ID){
                        return super.prepareMessage(messageType);
                        
//                      bb.put((byte) Globals.PROT_NEIGHBOR_DISCOVERY);
//                      bb.put(toBytes());
//                      return bb.array();
                }else{ // VITP
                        byte[] b = messagesToSend.get(messageType);
                        if (b == null) {
                                // System.out.println("NULL
                                // TIME="+Globals.engine.crtTime+"ID="+getVehicleId());
                                return null;
                        }
                        bb = ByteBuffer.allocate(b.length + 1);
                        if (this.sentTypes.contains(new Integer(messageType))) {
                                if (b.length>1 && b[0]=='R' && b[1]=='M') {
                                        bb.put(Globals.ROAD_METRICS_PROT);
                                } else {
                                        bb.put(Globals.ROAD_PLANNING_PROT);
                                }
                                this.sentTypes.remove(new Integer(messageType));
                                messagesToSend.remove(messageType);
                                bb.put(b);
                                //System.out.println("Sending a query to/from infrastruct! ");
                                //if (this instanceof InfrastructureNode) {
                                //      System.out.println("Sunt semafor!");
                                //}
                                return bb.array();
                        } else {
                                bb.put(Globals.VITP_PROT);
                                bb.put(b);
                        }

                        // remove it if it's not a periodical broadcast,
                        // or it is a periodical broadcast, but the node is not
                        // within the destination region anymore
                        if (!periodicalBroadcasts.containsKey(messageType)) {
                                messagesToSend.remove(messageType);
                        }
                        if (periodicalBroadcasts.containsKey(messageType)) {
                                RouteSegment r = periodicalBroadcasts.get(messageType);
                                Location myLoc = new Location(getRoadIdx(), getPointIdx());
                                if (!r.contains(myLoc)) {
                                        messagesToSend.remove(messageType);
                                        return null;
                                        // System.out.println("ID="+getVehicleId()+"; DISCARDING
                                        // BROADCAST!");
                                } else {
                                        Statistics.addBroadcast(10);
                                }
                        }
                        return bb.array();
                }
        }
}