Java 将音频缓冲区传递给UDP时发生NullPointerException

//UDP流线程

private AudioRecord.OnRecordPositionUpdateListener updateListener = new AudioRecord.OnRecordPositionUpdateListener() {

        @Override
        public void onPeriodicNotification(AudioRecord recorder) {
            // TODO Auto-generated method stub
            if (State.STOPPED == state) {
                Log.d(PcmRecord.this.getClass().getName(), "Recorder Stopped");
                return;
            }       

                audioRecorder.read(buffer, 0, buffer.length);

                try {               

                            mService.write(buffer);
                            if(D) Log.i(TAG,"Push Buffer to UDP  : "+buffer.length);    


                            mOutputStream.write(buffer);        
                            if(D) Log.i(TAG,"Write Buffer to FILE: " + buffer.length);  

                }catch (IOException e) {
                    Log.e(PcmRecord.class.getName(),"Error occured in UPDATELISTENER, RECORDING ABORTED");
                    e.printStackTrace();
                }       

        }

        @Override
        public void onMarkerReached(AudioRecord recorder) {
            // TODO Auto-generated method stub

        }
    };

/*
*流线程
* 
*/
公共类UdpClient扩展线程{
公共UdpClient（）{
超级（“流音频”）；
}
专用静态最终int端口=2562；
专用数据包；
私有DatagramSocket-mSocket；
私有地址myBcastIP；
公共无效写入（字节[]输出）{
用完；
}
公共无效运行（字节[]缓冲区）{
试试{
myBcastIP=getBroadcastAddress（）；
Log.d（标签“My Bcast IP:+myBcastIP”）；
//myLocalIP=getLocalAddress（）；
数据包=新数据包（缓冲区、缓冲区长度、myBcastIP、端口）；
mSocket.send（数据包）；
Log.d（标记“发送响应：”+packet.getLength（））；
睡眠（20）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
捕获（IOE异常）{
e、 printStackTrace（）；
}           
}   
}
//获取广播地址
私有InetAddress getBroadcastAddress（）引发IOException{
WifiManager mWifi=（WifiManager）getSystemService（Context.WIFI_服务）；
WifiInfo=mWifi.getConnectionInfo（）；
Log.d（标记“\n\nWifi状态：”+info.toString（））；
DhcpInfo dhcp=mWifi.getDhcpInfo（）；
如果（dhcp==null）{
Log.d（标记“无法获取dhcp信息”）；
返回null；
}
int broadcast=（dhcp.ipAddress&dhcp.netmask）|~dhcp.netmask；
字节[]四元组=新字节[4]；
对于（int k=0；k<4；k++）
四元组[k]=（字节）（（广播>>k*8）和0xFF）；
返回InetAddress.getByAddress（quads）；
}
//玩线
公共类UdpServer扩展线程{
公共UdpServer（）{
超级（“接收线程”）；
}
专用静态最终int端口=2562；
私有DatagramSocket-mSocket；
私有地址myLocalIP；
字节[]缓冲区=新字节[2048]；
公开募捐{
试一试{
myLocalIP=getLocalAddress（）；
Log.d（标记“我的本地IP:+myLocalIP”）；
mSocket=新的DatagramSocket（端口）；
mSocket.setboodcast（真）；
DatagramPacket数据包=新的DatagramPacket（Buffer，Buffer.length）；
虽然（正确）{
mSocket.receive（数据包）；
InetAddress remoteIP=packet.getAddress（）；
if（remoteIP.equals（myLocalIP））
继续；
byte[]data=packet.getData（）；
Log.d（标记“接收到的响应：”+数据长度）；
睡眠（25）；
}               
}捕捉（中断异常e）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}           
}
}
//获取本地地址
私有InetAddress getLocalAddress（）引发IOException{
试一试{
对于（枚举en=NetworkInterface.getNetworkInterfaces（）；en.hasMoreElements（）；）{
NetworkInterface intf=en.nextElement（）；
对于（枚举Enumeration EnumipAddress=intf.getInetAddresses（）；EnumipAddress.hasMoreElements（）；）{
InetAddress InetAddress=enumIpAddr.nextElement（）；
如果（！inetAddress.isLoopbackAddress（））{
返回地址；
}
}
}
}捕获（SocketException例外）{
Log.e（Tag，例如toString（））；
}
返回null；
}

getSystemService（）在哪里实现？它位于getBroadcastAddress（）中

private AudioRecord.OnRecordPositionUpdateListener updateListener = new AudioRecord.OnRecordPositionUpdateListener() {

        @Override
        public void onPeriodicNotification(AudioRecord recorder) {
            // TODO Auto-generated method stub
            if (State.STOPPED == state) {
                Log.d(PcmRecord.this.getClass().getName(), "Recorder Stopped");
                return;
            }       

                audioRecorder.read(buffer, 0, buffer.length);

                try {               

                            mService.write(buffer);
                            if(D) Log.i(TAG,"Push Buffer to UDP  : "+buffer.length);    


                            mOutputStream.write(buffer);        
                            if(D) Log.i(TAG,"Write Buffer to FILE: " + buffer.length);  

                }catch (IOException e) {
                    Log.e(PcmRecord.class.getName(),"Error occured in UPDATELISTENER, RECORDING ABORTED");
                    e.printStackTrace();
                }       

        }

        @Override
        public void onMarkerReached(AudioRecord recorder) {
            // TODO Auto-generated method stub

        }
    };

    /*
 * Stream Thread
 * 
 */

public class UdpClient extends Thread{

    public UdpClient(){
        super("STREAM AUDIO");
    }


    private static final int PORT = 2562;

    private DatagramPacket packet;

    private DatagramSocket mSocket;

    private InetAddress myBcastIP;


    public void write(byte[] out){
        run(out);
    }

    public void run(byte[] Buffer){

        try{        

            myBcastIP = getBroadcastAddress();

            Log.d(Tag,"My Bcast IP: "+myBcastIP);
            //myLocalIP = getLocalAddress();

            packet = new DatagramPacket(Buffer,Buffer.length,myBcastIP, PORT);

            mSocket.send(packet);

            Log.d(Tag,"Send Response: " + packet.getLength());

            Thread.sleep(20);

        }catch(InterruptedException e){

            e.printStackTrace();

        }
    catch(IOException e){

            e.printStackTrace();

        }           

    }   



}


//Get Broadcast Address

        private InetAddress getBroadcastAddress() throws IOException {

            WifiManager mWifi = (WifiManager) getSystemService(Context.WIFI_SERVICE);

            WifiInfo info = mWifi.getConnectionInfo();

            Log.d(Tag,"\n\nWifi Status: "+ info.toString());


            DhcpInfo dhcp = mWifi.getDhcpInfo();

            if(dhcp == null) {

                Log.d(Tag,"Could not get dhcp info");

                return null;

            }

            int broadcast = (dhcp.ipAddress & dhcp.netmask) | ~dhcp.netmask;

            byte[] quads = new byte [4];

            for (int k=0 ; k < 4 ; k++)

                quads [k] = (byte) ((broadcast >> k * 8) & 0xFF);           

            return InetAddress.getByAddress(quads);
        }




//Play Thread


public class UdpServer extends Thread{

    public UdpServer(){
        super("Receiving Thread");
    }


    private static final int PORT = 2562;

    private DatagramSocket mSocket;

    private InetAddress myLocalIP;

    byte[] Buffer = new byte[2048];

    public void run(){
        try{

            myLocalIP = getLocalAddress();

            Log.d(Tag,"My Local IP: "+myLocalIP);


            mSocket = new DatagramSocket(PORT);

            mSocket.setBroadcast(true); 

            DatagramPacket packet = new DatagramPacket(Buffer,Buffer.length);

            while(true){                


                mSocket.receive(packet);

                InetAddress remoteIP = packet.getAddress();

                if(remoteIP.equals(myLocalIP))
                    continue;

                byte[] data = packet.getData();

                Log.d(Tag,"Received Response : "+ data.length);

                Thread.sleep(25);

            }               

        }catch(InterruptedException e){

        e.printStackTrace();

    }catch(IOException e){

            e.printStackTrace();
        }           

    }

}




//Get Local Address


    private InetAddress getLocalAddress() throws IOException{

        try{

            for(Enumeration <NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();){

                NetworkInterface intf = en.nextElement();

                for(Enumeration <InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();){

                    InetAddress inetAddress = enumIpAddr.nextElement();

                    if(!inetAddress.isLoopbackAddress()){

                        return inetAddress;

                    }

                }

            }

        } catch (SocketException ex) {

            Log.e(Tag, ex.toString());

        }


        return null;
    }