title: NullPointerException when i call the write() method of BluetoothConnectionService object which sends my data to arduino via blueooth
body: <pre><code>package com.example.ayushiagarwal.voice_app;
  
  import android.content.ActivityNotFoundException;
  import android.content.Context;
  import android.content.Intent;
  import android.os.Bundle;
  import android.speech.RecognizerIntent;
  import android.support.v7.app.AppCompatActivity;
  import android.text.TextUtils;
  import android.view.View;
  import android.view.View.OnClickListener;
  import android.view.ViewGroup;
  import android.widget.BaseAdapter;
  import android.widget.GridView;
  import android.widget.ImageButton;
  import android.widget.ImageView;
  import android.widget.TextView;
  
  import java.util.ArrayList;
  import java.util.Locale;
  
  /**
   * Created by Ayushi Agarwal on 6/23/2017.
   */
  
  public class Activity2 extends AppCompatActivity {
  
      private static final int REQ_CODE_SPEECH_INPUT = 100;
      private TextView mVoiceInputTv;
      private ImageButton mSpeakBtn;
      public ArrayList&lt;String&gt; result;
      public char ch;
  
      BluetoothConnectionService mBluetoothConnection;
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.voice_recognition);
  
          mVoiceInputTv = (TextView) findViewById(R.id.voiceInput);
          mSpeakBtn = (ImageButton) findViewById(R.id.btnSpeak);
          mSpeakBtn.setOnClickListener(new View.OnClickListener() {
  
              @Override
              public void onClick(View v) {
                  startVoiceInput();
              }
          });
      }
  
      private void startVoiceInput() {
          Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
          intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
          intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault());
          intent.putExtra(RecognizerIntent.EXTRA_PROMPT, "Hello, How can I help you?");
          try {
              startActivityForResult(intent, REQ_CODE_SPEECH_INPUT);
          } catch (ActivityNotFoundException a) {
  
          }
      }
  
      @Override
      protected void onActivityResult(int requestCode, int resultCode, Intent data) {
          super.onActivityResult(requestCode, resultCode, data);
  
          switch (requestCode) {
              case REQ_CODE_SPEECH_INPUT: {
                  if (resultCode == RESULT_OK &amp;&amp; null != data) {
                      result = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
  
                      mVoiceInputTv.setText(result.get(0));
  
                  }
                  break;
              }
  
          }
          String str = TextUtils.join(" ", result);
  
  
          if (str.equals("turn on") || str.equals("turn off"))
              ch = 'a';
  
          else if (str.equals("one"))
              ch = '1';
          else if (str.equals("to"))
              ch = '2';
          else if (str.equals("three"))
              ch = '3';
          else if (str.equals("four"))
              ch = '4';
          else if (str.equals("five"))
              ch = '$';
          else if (str.equals("six"))
              ch = '6';
          else if (str.equals("seven"))
              ch = '7';
          else if (str.equals("eight"))
              ch = '8';
          else if (str.equals("nine"))
              ch = '9';
          else if (str.equals("zero"))
              ch = '0';
          else if (str.equals("volume up"))
              ch = '+';
          else if (str.equals("volume down"))
              ch = '-';
          else if (str.equals("channel up"))
              ch = '^';
          else if (str.equals("channel down"))
              ch = '}';
          else if (str.equals("mute"))
              ch = 'b';
          else if (str.equals("previous channel"))
              ch = 'n';
          else if (str.equals("channel list"))
              ch = '=';
          else if (str.equals("tools"))
              ch = '/';
          else if (str.equals("info"))
              ch = 'h';
          else if (str.equals("return"))
              ch = 's';
          else if (str.equals("exit"))
              ch = 'x';
          else if (str.equals("up"))
              ch = 'y';
          else if (str.equals("down"))
              ch = 'd';
          else if (str.equals("left"))
              ch = '.';
          else if (str.equals("right"))
              ch = ',';
          else if (str.equals("select"))
              ch = 'k';
          else if (str.equals("play"))
              ch = 'o';
          else if (str.equals("pause"))
              ch = 'i';
          else if (str.equals("forward"))
              ch = ']';
          else if (str.equals("reverse"))
              ch = '[';
          else if (str.equals("menu"))
              ch = 'm';
  
          else if (str.equals("source"))
              ch = '#';
          else if (str.equals("media"))
              ch = ':';
          else if (str.equals("hdmi"))
              ch = 'g';
  
  
          // byte[] bytes = new String(ch).getBytes();
          mBluetoothConnection=new BluetoothConnectionService(Activity2.this);
          mBluetoothConnection.write(ch);}
  
      }
  </code></pre>
  
  <p>I'm getting the error at the mBluetoothConnection.write(char) even though i initialized the object.</p>
  
  <p>the error in the logcat is as :</p>
  
  <blockquote>
    <p>Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'void com.example.ayushiagarwal.voice_app.BluetoothConnectionService$ConnectedThread.write(char)' on a null object reference
                                                                                               at com.example.ayushiagarwal.voice_app.BluetoothConnectionService.write(BluetoothConnectionService.java:326)
                                                                                               at com.example.ayushiagarwal.voice_app.Activity2.onActivityResult(Activity2.java:159)</p>
  </blockquote>
  
  <p>this is my BluetoothConnectionService class:</p>
  
  <pre><code> package com.example.ayushiagarwal.voice_app;
  
  /**
   * Created by Ayushi Agarwal on 6/22/2017.
   */
  
  import android.app.ProgressDialog;
  import android.bluetooth.BluetoothAdapter;
  import android.bluetooth.BluetoothDevice;
  import android.bluetooth.BluetoothServerSocket;
  import android.bluetooth.BluetoothSocket;
  import android.content.Context;
  import android.content.Intent;
  import android.support.v4.content.LocalBroadcastManager;
  import android.util.Log;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.nio.charset.Charset;
  import java.util.UUID;
  
  /**
   * Created by User on 12/21/2016.
   */
  
  public class BluetoothConnectionService {
      private static final String TAG = "BluetoothConnectionServ";
  
      private static final String appName = "MYAPP";
  
  
      private static final UUID MY_UUID_INSECURE = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
  
      private final BluetoothAdapter mBluetoothAdapter;
      Context mContext;
  
      private AcceptThread mInsecureAcceptThread;
  
      private ConnectThread mConnectThread;
      private BluetoothDevice mmDevice;
      private UUID deviceUUID;
      ProgressDialog mProgressDialog;
  
      private ConnectedThread mConnectedThread;
      public String incomingMessage;
  
      public BluetoothConnectionService(Context context) {
          mContext = context;
          mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
          start();
      }
  
  
  
  
      /**
       * This thread runs while listening for incoming connections. It behaves
       * like a server-side client. It runs until a connection is accepted
       * (or until cancelled).
       */
      private class AcceptThread extends Thread {
  
          // The local server socket
          private final BluetoothServerSocket mmServerSocket;
  
          public AcceptThread() {
              BluetoothServerSocket tmp = null;
  
              // Create a new listening server socket
              try {
                  tmp = mBluetoothAdapter.listenUsingInsecureRfcommWithServiceRecord(appName, MY_UUID_INSECURE);
  
                  Log.d(TAG, "AcceptThread: Setting up Server using: " + MY_UUID_INSECURE);
              } catch (IOException e) {
                  Log.e(TAG, "AcceptThread: IOException: " + e.getMessage());
              }
  
              mmServerSocket = tmp;
          }
  
          public void run() {
              Log.d(TAG, "run: AcceptThread Running.");
  
              BluetoothSocket socket = null;
  
              try {
                  // This is a blocking call and will only return on a
                  // successful connection or an exception
                  Log.d(TAG, "run: RFCOM server socket start.....");
  
                  socket = mmServerSocket.accept();
  
                  Log.d(TAG, "run: RFCOM server socket accepted connection.");
  
              } catch (IOException e) {
                  Log.e(TAG, "AcceptThread: IOException: " + e.getMessage());
              }
  
              //talk about this is in the 3rd
              if (socket != null) {
                  connected(socket, mmDevice);
              }
  
              Log.i(TAG, "END mAcceptThread ");
          }
  
          public void cancel() {
              Log.d(TAG, "cancel: Canceling AcceptThread.");
              try {
                  mmServerSocket.close();
              } catch (IOException e) {
                  Log.e(TAG, "cancel: Close of AcceptThread ServerSocket failed. " + e.getMessage());
              }
          }
  
      }
  
      /**
       * This thread runs while attempting to make an outgoing connection
       * with a device. It runs straight through; the connection either
       * succeeds or fails.
       */
      private class ConnectThread extends Thread {
          private BluetoothSocket mmSocket;
  
          public ConnectThread(BluetoothDevice device, UUID uuid) {
              Log.d(TAG, "ConnectThread: started.");
              mmDevice = device;
              deviceUUID = uuid;
          }
  
          public void run() {
              BluetoothSocket tmp = null;
              Log.i(TAG, "RUN mConnectThread ");
  
              // Get a BluetoothSocket for a connection with the
              // given BluetoothDevice
              try {
                  Log.d(TAG, "ConnectThread: Trying to create InsecureRfcommSocket using UUID: "
                          + MY_UUID_INSECURE);
                  tmp = mmDevice.createRfcommSocketToServiceRecord(deviceUUID);
              } catch (IOException e) {
                  Log.e(TAG, "ConnectThread: Could not create InsecureRfcommSocket " + e.getMessage());
  
              }
  
              mmSocket = tmp;
  
              // Always cancel discovery because it will slow down a connection
              mBluetoothAdapter.cancelDiscovery();
  
              // Make a connection to the BluetoothSocket
  
              try {
                  // This is a blocking call and will only return on a
                  // successful connection or an exception
                  mmSocket.connect();
  
                  Log.d(TAG, "run: ConnectThread connected.");
              } catch (IOException e) {
                  // Close the socket
                  try {
                      Log.i(TAG, "Trying fallback...");
                      mmSocket = (BluetoothSocket) mmDevice.getClass().getMethod("createRfcommSocket", new Class[]{int.class}).invoke(mmDevice, 2);
                      mmSocket.connect();
                      Log.i(TAG, "Connected");
                  } catch (Exception e2) {
                      Log.e(TAG, "Couldn't establish Bluetooth connection!");
                      try {
                          mmSocket.close();
                          Log.d(TAG, "run: Closed Socket.");
                      } catch (IOException e3) {
                          Log.e(TAG, "mConnectThread: run: Unable to close connection in socket " + e3.getMessage());
                      }
                      Log.d(TAG, "run: ConnectThread: Could not connect to UUID: " + MY_UUID_INSECURE);
                  }
              }
              //will talk about this in the 3rd video
              connected(mmSocket, mmDevice);
  
          }
  
          public void cancel() {
              try {
                  Log.d(TAG, "cancel: Closing Client Socket.");
                  mmSocket.close();
              } catch (IOException e) {
                  Log.e(TAG, "cancel: close() of mmSocket in Connectthread failed. " + e.getMessage());
              }
          }
      }
  
  
      /**
       * Start the chat service. Specifically start AcceptThread to begin a
       * session in listening (server) mode. Called by the Activity onResume()
       */
      public synchronized void start() {
          Log.d(TAG, "start");
  
          // Cancel any thread attempting to make a connection
          if (mConnectThread != null) {
              mConnectThread.cancel();
              mConnectThread = null;
          }
          if (mInsecureAcceptThread == null) {
              mInsecureAcceptThread = new AcceptThread();
              mInsecureAcceptThread.start();
          }
      }
  
      /**
       * AcceptThread starts and sits waiting for a connection.
       * Then ConnectThread starts and attempts to make a connection with the other devices AcceptThread.
       **/
  
      public void startClient(BluetoothDevice device, UUID uuid) {
          Log.d(TAG, "startClient: Started.");
  
          //initprogress dialog
          mProgressDialog = ProgressDialog.show(mContext, "Connecting Bluetooth"
                  , "Please Wait...", true);
  
          mConnectThread = new ConnectThread(device, uuid);
          mConnectThread.start();
      }
  
      /**
       * Finally the ConnectedThread which is responsible for maintaining the BTConnection, Sending the data, and
       * receiving incoming data through input/output streams respectively.
       **/
      private class ConnectedThread extends Thread {
          private final BluetoothSocket mmSocket;
          private final InputStream mmInStream;
          private final OutputStream mmOutStream;
          public String incomingMessage;
  
          public ConnectedThread(BluetoothSocket socket) {
              Log.d(TAG, "ConnectedThread: Starting.");
  
              mmSocket = socket;
              InputStream tmpIn = null;
              OutputStream tmpOut = null;
  
              //dismiss the progressdialog when connection is established
              try {
                  mProgressDialog.dismiss();
              } catch (NullPointerException e) {
                  e.printStackTrace();
              }
  
  
              try {
                  tmpIn = mmSocket.getInputStream();
                  tmpOut = mmSocket.getOutputStream();
              } catch (IOException e) {
                  e.printStackTrace();
              }
  
              mmInStream = tmpIn;
              mmOutStream = tmpOut;
          }
  
          public void run() {
              byte[] buffer = new byte[1024];  // buffer store for the stream
  
              int bytes; // bytes returned from read()
  
              // Keep listening to the InputStream until an exception occurs
              while (true) {
                  // Read from the InputStream
                  try {
                      bytes = mmInStream.read(buffer);
                      String incomingMessage = new String(buffer, 0, bytes);
                      Log.d(TAG, "InputStream: " + incomingMessage);
                  } catch (IOException e) {
                      Log.e(TAG, "write: Error reading Input Stream. " + e.getMessage());
                      break;
                  }
              }
          }
  
          //Call this from the main activity to send data to the remote device
          public void write(char msg) {
              String text = Character.toString(msg);
              Log.d(TAG, "write: Writing to outputstream: " + text);
              try {
                  mmOutStream.write(text.getBytes());
              } catch (IOException e) {
                  Log.e(TAG, "write: Error writing to output stream. " + e.getMessage());
              }
          }
  
          /* Call this from the main activity to shutdown the connection */
          public void cancel() {
              try {
                  mmSocket.close();
              } catch (IOException e) {
              }
          }
      }
  
      private void connected(BluetoothSocket mmSocket, BluetoothDevice mmDevice) {
          Log.d(TAG, "connected: Starting.");
  
          // Start the thread to manage the connection and perform transmissions
          mConnectedThread = new ConnectedThread(mmSocket);
          mConnectedThread.start();
      }
  
      /**
       * Write to the ConnectedThread in an unsynchronized manner
       *
       * @param out The bytes to write
       * @see ConnectedThread#write(char)
       */
      public void write(char out) {
          //Create temporary object
          ConnectedThread r;
  
          //Synchronize a copy of the ConnectedThread
          Log.d(TAG, "write: Write Called.");
          //perform the write
  
          mConnectedThread.write(out);
      }
  }
  </code></pre>