ServerService

package com.services;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.ArrayList;
import com.classes.*;
import com.database.DBHandler;
import com.takenumber.TakeNumber.MessageHandler;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.net.wifi.WifiManager;
import android.os.AsyncTask;
import android.os.Binder;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.preference.PreferenceManager;
import android.widget.Toast;

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 Messenger activityMessenger = new Messenger(new IncomingHandler());

    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;
    }



    /*
     * Get messages from UI
     */

    static class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message incomingMessage) {
            String stringMessage = (String)incomingMessage.obj;

            if (stringMessage.equals(StaticValues.MESSAGE_NUMBER_TAKEN))

            System.out.println("Message from UI: " + stringMessage);
        }
    }


    /*
     * 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 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();
    }

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

}