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<String> 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 && 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);}
}
I'm getting the error at the mBluetoothConnection.write(char) even though i initialized the object.
the error in the logcat is as :
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)
this is my BluetoothConnectionService class:
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);
}
}
