Android蓝牙发送/接收hashmap

Question

I'm trying to send a hashmap from one device to another via bluetooth. I'm creating the hashmap like this, and then calling the connection threads writeObject method:

Map<String,String> subInfo = new HashMap<>();
subInfo.put("type", "subInfo");
subInfo.put("num", "1");
BTService.connectedThread.writeObject(subInfo);

My bluetooth service has the following class thats used to handle data transfer between devices in a background thread:

public static class ConnectedThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final InputStream mmInStream;
        private final OutputStream mmOutStream;
        private final ObjectInputStream mmObjInStream;
        private final ObjectOutputStream mmObjOutStream;

        public ConnectedThread(BluetoothSocket socket) {
            mmSocket = socket;
            InputStream tmpIn = null;
            OutputStream tmpOut = null;
            ObjectInputStream tmpObjIn = null;
            ObjectOutputStream tmpObjOut = null;

            // Get the input and output streams, using temp objects because
            // member streams are final
            try {
                tmpIn = socket.getInputStream();
                tmpOut = socket.getOutputStream();
                tmpObjIn = new ObjectInputStream(socket.getInputStream());
                tmpObjOut = new ObjectOutputStream(socket.getOutputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }

            mmInStream = tmpIn;
            mmOutStream = tmpOut;
            mmObjInStream = tmpObjIn;
            mmObjOutStream = tmpObjOut;
        }

        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 (!this.isInterrupted()) {
                try {
                    // Read from the InputStream
                    bytes = mmInStream.read(buffer);
                    // Send the obtained bytes to the UI activity
                    mHandler.obtainMessage(Constants.MESSAGE_READ, bytes, -1, buffer)
                            .sendToTarget();
                } catch (IOException e) {
                    e.printStackTrace();
                    break;
                }

                try {
                    //Read objects from ObjectInputStream
                    Object object = mmObjInStream.readObject();
                    // Send the obtained object to the UI activity
                    mHandler.obtainMessage(Constants.MESSAGE_READ_OBJECT, -1, 0, object)
                            .sendToTarget();
                } catch (ClassNotFoundException | IOException e) {
                    e.printStackTrace();
                }
            }
        }

        /* Call this from the main activity to send data to the remote device */
        public void write(byte[] bytes) {
            try {
                mmOutStream.write(bytes);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        public void writeObject(Object object) {
            try {
                mmObjOutStream.writeObject(object);
            }catch(Exception e){
                Log.e(TAG, "Error ObjectOutputStream: " + e.getLocalizedMessage());
            }
        }

        /* Call this from the main activity to shutdown the connection */
        public void cancel() {
            try {
                mmSocket.close();
                this.interrupt();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

So when I call the writeObject method it should send the object down the Object output stream of the thread above.

On the other device, the code is similar. It just listens on the Object input stream for an object, once it has been found it sends a MESSAGE_READ_OBJECT message to my message handler in the main activity:

static class MessageHandler extends Handler {
        private final WeakReference<MainActivity> mActivity;

        MessageHandler(MainActivity activity) {
            mActivity = new WeakReference<>(activity);
        }
        @Override
        public void handleMessage(Message msg)
        {
            final MainActivity mainActivity = mActivity.get();
            if (mainActivity == null) {
                return;
            }
            switch(msg.what){

                case Constants.MESSAGE_READ_OBJECT:
                    Object receivedObject = msg.obj;

                    //How should I pull out the hashmap here?

                    switch(type){
                        case "subInfo":
                            //do some things
                            break;
                    }
                    break;
            }
        }
    }

What is the correct way to reassemble the hashmap in my message handler? I need to check the "type" key of the map and switch based on that, but as of right now I'm not sure how to get the map object back. The receivedObject object in my message handler doesn't seem to behave like a hashmap, and doesn't have the typical methods used for pulling out keys and values

Furthermore, instead of sending a generic Object over bluetooth, would it make more sense to directly send a Map type object?

Answer 1

Just direct convert

HashMap mHashmap = (HashMap) obj;

this is what I do , https://github.com/zhenbeiju/AndroidCommonUtil/blob/master/app/src/main/java/commanutil/utl/file/ObjUtil.java

useage: https://coding.net/u/zhenbeiju/p/javanlp_/git/blob/master/src/com/voice/common/util/nlp/Main.java