Android: Bluetooth-Klasse durch andere Klasse aufrufen

package com.example.bluetooth1;


import android.app.Activity;
import android.app.Service;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothSocket;
import android.content.Intent;
import android.os.*;
import android.os.Process;
import android.widget.Toast;
import java.io.OutputStream;
import java.util.UUID;
import java.io.IOException;
import java.lang.reflect.Method;
import android.bluetooth.BluetoothDevice;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;






public class Hintergrund extends Service {


    private static final String TAG = "bluetooth1";
    private Looper mServiceLooper;
    private ServiceHandler mServiceHandler;


    @Override
    public void onCreate() {
        // To avoid cpu-blocking, we create a background handler to run our service
        HandlerThread thread = new HandlerThread("TutorialService",
                Process.THREAD_PRIORITY_BACKGROUND);
        // start the new handler thread
        thread.start();


        mServiceLooper = thread.getLooper();
        // start the service using the background handler
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Toast.makeText(this, "onStartCommand", Toast.LENGTH_SHORT).show();


        // call a new service handler. The service ID can be used to identify the service
        Message message = mServiceHandler.obtainMessage();
        message.arg1 = startId;
        mServiceHandler.sendMessage(message);


        return START_STICKY;
    }


    protected void showToast(final String msg){
        //gets the main thread
        Handler handler = new Handler(Looper.getMainLooper());
        handler.post(new Runnable() {
            @Override
            public void run() {
                // run this code in the main thread
                Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_SHORT).show();
            }
        });
    }


    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }


    // Object responsible for
    private final class ServiceHandler extends Handler {


        public ServiceHandler(Looper looper) {
            super(looper);
        }


        @Override
        public void handleMessage(Message msg) {
           Blauzahn bl1=new Blauzahn();
            bl1.sendData("DIESEN TEXT WILL ICH SENDEN");
        }






        public class Blauzahn extends Activity
        {


            private static final String TAG = "bluetooth1";


            //Bluetooth Adapter Initialisierung
            private BluetoothAdapter btAdapter = null;
            private BluetoothSocket btSocket = null;
            private OutputStream outStream = null;


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


            // MAC-address von unserem Bluetooth modul
            private String address = "98:D3:31:FB:6C:B2";


            //Wird beim ersten Start aaufgerufen
            @Override
            public void onCreate(Bundle savedInstanceState)
            {
                super.onCreate(savedInstanceState);


                //checkt, ob Bluetooth am Gerät aktiviert ist
                btAdapter = BluetoothAdapter.getDefaultAdapter();
                checkBTState();


            }


            //Bluetooth-hardware check
            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);
            }




            //Bluetooth verbindungsaufbau
            @Override
            public void onResume()
            {
                super.onResume();


                Log.d(TAG, "...onResume - try connect...");


                BluetoothDevice device = btAdapter.getRemoteDevice(address);
                try
                {
                    btSocket = createBluetoothSocket(device);
                }
                catch (IOException e1)
                {
                    errorExit("Fatal Error", "In onResume() and socket create failed: " + e1.getMessage() + ".");
                }
                // Verbindungsaufbau-blockiert, bis verbunden
                btAdapter.cancelDiscovery();


                //Data-Stream wird erstellt um Verbindungsaufbau zum Server durchzusetzen
                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() and unable to close socket during connection failure" + e2.getMessage() + ".");
                    }
                }




                Log.d(TAG, "...Create Socket...");


                try
                {
                    outStream = btSocket.getOutputStream();
                } catch (IOException e)
                {
                    errorExit("Fatal Error", "In onResume() and output stream creation failed:" + e.getMessage() + ".");
                }
            }


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


                Log.d(TAG, "...In onPause()...");


                if (outStream != null)
                {
                    try
                    {
                        outStream.flush();
                    }
                    catch (IOException e)
                    {
                        errorExit("Fatal Error", "In onPause() and failed to flush output stream: " + e.getMessage() + ".");
                    }
                }


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


            //Überprüft Bluetooth Zustand
            private void checkBTState()
            {
                if(btAdapter==null)
                {
                    errorExit("Fatal Error", "Bluetooth not support");
                }
                else
                {
                    if (btAdapter.isEnabled())
                    {
                        Log.d(TAG, "...Bluetooth ON...");
                    }
                    else
                    {
                        //Zeigt an, dass Bluetooth angeschaltet werden muss
                        Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                        startActivityForResult(enableBtIntent, 1);
                    }
                }
            }


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


            //Methode um Daten über Bluetooth zu senden
            public void sendData(String message)
            {
                byte[] msgBuffer = message.getBytes();


                Log.d(TAG, "...Send data: " + message + "...");


                try
                {
                    outStream.write(msgBuffer);
                }
                catch (IOException e)
                {
                    String msg = "In onResume() and an exception occurred during write: " + e.getMessage();
                    if (address.equals("00:00:00:00:00:00"))
                        msg = msg + ".\n\nUpdate your server address from 00:00:00:00:00:00 to the correct address on line 35 in the java code";
                    msg = msg +  ".\n\nCheck that the SPP UUID: " + MY_UUID.toString() + " exists on server.\n\n";


                    errorExit("Fatal Error", msg);
                }
            }
        }
    }
}