阶段性总结：
-------
1）get√一种跳转的封装
2）get√调试的技巧
3）回调机制的学习和理解
4）wifi的开发①开启热点②连接该wifi热点
-------
1) A.activity中
public static void comeToMe(Context context) {
Intent intent = new Intent(context, A.class);
context.startActivity(intent);
}
在B.activity中调用，只需A.comeToMe(getApplicationContext());
这个样子的写法好处是，如果很多地方需要跳转到activityA的话，这样的封装就不用每次写很多的intent了，一句话ok了；
2）关于调试的技巧：不用每次都是debug as application的，也可以先run起来，这样的好处是，比较快，而且如果是run之后不用拔下来就可以debug了。具体的方法是：打开devices设备选项卡，在里面找到你需要调试的程序，点一下那个debug的按钮，就进入debug调试模式了。
3）关于回调函数的应用
有时候，我们可能在activity A中需要跳转到activity B，等B做完处理之后，需要返回一些参数给 activity A，这个时候就用到了回调的思想。不用每次都写个intent发来发去。因为android 系统已经封装了一个现成的回调。具体用法如下：
在A.activity中做两件事①启动activity B ②回收B返回的处理结果
①：btn_imei.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Intent intent = new Intent(A.this, B.class);
startActivityForResult(intent, 100);
}
});
btn_mark.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Intent intent = new Intent(A.this, B.class);
startActivityForResult(intent, 101);
}
});
②：protected void onActivityResult(int requestCode, int resultCode,
Intent intent) {
if (resultCode == RESULT_OK) {
if (requestCode == 100) {
imei = intent.getExtras().getString("result");
tv_test.setText("imei-----" + imei);
}
if (requestCode == 101) {
mark = intent.getExtras().getString("result");
tv_test.setText("mark----" + mark + "imei-----" + imei);
}
}
super.onActivityResult(requestCode, resultCode, intent);
}
然后在B.avtivity 中只需要一个步骤，即处理好了之后回传数据：
Intent intent = new Intent(B.this, A.class);
intent.putExtra("result", result);
setResult(RESULT_OK,intent);
finish();
/*详解*/
//startActivityForResult(Intent intent, Int requestCode)
intent 传给B的
requestCode >=0就好，随便用于在onActivityResult()区别哪个子模块回传的数据，如果还有C.java ,D甚至E子模块的话，每个区分开不同的requestCode就好。在上面的实例中我们用了100和101区分的。
setResut(int resultCode, Intent intent)
resultCode 如果B子模块可能有几种不同的结果返回，可以用这个参数予以识别区分。这里还有个特殊的 RESULT_OK 值，没有特殊情况用它就好了，sdk有说明的。
intent 继续不解释，传回给A的onActivityResult()
onActivityResult(int requestCode, int resultCode, Intent intent)
如果不对requestCode和resultCode 加以识别区分的话，只要有其他activity setResult到了A onActivityResult()会无差别处理。实例中我们是无差处理的。
最后一点，数据回传完成一定要B.finish()掉。
------------
以上是在android系统中封装好的这个回调思想应用。
有时候我们自己也需要写一个自己的.java文件来配合完成，并不是每次的情境都是activity A ->activity B ->activity A,实际需要可能是activity A->class B ->activity A.这样子就不能使用上面的一套了。要自己写。那么问题来了。怎么写。用什么写。
由于刚刚理解清楚这个玩意，所以暂时没有能力讲解，就拿别人写的我看懂的来说明一下吧。
--------
在我们现实生活中，有如下这样场景：有一位老板很忙，他没有时间盯着员工干活，然后他告诉自己的雇员，干完当前这些事情后，告诉他干活的结果。这个例子其实是一个回调+异步的例子，再举一个例子，A程序员写了一段程序a，其中预留了回调函数接口，并封装好了该程序，程序员B让a调用自己的程序b中的一个方法，于是，他通过a中的接口回调自己b中的方法，到这里你可能似懂非懂了，后面会继续说明回调的出现原因。接下来我们把上面例子变成代码，看到网上很多人最后搞混了异步和回调，因此例子中不加入异步调用。（注意：回调可不是解决什么调用时间过长问题，那是异步！）
首先创建一个回调接口，让老板得告知干完活如何找到他的方式：留下老板办公室地址：
[java] view plaincopy
1. package net.easyway.test;
2.
3. /**
4. * 此接口为联系的方式，不论是电话号码还是联系地址，作为
5. * 老板都必须要实现此接口
6. * @author Administrator
7. *
8. */
9. public interface CallBackInterface {
10.
11. public void execute();
12. }
创建回调对象，就是老板本人，因为员工干完活后要给他打电话，因此老板必须实现回调接口，不然员工去哪里找老板？
[java] view plaincopy
1. package net.easyway.test;
2.
3. /**
4. * 老板是作为上层应用身份出现的，下层应用（员工）是不知道
5. * 有哪些方法，因此他想被下层应用（员工）调用必须实现此接口
6. * @author Administrator
7. *
8. */
9. public class Boss implements CallBackInterface {
10.
11. @Override
12. public void execute() {
13. System.out.println("收到了！！" + System.currentTimeMillis());
14.
15. }
16. }
创建控制类，也就是员工对象，他必须持有老板的地址（回调接口），即使老板换了一茬又一茬，办公室不变，总能找到对应的老板。
[java] view plaincopy
1. package net.easyway.test;
2.
3. /**
4. * 员工类，必须要记住，这是一个底层类，底层是不了解上层服务的
5. * @author Administrator
6. *
7. */
8. public class Employee {
9.
10. private CallBackInterface callBack = null;
11.
12. //告诉老板的联系方式，也就是注册
13. public void setCallBack(CallBackInterface callBack){
14. this.callBack = callBack;
15. }
16.
17. //工人干活
18. public void doSome(){
19. //1.开始干活了
20. for(int i=0;i<10;i++){
21. System.out.println("第【" + i + "】事情干完了！");
22. }
23.
24. //2.告诉老板干完了
25. callBack.execute();
26. }
27. }
-------
上面是别人的博客，我看了很多的，关于回调的机制，就这个例子看懂了，真正的get到了回调怎么写。下面讲下我自己个理解，比如在你android开发过程中，有个activity A ，有一部分逻辑需要一个工具类worker来完成。那么时序应该是：
A-->worker-->A;这个就是回调的原因。
所以这里的activity A就是那个老板，那个worker工具类就是工人。
那么问题来了，老板和工人各自需要做些什么呢？
首先，工人需要汇报老板，那么就需要知道老板的电话，所以，worker中需要定义一个接口，public interface CallbackInterface{public void execute()};
那么，我们知道的，接口不能在这边实现里面具体的方法，那具体的实现在哪里写呢？
就像，老板本人得知道工人任务完成了啊，所以老板那边要实现回调接口，你打电话来的时候我就知道了。
1. public class Boss implements CallBackInterface {
2.
3. @Override
4. public void execute() {
5. System.out.println("收到了！！" + System.currentTimeMillis());
6.
7. }
8. }
那么老板的事情就完成了，通过定义接口工人知道了老板的手机号码，通过实现接口老板也知道了工人事情干好了。
剩下的就是工人要干活了啊，所以worker工具类里面要注册一下那个接口，相当于告诉工人老板的联系方式是这个，然后就是干活，活干完了要告诉老板，即要回调老板实现的接口。
1. package net.easyway.test;
2.
3. /**
4. * 员工类，必须要记住，这是一个底层类，底层是不了解上层服务的
5. * @author Administrator
6. *
7. */
8. public class Employee {
9.
10. private CallBackInterface callBack = null;
11.
12. //告诉老板的联系方式，也就是注册
13. public void setCallBack(CallBackInterface callBack){
14. this.callBack = callBack;
15. }
16.
17. //工人干活
18. public void doSome(){
19. //1.开始干活了
20. for(int i=0;i<10;i++){
21. System.out.println("第【" + i + "】事情干完了！");
22. }
23.
24. //2.告诉老板干完了
25. callBack.execute();
26. }
27. }
那个活干完了，就是说，你需要工具类处理的事情完成了，可以通知我（本人是老板）一下了。以上就是我get到的java中回调思想。总结一下，工具类需要做的是定义一下接口，然后注册一下接口，然后就是干活，干好的时候（满足回去的条件了）回调老板那边已经实现的接口。而老板做的就是实现那个接口中没有实现的方法，“哦，我知道了（交代你的事情处理好了），好的~”。
4）关于wifi的开发
Wifi不多说，这里讲两点，①开启热点AP；②编码实现连接上该热点AP
先上开启热点AP的代码：
public void setupWifiAp(String name) throws Exception {
if (name == null || "".equals(name)) {
throw new Exception("the name of the wifiap is cannot be null");
}
Method setupMethod = wifiManager.getClass().getMethod(
SETUP_WIFIAP_METHOD, WifiConfiguration.class, boolean.class);
WifiConfiguration netConfig = new WifiConfiguration();
netConfig.SSID = name;
netConfig.allowedAuthAlgorithms
.set(WifiConfiguration.AuthAlgorithm.OPEN);
netConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
netConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
netConfig.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.CCMP);
netConfig.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.TKIP);
netConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
netConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
// 开放式
netConfig.allowedKeyManagement.isEmpty();
setupMethod.invoke(wifiManager, netConfig, true);
}
}
开启一个热点，需要调用wifiManager的服务，然后配置一个方法Method setupMethod = wifiManager.getClass().getMethod(SETUP_WIFIAP_METHOD, WifiConfiguration.class, boolean.class);方法配置好了之后，需要设置一下你个热点，new一个wifiCOnfiguration()对象出来，然后把相应的设置像设置动态布局一下写好，如果用的是开放式（无密码）的话，那么configuration.allowedKeyManagement方法就可以写isEmpty();设置好了这个之后就是把它们应用到这个方法里面了，setupMethod.invoke(wifiManager, netConfig, true);这个时候开启热点AP的任务就完成了（这个最好放在一个worker工具类里面）。
那么下面就是写连接这个热点AP了。连接的代码也不多，就是你要设置一下wifi的配置.
先上代码：
wifiConfiguration .WifiConfiguration wifiConfig = new WifiConfiguration();
wifiConfig.SSID = String.format("\"%s\"",ssid);
wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
WifiManager wifiManager= (WifiManager) getSystemService(Context.WIFI_SERVICE);
if (!wifiManager.isWifiEnabled()) {
wifiManager.setWifiEnabled(true);
}
wifiManager.addNetwork(wifiConfig);
设置好了之后，调用系统的这个wifiManager管理对象的getCOnfiguredNetwork()方法抓一下当前周围已经存在的wifi，然后用个for循环遍历一下找到这个你开的AP的SSID名字，然后先断开一下wifi，在重新连接上这个networkId，注意了，这个Id是你的wifiConfiguration的networkId,类型是int，和他的SSID是同一个层次的参数。然后传给wifiManager这个networkId就好了。这个时候就连上了你自己开启的手机热点。相当于两部手机连接到了同一个局域网LAN里面。
List<WifiConfiguration> list = wifiManager.getConfiguredNetworks();
for (WifiConfiguration i : list) {
if (i.SSID != null && i.SSID.equals("\"" + FileReceInfo.getInstance().ssid + "\"")) {
wifiManager.disconnect();
wifiManager.enableNetwork(i.networkId, true);
wifiManager.reconnect();
isConnected = true;
break;
}
}
5）关于p2p文件传输的研究
关于手机p2p的研究，暂时还没有精深，所以等项目完全结束了在详细的写一下这个吧。
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
