hostage/src/de/tudarmstadt/informatik/hostage/sync/wifi_direct/WiFiP2pClientTask.java

package de.tudarmstadt.informatik.hostage.sync.wifi_direct;

import android.util.Log;

import com.example.android.wifidirect.WiFiDirectActivity;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;

/**
 * Created by Julien on 07.01.2015.
 */
public class WiFiP2pClientTask extends BackgroundTask {

    public interface WiFiP2pCompletionListener {
        public void didSucceed();
        public void didFail();
    }

    private String hostIP;
    private Socket socket;
    private WiFiP2pCompletionListener completionListener;

    public String getHostIP() {
        return hostIP;
    }

    public void setHostIP(String hostIP) {
        this.hostIP = hostIP;
    }


    public int port(){
        return 8988;
    }
    public int time_out(){
        return 1000;
    }


    public WiFiP2pClientTask(String hostIP, WiFiP2pCompletionListener l){
        super();
        this.hostIP = hostIP;
        this.completionListener = l;
    }


    @Override
    public void interrupt(boolean b){
        super.interrupt(b);
        if (b && this.socket != null) {
            try {
                this.socket.close();
            } catch (IOException e) {
                Log.e("WiFiP2pClientTask", e.getMessage());
            }
        }
    }

    @Override
    public void performInBackground(){
        int tryNum = 0;
        while (!this.isInterrupted()){
            this.socket = new Socket();

            try {
                Log.d(WiFiDirectActivity.TAG, "Opening client socket - ");
                socket.bind(null);
                socket.connect((new InetSocketAddress(hostIP, this.port())), this.time_out());

                Log.d(WiFiDirectActivity.TAG, "Client socket - " + socket.isConnected());
                this.handleConnection(socket);

                Log.d("WiFiP2pClientTask", "Client: Data written");
            } catch (ClassNotFoundException e){
                Log.e("WiFiP2pClientTask", e.getMessage());
                this.completionListener.didFail();
                return;
            } catch (IOException e) {
                Log.e("WiFiP2pClientTask", e.getMessage());

                if(tryNum >= 5) {
                    this.interrupt(true);
                    break;
                }

                long seconds_to_wait = (long) Math.min(60, Math.pow(2, tryNum));
                Log.i("client", "could not connect to server. Will try again in " + seconds_to_wait + "s");

                try {
                    Thread.sleep(seconds_to_wait * 1000);
                } catch (InterruptedException ie){
                }
            } finally {
                if (socket != null) {
                    if (socket.isConnected()) {
                        try {
                            socket.close();
                        } catch (IOException e) {
                            // Give up
                            e.printStackTrace();
                            this.completionListener.didFail();
                            return;
                        }
                    }
                }
            }
        }
        this.completionListener.didSucceed();
    }



    private void handleConnection(Socket client) throws IOException, ClassNotFoundException {
        InputStream is = client.getInputStream();
        ObjectInputStream ois = new ObjectInputStream(is);
        OutputStream os = client.getOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(os);

        Object obj = null;

        do {
            WiFiP2pSerializableObject receivedObj = (  WiFiP2pSerializableObject) obj;
            obj = null;
            WiFiP2pSerializableObject toSend = this.handleReceivedObject(receivedObj);
            if (toSend != null) {
                oos.writeObject(toSend);
                oos.flush();
                oos.reset();
                obj = ois.readObject();
            }
        } while (obj != null && obj instanceof WiFiP2pSerializableObject);

        oos.close();
        os.close();
        ois.close();
        is.close();

        this.interrupt(true);
    }

    public WiFiP2pSerializableObject handleReceivedObject(WiFiP2pSerializableObject receivedObj){

        return null;
    }

}