ServerService

package com.services;

import ...
public class ServerService extends Service {

	private MessageHandler messageHandlerIn = new MessageHandler();
	private Messenger messageHandler;
	private String deviceType;
	private ArrayList<Client> clients = new ArrayList<Client>();
	private InetAddress broadcastInetAdress;
	private DatagramSocket socketIn, socketOut;
	private byte[] bufIn = new byte[2000];
	private byte[] bufOut = new byte[2000];
	private DatagramPacket packetIn = new DatagramPacket(bufIn, bufIn.length);
	private DatagramPacket packetOut = new DatagramPacket(bufOut, bufOut.length);
	private SharedPreferences sp;
	private Editor spEditor;
	private final IBinder binder = new CustomBinder();

	public void onCreate() {
		super.onCreate();

		WifiManager wifi = (WifiManager)getSystemService(Context.WIFI_SERVICE);
        if (wifi != null){
            WifiManager.WifiLock lock = wifi.createWifiLock("mylock");
            lock.acquire();
        }

		// Shared prefs init
		sp			 = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
		spEditor 	 = sp.edit();

		db = new DBHandler(getApplicationContext());

		// Socket + broadcast adress init
		try {
			broadcastInetAdress	  = InetAddress.getByName("255.255.255.255");
			socketOut 				  = new DatagramSocket(StaticValues.PORT_TOCLIENT);
			socketIn 				  = new DatagramSocket(StaticValues.PORT_TOSERVER);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}


	@Override
	public int onStartCommand(Intent intent,  int flags, int startId) {
		// Get data from previous activity
			Bundle extras 	 = intent.getExtras();

			String messageType = (String) extras.get("messageType");
			deviceType 		   = (String) extras.get("devicetype");

			if (messageType.equals(StaticValues.MESSAGE_START_SERVICE)) {
				messageHandler	 	 = (Messenger) extras.get("MESSENGER");

				sendMessageToActivity(StaticValues.MESSAGE_ADD_MESSENGER, StaticValues.NOSTRING); // Send messenger to activity
				sendMessageToActivity(StaticValues.MESSAGE_SERVICE_LOADED, StaticValues.NOSTRING); // Service loaded

				getUdpMessages();
				shouldThisServiceRun();

			} else if (messageType.equals(StaticValues.MESSAGE_PASS_TO_SERVICE)) {
				String message	 	 = (String) extras.get("message");
				String sendTo		 = (String) extras.get("sendTo");
				sendMessageToClients(sendTo, null, message);
			}


		return Service.START_NOT_STICKY;
	}



	/*
	 * Send messages to ui
	 */
	public void sendMessageToActivity(String messageType, String messageString) {

		try {
			Message message = Message.obtain();
			if (messageType.equals(StaticValues.MESSAGE_ADD_MESSENGER)) {
				message.obj = new Messenger(messageHandlerIn);
			} else {
				message.obj = messageType + StaticValues.MESSAGE_DELIMITER + messageString;
			}
			messageHandler.send(message);

		} catch (RemoteException e) {
			e.printStackTrace();
		}
	}


	/*
	 * Get messages from activity
	 */
	public void getMessagesFromUI(String message) {
		System.out.println(message);
	}


	/*
	 * Get UDP messages from clients
	 */

	private InetAddress clientIP;
	private String message, clientDevice;
	private String[] splittedMessages;
	private DBHandler db;

	public void getUdpMessages() {
		new Thread(new Runnable() {
		    public void run() {

			    	try {
				    	while(sp.getBoolean(StaticValues.SERVER_RUNNING, false)) {
							// Message from client received

								socketIn.receive(packetIn);
								message			 = new String(packetIn.getData(), packetIn.getOffset(), packetIn.getLength());

							// Split message
								splittedMessages = message.split(StaticValues.MESSAGE_DELIMITER);

							// Connection request - add client to arraylist
								if (splittedMessages[0].equals(StaticValues.MESSAGE_UDP_REQUEST)) {
									clientIP	 = packetIn.getAddress();
									clientDevice = splittedMessages[1];

									Client client = new Client(clientIP, clientDevice);
									clients.add(client);
									sendMessageToClients(StaticValues.SENDTO_IP, client.ipAdress, StaticValues.MESSAGE_UDP_CONFIRMED); // confirmation on the request

									// send all categories to client
										String messageOut;
										int isVisible = 1;
										for (Category category : db.getAllCategories()) {
											if (category.visible) {
												isVisible = 1;
											} else {
												isVisible = 0;
											}

											messageOut = StaticValues.MESSAGE_ADD_CATEGORY + StaticValues.MESSAGE_DELIMITER + category.id + StaticValues.MESSAGE_DELIMITER + category.title + StaticValues.MESSAGE_DELIMITER + isVisible;
											sendMessageToClients(StaticValues.SENDTO_IP, client.ipAdress, messageOut); // confirmation on the request
										}

										sendMessageToClients(StaticValues.SENDTO_IP, client.ipAdress, StaticValues.MESSAGE_ADD_CATEGORY_TO_GUI); // confirmation on the request


							// Number taken by client
								} else if (splittedMessages[0].equals(StaticValues.MESSAGE_NUMBER_TAKEN)) {
									System.out.println("SOMEONE TOOK A NUMBER");
									sendMessageToActivity(StaticValues.MESSAGE_SHOW_TOAST, "Someone took a number man!");
								}
						}

					} catch (SocketException e) {
						e.printStackTrace();
					} catch (IOException e) {
						e.printStackTrace();
					}

		    }
		  }).start();
	}



	/*
	 * Outgoing messages to clients
	 * sendTo = send the message to who? (ip/all/specific devices)
	 */
	public void sendMessageToClients(String sendTo, InetAddress ipAdress, String message) {
		try {
			// Send to all clients
				if (sendTo.equals(StaticValues.SENDTO_ALL)) {

			// Send to specific IP adress
				} else if (sendTo.equals(StaticValues.SENDTO_IP)) {
					bufOut	  = message.getBytes();
					packetOut = new DatagramPacket(bufOut, bufOut.length, ipAdress, StaticValues.PORT_TOCLIENT);
					socketOut.send(packetOut);

			// Send to all "take number" devices
				} else if (sendTo.equals(StaticValues.SENDTO_DEVICES_TAKENUMBER)) {

				}

		} catch (IOException e) {
			e.printStackTrace();
		}
	}





	/*
	 * Checks if the Service still should be running
	 */

	public void shouldThisServiceRun() {
		new Thread(new Runnable() {
		    public void run() {

				while(sp.getBoolean(StaticValues.SERVER_RUNNING, false)) {
					try {
						// Send message to UI
						Thread.sleep(200);
					} catch (InterruptedException e) {
						e.printStackTrace();
						}
				}
				// Closing the service
				stopThisService();

		    }
		  }).start();
	}



	public void stopThisService() {
		spEditor.putBoolean(StaticValues.SERVER_RUNNING, false);
		spEditor.putBoolean(StaticValues.CLIENT_RUNNING, false);
		spEditor.commit();
		socketIn.close();
		socketOut.close();
		stopSelf();
	}

	/*
	 * Overrides
	 */

	public void onDestroy() {
		super.onDestroy();
		// stopThisService();
	}

	// create an inner Binder class
	public class CustomBinder extends Binder {
	    public ServerService getService() {
	    	System.out.println("CustomBinder");
	        return ServerService.this;
	    }
	}

	@Override
	public IBinder onBind(Intent arg0) {
		System.out.println("onBind");
		return binder;
	}

}