Android 用于文件共享的wifidirect连接

**一,。我为android文件共享创建了一个应用程序，但我的编码有一个错误，搜索对等功能无法正常工作。请任何人帮助我。下面是我的代码。 包com.example.com.MARK2

import java.io.BufferedReader; import java.io.BufferedWriter; import
java.io.File; import java.io.FileReader; import java.io.FileWriter;
import java.io.IOException; import java.util.HashMap; import
java.util.Iterator; import java.util.Set;

import android.app.Activity; import android.app.AlertDialog; import
android.content.BroadcastReceiver; import android.content.Context;
import android.content.DialogInterface; import
android.content.Intent; import android.content.IntentFilter; import
android.net.wifi.p2p.WifiP2pConfig; import
android.net.wifi.p2p.WifiP2pDevice; import
android.net.wifi.p2p.WifiP2pManager; import
android.net.wifi.p2p.WifiP2pManager.ActionListener; import
android.net.wifi.p2p.WifiP2pManager.Channel; import
android.net.wifi.p2p.WifiP2pManager.ChannelListener; import
android.os.Bundle; import android.provider.Settings; import
android.util.Log; import android.view.Menu; import
android.view.MenuInflater; import android.view.MenuItem; import
android.view.View; import android.widget.TextView; import
android.widget.Toast;

public class MainActivity extends Activity implements
ChannelListener{

    private WifiP2pManager manager;
    private Channel channel;
    private BroadcastReceiver receiver;
    private final IntentFilter intentFilter = new IntentFilter();
    private boolean isWifiP2pEnabled = false;
    Context CONTEXT=this;
    private boolean retryChannel=false;
    public final static int BYTESPERCHUNK=100000;
    static HashMap<String, String> allFileList= new HashMap<String, String>();
    static HashMap<String, Integer> numOfChunks= new HashMap<String, Integer>();
    static String fileNeeded=new String();

     @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        File file= new File("/sdcard/raja");
        if(!file.exists()) file.mkdirs();
        initialization();
       fileNeeded=getFileNeeded();
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);

        manager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
        channel = manager.initialize(this, getMainLooper(), null);
        receiver = new WiFiDirectBroadcastReceiver(manager, channel, this);
        registerReceiver(receiver, intentFilter);
        //searchPeer();
    }
    @Override
    public void onResume() { 
        super.onResume();
        registerReceiver(receiver, intentFilter);
    }

    @Override
    public void onPause() { 
        super.onPause();
        unregisterReceiver(receiver);
    }
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.menuitem, menu);
        return true;
    }
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.exit:             
            disconnect();
            cancelDisconnect();
            unregisterReceiver(receiver);
            this.finish();
            System.exit(0);
            return true;
            case R.id.folder:           
            Intent browseFolder= new Intent(this,BrowserFolder.class);
            startActivity(browseFolder);    
            default:
                return super.onOptionsItemSelected(item);
        }
    }
    public void setIsWifiP2pEnabled(boolean isWifiP2pEnabled) {
        this.isWifiP2pEnabled = isWifiP2pEnabled;
        return;
    }

    public void showMessage(String str){    Toast.makeText(CONTEXT, str,Toast.LENGTH_SHORT).show();
    }

    public void searchButton(View view){    searchPeer();   return;
    }


    public void searchPeer(){
            if(!isWifiP2pEnabled){
            new AlertDialog.Builder(this)
            .setIcon(R.drawable.ic_launcher)
            .setTitle("WiFi Direct is Disabled!")
            .setPositiveButton("Setting", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int whichButton) {
                    startActivity(new Intent(Settings.ACTION_WIRELESS_SETTINGS)); 
                }
            }).show();
            return;
        }
      /*  if(fileNeeded==null){
        showMessage("You have ALL files updated. Don't need to transfer anymore.");
        return;
        }*/     final DeviceListFragment fragment = (DeviceListFragment) getFragmentManager()
                    .findFragmentById(R.id.devicelist);     fragment.onInitiateDiscovery();
    fragment.getView().setVisibility(View.VISIBLE);
    manager.discoverPeers(channel, new WifiP2pManager.ActionListener()
{
             @Override
             public void onSuccess() {
                 //Toast.makeText(CONTEXT, "Searching",Toast.LENGTH_SHORT).show();
                 return;
             }
             @Override
             public void onFailure(int reasonCode) {
                 Toast.makeText(CONTEXT, "Search Failed: "+reasonCode,Toast.LENGTH_SHORT).show();
                 return;
             }
         });
    }

    public static String getDeviceStatus(int deviceStatus) {
        switch (deviceStatus) {
            case WifiP2pDevice.AVAILABLE:
                return "Available";
            case WifiP2pDevice.INVITED:
                return "Invited";
            case WifiP2pDevice.CONNECTED:
                return "Connected";
            case WifiP2pDevice.FAILED:
                return "Failed";
            case WifiP2pDevice.UNAVAILABLE:
                return "Unavailable";
            default:
                return "Unknown";

        }
    }

    public static int divRoundUp(int n,int s){  return (((n) / (s)) + ((((n) % (s)) > 0) ? 1 : 0));
    }

    public void updateThisDevice(WifiP2pDevice device) {
        TextView view = (TextView)findViewById(R.id.mystatus);
        view.setText("My Name: "+device.deviceName+"\nMy Address: "+device.deviceAddress+"\nMy Status:
"+getDeviceStatus(device.status));
        return;
    }

    public void connect(WifiP2pConfig config){   manager.connect(channel, config, new ActionListener() {
         @Override
         public void onSuccess() {

         }

         @Override
         public void onFailure(int reason) {         showMessage("Connect failed: "+reason);
         }   });                 return;
    }


    public void disconnect(){
        final DeviceDetailFragment fragment = (DeviceDetailFragment) getFragmentManager()
                .findFragmentById(R.id.devicedetail);
        fragment.blockDetail();
        updateRecord();
        manager.removeGroup(channel, new ActionListener() {
            @Override
            public void onFailure(int reasonCode) {
                showMessage("Disconnect failed. Reason :" + reasonCode);
            }

            @Override
            public void onSuccess() {
                //fragment.getView().setVisibility(View.GONE); 
            showMessage("Disconnected.");
            }
        });
        return;
    }


    @Override
    public void onChannelDisconnected() {
        if (manager != null && !retryChannel) {
            Toast.makeText(this, "Channel lost. Trying again", Toast.LENGTH_LONG).show();
            retryChannel = true;
            manager.initialize(this, getMainLooper(), this);
        } else {
            Toast.makeText(this,
                    "Channel is probably lost premanently. Try Disable/Re-Enable P2P.",
                    Toast.LENGTH_LONG).show();
        }
        return; 
    }


    public void cancelDisconnect() {
        if (manager != null) {
            final DeviceDetailFragment fragment = (DeviceDetailFragment) getFragmentManager()
                    .findFragmentById(R.id.devicedetail);
            if (fragment.device == null
                    || fragment.device.status == WifiP2pDevice.CONNECTED) {
                disconnect();
            } else if (fragment.device.status == WifiP2pDevice.AVAILABLE
                    || fragment.device.status == WifiP2pDevice.INVITED) {

                manager.cancelConnect(channel, new ActionListener() {

                    @Override
                    public void onSuccess() {
                        showMessage("Aborting connection");
                        return;
                    }

                    @Override
                    public void onFailure(int reasonCode) {
                        showMessage("Connect abort request failed. Reason Code: " + reasonCode);
                    }
                });
            }
        }
        return;
    }

     /* 
    static HashMap<String, HashMap<String, Boolean>> availableFileChunks= new HashMap<String, HashMap<String,
Boolean>>();
    static HashMap<String, HashMap<String, Boolean>> neededFileChunks= new HashMap<String, HashMap<String, Boolean>>();
    void initialization(){  File listFile=new File("/sdcard/akalyvan.txt");     File recordFile=new
File("/sdcard/akalyvan2.txt");  try {
        BufferedReader inputReader = new BufferedReader(new FileReader(listFile));
        String buffer = new String(); 
        while((buffer=inputReader.readLine())!=null){           String [] fileInfo= buffer.split(",");              allFileList.put(fileInfo[0],
fileInfo[1]);       int
num=divRoundUp(Integer.parseInt(fileInfo[2]),BYTESPERCHUNK);
        numOfChunks.put(fileInfo[0],num);
        }
        inputReader.close();
        inputReader=new BufferedReader(new FileReader(recordFile));
        while((buffer=inputReader.readLine())!=null){           String [] fileInfo= buffer.split(",");      
        if((buffer=inputReader.readLine())!=null){
            HashMap<String, Boolean> chunkMap= new HashMap<String, Boolean>();
            String [] chunkNum= buffer.split(",");
            for(int i=0;i<chunkNum.length;i++){             chunkMap.put(chunkNum[i], true);
            }
            availableFileChunks.put(fileInfo[0], chunkMap);         }
        }
        inputReader.close();
        Set<String>files= allFileList.keySet();
        Iterator<String> it=files.iterator();
        while(it.hasNext()){        buffer=it.next();       if(availableFileChunks.get(buffer)==null){
            HashMap<String, Boolean> chunkMap= new HashMap<String, Boolean>();
            for(int i=0;i<numOfChunks.get(buffer);i++){             chunkMap.put(new Integer(i).toString(), true);
            }
            neededFileChunks.put(buffer, chunkMap);         }else{
            HashMap<String, Boolean> chunkMap=availableFileChunks.get(buffer);
            HashMap<String, Boolean> neededChunkMap= new HashMap<String, Boolean>();
            for(int i=0;i<numOfChunks.get(buffer);i++){             if(chunkMap.get(new Integer(i).toString())==null){
                neededChunkMap.put(new Integer(i).toString(), true);            }
            } 
            neededFileChunks.put(buffer, neededChunkMap);       }
        }   } catch (IOException e) {
        showMessage("IO Error.");   }

    }
    public static String getFileNeeded(){   String result=new String();     Set<String> files=neededFileChunks.keySet();
    if(files.isEmpty()) return null;    Iterator<String>
it=files.iterator();    int i=0;    while(it.hasNext()){
        if(i++!=0) result+=",";
        String buffer=it.next();
        result+=buffer+",";
        HashMap<String, Boolean> neededChunkMap=neededFileChunks.get(buffer);
        Set<String> chunks=neededChunkMap.keySet();
        Iterator<String> chunkit=chunks.iterator();
        int j=0;
        while(chunkit.hasNext()){       if(j++!=0) result+="+";         result+=chunkit.next();
        }   }   return result;  
    }

    public void updateRecord(){     File recordFile=new File("/sdcard/akalyvan2.txt");  try {
        BufferedWriter outputWriter = new BufferedWriter(new FileWriter(recordFile,false));
        Set<String>files= availableFileChunks.keySet();
        Iterator<String> it=files.iterator();
        while(it.hasNext()){        outputWriter.write(it.next()+"\n");         HashMap<String, Boolean>
chunkMap=availableFileChunks.get(it.next());        Set<String> chunks=
chunkMap.keySet();      Iterator<String> chunkit=chunks.iterator();
        String chunkList=new String();      int i=0;
        while(chunkit.hasNext()){
            if(i++!=0) chunkList+=",";
            chunkList+=chunkit.next();      }       outputWriter.write(chunkList+"\n");
        }
        outputWriter.flush();
        outputWriter.close();   } catch (IOException e) {
        showMessage("IO Error.");   }
    }*/

    public static HashMap<String, BitMap> availableChunkMap= new HashMap<String, BitMap>();
    public static HashMap<String, BitMap> neededChunkMap= new HashMap<String, BitMap>();
    void initialization(){  File listFile=new File("/sdcard/akalyvan3.txt");    File recordFile=new
File("/sdcard/gurubitmaprecord.txt");   try {
        if(!listFile.exists()){         showMessage("Fatal Error: Config file not found.");         return;
        }
        BufferedReader inputReader = new BufferedReader(new FileReader(listFile));
        String buffer = new String(); 
        while((buffer=inputReader.readLine())!=null){           String [] fileInfo= buffer.split(",");              allFileList.put(fileInfo[0],
fileInfo[1]);       int
num=divRoundUp(Integer.parseInt(fileInfo[2]),BYTESPERCHUNK);
        numOfChunks.put(fileInfo[0],num);
        File oneFile= new File("/sdcard/raja/"+fileInfo[1]);        if(oneFile.exists()){
            BitMap chunkMap= new BitMap(num);
            for(int i=0;i<num;i++) chunkMap.Mark(i);
            availableChunkMap.put(fileInfo[0], chunkMap);                       }
        }
        inputReader.close();
        recordFile.createNewFile();
        inputReader=new BufferedReader(new FileReader(recordFile));
        while((buffer=inputReader.readLine())!=null){           String [] fileInfo= buffer.split(",");  
        if(availableChunkMap.get(fileInfo[0])!=null){
        buffer=inputReader.readLine();
            continue;       }       if((buffer=inputReader.readLine())!=null){  
            BitMap chunkMap= new BitMap(buffer);
            if(chunkMap.length()!=numOfChunks.get(fileInfo[0])){            showMessage("Error: BitMap length not correct");            return;
            }
            availableChunkMap.put(fileInfo[0], chunkMap);       }
        }
        inputReader.close();
         Set<String>files= allFileList.keySet();
        Iterator<String> it=files.iterator();
        while(it.hasNext()){        buffer=it.next();       if(availableChunkMap.get(buffer)==null){
            BitMap chunkMap=new BitMap(numOfChunks.get(buffer));
            for(int i=0;i<numOfChunks.get(buffer);i++){             chunkMap.Mark(i);
            }
            neededChunkMap.put(buffer, chunkMap);       }else{
            BitMap chunkMap=availableChunkMap.get(buffer);
            if(chunkMap.numMarked()==numOfChunks.get(buffer)) continue;
            BitMap neededChunk= new BitMap(numOfChunks.get(buffer));
            for(int i=0;i<numOfChunks.get(buffer);i++){             if(!chunkMap.Test(i)){
                neededChunk.Mark(i);            }
            } 
            neededChunkMap.put(buffer, neededChunk);        }
        }   } catch (IOException e) {
        showMessage("IO Error: "+e.toString());     }   
    }

    public static String getFileNeeded(){   String result=new String();     Set<String> files=neededChunkMap.keySet();
    //if(files.isEmpty()) return null;  Iterator<String>
it=files.iterator();    int i=0;    while(it.hasNext()){
        if(i++!=0) result+=",";
        String buffer=it.next();
        result+=buffer+",";
            result+=neededChunkMap.get(buffer).toString();  }   return result;  
    }

    public static void updateRecord(){  File recordFile=new File("/sdcard/gurubitmaprecord.txt");   try {
        BufferedWriter outputWriter = new BufferedWriter(new FileWriter(recordFile,false));
        Set<String>files= availableChunkMap.keySet();
        Iterator<String> it=files.iterator();
        while(it.hasNext()){        String buffer=it.next();        outputWriter.write(buffer+","+allFileList.get(buffer)+"\n");
        BitMap chunkMap=availableChunkMap.get(buffer);
        outputWriter.write(chunkMap.toString()+"\n");
        }
        outputWriter.flush();
        outputWriter.close();   } catch (IOException e) {
        Log.d("EE579","IO Error.");     }
    }
        /*    public static BloomFilter availableChunks=new BloomFilter();
    void initialization(){  File listFile=new File("/sdcard/akalyvan2t.txt");   try {
        if(!listFile.exists()){         showMessage("Fatal Error: Config file not found.");         return;
        }
        BufferedReader inputReader = new BufferedReader(new FileReader(listFile));
        String buffer = new String(); 
        while((buffer=inputReader.readLine())!=null){           String [] fileInfo= buffer.split(",");              allFileList.put(fileInfo[0],
fileInfo[1]);       int
num=divRoundUp(Integer.parseInt(fileInfo[2]),BYTESPERCHUNK);
        numOfChunks.put(fileInfo[0],num);       File oneFile= new
File("/sdcard/raja/"+fileInfo[1]);      if(oneFile.exists()){
            for(int i=0;i<num;i++){             availableChunks.mark(fileInfo[0]+"-"+i);
            }       }
        }
        inputReader.close();
        File oneFile= new File("/sdcard/raja/tmp");
        if(oneFile.exists()){       File[] files=oneFile.listFiles();       for(int i=0;i<files.length;i++){
            String fileName= files[i].getName().split("\\.")[0];
            availableChunks.mark(fileName);         }
        }   }catch(IOException e){
        showMessage("IO Error: "+e.toString());     }
    }
    public static String getFileNeeded(){   String result=new String();     Set<String>files= allFileList.keySet();     Iterator<String>
it=files.iterator();    while(it.hasNext()){
        String buffer=it.next();
        for(int i=0;i<numOfChunks.get(buffer);i++){         if(!availableChunks.test(buffer+"-"+i)){
            result+=buffer+"-"+i+",";       }
        }   }   return result;  
    }*/ }**

导入java.io.BufferedReader；导入java.io.BufferedWriter；进口
java.io.File；导入java.io.FileReader；导入java.io.FileWriter；
导入java.io.IOException；导入java.util.HashMap；进口
java.util.Iterator；导入java.util.Set；
导入android.app.Activity；导入android.app.AlertDialog；进口
android.content.BroadcastReceiver；导入android.content.Context；
导入android.content.DialogInterface；进口
android.content.Intent；导入android.content.IntentFilter；进口
android.net.wifi.p2p.WifiP2pConfig；进口
android.net.wifi.p2p.wifip2p设备；进口
android.net.wifi.p2p.WifiP2pManager；进口
android.net.wifi.p2p.WifiP2pManager.ActionListener；进口
android.net.wifi.p2p.WifiP2pManager.Channel；进口
android.net.wifi.p2p.WifiP2pManager.ChannelListener；进口
android.os.Bundle；导入android.provider.Settings；进口
android.util.Log；导入android.view.Menu；进口
android.view.MenuInflater；导入android.view.MenuItem；进口
android.view.view；导入android.widget.TextView；进口
android.widget.Toast；
公共类MainActivity扩展活动实现
信道侦听器{
私人WifiP2pManager经理；
专用信道；
专用广播接收机；
私有最终IntentFilter IntentFilter=新IntentFilter（）；
私有布尔值isWifiP2pEnabled=false；
上下文=这个；
私有布尔retryChannel=false；
公共最终静态整数字节数=100000；
静态HashMap allFileList=新HashMap（）；
静态HashMap numOfChunks=新HashMap（）；
静态字符串fileNeeded=新字符串（）；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.main）；
File File=新文件（“/sdcard/raja”）；
如果（！file.exists（））file.mkdirs（）；
初始化（）；
fileNeeded=getFileNeeded（）；
intentFilter.addAction（WifiP2pManager.WIFI\u P2P\u STATE\u CHANGED\u ACTION）；
intentFilter.addAction（WifiP2pManager.WIFI\u P2P\u PEERS\u CHANGED\u ACTION）；
intentFilter.addAction（WifiP2pManager.WIFI\u P2P\u CONNECTION\u CHANGED\u ACTION）；
intentFilter.addAction（WifiP2pManager.WIFI\u P2P\u此设备\u更改\u操作）；
manager=（WifiP2pManager）getSystemService（Context.WIFI\u P2P\u服务）；
channel=manager.initialize（this，getMainLooper（），null）；
接收器=新的WiFiDirectBroadcastReceiver（管理器、频道、本机）；
注册接收者（接收者、意图过滤器）；
//searchPeer（）；
}
@凌驾
在Resume（）上公共无效{
super.onResume（）；
注册接收者（接收者、意图过滤器）；
}
@凌驾
public void onPause（）{
super.onPause（）；
未注册接收人（接收人）；
}
@凌驾
公共布尔onCreateOptions菜单（菜单）{
MenuInflater充气机=getMenuInflater（）；
充气机。充气（R.menu.menuitem，menu）；
返回true；
}
@凌驾
公共布尔值onOptionsItemSelected（菜单项项）{
开关（item.getItemId（））{
案例R.id.exit：
断开连接（）；
取消断开连接（）；
未注册接收人（接收人）；
这个；
系统出口（0）；
返回true；
案例R.id.文件夹：
Intent browseFolder=新Intent（这是BrowserFolder.class）；
startActivity（浏览文件夹）；
违约：
返回super.onOptionsItemSelected（项目）；
}
}
公共无效集isWifiP2pEnabled（布尔值isWifiP2pEnabled）{
this.isWifiP2pEnabled=isWifiP2pEnabled；
返回；
}
public void showMessage（String str）{Toast.makeText（CONTEXT，str，Toast.LENGTH_SHORT）.show（）；
}
publicsvoidsearchbutton（视图）{searchPeer（）；返回；
}
公共void searchPeer（）{
如果（！isWifiP2pEnabled）{
新建AlertDialog.Builder（此）
.setIcon（R.drawable.ic_启动器）
.setTitle（“已禁用WiFi Direct！”）
.setPositiveButton（“设置”，新的DialogInterface.OnClickListener（）{
public void onClick（对话框接口对话框，int whichButton）{
startActivity（新意图（设置、动作和无线设置））；
}
}).show（）；
返回；
}
/*if（fileNeeded==null）{
showMessage（“您已经更新了所有文件，不再需要传输了。”）；
返回；
}*/最终的DeviceListFragment片段=（DeviceListFragment）getFragmentManager（）
.findFragmentById（R.id.devicelist）；fragment.onInitiateDiscovery（）；
fragment.getView（）.setVisibility（View.VISIBLE）；
manager.discoverPeers（通道，新的WifiP2pManager.ActionListener（）
{
@凌驾
成功时的公共无效（）{
//Toast.makeText（上下文，“搜索”，Toast.LENGTH_SHORT）.show（）；
返回；
}
@凌驾
公共失效失效失效（int推理代码）{
Toast.makeText（上下文，“搜索失败：”+reasonCode，Toast.LENGTH_SHORT.show（）；
返回；
}
});
}
公共静态字符串getDeviceStatus（int deviceStatus）{
开关（设备状态）{
案例WifiP2pDevice.AVAILABLE：
返回“可用”；
案例WifiP2pDevice.invested：
返回“邀请”；
案例WifiP2pDevice.CONNECTED：
返回“已连接”；
案例WifiP2pDevice.FAILED：
返回“失败”；
案例WifiP2pDevice.UNAVAILABLE：
返回“不可用”；
违约：