SIGMA-FF

/*

 * Copyright (C) 2014 The Android Open Source Project

 *

 * 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.

 */



package com.example.android.bluetoothchat;



import android.app.ActionBar;

import android.app.Activity;

import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothDevice;

import android.content.Intent;

import android.graphics.Color;
import android.os.Bundle;

import android.os.Handler;

import android.os.Message;

import android.view.KeyEvent;

import android.view.LayoutInflater;

import android.view.Menu;

import android.view.MenuInflater;

import android.view.MenuItem;

import android.view.View;

import android.view.ViewGroup;

import android.view.inputmethod.EditorInfo;

import android.widget.ArrayAdapter;

import android.widget.Button;

import android.widget.EditText;

import android.widget.ListView;

import android.widget.TextView;

import android.widget.Toast;



import androidx.annotation.NonNull;

import androidx.annotation.Nullable;

import androidx.fragment.app.Fragment;

import androidx.fragment.app.FragmentActivity;



import com.example.android.common.logger.Log;

//#graphView
import com.jjoe64.graphview.GraphView;
import com.jjoe64.graphview.series.DataPoint;
import com.jjoe64.graphview.series.LineGraphSeries;
import com.jjoe64.graphview.GridLabelRenderer;

import java.util.Random;


/**

 * This fragment controls Bluetooth to communicate with other devices.

 */

public class BluetoothChatFragment extends Fragment{


    private static final String TAG = "BluetoothChatFragment";


    // Intent request codes

    private static final int REQUEST_CONNECT_DEVICE_SECURE = 1;

    private static final int REQUEST_CONNECT_DEVICE_INSECURE = 2;

    private static final int REQUEST_ENABLE_BT = 3;



    // Layout Views

    private ListView mConversationView;

    private EditText mOutEditText;

    private Button mSendButton;


    /**
     * Name of the connected device
     */

    private String mConnectedDeviceName = null;


    /**
     * Array adapter for the conversation thread
     */

    private ArrayAdapter<String> mConversationArrayAdapter;


    /**
     * String buffer for outgoing messages
     */

    private StringBuffer mOutStringBuffer;


    /**
     * Local Bluetooth adapter
     */

    private BluetoothAdapter mBluetoothAdapter = null;


    /**
     * Member object for the chat services
     */

    private BluetoothChatService mChatService = null;

    private String hexX, hexY;
    public static int  decimalX,decimalY;
    public int i =0;



    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setHasOptionsMenu(true);

        // Get local Bluetooth adapter

        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();


        // If the adapter is null, then Bluetooth is not supported

        FragmentActivity activity = getActivity();

        if (mBluetoothAdapter == null && activity != null) {

            Toast.makeText(activity, "Bluetooth is not available", Toast.LENGTH_LONG).show();

            activity.finish();

        }
        //#graphView https://github.com/jjoe64/GraphView
        //GraphView graph = (GraphView) findViewById(R.id.graph);
//        GraphView graph = (GraphView) findViewById(R.id.graph);
//        initGraph(graph);
//

    }

    @Override

    public void onStart() {

        super.onStart();

        if (mBluetoothAdapter == null) {

            return;

        }

        // If BT is not on, request that it be enabled.

        // setupChat() will then be called during onActivityResult

        if (!mBluetoothAdapter.isEnabled()) {

            Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);

            startActivityForResult(enableIntent, REQUEST_ENABLE_BT);

            // Otherwise, setup the chat session

        } else if (mChatService == null) {

            setupChat();

        }

    }


    @Override

    public void onDestroy() {

        super.onDestroy();

        if (mChatService != null) {

            mChatService.stop();

        }

    }



    @Override

    public void onResume() {

        super.onResume();


        // Performing this check in onResume() covers the case in which BT was

        // not enabled during onStart(), so we were paused to enable it...

        // onResume() will be called when ACTION_REQUEST_ENABLE activity returns.

        if (mChatService != null) {

            // Only if the state is STATE_NONE, do we know that we haven't started already

            if (mChatService.getState() == BluetoothChatService.STATE_NONE) {

                // Start the Bluetooth chat services

                mChatService.start();

            }

        }

    }


    @Override

    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,

                             @Nullable Bundle savedInstanceState) {

        return inflater.inflate(R.layout.fragment_bluetooth_chat, container, false);

    }


    @Override

    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {

        mConversationView = view.findViewById(R.id.in);

        mOutEditText = view.findViewById(R.id.edit_text_out);

        mSendButton = view.findViewById(R.id.button_send);



    }


    /**
     * Set up the UI and background operations for chat.
     */

    private void setupChat() {

        Log.d(TAG, "setupChat()");


        // Initialize the array adapter for the conversation thread

        FragmentActivity activity = getActivity();

        if (activity == null) {

            return;

        }

        mConversationArrayAdapter = new ArrayAdapter<>(activity, R.layout.message);


        mConversationView.setAdapter(mConversationArrayAdapter);


        // Initialize the compose field with a listener for the return key

        mOutEditText.setOnEditorActionListener(mWriteListener);


        // Initialize the send button with a listener that for click events

        mSendButton.setOnClickListener(new View.OnClickListener() {

            public void onClick(View v) {

                // Send a message using content of the edit text widget

                View view = getView();

                if (null != view) {

                    TextView textView = view.findViewById(R.id.edit_text_out);

                    String message = textView.getText().toString();

                    sendMessage(message);

                }

            }

        });


        // Initialize the BluetoothChatService to perform bluetooth connections

        mChatService = new BluetoothChatService(activity, mHandler);


        // Initialize the buffer for outgoing messages

        mOutStringBuffer = new StringBuffer();

    }


    /**
     * Makes this device discoverable for 300 seconds (5 minutes).
     */

    private void ensureDiscoverable() {

        if (mBluetoothAdapter.getScanMode() !=

                BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {

            Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);

            discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);

            startActivity(discoverableIntent);

        }

    }


    /**
     * Sends a message.
     *
     * @param message A string of text to send.
     */

    private void sendMessage(String message) {

        // Check that we're actually connected before trying anything

        if (mChatService.getState() != BluetoothChatService.STATE_CONNECTED) {

            Toast.makeText(getActivity(), R.string.not_connected, Toast.LENGTH_SHORT).show();

            return;

        }


        // Check that there's actually something to send

        if (message.length() > 0) {

            // Get the message bytes and tell the BluetoothChatService to write

            byte[] send = message.getBytes();

            mChatService.write(send);


            // Reset out string buffer to zero and clear the edit text field

            mOutStringBuffer.setLength(0);

            mOutEditText.setText(mOutStringBuffer);

        }

    }


    /**
     * The action listener for the EditText widget, to listen for the return key
     */

    private TextView.OnEditorActionListener mWriteListener

            = new TextView.OnEditorActionListener() {

        public boolean onEditorAction(TextView view, int actionId, KeyEvent event) {

            // If the action is a key-up event on the return key, send the message

            if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_UP) {

                String message = view.getText().toString();

                sendMessage(message);

            }

            return true;

        }

    };


    /**
     * Updates the status on the action bar.
     *
     * @param resId a string resource ID
     */

    private void setStatus(int resId) {

        FragmentActivity activity = getActivity();

        if (null == activity) {

            return;

        }

        final ActionBar actionBar = activity.getActionBar();

        if (null == actionBar) {

            return;

        }

        actionBar.setSubtitle(resId);

    }


    /**
     * Updates the status on the action bar.
     *
     * @param subTitle status
     */

    private void setStatus(CharSequence subTitle) {

        FragmentActivity activity = getActivity();

        if (null == activity) {

            return;

        }

        final ActionBar actionBar = activity.getActionBar();

        if (null == actionBar) {

            return;

        }

        actionBar.setSubtitle(subTitle);

    }


    /**
     * The Handler that gets information back from the BluetoothChatService
     */

    private final Handler mHandler = new Handler() {

        @Override

        public void handleMessage(Message msg) {

            FragmentActivity activity = getActivity();

            switch (msg.what) {

                case Constants.MESSAGE_STATE_CHANGE:

                    switch (msg.arg1) {

                        case BluetoothChatService.STATE_CONNECTED:

                            setStatus(getString(R.string.title_connected_to, mConnectedDeviceName));

                            mConversationArrayAdapter.clear();

                            break;

                        case BluetoothChatService.STATE_CONNECTING:

                            setStatus(R.string.title_connecting);

                            break;

                        case BluetoothChatService.STATE_LISTEN:

                        case BluetoothChatService.STATE_NONE:

                            setStatus(R.string.title_not_connected);

                            break;

                    }

                    break;

                case Constants.MESSAGE_WRITE:

                    byte[] writeBuf = (byte[]) msg.obj;

                    // construct a string from the buffer

                    String writeMessage = new String(writeBuf);
                    //String writeMessage="aaa";

                    mConversationArrayAdapter.add(writeMessage);

                    break;

                case Constants.MESSAGE_READ:

                    byte[] readBuf = (byte[]) msg.obj;

                    // construct a string from the valid bytes in the buffer

                    // String readMessage = new String(readBuf, 0, msg.arg1);

                    String readMessage = new String(readBuf, 0, 80);

                    //Operator ID, inteiro de 0 a 9
                    Mensagem ID = new Mensagem();
                    ID.setMensagem(readMessage.substring(1, 3));
                    String palavra = ID.getMessagem();

                    //Message counter, inteiro de 0 a 65535
                    Mensagem MessageCounter = new Mensagem();
                    MessageCounter.setMensagem(readMessage.substring(3, 7));

                    //Step Counter, inteiro de 0 a 65535
                    Mensagem StepCounter = new Mensagem();
                    StepCounter.setMensagem(readMessage.substring(7, 11));

                    //Flag x 16: bit0: initial stance OK, bit1: no magnetic calibration, bit2: operator KO,
                    // bit3: high temperature
                    Mensagem Flag = new Mensagem();
                    Flag.setMensagem(readMessage.substring(11, 15));

                    // Position estimation given by integration of inertial and magnetic data, X (North), LSB 0.1 m,
                    // value from -52.4288 km to +52.4288 km
                    Mensagem PositionIMX = new Mensagem();
                    PositionIMX.setMensagem(readMessage.substring(15, 20));

                    // Position estimation given by integration of inertial and magnetic data, Y (East) , LSB 0.1 m,
                    // value from -52.4288 km to +52.4288 km
                    Mensagem PositionIMY = new Mensagem();
                    PositionIMY.setMensagem(readMessage.substring(20, 25));

                    //Position estimation given by integration of inertial data only, X (North) , LSB 0.1 m,
                    // value from -52.4288 km to +52.4288 km 8
                    Mensagem PositionIX = new Mensagem();
                    PositionIX.setMensagem(readMessage.substring(25, 30));

                    // Position estimation given by integration of inertial data only, Y (East) , LSB 0.1 m,
                    // value from -52.4288 km to +52.4288 km
                    Mensagem PositionIY = new Mensagem();
                    PositionIY.setMensagem(readMessage.substring(30, 35));

                    //Altitude estimation given by integration of inertial data only, Z (Down) , LSB 0.1 m,
                    // value from -3276.8 m to +3276.8 m
                    Mensagem PositionIZ = new Mensagem();
                    PositionIZ.setMensagem(readMessage.substring(35, 39));

                    //Altitude estimation given by pressometer, Z (Down), LSB 0.1 m, value from -3276.8 m to +3276.8 m
                    Mensagem Altitude = new Mensagem();
                    Altitude.setMensagem(readMessage.substring(39, 43));

                    // Latitude estimation from GPS, LSB = 2^-29 rad (nearly 1.2 c at sea level),
                    // value from –PI/2 to +PI/2 rad
                    Mensagem Latitude = new Mensagem();
                    Latitude.setMensagem(readMessage.substring(43, 51));

                    // Longitude estimation from GPS, LSB = 2^-29 rad (nearly 1.2 c at sea level),
                    // value from –PI to +PI rad
                    Mensagem Longitude = new Mensagem();
                    Longitude.setMensagem(readMessage.substring(51, 59));

                    //GPS estimation quality, value from 0 to 99
                    Mensagem GPS = new Mensagem();
                    GPS.setMensagem(readMessage.substring(59, 61));

                    //North alignment angle of inertial path, LSB 2^-13 rad, value from –PI to PI rad
                    Mensagem Angle = new Mensagem();
                    Angle.setMensagem(readMessage.substring(61, 65));

                    //Yaw drift of inertial path, in rotation per step, LSB 2^-19 rad,
                    // value from –3.56 to 3.56 rad
                    Mensagem Drift = new Mensagem();
                    Drift.setMensagem(readMessage.substring(65, 69));

                    //CRC-CCITT
                    Mensagem CRC = new Mensagem();
                    CRC.setMensagem(readMessage.substring(69, 73));
                    //String hex="FE" ;



                    if(i<=3) {
                        hexX="00000";
                        hexY="00000";
                        i++;
                    }
                    else {
                        hexX=PositionIMX.getMessagem();
                        hexY=PositionIMX.getMessagem();
                    }
                    decimalX=Integer.parseInt(hexX,16);
                    decimalY=Integer.parseInt(hexY,16);

                    //String valor= Integer.toString(decimal);
                    // mConversationArrayAdapter.add(mConnectedDeviceName + ":  " + readMessage);
                    // mConversationArrayAdapter.add("XXXXXX "+readMessage+"XXXXXX");
//                    mConversationArrayAdapter.add("XXXXXX "+readMessage+"XXXXXX"+ID.getMessagem()
//                            +MessageCounter.getMessagem()+StepCounter.getMessagem()+Flag.getMessagem());

                    //mConversationArrayAdapter.add("X:"+PositionIMX.getMessagem()+" Y:"
                    //      +PositionIMY.getMessagem()+"XX" +decimal);
                    //System.out.println(decimal);

                    mConversationArrayAdapter.add("X:"+decimalX+" Y:"+decimalY);

                    break;

                case Constants.MESSAGE_DEVICE_NAME:

                    // save the connected device's name

                    mConnectedDeviceName = msg.getData().getString(Constants.DEVICE_NAME);

                    if (null != activity) {

                        Toast.makeText(activity, "Connected to "

                                + mConnectedDeviceName, Toast.LENGTH_SHORT).show();

                    }

                    break;

                case Constants.MESSAGE_TOAST:

                    if (null != activity) {

                        Toast.makeText(activity, msg.getData().getString(Constants.TOAST),

                                Toast.LENGTH_SHORT).show();

                    }

                    break;

            }

        }

    };


    public void onActivityResult(int requestCode, int resultCode, Intent data) {

        switch (requestCode) {

            case REQUEST_CONNECT_DEVICE_SECURE:

                // When DeviceListActivity returns with a device to connect

                if (resultCode == Activity.RESULT_OK) {

                    connectDevice(data, true);

                }

                break;

            case REQUEST_CONNECT_DEVICE_INSECURE:

                // When DeviceListActivity returns with a device to connect

                if (resultCode == Activity.RESULT_OK) {

                    connectDevice(data, false);

                }

                break;

            case REQUEST_ENABLE_BT:

                // When the request to enable Bluetooth returns

                if (resultCode == Activity.RESULT_OK) {

                    // Bluetooth is now enabled, so set up a chat session

                    setupChat();

                } else {

                    // User did not enable Bluetooth or an error occurred

                    Log.d(TAG, "BT not enabled");

                    FragmentActivity activity = getActivity();

                    if (activity != null) {

                        Toast.makeText(activity, R.string.bt_not_enabled_leaving,

                                Toast.LENGTH_SHORT).show();

                        activity.finish();

                    }

                }

        }

    }


    /**
     * Establish connection with other device
     *
     * @param data   An {@link Intent} with {@link DeviceListActivity#EXTRA_DEVICE_ADDRESS} extra.
     * @param secure Socket Security type - Secure (true) , Insecure (false)
     */

    private void connectDevice(Intent data, boolean secure) {

        // Get the device MAC address

        Bundle extras = data.getExtras();

        if (extras == null) {

            return;

        }

        String address = extras.getString(DeviceListActivity.EXTRA_DEVICE_ADDRESS);

        // Get the BluetoothDevice object

        BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);

        // Attempt to connect to the device

        mChatService.connect(device, secure);

    }


    @Override

    public void onCreateOptionsMenu(@NonNull Menu menu, MenuInflater inflater) {


        inflater.inflate(R.menu.bluetooth_chat, menu);

    }


    @Override

    public boolean onOptionsItemSelected(MenuItem item) {

        switch (item.getItemId()) {

            case R.id.secure_connect_scan: {

                // Launch the DeviceListActivity to see devices and do scan

                Intent serverIntent = new Intent(getActivity(), DeviceListActivity.class);

                startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE_SECURE);

                return true;

            }

            case R.id.insecure_connect_scan: {

                // Launch the DeviceListActivity to see devices and do scan

                Intent serverIntent = new Intent(getActivity(), DeviceListActivity.class);

                startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE_INSECURE);

                return true;

            }

            case R.id.discoverable: {

                // Ensure this device is discoverable by others

                ensureDiscoverable();

                return true;

            }

        }

        return false;

    }

    public class Mensagem {
        private String mensagem;

        // Getter
        public String getMessagem() {

            return mensagem;
        }

        //Setter
        public void setMensagem(String m) {

            this.mensagem = m;


        }



    }

    public static class Decimal{
        int ValorX = decimalX;
        int ValorY = decimalY;

    }


}




/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * 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.
 */

package com.example.android.bluetoothchat;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Color;
import android.icu.text.Transliterator;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.view.Window;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.TextView;

import com.example.android.common.logger.Log;
import com.jjoe64.graphview.GraphView;
import com.jjoe64.graphview.GridLabelRenderer;
import com.jjoe64.graphview.series.DataPoint;
import com.jjoe64.graphview.series.LineGraphSeries;

import java.util.Random;
import java.util.Set;


/**
 * This Activity appears as a dialog. It lists any paired devices and
 * devices detected in the area after discovery. When a device is chosen
 * by the user, the MAC address of the device is sent back to the parent
 * Activity in the result Intent.
 */
public class DeviceListActivity extends Activity {


    public int i =0;


    //#graphView

    private final Handler mHandler = new Handler();
    private Runnable mTimer;
    private double graphLastXValue = 5d;
    private double yvalue = 5d;
    private LineGraphSeries<DataPoint> mSeries;


    /**
     * Tag for Log
     */
    private static final String TAG = "DeviceListActivity";

    /**
     * Return Intent extra
     */
    public static String EXTRA_DEVICE_ADDRESS = "device_address";

    /**
     * Member fields
     */
    private BluetoothAdapter mBtAdapter;

    /**
     * Newly discovered devices
     */
    private ArrayAdapter<String> mNewDevicesArrayAdapter;



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


        if(i<=3) {
            i++;
        }
        else {
            GraphView graph = (GraphView) findViewById(R.id.graph);
            initGraph(graph);
        }



        // Setup the window
        requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
        setContentView(R.layout.activity_device_list);

        // Set result CANCELED in case the user backs out
        setResult(Activity.RESULT_CANCELED);

        // Initialize the button to perform device discovery
        Button scanButton = findViewById(R.id.button_scan);
        scanButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                doDiscovery();
                v.setVisibility(View.GONE);
            }
        });

        // Initialize array adapters. One for already paired devices and
        // one for newly discovered devices
        ArrayAdapter<String> pairedDevicesArrayAdapter =
                new ArrayAdapter<>(this, R.layout.device_name);
        mNewDevicesArrayAdapter = new ArrayAdapter<>(this, R.layout.device_name);

        // Find and set up the ListView for paired devices
        ListView pairedListView = findViewById(R.id.paired_devices);
        pairedListView.setAdapter(pairedDevicesArrayAdapter);
        pairedListView.setOnItemClickListener(mDeviceClickListener);

        // Find and set up the ListView for newly discovered devices
        ListView newDevicesListView = findViewById(R.id.new_devices);
        newDevicesListView.setAdapter(mNewDevicesArrayAdapter);
        newDevicesListView.setOnItemClickListener(mDeviceClickListener);

        // Register for broadcasts when a device is discovered
        IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
        this.registerReceiver(mReceiver, filter);

        // Register for broadcasts when discovery has finished
        filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
        this.registerReceiver(mReceiver, filter);

        // Get the local Bluetooth adapter
        mBtAdapter = BluetoothAdapter.getDefaultAdapter();

        // Get a set of currently paired devices
        Set<BluetoothDevice> pairedDevices = mBtAdapter.getBondedDevices();

        // If there are paired devices, add each one to the ArrayAdapter
        if (pairedDevices.size() > 0) {
            findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE);
            for (BluetoothDevice device : pairedDevices) {
                pairedDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
            }
        } else {
            String noDevices = getResources().getText(R.string.none_paired).toString();
            pairedDevicesArrayAdapter.add(noDevices);
        }


    }


    public void initGraph(GraphView graph)
    {
        graph.getViewport().setXAxisBoundsManual(true);



        graph.getViewport().setMinX(0);

        graph.getViewport().setMaxX(1048575);



        graph.getViewport().setYAxisBoundsManual(true);

        graph.getViewport().setMinY(0);

        graph.getViewport().setMaxY(1048575);



        graph.getViewport().setScrollable(true); // enables horizontal scrolling

        graph.getViewport().setScalable(true); // enables horizontal zooming and scrolling





        //graph.getGridLabelRenderer().setLabelVerticalWidth(100);

        GridLabelRenderer gridLabel = graph.getGridLabelRenderer();

        gridLabel.setHorizontalAxisTitle("x axis");

        gridLabel.setVerticalAxisTitle("y axis");



        // first mSeries is a line

        mSeries = new LineGraphSeries<>();

        mSeries.setDrawDataPoints(false);

        mSeries.setDrawBackground(true);

        graph.addSeries(mSeries);

        mSeries.setColor(Color.RED);
    }


    //#graphView
   // double mLastRandom = 2;
    // String sharedFact = mDataField.getText().toString();
    //double yvalue = Double.parseDouble(data);
    //Random mRand = new Random();
   // private double getRandom()
    //{
  //      mLastRandom += mRand.nextDouble()*0.05 - 0.05;
  //      return mLastRandom ;
  //  }



    @Override

    public void onResume() {

        super.onResume();

        //#graphView
        mTimer = new Runnable()
        {
            @Override
            public void run()
            {
                graphLastXValue += 1.0;

              BluetoothChatFragment.Decimal Xvalue= new BluetoothChatFragment.Decimal();
              BluetoothChatFragment.Decimal Yvalue= new BluetoothChatFragment.Decimal();



                double a =Xvalue.ValorX;
                double b =Yvalue.ValorY;
                mSeries.appendData(new DataPoint(graphLastXValue, graphLastXValue),
                       true, 22);

               //mSeries.appendData(new DataPoint(Xvalue.ValorX,Yvalue.ValorY),
                //       true, 100);

               // mHandler.postDelayed(this, 330);
            }
        };
        mHandler.postDelayed(mTimer, 1500);



    }


    @Override
    protected void onDestroy() {
        super.onDestroy();

        // Make sure we're not doing discovery anymore
        if (mBtAdapter != null) {
            mBtAdapter.cancelDiscovery();
        }

        // Unregister broadcast listeners
        this.unregisterReceiver(mReceiver);
    }

    /**
     * Start device discover with the BluetoothAdapter
     */
    private void doDiscovery() {
        Log.d(TAG, "doDiscovery()");

        // Indicate scanning in the title
        setProgressBarIndeterminateVisibility(true);
        setTitle(R.string.scanning);

        // Turn on sub-title for new devices
        findViewById(R.id.title_new_devices).setVisibility(View.VISIBLE);

        // If we're already discovering, stop it
        if (mBtAdapter.isDiscovering()) {
            mBtAdapter.cancelDiscovery();
        }

        // Request discover from BluetoothAdapter
        mBtAdapter.startDiscovery();
    }

    /**
     * The on-click listener for all devices in the ListViews
     */
    private AdapterView.OnItemClickListener mDeviceClickListener
            = new AdapterView.OnItemClickListener() {
        public void onItemClick(AdapterView<?> av, View v, int arg2, long arg3) {
            // Cancel discovery because it's costly and we're about to connect
            mBtAdapter.cancelDiscovery();

            // Get the device MAC address, which is the last 17 chars in the View
            String info = ((TextView) v).getText().toString();
            String address = info.substring(info.length() - 17);

            // Create the result Intent and include the MAC address
            Intent intent = new Intent();
            intent.putExtra(EXTRA_DEVICE_ADDRESS, address);

            // Set result and finish this Activity
            setResult(Activity.RESULT_OK, intent);
            finish();
        }
    };

    /**
     * The BroadcastReceiver that listens for discovered devices and changes the title when
     * discovery is finished
     */
    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();

            // When discovery finds a device
            if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                // Get the BluetoothDevice object from the Intent
                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                // If it's already paired, skip it, because it's been listed already
                if (device != null && device.getBondState() != BluetoothDevice.BOND_BONDED) {
                    mNewDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
                }
                // When discovery is finished, change the Activity title
            } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
                setProgressBarIndeterminateVisibility(false);
                setTitle(R.string.select_device);
                if (mNewDevicesArrayAdapter.getCount() == 0) {
                    String noDevices = getResources().getText(R.string.none_found).toString();
                    mNewDevicesArrayAdapter.add(noDevices);
                }
            }
        }
    };

}