private  void listenToSocket() throws IOException {
        LocalSocket socket =  null;
    Slog.w(TAG,String.format( " NativeDaemonConnector--->listenToSocket:start "));
         try {
            socket =  new LocalSocket();
             LocalSocketAddress address = new LocalSocketAddress(mSocket,

                    LocalSocketAddress.Namespace.RESERVED);

            socket.connect(address);

            InputStream inputStream = socket.getInputStream();
            mOutputStream = socket.getOutputStream();

            mCallbacks.onDaemonConnected();

             byte[] buffer =  new  byte[BUFFER_SIZE];
             int start =  0;

             while ( true) {
                 int count = inputStream.read(buffer, start, BUFFER_SIZE - start);
                 if (count <  0)  break;

                 //  Add our starting point to the count and reset the start.

                count += start;
                start =  0;

                 for ( int i =  0; i < count; i++) {
                     if (buffer[i] ==  0) {
                         String event = new String(buffer, start, i - start);//解析socket 的数据并获取event
                         if (LOCAL_LOGD) Slog.d(TAG, String.format( " RCV <- {%s} ",  event));

                        String[] tokens =  event.split( "   ",  2);
                         try {
                             int code = Integer.parseInt(tokens[ 0]);

                             if (code >= ResponseCode.UnsolicitedInformational) {
                                mCallbackHandler.sendMessage(
                                        mCallbackHandler.obtainMessage(code,  event));//发送消息给handler
                            }  else {
                                 try {
                                    mResponseQueue.put( event);
                                }  catch (InterruptedException ex) {
                                    Slog.e(TAG,  " Failed to put response onto queue ", ex);
                                }
                            }
                        }  catch (NumberFormatException nfe) {
                            Slog.w(TAG, String.format( " Bad msg (%s) ",  event));
                        }
                        start = i +  1;
                    }
                }

                 //  We should end at the amount we read. If not, compact then

                 //  buffer and read again.

                 if (start != count) {
                    final  int remaining = BUFFER_SIZE - start;
                    System.arraycopy(buffer, start, buffer,  0, remaining);
                    start = remaining;
                }  else {
                    start =  0;
                }
            }
        }  catch (IOException ex) {
            Slog.e(TAG,  " Communications error ", ex);
             throw ex;
        }  finally {
            synchronized (mDaemonLock) {
                 if (mOutputStream !=  null) {
                     try {
                        mOutputStream.close();
                    }  catch (IOException e) {
                        Slog.w(TAG,  " Failed closing output stream ", e);
                    }
                    mOutputStream =  null;
                }
            }

             try {
                 if (socket !=  null) {
                    socket.close();
                }
            }  catch (IOException ex) {
                Slog.w(TAG,  " Failed closing socket ", ex);
            }
        }
    } 

  public boolean handleMessage(Message msg) {
        String  event = (String) msg.obj;
        Slog.w(TAG,String.format( " NativeDaemonConnector--->handleMessage the event value is  "+ event));
         try {
             if (! mCallbacks.onEvent(msg.what, event, event.split(" "))) {
                Slog.w(TAG, String.format(
                         " Unhandled event '%s' ",  event));
            }
        }  catch (Exception e) {
            Slog.e(TAG, String.format(
                     " Error handling '%s' ",  event), e);
        }
         return  true;
    }