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