package com.example.xxx;





import java.io.File;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import android.app.Activity;
import android.content.Context;
import android.hardware.Camera;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;

import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.Spinner;


import android.widget.Toast;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.os.Build;
import android.os.Handler;
import android.util.Log;
import android.view.View.OnClickListener;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends Activity {
    private static final String TAG = "Musiktherapie";

    //Variablen setzen
    Button btnOn, btnOff;
    TextView txtArduino;
    Handler h;
    EditText dateipfad;
    boolean recording;
    final int RECIEVE_MESSAGE = 1;        // Status  for Handler

    //Methoden setzen
    private BluetoothAdapter btAdapter = null;
    private BluetoothSocket btSocket = null;
    private StringBuilder sb = new StringBuilder();
    private ConnectedThread mConnectedThread;
    private Camera myCamera;
    private MyCameraSurfaceView myCameraSurfaceView;
    private MediaRecorder mediaRecorder;

    // SPP UUID Service
    private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");


    private static String address = "20:15:06:24:45:69";

    /**
     * Wird einmal aufgerufen wenn Activity startet
     */
    @Override

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        recording = false;
        setContentView(R.layout.activity_main);




        //Spinner inizialisieren für die G-Settings

        //liste mit items
        final List<String> list=new ArrayList<String>();
        list.add("G_Range 2");
        list.add("G_Range 4");
        list.add("G_Range 8");



        //spinner erstellen
        final Spinner G  =(Spinner) findViewById(R.id.spinner);


            //liste als adapter
            ArrayAdapter<String> adp = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, list);
            adp.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
            G.setAdapter(adp);


        G.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
            @Override
            public void onItemSelected(AdapterView<?> parentView, View selectedItemView, int position, long id) {
                mConnectedThread.write(String.valueOf(2*(G.getSelectedItemPosition())));
            }@Override
             public void onNothingSelected(AdapterView<?> parentView) {
                  //  do nothing
            }



        });




                ///////////Kameravorschau/////////////
                myCamera = getCameraInstance();

            myCameraSurfaceView=new MyCameraSurfaceView(this,myCamera);

            FrameLayout myCameraPreview = (FrameLayout) findViewById(R.id.videoview);
            myCameraPreview.addView(myCameraSurfaceView);

            btnOn=(Button) findViewById(R.id.btnOn);

            btnOff=(Button) findViewById(R.id.btnOff);

    dateipfad=(EditText)this.findViewById(R.id.dateipfad);


    Button btnOff = (Button) findViewById(R.id.btnOff);
    btnOff.setOnClickListener(new

    OnClickListener() {
        public void onClick (View v){
            mediaRecorder.stop();
            mConnectedThread.write("3");
                    recording = false;
                    Toast.makeText(getBaseContext(),
                            "Messwerte gespeichert!",
                            Toast.LENGTH_SHORT).show();
                }
            }

            );






        h=new

            Handler() {
                public void handleMessage (android.os.Message msg){



                    switch (msg.what) {
                        case RECIEVE_MESSAGE:

                            // wenn Daten empfangen werden
                            byte[] readBuf = (byte[]) msg.obj;


                            String path = "/sdcard/" + dateipfad.getText().toString() + ".txt";  //Environment.getExternalStorageDirectory().getPath()








                                ///////Messwertedatei beschreiben//////////
                                try {



                                    File myFile = new File(path);
                                    myFile.createNewFile();
                                    FileOutputStream fOut = new FileOutputStream(myFile,true);

                                    fOut.write(readBuf);
                                    fOut.flush();
                                    fOut.close();




                                } catch (Exception e) {
                                    Toast.makeText(getBaseContext(), e.getMessage(),
                                            Toast.LENGTH_SHORT).show();
                                }

                            break;
                    }
                }

            }

            ;

            btAdapter=BluetoothAdapter.getDefaultAdapter();        // get Bluetooth adapter vom Smartphone

            checkBTState();

            //////////////ON-Button/////////////////
            btnOn.setOnClickListener(new

            OnClickListener() {
                public void onClick (View v){


                    if (recording) {
                        // Aufnahme stoppen und Kamera loslassen
                        mediaRecorder.stop();                       // Aufnahme stoppen
                        releaseMediaRecorder();                      // Mediarecorder Objekt loslassen

                    } else {

                        //Kamera loslassen bevor der MediaRecorder startet
                        releaseCamera();
                        if (!prepareMediaRecorder()) {
                            Toast.makeText(MainActivity.this,
                                    "Fail in prepareMediaRecorder()!\n - Ended -",
                                    Toast.LENGTH_LONG).show();
                        }
                        /////////// Aufnahme starten///////////
                        mediaRecorder.start();
                        recording = true;
                    }

                    mConnectedThread.write("1");    // Sende "1" über Bluetooth zum mikrocontroller
                    Toast.makeText(getBaseContext(), "Starte Messung", Toast.LENGTH_SHORT).show();
                }
            }

            );

        }



    private Camera getCameraInstance() {
// TODO Auto-generated method stub
        Camera c = null;
        try {
            c = Camera.open();                  // Kamera-Instanz öffnen
            c.setDisplayOrientation(90);
        } catch (Exception e) {
                                                // Kamera nicht verfügbar
        }
        return c;                               // gibt null aus wenn Kamera nicht verfügbar
    }


    private boolean prepareMediaRecorder() {
        myCamera = getCameraInstance();
        mediaRecorder = new MediaRecorder();

        myCamera.unlock();
        mediaRecorder.setCamera(myCamera);
        //////Eigenschaften Videoaufnahme//////////
        mediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
        mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
        mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
        mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
        mediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
        mediaRecorder.setAudioEncodingBitRate(128000);
        mediaRecorder.setAudioSamplingRate(48000);
        mediaRecorder.setVideoSize(1280,720);
        mediaRecorder.setVideoEncodingBitRate(12000000);
        mediaRecorder.setVideoFrameRate(30);
        mediaRecorder.setOutputFile("sdcard/Musiktherapie.mp4");  //Dateipfad



        mediaRecorder.setPreviewDisplay(myCameraSurfaceView.getHolder().getSurface());
        try {
            mediaRecorder.prepare();
        } catch (IllegalStateException e) {
            releaseMediaRecorder();
            return false;
        } catch (IOException e) {
            releaseMediaRecorder();
            return false;
        }
        return true;
    }

    private void releaseMediaRecorder() {
        if (mediaRecorder != null) {
            mediaRecorder.reset();          // Lösche Recorder Konfiguration
            mediaRecorder.release();        // Lasse Recorderobjekt los
            mediaRecorder = null;
            myCamera.lock();                // Kamera schließen für später
        }
    }

    private void releaseCamera() {
        if (myCamera != null) {
            myCamera.release();             // Kamera loslassen für evtl. andere Anwendungen
            myCamera = null;
        }
    }

    public class MyCameraSurfaceView extends SurfaceView implements SurfaceHolder.Callback{

        private SurfaceHolder mHolder;
        private Camera mCamera;

        public MyCameraSurfaceView(Context context, Camera camera) {
            super(context);
            mCamera = camera;
            mHolder = getHolder();
            mHolder.addCallback(this);
            // deprecated setting, but required on Android versions prior to 3.0
            //mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        }


        public void surfaceChanged(SurfaceHolder holder, int format, int weight,
                                   int height) {
            if (mHolder.getSurface() == null){

                return;
            }


            try {
                mCamera.stopPreview();
            } catch (Exception e){
            }


            try {
                mCamera.setPreviewDisplay(mHolder);
                mCamera.startPreview();
            } catch (Exception e){
            }
        }

        public void surfaceCreated(SurfaceHolder holder) {

            try {
                mCamera.setPreviewDisplay(holder);
                mCamera.startPreview();
            } catch (IOException e) {
            }
        }


        public void surfaceDestroyed(SurfaceHolder holder) {
            // TODO Auto-generated method stub
        }
    }

  private BluetoothSocket createBluetoothSocket(BluetoothDevice device) throws IOException {
      if(Build.VERSION.SDK_INT >= 10){
          try {
              final Method  m = device.getClass().getMethod("createInsecureRfcommSocketToServiceRecord", new Class[] { UUID.class });
              return (BluetoothSocket) m.invoke(device, MY_UUID);
          } catch (Exception e) {
              Log.e(TAG, "Could not create Insecure RFComm Connection",e);
          }
      }
      return  device.createRfcommSocketToServiceRecord(MY_UUID);
  }

  @Override
  public void onResume() {
    super.onResume();

    Log.d(TAG, "...onResume - try connect...");
    BluetoothDevice device = btAdapter.getRemoteDevice(address);

	try {
		btSocket = createBluetoothSocket(device);
	} catch (IOException e) {
		errorExit("Fatal Error", "In onResume() and socket create failed: " + e.getMessage() + ".");
	}

    btAdapter.cancelDiscovery();

    /////////////Verbindung aufbauen//////////
    Log.d(TAG, "...Connecting...");
    try {
      btSocket.connect();
      Log.d(TAG, "....Connection ok...");
    } catch (IOException e) {
      try {
        btSocket.close();
      } catch (IOException e2) {
        errorExit("Fatal Error", "In onResume()" + e2.getMessage() + ".");
      }
    }

    //////////////Datenstrom erstellen///////////////
    Log.d(TAG, "...Create Socket...");
    mConnectedThread = new ConnectedThread(btSocket);
    mConnectedThread.start();
  }

  @Override
  public void onPause() {
    super.onPause();
      releaseMediaRecorder();          // in der Pause mediarecorder loslassen
      releaseCamera();                 // und Kamera loslassen
    Log.d(TAG, "...In onPause()...");

    try     {
      btSocket.close();
    } catch (IOException e2) {
      errorExit("Fatal Error", "In onPause() and failed to close socket." + e2.getMessage() + ".");
    }
  }

  private void checkBTState() {
    // Prüfe Bluetooth Unterstützung und prüfe ob eingeschalten
    if(btAdapter==null) {
      errorExit("Fatal Error", "Bluetooth not support");
    } else {
      if (btAdapter.isEnabled()) {
        Log.d(TAG, "...Bluetooth ON...");
      } else {
        //////Bluetooth einschalten//////
          BluetoothAdapter.getDefaultAdapter().enable();
      }
    }
  }

  private void errorExit(String title, String message){
    Toast.makeText(getBaseContext(), title + " - " + message, Toast.LENGTH_LONG).show();
    finish();
  }

//////Datenverbindung///////
  private class ConnectedThread extends Thread {
	    private final InputStream mmInStream;
	    private final OutputStream mmOutStream;

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

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

	        mmInStream = tmpIn;
	        mmOutStream = tmpOut;
	    }

	    public void run() {
	        byte[] buffer = new byte[255];  // Pufferspeicher für den Stream
	        int bytes; // ausgegebene Bytes von read()



	        //  InputStream lesen bis Fehler auftreten
	        while (true) {
	        	try {
	                // Lese InputStream
	                bytes = mmInStream.read(buffer);		// Erhalte Anzahl der Bytes und der Daten in "buffer"
                    h.obtainMessage(RECIEVE_MESSAGE, bytes, -1, buffer).sendToTarget();		// Sende zum Handler
	            } catch (IOException e) {
	                break;
	            }
	        }
	    }

	    /* aus der Main activity aufrufen für das Senden zum msp */
	    public void write(String message) {
	    	//Log.d(TAG, "...Data to send: " + message + "...");
	    	byte[] msgBuffer = message.getBytes();
	    	try {
	            mmOutStream.write(msgBuffer);
	        } catch (IOException e) {
	         //   Log.d(TAG, "...Error data send: " + e.getMessage() + "...");
	          }
	    }
	}




}