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

}