gdx-studio

package scene2d;
/*
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.LinkedList;
import java.util.UUID;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;

import com.badlogic.gdx.Application.ApplicationType;
import com.badlogic.gdx.Gdx;*/


/*******************************************************************************
 * Copyright 2013 pyros2097
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/

 
public final class Net {
	public static BlueTooth bluetooth;
	
	private Net(){
		//if(Gdx.app.getType() == ApplicationType.Desktop)
		//	bluetooth = new IBlueTooth();
		//else
		//	bluetooth = new BlueToothAndroid();
	}

	/*private static class BlueToothAndroid implements IBlueTooth {
			public LinkedList<BluetoothDevice> devices;
			private BluetoothDevice connectedDevice = null;
			private int deviceIndex = 0;
			private Activity currentActivity;
			private final Handler mHandler;
			private int mState;
			private AcceptThread mAcceptThread;
			private ConnectThread mConnectThread;
			private ConnectedThread mConnectedThread;

			public static final int STATE_NONE = 0;
			public static final int STATE_LISTEN = 1;
			public static final int STATE_CONNECTING = 2;
			public static final int STATE_CONNECTED = 3;

			public boolean isConnected = false;
			public boolean canConnect = true;

			public String message;
			public boolean messageTaken = true;

			public BluetoothAdapter bta = null;

			private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
				@Override
				public void onReceive(Context context, Intent intent) {
					String action = intent.getAction();

					if (BluetoothDevice.ACTION_FOUND.equals(action)) {
						BluetoothDevice device = intent
								.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
						devices.add(device);
					}
				}
			};

			public boolean isConnected() {
				return isConnected;
			}

			public String getMessage() {
				if (!messageTaken) {
					messageTaken = true;
					if (message != null)
						message = message.substring(0, 2);
					return message;
				}

				return null;
			}

			public String getTest() {
				try {
					for (int i = 0; i < devices.size(); i++) {
						if (devices.get(i).getName().contains("HTC")
								|| devices.get(i).getName().contains("GT")) {
							connectedDevice = devices.get(i);
							return devices.get(i).getName();
						}
					}
				} catch (Exception exc) {

				}
				return null;
			}

			public String getDevice() {
				try {
					connectedDevice = devices.get(deviceIndex);
					return connectedDevice.getName();
				} catch (Exception exc) {

				}

				return null;
			}

			public boolean isLast() {
				try {
					if (connectedDevice == null)
						return true;
					if (devices.isEmpty())
						return true;
					if (connectedDevice.equals(devices.getLast())) {
						return true;
					}
				} catch (Exception exc) {

				}

				return false;
			}

			public boolean isFirst() {
				try {
					if (connectedDevice == null)
						return true;
					if (devices.isEmpty())
						return true;
					if (connectedDevice.equals(devices.getFirst())) {
						return true;
					}
				} catch (Exception exc) {

				}

				return false;
			}

			public void switchToNextDevice() {
				if (!isLast()) {
					connectedDevice = devices.get(++deviceIndex);
				}
			}

			public void switchToPrevDevice() {
				if (!isFirst()) {
					connectedDevice = devices.get(--deviceIndex);
				}
			}

			private void init() {
				devices = new LinkedList<BluetoothDevice>();
			}

			public BluetoothManager(Activity activity, Handler handler) {
				init();

				currentActivity = activity;
				mState = STATE_NONE;
				mHandler = handler;

				IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
				currentActivity.registerReceiver(mReceiver, filter);
			}

			private synchronized void setState(int state) {
				mState = state;

				mHandler.obtainMessage(MainActivity.MESSAGE_STATE_CHANGE, state, -1)
						.sendToTarget();
			}

			public synchronized int getState() {
				return mState;
			}

			public synchronized void start() {
				if (mConnectThread != null) {
					mConnectThread.cancel();
					mConnectThread = null;
				}

				if (mConnectedThread != null) {
					mConnectedThread.cancel();
					mConnectedThread = null;
				}

				if (mAcceptThread == null) {
					mAcceptThread = new AcceptThread();
					mAcceptThread.start();
				}
				setState(STATE_LISTEN);
			}

			public synchronized void connect(BluetoothDevice device) {
				if (mState == STATE_CONNECTING) {
					if (mConnectThread != null) {
						mConnectThread.cancel();
						mConnectThread = null;
					}
				}

				if (mConnectedThread != null) {
					mConnectedThread.cancel();
					mConnectedThread = null;
				}

				mConnectThread = new ConnectThread(device);
				mConnectThread.start();
				setState(STATE_CONNECTING);
			}

			public synchronized void connected(BluetoothSocket socket,
					BluetoothDevice device) {
				if (mConnectThread != null) {
					mConnectThread.cancel();
					mConnectThread = null;
				}

				if (mConnectedThread != null) {
					mConnectedThread.cancel();
					mConnectedThread = null;
				}

				if (mAcceptThread != null) {
					mAcceptThread.cancel();
					mAcceptThread = null;
				}

				mConnectedThread = new ConnectedThread(socket);
				mConnectedThread.start();

				Message msg = mHandler.obtainMessage(MainActivity.MESSAGE_DEVICE_NAME);
				Bundle bundle = new Bundle();
				bundle.putString(MainActivity.DEVICE_NAME, device.getName());
				msg.setData(bundle);
				mHandler.sendMessage(msg);

				setState(STATE_CONNECTED);
			}

			public synchronized void stop() {
				if (mConnectThread != null) {
					mConnectThread.cancel();
					mConnectThread = null;
				}
				if (mConnectedThread != null) {
					mConnectedThread.cancel();
					mConnectedThread = null;
				}
				if (mAcceptThread != null) {
					mAcceptThread.cancel();
					mAcceptThread = null;
				}
				setState(STATE_NONE);
				isConnected = false;
			}

			public void write(byte[] out) {
				ConnectedThread r;
				synchronized (this) {
					if (mState != STATE_CONNECTED)
						return;
					r = mConnectedThread;
				}
				r.write(out);
			}

			private void connectionFailed() {
				setState(STATE_LISTEN);

				canConnect = false;
				Message msg = mHandler.obtainMessage(MainActivity.MESSAGE_TOAST);
				Bundle bundle = new Bundle();
				bundle.putString(MainActivity.TOAST, "Unable to connect device");
				msg.setData(bundle);
				mHandler.sendMessage(msg);
			}

			private void connectionLost() {
				setState(STATE_LISTEN);

				Message msg = mHandler.obtainMessage(MainActivity.MESSAGE_TOAST);
				Bundle bundle = new Bundle();
				bundle.putString(MainActivity.TOAST, "Device connection was lost");
				msg.setData(bundle);
				mHandler.sendMessage(msg);
			}

			public void enableDiscoveribility() {
				Intent discoverableIntent = new Intent(
						BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
				discoverableIntent.putExtra(
						BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 3600);
				currentActivity.startActivity(discoverableIntent);
			}

			public BluetoothAdapter getAdapter() {
				if (bta == null) {
					bta = BluetoothAdapter.getDefaultAdapter();
				}

				return bta;
			}

			public void enableBluetooth() {
				if (!getAdapter().isEnabled()) {
					Intent enableIntent = new Intent(
							BluetoothAdapter.ACTION_REQUEST_ENABLE);
					currentActivity.startActivityForResult(enableIntent, 2);
				}
			}

			public boolean isDiscovering() {
				return getAdapter().isDiscovering();
			}
			
			public void discoverDevices() {
				if (getAdapter().isDiscovering()) {
					getAdapter().cancelDiscovery();
				}

				getAdapter().startDiscovery();
			}

			public void stopDiscovering() {
				getAdapter().cancelDiscovery();
			}

			public boolean startServer() { 
				if (getAdapter().isEnabled()) {
					this.start();
					return true;
				}
				
				return false;
			}

			public boolean canConnect() {
				return this.canConnect;
			}

			public void connectToServer() {
				canConnect = true;
				try {
					BluetoothDevice device = getAdapter().getRemoteDevice(
							connectedDevice.getAddress());
					this.connect(device);
				} catch (Exception exc) {
					
				}
			}

			public void sendMessage(String message) {
				if (message.length() > 0) {
					if (message.length() == 1) {
						message = "0" + message;
					}
					byte[] send = message.getBytes();
					this.write(send);
				}
			}

			private class AcceptThread extends Thread {
				private final BluetoothServerSocket mmServerSocket;

				public AcceptThread() {
					BluetoothServerSocket tmp = null;
					try {
						tmp = getAdapter()
								.listenUsingRfcommWithServiceRecord(
										"ServiceName",
										UUID.fromString("AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE"));
					} catch (IOException e) {
					}
					mmServerSocket = tmp;
				}

				public void run() {
					BluetoothSocket socket = null;
					while (mState != STATE_CONNECTED) {
						try {
							socket = mmServerSocket.accept();
						} catch (IOException e) {
							break;
						}
						if (socket != null) {
							synchronized (BluetoothManager.this) {
								switch (mState) {
								case STATE_LISTEN:
								case STATE_CONNECTING:
									connected(socket, socket.getRemoteDevice());
									break;
								case STATE_NONE:
								case STATE_CONNECTED:
									try {
										socket.close();
									} catch (IOException e) {
									}
									break;
								}
							}
							try {
								mmServerSocket.close();
							} catch (IOException e) {
								e.printStackTrace();
							}
							break;
						}
					}
				}

				public void cancel() {
					try {
						mmServerSocket.close();
					} catch (IOException e) {
					}
				}
			}

			private class ConnectThread extends Thread {
				private final BluetoothSocket mmSocket;
				private final BluetoothDevice mmDevice;

				public ConnectThread(BluetoothDevice device) {
					BluetoothSocket tmp = null;
					mmDevice = device;

					try {
						tmp = device.createRfcommSocketToServiceRecord(UUID
								.fromString("AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE"));
					} catch (IOException e) {
					}
					mmSocket = tmp;
				}

				public void run() {
					getAdapter().cancelDiscovery();

					try {
						mmSocket.connect();
					} catch (IOException connectException) {
						connectionFailed();
						try {
							mmSocket.close();
						} catch (IOException closeException) {
						}

						return;
					}

					synchronized (BluetoothManager.this) {
						mConnectThread = null;
					}

					connected(mmSocket, mmDevice);
				}

				public void cancel() {
					try {
						mmSocket.close();
					} catch (IOException e) {
					}
				}
			}

			private class ConnectedThread extends Thread {
				private final BluetoothSocket mmSocket;
				private final InputStream mmInStream;
				private final OutputStream mmOutStream;

				public ConnectedThread(BluetoothSocket socket) {
					mmSocket = socket;
					InputStream tmpIn = null;
					OutputStream tmpOut = null;
					isConnected = true;

					try {
						tmpIn = socket.getInputStream();
						tmpOut = socket.getOutputStream();
					} catch (IOException e) {
					}

					mmInStream = tmpIn;
					mmOutStream = tmpOut;
				}

				public void run() {
					byte[] buffer = new byte[1024];
					int bytes;

					while (true) {
						try {
							bytes = mmInStream.read(buffer);
							setMessage(new String(buffer, "UTF-8"));
							mHandler.obtainMessage(MainActivity.MESSAGE_READ, bytes, -1,
									buffer).sendToTarget();
						} catch (IOException e) {
							connectionLost();
							break;
						}
					}
				}

				public void write(byte[] bytes) {
					try {
						mmOutStream.write(bytes);
					} catch (IOException e) {
					}
				}

				public void cancel() {
					try {
						mmSocket.close();
						isConnected = false;
					} catch (IOException e) {
					}
				}
			}

			private void setMessage(String message) {
				if (messageTaken) {
					this.message = message;
					messageTaken = false;
				}
			}
	}*/
	
	public static interface BlueTooth {
		public void enableWifi();
		public void enableDiscoveribility();
		public void discoverDevices();
		public void stopDiscovering();
		public boolean startServer();
		public void connectToServer();
		public String getTest();
		public void sendMessage(String message);
		public String getMessage();
		public boolean isConnected();
		public boolean canConnect();
		public void switchToNextDevice();
		public void switchToPrevDevice();
		public String getDevice();
		public void stop();
		public boolean isFirst();
		public boolean isLast();
		public boolean isDiscovering();
	}
	
}