android 发送消息时指针异常

zbwhf8kr  于 2024-01-04  发布在  Android
关注(0)|答案(1)|浏览(157)

我构建了Android应用程序的语音识别命令，通过嵌入式蓝牙控制设备，我使用示例代码蓝牙聊天发送语音识别结果。但我得到了这样的错误。

  1. enter FATAL EXCEPTION: main
  2. java.lang.RuntimeException: Failure delivering result ResultInfo{who=null, request=100, result=-1, data=Intent { (has extras) }} to activity {com.embox.rumahpintar/com.embox.rumahpintar.MainActivity}: java.lang.NullPointerException
  3.         at android.app.ActivityThread.deliverResults(ActivityThread.java:3378)
  4.         at android.app.ActivityThread.handleSendResult(ActivityThread.java:3421)
  5.         at android.app.ActivityThread.access$1100(ActivityThread.java:148)
  6.         at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1311)
  7.         at android.os.Handler.dispatchMessage(Handler.java:99)
  8.         at android.os.Looper.loop(Looper.java:137)
  9.         at android.app.ActivityThread.main(ActivityThread.java:5162)
  10.         at java.lang.reflect.Method.invokeNative(Native Method)
  11.         at java.lang.reflect.Method.invoke(Method.java:525)
  12.         at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:756)
  13.         at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:572)
  14.         at miui.dexspy.DexspyInstaller.main(DexspyInstaller.java:171)
  15.         at dalvik.system.NativeStart.main(Native Method)
  16.  Caused by: java.lang.NullPointerException
  17.         at com.embox.rumahpintar.MainActivity.sendMessage(MainActivity.java:102)
  18.         at com.embox.rumahpintar.MainActivity.onActivityResult(MainActivity.java:89)
  19.         at android.app.Activity.dispatchActivityResult(Activity.java:5324)
  20.         at android.app.ActivityThread.deliverResults(ActivityThread.java:3374)
  21. at android.app.ActivityThread.access$1100(ActivityThread.java:148)

字符串
这是MainActivity类：
public class MyClass {

  1. private static final String TAG = "voice";
  2. private final int REQ_CODE_SPEECH_INPUT = 100;
  3. private TextView speakInput;
  4. ArrayList<String> result;
  5. Button tapSpeak;
  7. String perintah = "hidupkan lampu kamar";
  8. BluetoothService mService = null;
  11. @Override
  12. protected void onCreate(Bundle savedInstanceState) {
  13.     super.onCreate(savedInstanceState);
  14.     setContentView(R.layout.activity_main);
  16.     if (savedInstanceState == null) {
  17.         FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
  18.         BluetoothFragment fragment = new BluetoothFragment();
  19.         transaction.replace(R.id.sample_content_fragment, fragment);
  20.         transaction.commit();
  21.     }
  22.     Toast.makeText(this, "Smart Home @Created by Akmal Fadli", Toast.LENGTH_LONG).show();
  23.     speakInput = (TextView) findViewById(R.id.speakInput);
  24.     tapSpeak = (Button) findViewById(R.id.tapSpeak);
  25.     tapSpeak.setOnClickListener(new View.OnClickListener() {
  26.         @Override
  27.         public void onClick(View v) {
  28.             Log.i(TAG, "Speak recognition open....");
  29.             promptSpeechInput();
  30.         }
  31.     });
  32. }
  34. public void promptSpeechInput() {
  35.     Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
  36.     intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
  37.             RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
  38.     intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault());
  39.     intent.putExtra(RecognizerIntent.EXTRA_PROMPT,
  40.             getString(R.string.speech_prompt));
  41.     try {
  42.         startActivityForResult(intent, REQ_CODE_SPEECH_INPUT);
  43.     } catch (ActivityNotFoundException a) {
  44.         Toast.makeText(getApplicationContext(),
  45.                 getString(R.string.speech_not_supported),
  46.                 Toast.LENGTH_SHORT).show();
  47.     }
  48. }
  50. /**
  51.  * Receiving speech input
  52.  */
  53. @Override
  54. protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  55.     super.onActivityResult(requestCode, resultCode, data);
  57.     switch (requestCode) {
  58.         case REQ_CODE_SPEECH_INPUT: {
  59.             if (resultCode == RESULT_OK && null != data) {
  61.                 result = data
  62.                         .getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
  63.                 speakInput.setText(result.get(0));
  64.                 BluetoothFragment m = new BluetoothFragment();
  65.                 if (result.contains(perintah)) {
  66.                     Toast.makeText(this, "Perintah terkirim . . .", Toast.LENGTH_LONG).show();
  67.                    sendMessage(perintah);
  68.                 }
  69.                 break;
  70.             }
  72.         }
  74.     }
  76. }
  78. private void sendMessage(String message) {
  79.     // Check that we're actually connected before trying anything
  80.     if (mService.getState() != BluetoothService.STATE_CONNECTED) {
  81.         Toast.makeText(this, R.string.not_connected, Toast.LENGTH_SHORT).show();
  82.         return;
  83.     }
  85.     // Check that there's actually something to send
  86.     if (message.length() > 0) {
  87.         // Get the message bytes and tell the BluetoothChatService to write
  88.         byte[] send = message.getBytes();
  89.         mService.write(send);
  90.     }
  91. }

型
这就是SendMessage方法：

  1. public void sendMessage(String message) {
  2.     // Check that we're actually connected before trying anything
  3.     if (mService.getState() != BluetoothService.STATE_CONNECTED) {
  4.         Toast.makeText(getActivity(), R.string.not_connected, Toast.LENGTH_SHORT).show();
  5.         return;
  6.     }
  8.     // Check that there's actually something to send
  9.     if (message.length() > 0) {
  10.         // Get the message bytes and tell the BluetoothChatService to write
  11.         byte[] send = message.getBytes();
  12.         mService.write(send);
  13.     }
  14. }

型
请给予我建议.
蓝牙服务类：

  1. public class BluetoothService {
  2. // Debugging
  3. private static final String TAG = "BluetoothChatService";
  5. // Name for the SDP record when creating server socket
  6. private static final String NAME_INSECURE = "BluetoothChatInsecure";
  8. // Unique UUID for this application
  9. private static final UUID MY_UUID_SECURE = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
  11. //UUID uuid = device.getUuids()[0].getUuid();
  12. //MY_UUID_SECURE = uuid;
  14. // Member fields
  15. private final BluetoothAdapter mAdapter;
  16. private final Handler mHandler;
  17. private AcceptThread mSecureAcceptThread;
  18. private AcceptThread mInsecureAcceptThread;
  19. private ConnectThread mConnectThread;
  20. private ConnectedThread mConnectedThread;
  21. private int mState;
  23. // Constants that indicate the current connection state
  24. public static final int STATE_NONE = 0;       // we're doing nothing
  25. public static final int STATE_LISTEN = 1;     // now listening for incoming connections
  26. public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection
  27. public static final int STATE_CONNECTED = 3;  // now connected to a remote device
  29. /**
  30.  * Constructor. Prepares a new BluetoothChat session.
  31.  *
  32.  * @param context The UI Activity Context
  33.  * @param handler A Handler to send messages back to the UI Activity
  34.  */
  35. public BluetoothService(Context context, Handler handler) {
  36.     mAdapter = BluetoothAdapter.getDefaultAdapter();
  37.     mState = STATE_NONE;
  38.     mHandler = handler;
  39. }
  41. /**
  42.  * Set the current state of the chat connection
  43.  *
  44.  * @param state An integer defining the current connection state
  45.  */
  46. private synchronized void setState(int state) {
  47.     Log.d(TAG, "setState() " + mState + " -> " + state);
  48.     mState = state;
  50.     // Give the new state to the Handler so the UI Activity can update
  51.     mHandler.obtainMessage(Constants.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
  52. }
  54. /**
  55.  * Return the current connection state.
  56.  */
  57. public synchronized int getState() {
  58.     return mState;
  59. }
  61. /**
  62.  * Start the chat service. Specifically start AcceptThread to begin a
  63.  * session in listening (server) mode. Called by the Activity onResume()
  64.  */
  65. public synchronized void start() {
  66.     Log.d(TAG, "start");
  68.     // Cancel any thread attempting to make a connection
  69.     if (mConnectThread != null) {
  70.         mConnectThread.cancel();
  71.         mConnectThread = null;
  72.     }
  74.     // Cancel any thread currently running a connection
  75.     if (mConnectedThread != null) {
  76.         mConnectedThread.cancel();
  77.         mConnectedThread = null;
  78.     }
  80.     setState(STATE_LISTEN);
  82.     // Start the thread to listen on a BluetoothServerSocket
  83.     if (mSecureAcceptThread == null) {
  84.         mSecureAcceptThread = new AcceptThread(true);
  85.         mSecureAcceptThread.start();
  86.     }
  87.     if (mInsecureAcceptThread == null) {
  88.         mInsecureAcceptThread = new AcceptThread(false);
  89.         mInsecureAcceptThread.start();
  90.     }
  91. }
  93. /**
  94.  * Start the ConnectThread to initiate a connection to a remote device.
  95.  *
  96.  * @param device The BluetoothDevice to connect
  97.  *
  98.  */
  99. public synchronized void connect(BluetoothDevice device) {
  100.     Log.d(TAG, "connect to: " + device);
  101.     mAdapter.cancelDiscovery();
  102.     // Cancel any thread attempting to make a connection
  103.     if (mState == STATE_CONNECTING) {
  104.         if (mConnectThread != null) {
  105.             mConnectThread.cancel();
  106.             mConnectThread = null;
  107.         }
  108.     }
  110.     // Cancel any thread currently running a connection
  111.     if (mConnectedThread != null) {
  112.         mConnectedThread.cancel();
  113.         mConnectedThread = null;
  114.     }
  116.     // Start the thread to connect with the given device
  117.     mConnectThread = new ConnectThread(device);
  118.     mConnectThread.start();
  119.     setState(STATE_CONNECTING);
  120. }
  122. /**
  123.  * Start the ConnectedThread to begin managing a Bluetooth connection
  124.  *
  125.  * @param socket The BluetoothSocket on which the connection was made
  126.  * @param device The BluetoothDevice that has been connected
  127.  */
  128. public synchronized void connected(BluetoothSocket socket, BluetoothDevice
  129.         device) {
  130.    // Log.d(TAG, "connected, Socket Type:" + socketType);
  132.     // Cancel the thread that completed the connection
  133.     if (mConnectThread != null) {
  134.         mConnectThread.cancel();
  135.         mConnectThread = null;
  136.     }
  138.     // Cancel any thread currently running a connection
  139.     if (mConnectedThread != null) {
  140.         mConnectedThread.cancel();
  141.         mConnectedThread = null;
  142.     }
  144.     // Cancel the accept thread because we only want to connect to one device
  145.     if (mSecureAcceptThread != null) {
  146.         mSecureAcceptThread.cancel();
  147.         mSecureAcceptThread = null;
  148.     }
  149.     if (mInsecureAcceptThread != null) {
  150.         mInsecureAcceptThread.cancel();
  151.         mInsecureAcceptThread = null;
  152.     }
  154.     // Start the thread to manage the connection and perform transmissions
  155.     mConnectedThread = new ConnectedThread(socket);
  156.     mConnectedThread.start();
  157.     String konek = "Device connected...";
  158.     byte[] pesan = konek.getBytes();
  159.     mConnectedThread.write(pesan);
  161.     // Send the name of the connected device back to the UI Activity
  162.     Message msg = mHandler.obtainMessage(Constants.MESSAGE_DEVICE_NAME);
  163.     Bundle bundle = new Bundle();
  164.     bundle.putString(Constants.DEVICE_NAME, device.getName());
  165.     msg.setData(bundle);
  166.     mHandler.sendMessage(msg);
  168.     setState(STATE_CONNECTED);
  169. }
  171. /**
  172.  * Stop all threads
  173.  */
  174. public synchronized void stop() {
  175.     Log.d(TAG, "stop");
  177.     if (mConnectThread != null) {
  178.         mConnectThread.cancel();
  179.         mConnectThread = null;
  180.     }
  182.     if (mConnectedThread != null) {
  183.         mConnectedThread.cancel();
  184.         mConnectedThread = null;
  185.     }
  187.     if (mSecureAcceptThread != null) {
  188.         mSecureAcceptThread.cancel();
  189.         mSecureAcceptThread = null;
  190.     }
  192.     if (mInsecureAcceptThread != null) {
  193.         mInsecureAcceptThread.cancel();
  194.         mInsecureAcceptThread = null;
  195.     }
  196.     setState(STATE_NONE);
  197. }
  199. /**
  200.  * Write to the ConnectedThread in an unsynchronized manner
  201.  *
  202.  * @param out The bytes to write
  203.  * @see ConnectedThread#write(byte[]) (java.lang.String)
  204.  */
  205. public void write(byte[] out) {
  206.     // Create temporary object
  207.     ConnectedThread r;
  208.     // Synchronize a copy of the ConnectedThread
  209.     synchronized (this) {
  210.         if (mState != STATE_CONNECTED) return;
  211.         r = mConnectedThread;
  212.     }
  213.     // Perform the write unsynchronized
  214.     r.write(out);
  215. }
  217. /**
  218.  * Indicate that the connection attempt failed and notify the UI Activity.
  219.  */
  220. private void connectionFailed() {
  221.     // Send a failure message back to the Activity
  222.     Message msg = mHandler.obtainMessage(Constants.MESSAGE_TOAST);
  223.     Bundle bundle = new Bundle();
  224.     bundle.putString(Constants.TOAST, "Unable to connect device");
  225.     msg.setData(bundle);
  226.     mHandler.sendMessage(msg);
  228.     // Start the service over to restart listening mode
  229.    // BluetoothService.this.start();
  230. }
  232. /**
  233.  * Indicate that the connection was lost and notify the UI Activity.
  234.  */
  235. private void connectionLost() {
  236.     // Send a failure message back to the Activity
  237.     Message msg = mHandler.obtainMessage(Constants.MESSAGE_TOAST);
  238.     Bundle bundle = new Bundle();
  239.     bundle.putString(Constants.TOAST, "Device connection was lost");
  240.     msg.setData(bundle);
  241.     mHandler.sendMessage(msg);
  243.     // Start the service over to restart listening mode
  244.     //BluetoothService.this.start();
  245. }
  247. /**
  248.  * This thread runs while listening for incoming connections. It behaves
  249.  * like a server-side client. It runs until a connection is accepted
  250.  * (or until cancelled).
  251.  */
  252. private class AcceptThread extends Thread {
  253.     // The local server socket
  254.     private final BluetoothServerSocket mmServerSocket;
  255.     private String mSocketType;
  257.     public AcceptThread(boolean secure) {
  258.         BluetoothServerSocket tmp = null;
  259.         mSocketType = secure ? "Secure" : "Insecure";
  261.         // Create a new listening server socket
  262.         try {
  264.                 tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(
  265.                         NAME_INSECURE, MY_UUID_SECURE);
  267.         } catch (IOException e) {
  268.             Log.e(TAG, "Socket Type: " + mSocketType + "listen() failed", e);
  269.         }
  270.         mmServerSocket = tmp;
  271.     }
  273.     public void run() {
  274.         Log.d(TAG, "Socket Type: " + mSocketType +
  275.                 "BEGIN mAcceptThread" + this);
  276.         setName("AcceptThread" + mSocketType);
  278.         BluetoothSocket socket = null;
  280.         // Listen to the server socket if we're not connected
  281.         while (mState != STATE_CONNECTED) {
  282.             try {
  283.                 // This is a blocking call and will only return on a
  284.                 // successful connection or an exception
  285.                 socket = mmServerSocket.accept();
  286.             } catch (IOException e) {
  287.                 Log.e(TAG, "Socket Type: " + mSocketType + "accept() failed", e);
  288.                 break;
  289.             }
  291.             // If a connection was accepted
  292.             if (socket != null) {
  293.                 synchronized (BluetoothService.this) {
  294.                     switch (mState) {
  295.                         case STATE_LISTEN:
  296.                         case STATE_CONNECTING:
  297.                             // Situation normal. Start the connected thread.
  298.                             connected(socket, socket.getRemoteDevice());
  299.                             break;
  300.                         case STATE_NONE:
  301.                         case STATE_CONNECTED:
  302.                             // Either not ready or already connected. Terminate new socket.
  303.                             try {
  304.                                 socket.close();
  305.                             } catch (IOException e) {
  306.                                 Log.e(TAG, "Could not close unwanted socket", e);
  307.                             }
  308.                             break;
  309.                     }
  310.                 }
  311.             }
  312.         }
  313.         Log.i(TAG, "END mAcceptThread, socket Type: " + mSocketType);
  315.     }
  317.     public void cancel() {
  318.         Log.d(TAG, "Socket Type" + mSocketType + "cancel " + this);
  319.         try {
  320.             mmServerSocket.close();
  321.         } catch (IOException e) {
  322.             Log.e(TAG, "Socket Type" + mSocketType + "close() of server failed", e);
  323.         }
  324.     }
  325. }
  327. /**
  328.  * This thread runs while attempting to make an outgoing connection
  329.  * with a device. It runs straight through; the connection either
  330.  * succeeds or fails.
  331.  */
  332. private class ConnectThread extends Thread {
  333.     private final BluetoothSocket mmSocket;
  334.     private final BluetoothDevice mmDevice;
  336.     public ConnectThread(BluetoothDevice device) {
  337.         mmDevice = device;
  338.         BluetoothSocket tmp = null;
  339.        // mSocketType = secure ? "Secure" : "Insecure";
  341.         // Get a BluetoothSocket for a connection with the
  342.         // given BluetoothDevice
  343.         try {
  344.                tmp = device.createRfcommSocketToServiceRecord(
  345.                        MY_UUID_SECURE);
  346.         } catch (IOException e) {
  347.             Log.e(TAG, "Socket Type: " + "create() failed", e);
  348.         }
  349.         mmSocket = tmp;
  350.     }
  352.     public void run() {
  355.         // Always cancel discovery because it will slow down a connection
  356.         mAdapter.cancelDiscovery();
  358.         // Make a connection to the BluetoothSocket
  359.         try {
  360.             // This is a blocking call and will only return on a
  361.             // successful connection or an exception
  363.                 mmSocket.connect();
  365.         } catch (IOException e) {
  366.             // Close the socket
  367.             try {
  368.                 mmSocket.close();
  369.             } catch (IOException e2) {
  370.                 Log.e(TAG, "unable to close() " +
  371.                         " socket during connection failure", e2);
  372.             }
  373.             connectionFailed();
  374.             return;
  375.         }
  377.         // Reset the ConnectThread because we're done
  378.         synchronized (BluetoothService.this) {
  379.             mConnectThread = null;
  380.         }
  382.         // Start the connected thread
  383.         connected(mmSocket, mmDevice);
  384.     }
  386.     public void cancel() {
  387.         try {
  388.             mmSocket.close();
  389.         } catch (IOException e) {
  390.             Log.e(TAG, "close() of connect " + " socket failed", e);
  391.         }
  392.     }
  393. }
  395. /**
  396.  * This thread runs during a connection with a remote device.
  397.  * It handles all incoming and outgoing transmissions.
  398.  */
  399. //public class dulunya private
  400. private class ConnectedThread extends Thread {
  401.     private final BluetoothSocket mmSocket;
  402.     private final InputStream mmInStream;
  403.     private final OutputStream mmOutStream;
  405.     public ConnectedThread(BluetoothSocket socket) {
  406.        // Log.d(TAG, "create ConnectedThread: " + socketType);
  407.         mmSocket = socket;
  408.         InputStream tmpIn = null;
  409.         OutputStream tmpOut = null;
  411.         // Get the BluetoothSocket input and output streams
  412.         try {
  413.             tmpIn = socket.getInputStream();
  414.             tmpOut = socket.getOutputStream();
  415.         } catch (IOException e) {
  416.             Log.e(TAG, "temp sockets not created", e);
  417.         }
  419.         mmInStream = tmpIn;
  420.         mmOutStream = tmpOut;
  421.     }
  423.     public void run() {
  424.         Log.i(TAG, "BEGIN mConnectedThread");
  425.         byte[] buffer = new byte[1024];
  426.         int bytes;
  428.         // Keep listening to the InputStream while connected
  429.         while (true) {
  430.             try {
  431.                 // Read from the InputStream
  432.                 bytes = mmInStream.read(buffer);
  434.                 // Send the obtained bytes to the UI Activity
  435.                 mHandler.obtainMessage(Constants.MESSAGE_READ, bytes, -1, buffer)
  436.                         .sendToTarget();
  437.             } catch (IOException e) {
  438.                 Log.e(TAG, "disconnected", e);
  439.                 connectionLost();
  440.                 // Start the service over to restart listening mode
  441.                 BluetoothService.this.start();
  442.                 break;
  443.             }
  444.         }
  445.     }
  447.     /**
  448.      * Write to the connected OutStream.
  449.      *
  450.      * @param buffer The bytes to write
  451.      */
  452.     public void write(byte[] buffer) {
  453.         try {
  454.             mmOutStream.write(buffer);
  456.             // Share the sent message back to the UI Activity
  457.             mHandler.obtainMessage(Constants.MESSAGE_WRITE, -1, -1, buffer)
  458.                     .sendToTarget();
  459.         } catch (IOException e) {
  460.             Log.e(TAG, "Exception during write", e);
  461.         }
  462.     }
  464.     public void cancel() {
  465.         try {
  466.             mmSocket.close();
  467.         } catch (IOException e) {
  468.             Log.e(TAG, "close() of connect socket failed", e);
  469.         }
  470.     }
  471. }

型
解决了，我修改了我的代码到一个活动（MainActivity.class），所以我把蓝牙服务移动到MainActivity。

android

1条答案

按热度按时间
nzkunb0c

nzkunb0c1#

你从来没有初始化kirimPesan，所以它有null值。所以你有NullPointerException（异常告诉你什么是null）。
在发送消息之前，你需要用构造函数初始化kirimPesan。
或者，你可以把方法sendMessage放在你自己的类MainActivity中，那么你就根本不需要kirimPesan对象了。

赞(0）分享  回复(0）举报  2024-01-04
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com