hostage/src/de/tudarmstadt/informatik/hostage/sync/wifi_direct/ui/WiFiP2pSyncActivity.java

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

import android.app.Activity;
import android.content.Context;
import android.net.wifi.p2p.WifiP2pDevice;
import android.net.wifi.p2p.WifiP2pInfo;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.ViewAnimator;

import java.util.ArrayList;
import java.util.List;

import de.tudarmstadt.informatik.hostage.R;
import de.tudarmstadt.informatik.hostage.sync.wifi_direct.BackgroundTask;
import de.tudarmstadt.informatik.hostage.sync.wifi_direct.WiFiP2pEventHandler;
import de.tudarmstadt.informatik.hostage.sync.wifi_direct.sync_tasks.SyncClientTask;
import de.tudarmstadt.informatik.hostage.sync.wifi_direct.sync_tasks.SyncHostTask;

/**
 * Created by Julien on 14.01.2015.
 */
public class WiFiP2pSyncActivity extends Activity implements AdapterView.OnItemClickListener {

    private SyncClientTask clientTask;
    private SyncHostTask  hostTask;
    private boolean isHost;

    private WiFiP2pEventHandler _wifiEventHandler = null;

    private WiFiP2pEventHandler.WiFiP2pEventListener _p2pEventListener = null;
    private BackgroundTask.BackgroundTaskCompletionListener _syncCompletionListener = null;


    private TextView mTxtP2PDeviceName;
    private TextView mTxtP2PDeviceStatus;
    private ViewAnimator mViewAnimator;
    private RelativeLayout mDevicesContainer;
    private TextView mTxtP2PSearchProgress;
    private ListView mLstP2PDevices;
    private RelativeLayout mWelcomeContainer;
    private TextView mTxtP2PNotAvailable;
    private TextView mTxtP2PChangeDeviceName;

    private WifiP2pDevice mDevice;
    private WifiP2pDevice mOtherDevice;

    private ArrayList<WifiP2pDevice> discoveredDevices = new ArrayList<WifiP2pDevice>();



    public boolean isHost() {
        return isHost;
    }

    public void setHost(boolean isHost) {
        this.isHost = isHost;
    }


    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        this.wifiEventHandler();

        setContentView(R.layout.activity_p2_psync);

        assert getActionBar() != null;
        getActionBar().setTitle("WifiDirect Synchronization");

        this.extractFromView();
        this.registerListeners();

    }

    @Override
    public void onResume() {
        super.onResume();
        this.wifiEventHandler().onResume();
    }

    @Override
    public void onPause() {
        this.wifiEventHandler().onPause();
        super.onPause();
    }

    @Override
    protected void onStart()
    {
        super.onStart();
        this.wifiEventHandler().onResume();
    }

    @Override
    protected void onStop()
    {
        this.wifiEventHandler().disconnect();
        this.wifiEventHandler().onPause();
        super.onStop();
    }

    @Override
    protected void onDestroy(){
        this.wifiEventHandler().onPause();
        super.onDestroy();
    }

    private WiFiP2pEventHandler.WiFiP2pEventListener eventListener(){
        if (_p2pEventListener == null){
            _p2pEventListener = new WiFiP2pEventHandler.WiFiP2pEventListener() {
                WiFiP2pSyncActivity activity = null;
                public WiFiP2pEventHandler.WiFiP2pEventListener init(WiFiP2pSyncActivity act){
                    this.activity = act;
                    return this;
                }

                @Override
                public void discoveredDevices(List<WifiP2pDevice> peers) {
                    Log.d("WiFiP2pSyncActivity", "Actualise devices list" + ".");
                    this.activity.updateDeviceListView(peers);
                }

                @Override
                public void wifiP2pIsEnabled(boolean enabled) {
                    String tmp = enabled? "enabled" : "disabled";
                    Log.d("WiFiP2pSyncActivity", "Peer to peer is " + tmp + ".");
                    this.activity.setWifiDirectAvailable(enabled);
                }

                @Override
                public void didConnect(boolean isHost, WifiP2pInfo connectionInfo) {
                    Log.d("WiFiP2pSyncActivity", "Did connect" + ".");
                    this.activity.setHost(isHost);
                    if (isHost){
                        Log.d("WiFiP2pSyncActivity", "Connected as HOST" + ".");
                        this.activity.startHost();
                    } else {
                        Log.d("WiFiP2pSyncActivity", "Connected as Client" + ".");
                        this.activity.startClient(connectionInfo);
                    }
                }

                @Override
                public void failedToConnect() {
                    Log.d("WiFiP2pSyncActivity", "Failed to connect" + ".");
                    Toast.makeText(this.activity, "Could not connect to device. Retry.", Toast.LENGTH_LONG).show();
                }

                @Override
                public void didDisconnect() {
                    Log.d("WiFiP2pSyncActivity", "Did disconnect" + ".");

                }

                @Override
                public void failedToDisconnect() {
                    Log.d("WiFiP2pSyncActivity", "Failed to disconnect" + ".");
                    Toast.makeText(this.activity, "Could not disconnect with device. Retry.", Toast.LENGTH_LONG).show();
                }

                @Override
                public void deviceIsUpdated(WifiP2pDevice device) {
                    Log.d("WiFiP2pSyncActivity", "Updated device " + device.deviceName + " " + device.deviceAddress + ".");
                    this.activity.updateDevice(device);
                    this.activity.searchForDevices();

                }
            }.init(this);
        }

        return _p2pEventListener;
    }

    private WiFiP2pEventHandler wifiEventHandler(){
        if (this._wifiEventHandler == null){
            this._wifiEventHandler = new WiFiP2pEventHandler(this, this.eventListener());
        }
        return this._wifiEventHandler;
    }



    private BackgroundTask.BackgroundTaskCompletionListener syncCompletionListener(){
        if (_syncCompletionListener == null){
            _syncCompletionListener = new BackgroundTask.BackgroundTaskCompletionListener() {
                WiFiP2pSyncActivity activity = null;
                public BackgroundTask.BackgroundTaskCompletionListener init(WiFiP2pSyncActivity act){
                    this.activity = act;
                    return this;
                }
                @Override
                public void didSucceed() {
                    this.activity.runOnUiThread(new Runnable() {
                        private WiFiP2pSyncActivity activity;
                        @Override
                        public void run() {
                            Toast.makeText(this.activity, "Synchronization complete.", Toast.LENGTH_SHORT).show();
                            this.activity.wifiEventHandler().disconnect();
                        }
                        public Runnable init(WiFiP2pSyncActivity activity){
                            this.activity = activity;
                            return this;
                        }
                    }.init(this.activity));
                }

                @Override
                public void didFail() {
                    this.activity.runOnUiThread(new Runnable() {
                        private WiFiP2pSyncActivity activity;
                        @Override
                        public void run() {
                            Toast.makeText(this.activity, "Could not synchronize with device. Retry.", Toast.LENGTH_LONG).show();
                            this.activity.wifiEventHandler().disconnect();
                        }
                        public Runnable init(WiFiP2pSyncActivity activity){
                            this.activity = activity;
                            return this;
                        }
                    }.init(this.activity));
                }
            }.init(this);
        }
        return _syncCompletionListener;
    }


    private void updateDeviceListView(List<WifiP2pDevice> peers){
        mTxtP2PSearchProgress.setVisibility(View.GONE);

        this.discoveredDevices = new ArrayList<WifiP2pDevice>();
        this.discoveredDevices.addAll(peers);
        WiFiPeerListAdapter listAdapter = (WiFiPeerListAdapter) this.mLstP2PDevices.getAdapter();
        listAdapter.addItems(peers);
        this.runOnUiThread(new Runnable() {
            private ListView listView;

            @Override
            public void run() {
                WiFiPeerListAdapter adapter = (WiFiPeerListAdapter) this.listView.getAdapter();
                this.listView.setAdapter(null);
                adapter.notifyDataSetChanged();
                this.listView.setAdapter(adapter);
            }

            public Runnable init(ListView listview) {
                this.listView = listview;
                return this;
            }
        }.init(this.mLstP2PDevices));
        Log.d("WiFiP2pSyncActivity", " Discovered "+peers.size()+" devices.");
    }

    private void startHost(){
        Log.d("WiFiP2pSyncActivity", "Starting HOST Task" + ".");
        Toast.makeText(this, "Acting as Host.", Toast.LENGTH_SHORT).show();
        this.hostTask = new SyncHostTask(this.syncCompletionListener(), getApplicationContext());
        this.hostTask.execute();
    }

    private void startClient(WifiP2pInfo info){
        Log.d("WiFiP2pSyncActivity", "Starting CLIENT Task" + ".");
        Toast.makeText(this, "Acting as Client.", Toast.LENGTH_SHORT).show();
        this.clientTask = new SyncClientTask(info.groupOwnerAddress.getHostAddress(), this.syncCompletionListener(), getApplicationContext() );
        this.clientTask.execute();
    }


    private static String getDeviceStatus(int deviceStatus) {
        switch (deviceStatus) {
            case WifiP2pDevice.AVAILABLE:
                return "Available";
            case WifiP2pDevice.INVITED:
                return "Invited";
            case WifiP2pDevice.CONNECTED:
                return "Connected";
            case WifiP2pDevice.FAILED:
                return "Failed";
            case WifiP2pDevice.UNAVAILABLE:
                return "Unavailable";
            default:
                return "Unknown";
        }
    }


    private void updateDevice(WifiP2pDevice device){
        mTxtP2PDeviceName.setText(device.deviceName);
        mTxtP2PDeviceStatus.setText(getDeviceStatus(device.status));
        mDevice = device;
    }

    private void searchForDevices(){
        mTxtP2PSearchProgress.setVisibility(View.VISIBLE);
        this.wifiEventHandler().discoverDevices();
    }

    /********************** UI ************************/


    public void setWifiDirectAvailable(boolean enabled){
        if (enabled){
            mTxtP2PNotAvailable.setVisibility(View.GONE);
        } else {
            mTxtP2PNotAvailable.setVisibility(View.VISIBLE);
            ((WiFiPeerListAdapter) mLstP2PDevices.getAdapter()).notifyDataSetChanged();
            mDevice = null;
            this.updateDeviceListView(new ArrayList<WifiP2pDevice>());

            Toast.makeText(this, "WiFi Direct P2P is disabled.", Toast.LENGTH_LONG).show();
        }
    }



    private void extractFromView(){
        this.mTxtP2PDeviceName = (TextView) findViewById(R.id.txt_p2p_device_name);
        this.mTxtP2PDeviceStatus = (TextView) findViewById(R.id.txt_p2p_device_status);
        this.mTxtP2PChangeDeviceName = (TextView) findViewById(R.id.txtP2PChangeDeviceName);

        this.mViewAnimator = (ViewAnimator) findViewById(R.id.viewAnimator);
        this.mDevicesContainer = (RelativeLayout) findViewById(R.id.devicesContainer);
        this.mWelcomeContainer = (RelativeLayout) findViewById(R.id.welcomeContainer);
        this.mTxtP2PSearchProgress = (TextView) findViewById(R.id.txtP2PSearchProgress);
        this.mLstP2PDevices = (ListView) findViewById(R.id.lstP2PDevices);
        this.mTxtP2PNotAvailable = (TextView) findViewById(R.id.txtP2PNotAvailable);
    }

    public void registerListeners(){
        /*
        mTxtP2PChangeDeviceName.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Method method1 = null;
                try {
                    method1 = mManager.getClass().getDeclaredMethod("setDeviceName", WifiP2pManager.Channel.class);
                    method1.invoke(mManager, mChannel, "Android_fc546");
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        });*/

        if (this.mLstP2PDevices.getOnItemClickListener() != this)
            this.mLstP2PDevices.setOnItemClickListener(this);

        if (this.mLstP2PDevices.getAdapter() == null){
            this.discoveredDevices = new ArrayList();
            WiFiPeerListAdapter listAdapter = new WiFiPeerListAdapter(this, R.layout.row_devices, this.discoveredDevices);
            this.mLstP2PDevices.setAdapter(listAdapter);
        }
    }


    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
        final WifiP2pDevice device = (WifiP2pDevice) this.mLstP2PDevices.getAdapter().getItem(position);
        this.wifiEventHandler().connect(device);
        mOtherDevice = device;
    }


    /**
     * Array adapter for ListFragment that maintains WifiP2pDevice list.
     */
    private class WiFiPeerListAdapter extends ArrayAdapter<WifiP2pDevice> {
        private List<WifiP2pDevice> items;
        /**
         * @param context
         * @param textViewResourceId
         * @param objects
         */
        public WiFiPeerListAdapter(Context context, int textViewResourceId,
                                   List<WifiP2pDevice> objects) {
            super(context, textViewResourceId, objects);
            items = objects;
        }

        @Override
        public int getCount() {
            return items.size();
        }


        public void addItems(List<WifiP2pDevice> devicesToAdd){
            items.clear();
            items.addAll(devicesToAdd);
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            View v = convertView;
            if (v == null) {
                LayoutInflater vi = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
                v = vi.inflate(R.layout.row_devices, null);
            }
            WifiP2pDevice device = items.get(position);
            if (device != null) {
                TextView top = (TextView) v.findViewById(R.id.device_name);
                TextView bottom = (TextView) v.findViewById(R.id.device_details);
                if (top != null) {
                    top.setText(device.deviceName);
                }
                if (bottom != null) {
                    bottom.setText(getDeviceStatus(device.status));
                }
            }
            return v;
        }
    }
}