Android bluetooth envoyer/recevoir un hashmap

Question

J'essaie d'envoyer un hashmap d'un appareil à un autre via bluetooth. Je crée le hashmap comme celui-ci, puis d'appeler les fils de connexion writeObject méthode:

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

Mon service bluetooth a les thats classe suivants utilisés pour gérer le transfert de données entre les périphériques dans un thread d'arrière-plan:

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(); 
      } 
     } 
    } 

Ainsi, lorsque j'appelle la méthode writeObject, il doit envoyer l'objet dans le flux de sortie Objet du thread ci-dessus.

Sur l'autre périphérique, le code est similaire. Il écoute seulement sur le flux d'entrée d'objet pour un objet, une fois qu'il a été trouvé il envoie un message MESSAGE_READ_OBJECT à mon gestionnaire de messages dans l'activité principale:

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; 
      } 
     } 
    } 

Quelle est la bonne façon de remonter le hashmap dans mon message gestionnaire? J'ai besoin de vérifier la clé "type" de la carte et de changer en fonction de cela, mais pour le moment, je ne suis pas sûr de savoir comment récupérer l'objet de la carte. L'objet receivedObject dans mon gestionnaire de message ne semble pas se comporter comme un hashmap, et n'a pas les méthodes typiques utilisées pour extraire les clés et les valeurs

En outre, au lieu d'envoyer un Object générique sur bluetooth, ferait-il plus de sens pour envoyer directement un objet de type Map?

Answer 1

Il suffit de diriger convertir

HashMap mHashmap = (HashMap) obj;

ce que je fais, 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