在Fragment中添加了一个按钮跳转到activity，但是一按按钮就闪退，求大神指点！！！

图片说明

异常报你在主线程操作网络了，把网络请求放在子线程就行了

主线程为UI线程，请求网络之类的耗时操作要放到子线程中处理

当你请求网络是就去new一个子线程去处理网络请求：
new Thread( new Runnable() {
public void run() {
//这里加上处理网络的逻辑
//据题怎么请求网络可以看看专门的介绍
//这就是如何开启子线程
}
}).start();

public MyTimerCheck() {  
    mThread = new Thread(new Runnable() {  

        @Override  
        public void run() {  
            // TODO Auto-generated method stub  
            while (!mExitFlag) {  
                mCount++;  
                if (mCount < mTimeOutCount) {  
                    doTimerCheckWork();  
                    try {  
                        mThread.sleep(mSleepTime);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                        exit();  
                    }  
                } else {  
                    doTimeOutWork();  
                }  
            }  
        }  
    });  
}  

/** 
 * start 
 * @param times  How many times will check? 
 * @param sleepTime ms, Every check sleep time. 
 */  
public void start(int timeOutCount, int sleepTime) {  
    mTimeOutCount = timeOutCount;  
    mSleepTime = sleepTime;  

    mThread.start();  
}  

public void exit() {  
    mExitFlag = true;  
}

}

public abstract class WifiAdmin {

private static final String TAG = "WifiAdmin";  

private WifiManager mWifiManager;  
private WifiInfo mWifiInfo;  
// 扫描出的网络连接列表  
private List<ScanResult> mWifiList;  
private List<WifiConfiguration> mWifiConfiguration;  

private WifiLock mWifiLock;  

private String mPasswd = "";  
private String mSSID = "";  

private Context mContext = null;  

public WifiAdmin(Context context) {  

    mContext = context;  

    // 取得WifiManager对象  
    mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);  
    // 取得WifiInfo对象  
    mWifiInfo = mWifiManager.getConnectionInfo();  

    Log.v(TAG, "getIpAddress = " + mWifiInfo.getIpAddress());  
}  

// 打开WIFI  
public void openWifi() {  
    if (!mWifiManager.isWifiEnabled()) {  
        mWifiManager.setWifiEnabled(true);  
    }  
}  

// 关闭WIFI  
public void closeWifi() {  
    if (mWifiManager.isWifiEnabled()) {  
        mWifiManager.setWifiEnabled(false);  
    }  
}  

public abstract Intent myRegisterReceiver(BroadcastReceiver receiver, IntentFilter filter);  

public abstract void myUnregisterReceiver(BroadcastReceiver receiver);  

public abstract void onNotifyWifiConnected();  

public abstract void onNotifyWifiConnectFailed();  

// 添加一个网络并连接  
public void addNetwork(WifiConfiguration wcg) {  

    register();  

    WifiApAdmin.closeWifiAp(mContext);  

    int wcgID = mWifiManager.addNetwork(wcg);  
    boolean b = mWifiManager.enableNetwork(wcgID, true);  
}  

public static final int TYPE_NO_PASSWD = 0x11;  
public static final int TYPE_WEP = 0x12;  
public static final int TYPE_WPA = 0x13;  

public void addNetwork(String ssid, String passwd, int type) {  
    if (ssid == null || passwd == null || ssid.equals("")) {  
        Log.e(TAG, "addNetwork() ## nullpointer error!");  
        return;  
    }  

    if (type != TYPE_NO_PASSWD && type != TYPE_WEP && type != TYPE_WPA) {  
        Log.e(TAG, "addNetwork() ## unknown type = " + type);  
    }  

    stopTimer();  
    unRegister();  

    addNetwork(createWifiInfo(ssid, passwd, type));  
}  

private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {  

    @Override  
    public void onReceive(Context context, Intent intent) {  
        // TODO Auto-generated method stub  
        if (intent.getAction().equals(WifiManager.RSSI_CHANGED_ACTION)) {  
            Log.d(TAG, "RSSI changed");  

            //有可能是正在获取，或者已经获取了  
            Log.d(TAG, " intent is " + WifiManager.RSSI_CHANGED_ACTION);  

            if (isWifiContected(mContext) == WIFI_CONNECTED) {  
                stopTimer();  
                onNotifyWifiConnected();  
                unRegister();  
            } else if (isWifiContected(mContext) == WIFI_CONNECT_FAILED) {  
                stopTimer();  
                closeWifi();  
                onNotifyWifiConnectFailed();  
                unRegister();  
            } else if (isWifiContected(mContext) == WIFI_CONNECTING) {  

            }  
        }  
    }  
};  

private final int STATE_REGISTRING = 0x01;  
private final int STATE_REGISTERED = 0x02;  
private final int STATE_UNREGISTERING = 0x03;  
private final int STATE_UNREGISTERED = 0x04;  

private int mHaveRegister = STATE_UNREGISTERED;  
private synchronized void register() {  
    Log.v(TAG, "register() ##mHaveRegister = " + mHaveRegister);  

    if (mHaveRegister == STATE_REGISTRING   
            || mHaveRegister == STATE_REGISTERED) {  
        return ;  
    }  

    mHaveRegister = STATE_REGISTRING;  
    myRegisterReceiver(mBroadcastReceiver, new IntentFilter(WifiManager.RSSI_CHANGED_ACTION));  
    mHaveRegister = STATE_REGISTERED;  

    startTimer();  
}  

private synchronized void unRegister() {  
    Log.v(TAG, "unRegister() ##mHaveRegister = " + mHaveRegister);  

    if (mHaveRegister == STATE_UNREGISTERED   
            || mHaveRegister == STATE_UNREGISTERING) {  
        return ;  
    }  

    mHaveRegister = STATE_UNREGISTERING;  
    myUnregisterReceiver(mBroadcastReceiver);  
    mHaveRegister = STATE_UNREGISTERED;  
}  

private Timer mTimer = null;  
private void startTimer() {  
    if (mTimer != null) {  
        stopTimer();  
    }  

    mTimer = new Timer(true);

// mTimer.schedule(mTimerTask, 0, 20 * 1000);// 20s

mTimer.schedule(mTimerTask, 30 * 1000);

}

private TimerTask mTimerTask = new TimerTask() {  

    @Override  
    public void run() {  
        // TODO Auto-generated method stub  
        Log.e(TAG, "timer out!");  
        onNotifyWifiConnectFailed();  
        unRegister();  
    }  
};  

private void stopTimer() {  
    if (mTimer != null) {  
        mTimer.cancel();  
        mTimer = null;  
    }  
}  

@Override  
protected void finalize() {  
    try {  
        super.finalize();  
        unRegister();  
    } catch (Throwable e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    }  
}  

public WifiConfiguration createWifiInfo(String SSID, String password, int type) {  

    Log.v(TAG, "SSID = " + SSID + "## Password = " + password + "## Type = " + type);  

    WifiConfiguration config = new WifiConfiguration();  
    config.allowedAuthAlgorithms.clear();  
    config.allowedGroupCiphers.clear();  
    config.allowedKeyManagement.clear();  
    config.allowedPairwiseCiphers.clear();  
    config.allowedProtocols.clear();  
    config.SSID = "\"" + SSID + "\"";  

    WifiConfiguration tempConfig = this.IsExsits(SSID);  
    if (tempConfig != null) {  
        mWifiManager.removeNetwork(tempConfig.networkId);  
    }  

    // 分为三种情况：1没有密码2用wep加密3用wpa加密  
    if (type == TYPE_NO_PASSWD) {// WIFICIPHER_NOPASS  
        config.wepKeys[0] = "";  
        config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
        config.wepTxKeyIndex = 0;  

    } else if (type == TYPE_WEP) {  //  WIFICIPHER_WEP   
        config.hiddenSSID = true;  
        config.wepKeys[0] = "\"" + password + "\"";  
        config.allowedAuthAlgorithms  
                .set(WifiConfiguration.AuthAlgorithm.SHARED);  
        config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
        config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);  
        config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);  
        config.allowedGroupCiphers  
                .set(WifiConfiguration.GroupCipher.WEP104);  
        config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
        config.wepTxKeyIndex = 0;  
    } else if (type == TYPE_WPA) {   // WIFICIPHER_WPA  
        config.preSharedKey = "\"" + password + "\"";  
        config.hiddenSSID = true;  
        config.allowedAuthAlgorithms  
                .set(WifiConfiguration.AuthAlgorithm.OPEN);  
        config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);  
        config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);  
        config.allowedPairwiseCiphers  
                .set(WifiConfiguration.PairwiseCipher.TKIP);  
        // config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);  
        config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
        config.allowedPairwiseCiphers  
                .set(WifiConfiguration.PairwiseCipher.CCMP);  
        config.status = WifiConfiguration.Status.ENABLED;  
    }   

    return config;  
}  

public static final int WIFI_CONNECTED = 0x01;  
public static final int WIFI_CONNECT_FAILED = 0x02;  
public static final int WIFI_CONNECTING = 0x03;  
/** 
 * 判断wifi是否连接成功,不是network 
 *  
 * @param context 
 * @return 
 */  
public int isWifiContected(Context context) {  
    ConnectivityManager connectivityManager = (ConnectivityManager) context  
            .getSystemService(Context.CONNECTIVITY_SERVICE);  
    NetworkInfo wifiNetworkInfo = connectivityManager  
            .getNetworkInfo(ConnectivityManager.TYPE_WIFI);  

    Log.v(TAG, "isConnectedOrConnecting = " + wifiNetworkInfo.isConnectedOrConnecting());  
    Log.d(TAG, "wifiNetworkInfo.getDetailedState() = " + wifiNetworkInfo.getDetailedState());  
    if (wifiNetworkInfo.getDetailedState() == DetailedState.OBTAINING_IPADDR  
            || wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTING) {  
        return WIFI_CONNECTING;  
    } else if (wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTED) {  
        return WIFI_CONNECTED;  
    } else {  
        Log.d(TAG, "getDetailedState() == " + wifiNetworkInfo.getDetailedState());  
        return WIFI_CONNECT_FAILED;  
    }  
}  

private WifiConfiguration IsExsits(String SSID) {  
    List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();  
    for (WifiConfiguration existingConfig : existingConfigs) {  
        if (existingConfig.SSID.equals("\"" + SSID + "\"") /*&& existingConfig.preSharedKey.equals("\"" + password + "\"")*/) {  
            return existingConfig;  
        }  
    }  
    return null;  
}  



// 断开指定ID的网络  
public void disconnectWifi(int netId) {  
    mWifiManager.disableNetwork(netId);  
    mWifiManager.disconnect();  
}  

// 检查当前WIFI状态  
public int checkState() {  
    return mWifiManager.getWifiState();  
}  

// 锁定WifiLock  
public void acquireWifiLock() {  
    mWifiLock.acquire();  
}  

// 解锁WifiLock  
public void releaseWifiLock() {  
    // 判断时候锁定  
    if (mWifiLock.isHeld()) {  
        mWifiLock.acquire();  
    }  
}  

// 创建一个WifiLock  
public void creatWifiLock() {  
    mWifiLock = mWifiManager.createWifiLock("Test");  
}  

// 得到配置好的网络  
public List<WifiConfiguration> getConfiguration() {  
    return mWifiConfiguration;  
}  

// 指定配置好的网络进行连接  
public void connectConfiguration(int index) {  
    // 索引大于配置好的网络索引返回  
    if (index > mWifiConfiguration.size()) {  
        return;  
    }  
    // 连接配置好的指定ID的网络  
    mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,  
            true);  
}  

public void startScan() {  
    mWifiManager.startScan();  
    mWifiList = mWifiManager.getScanResults();  
    mWifiConfiguration = mWifiManager.getConfiguredNetworks();  
}  

// 得到网络列表  
public List<ScanResult> getWifiList() {  
    return mWifiList;  
}  

// 查看扫描结果  
public StringBuilder lookUpScan() {  
    StringBuilder stringBuilder = new StringBuilder();  
    for (int i = 0; i < mWifiList.size(); i++) {  
        stringBuilder  
                .append("Index_" + new Integer(i + 1).toString() + ":");  
        // 将ScanResult信息转换成一个字符串包  
        // 其中把包括：BSSID、SSID、capabilities、frequency、level  
        stringBuilder.append((mWifiList.get(i)).toString());  
        stringBuilder.append("/n");  
    }  
    return stringBuilder;  
}  

// 得到MAC地址  
public String getMacAddress() {  
    return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();  
}  

// 得到接入点的BSSID  
public String getBSSID() {  
    return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();  
}  

// 得到IP地址  
public int getIPAddress() {  
    return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();  
}  

// 得到连接的ID  
public int getNetworkId() {  
    return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();  
}  

// 得到WifiInfo的所有信息包  
public String getWifiInfo() {  
    return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();  
}

}

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.Timer;

import java.util.TimerTask;

import android.content.Context;

import android.net.wifi.WifiConfiguration;

import android.net.wifi.WifiManager;

import android.util.Log;

/**

创建热点

*/

public class WifiApAdmin {

public static final String TAG = "WifiApAdmin";

public static void closeWifiAp(Context context) {

WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);

closeWifiAp(wifiManager);

}

private WifiManager mWifiManager = null;

private Context mContext = null;

public WifiApAdmin(Context context) {

mContext = context;

mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);    

closeWifiAp(mWifiManager);

}

private String mSSID = "";

private String mPasswd = "";

public void startWifiAp(String ssid, String passwd) {

mSSID = ssid;

mPasswd = passwd;

if (mWifiManager.isWifiEnabled()) {  
    mWifiManager.setWifiEnabled(false);  
}   

stratWifiAp();  

MyTimerCheck timerCheck = new MyTimerCheck() {  

    @Override  
    public void doTimerCheckWork() {  
        // TODO Auto-generated method stub  

        if (isWifiApEnabled(mWifiManager)) {  
            Log.v(TAG, "Wifi enabled success!");  
            this.exit();  
        } else {  
            Log.v(TAG, "Wifi enabled failed!");  
        }  
    }  

    @Override  
    public void doTimeOutWork() {  
        // TODO Auto-generated method stub  
        this.exit();  
    }  
};  
timerCheck.start(15, 1000);

}

public void stratWifiAp() {

Method method1 = null;

try {

method1 = mWifiManager.getClass().getMethod("setWifiApEnabled",

WifiConfiguration.class, boolean.class);

WifiConfiguration netConfig = new WifiConfiguration();

    netConfig.SSID = mSSID;  
    netConfig.preSharedKey = mPasswd;  

    netConfig.allowedAuthAlgorithms  
            .set(WifiConfiguration.AuthAlgorithm.OPEN);  
    netConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);  
    netConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);  
    netConfig.allowedKeyManagement  
            .set(WifiConfiguration.KeyMgmt.WPA_PSK);  
    netConfig.allowedPairwiseCiphers  
            .set(WifiConfiguration.PairwiseCipher.CCMP);  
    netConfig.allowedPairwiseCiphers  
            .set(WifiConfiguration.PairwiseCipher.TKIP);  
    netConfig.allowedGroupCiphers  
            .set(WifiConfiguration.GroupCipher.CCMP);  
    netConfig.allowedGroupCiphers  
            .set(WifiConfiguration.GroupCipher.TKIP);  

    method1.invoke(mWifiManager, netConfig, true);  

} catch (IllegalArgumentException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
} catch (IllegalAccessException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
} catch (InvocationTargetException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
} catch (SecurityException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
} catch (NoSuchMethodException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
}

}

private static void closeWifiAp(WifiManager wifiManager) {

if (isWifiApEnabled(wifiManager)) {

try {

Method method = wifiManager.getClass().getMethod("getWifiApConfiguration");

method.setAccessible(true);

        WifiConfiguration config = (WifiConfiguration) method.invoke(wifiManager);  

        Method method2 = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);  
        method2.invoke(wifiManager, config, false);  
    } catch (NoSuchMethodException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    } catch (IllegalArgumentException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    } catch (IllegalAccessException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    } catch (InvocationTargetException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    }  
}

}

private static boolean isWifiApEnabled(WifiManager wifiManager) {

try {

Method method = wifiManager.getClass().getMethod("isWifiApEnabled");

method.setAccessible(true);

return (Boolean) method.invoke(wifiManager);

} catch (NoSuchMethodException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
} catch (Exception e) {  
    e.printStackTrace();  
}  

return false;

}

public class MessageFragment extends Fragment {
public static final String TAG = "MessageFragment";

private Button mBtn1, mBtn2, mBtn3;  

private WifiAdmin mWifiAdmin;  

private Context mContext = null;  


@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {
    View newsLayout = inflater.inflate(R.layout.message_layout, container,
            false);
    return newsLayout;
}

    public void onViewCreated(View view, Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onViewCreated(view, savedInstanceState);
          mContext = getActivity();  
     mBtn1 = (Button)view.findViewById(R.id.button1);  
     mBtn2 = (Button)view.findViewById(R.id.button2); 
     mBtn3 = (Button)view.findViewById(R.id.button3); 
     mBtn1.setText("点击连接Wifi");  
     mBtn2.setText("点击创建Wifi热点");  
     mBtn3.setText("聊天发文件");  
     mBtn1.setOnClickListener(new Button.OnClickListener() {  


         @Override  
         public void onClick(View v) {  
             // TODO Auto-generated method stub  
             Intent wifiSettingsIntent = new Intent("android.settings.WIFI_SETTINGS");   
                startActivity(wifiSettingsIntent);  
             mWifiAdmin = new WifiAdmin(mContext) {  

                 @Override  
                 public void myUnregisterReceiver(BroadcastReceiver receiver) {  
                     // TODO Auto-generated method stub  
                     getActivity().unregisterReceiver(receiver);  
                 }  

                 @Override  
                 public Intent myRegisterReceiver(BroadcastReceiver receiver,  
                         IntentFilter filter) {  
                     // TODO Auto-generated method stub  
                     getActivity().registerReceiver(receiver, filter);  
                     return null;  
                 }  

                 @Override  
                 public void onNotifyWifiConnected() {  
                     // TODO Auto-generated method stub  
                     Log.v(TAG, "have connected success!");  
                     Log.v(TAG, "###############################");  
                 }  

                 @Override  
                 public void onNotifyWifiConnectFailed() {  
                     // TODO Auto-generated method stub  
                     Log.v(TAG, "have connected failed!");  
                     Log.v(TAG, "###############################");  
                 }  
             };  
             mWifiAdmin.openWifi();  
             mWifiAdmin.addNetwork(mWifiAdmin.createWifiInfo("YOU_WIFI", "MM123456", WifiAdmin.TYPE_WPA));  

         }  
     });  

     mBtn2.setOnClickListener(new Button.OnClickListener() {  

         @Override  
         public void onClick(View v) {  
             // TODO Auto-generated method stub  

             WifiApAdmin wifiAp = new WifiApAdmin(mContext);  
             wifiAp.startWifiAp("\"HotSpot\"", "hhhhhh123");  
         }  
     });  



     mBtn3.setOnClickListener(new Button.OnClickListener() {  

         @Override  
         public void onClick(View v) {  
             // TODO Auto-generated method stub  

             Intent i = new Intent(getActivity() , MyFeiGeActivity.class);
            ////启动 

             getActivity().startActivity(i);
         }  
     });  

 }  
  @Override  
     public void onResume() {  
         super.onResume();  

         Log.d("Rssi", "Registered");  
     }  

     @Override  
     public void onPause() {  
         super.onPause();  

         Log.d("Rssi", "Unregistered");  



     }

}