阅读本文前，请先去下载源代码（传送门）
MBProgressHUD是一个iOS的类，当等待后台进程执行时，可以显示出一个包含指示器或者标签的半透明的HUD。HUD是UIKit包中不允许开发者使用的UIProgressHUD的替代品。
使用前提
MBProgressHUD可以以ARC或者non-ARCf方式运行在iOS的任何版本，它使用到下列Cocoa Touch框架
- Foundation.framework
- UIKit.framework
- CoreGraphics.framework
我们从MBProgressHUD.h看起，首先MBProgressHUD继承子UIView,它具有View的特性，其头文件中，定义的枚举类型MBProgressHUDMode和MBProgressHUDAnimation，分别对应不同的加载等待框样式和消失动画类型。通过接下来的宏定义，来标志ARC和non-ARC模式及对BLOCK的支持。通过类方法+ (MBProgressHUD *)showHUDAddedTo:(UIView *)view animated:(BOOL)animated; 或者通过对象方法alloc及initWithView可以获得MBProgressHUD对象，可以通过MBProgressHUD的delegate属性，将遵循MBProgressHUDDelegate协议的对象，设为委托，在MBProgressHUD将要隐藏时回调。
在程序遇到异步或者耗时较长的任务需要执行时，可以使用- (void)showWhileExecuting:(SEL)method onTarget:(id)target withObject:(id)object animated:(BOOL)animated;方法，“锁住“主界面，并显示加载等待框。重点变在该函数内部，我们看一下：
- (void)showWhileExecuting:(SEL)method onTarget:(id)target withObject:(id)object animated:(BOOL)animated {
methodForExecution = method;
targetForExecution =MB_RETAIN(target);
objectForExecution =MB_RETAIN(object);
// Launch execution in new thread
self.taskInProgress =YES;
[NSThreaddetachNewThreadSelector:@selector(launchExecution)toTarget:selfwithObject:nil];
// Show HUD view
[selfshow:animated];
}
首先，我们将要执行的任务及目标对象传入后，MB_RETAIN实际只是宏，在之前说的那段头文件中，在non-ARC下，它将先将target和object的内存计数加1，熟悉内存管理的应该知道，接到参数后先retain，才能防止对象被提前释放。接着使用NSThread开一个线程，这是重点，现在有了新的一条线程，他将去执行我们的传进来的任务，可不让任务在主线程中调用，这样才不会阻塞主线程。新线程发消息给launchExecution。
- (void)launchExecution {
@autoreleasepool {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
// Start executing the requested task
[targetForExecutionperformSelector:methodForExecutionwithObject:objectForExecution];
#pragma clang diagnostic pop
// Task completed, update view in main thread (note: view operations should
// be done only in the main thread)
[selfperformSelectorOnMainThread:@selector(cleanUp)withObject:nilwaitUntilDone:NO];
}
}targetForExecution完成具体任务的执行，这时候该线程在一直执行我们的任务，performSelectorOnMainThread的意思是在主线程执行cleanUp，所以当我们任务在其他线程执行完，回到主线程时，执行cleanUp。
cleanUp执行一些release和赋值nil操作后，将执行- (void)hide:(BOOL)animated这个将去执行触发动画效果的方法，接着将调用- (void)done，在done中有一段这样的代码
if ([delegaterespondsToSelector:@selector(hudWasHidden:)]) {
[delegateperformSelector:@selector(hudWasHidden:)withObject:self];
}
向我们代理的对象发送hudWasHidden:消息，如果之前设置这确，便可以响应。
在头文件中有
@property (atomic, copy) NSString *labelText; @property (atomic, copy) NSString *detailsLabelText;
我们对这两个NSString类型的属性的赋值，会直接更新界面中的Label，这里使用到的是KVO编程，通过#pragma mark - KVO标记可以查看该部分代码，所有键值信息
- (NSArray *)observableKeypaths {
return [NSArray arrayWithObjects:@"mode", @"customView", @"labelText", @"labelFont",
@"detailsLabelText", @"detailsLabelFont", @"progress", nil];
}
注册键值
- (void)registerForKVO {
for (NSString *keyPath in [self observableKeypaths]) {
[self addObserver:self forKeyPath:keyPath options:NSKeyValueObservingOptionNew context:NULL];
}
}
当键值改变时，更新UI
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
if (![NSThread isMainThread]) {
[self performSelectorOnMainThread:@selector(updateUIForKeypath:) withObject:keyPath waitUntilDone:NO];
} else {
[self updateUIForKeypath:keyPath];
}
}
MainActivity如下:
package com.cn.testpopupwindow;
import android.app.Activity;
import android.graphics.drawable.BitmapDrawable;
import android.os.Bundle;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup.LayoutParams;
import android.widget.Button;
import android.widget.PopupWindow;
public class MainActivity extends Activity {
private Button button;
private Button button1;
private Button button2;
private Button button3;
private Button button4;
private View popupWindowView;
private PopupWindow popupWindow;
private LayoutInflater inflater;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
button=(Button) findViewById(R.id.button);
button.setOnClickListener(new ButtonOnClickListener());
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
private class ButtonOnClickListener implements OnClickListener{
public void onClick(View v) {
inflater=(LayoutInflater) getSystemService(LAYOUT_INFLATER_SERVICE);
popupWindowView=inflater.inflate(R.layout.popupwindow, null);
popupWindow=new PopupWindow(popupWindowView, LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT,true);
//必须要有这句否则弹出popupWindow后监听不到Back键
popupWindow.setBackgroundDrawable(new BitmapDrawable());
popupWindow.showAtLocation(findViewById(R.id.button), Gravity.NO_GRAVITY, 0, 0);
//让popupWindow获得焦点
popupWindow.setFocusable(true);
//设置动画
popupWindow.setAnimationStyle(R.style.popupWindowAnimation);
popupWindow.update();
//popupWindow中按钮的处理
button1=(Button) popupWindowView.findViewById(R.id.button1);
button2=(Button) popupWindowView.findViewById(R.id.button2);
button3=(Button) popupWindowView.findViewById(R.id.button3);
button4=(Button) popupWindowView.findViewById(R.id.button4);
button1.setOnClickListener(new ButtonsOnClickListener());
button2.setOnClickListener(new ButtonsOnClickListener());
button3.setOnClickListener(new ButtonsOnClickListener());
button4.setOnClickListener(new ButtonsOnClickListener());
}
}
private class ButtonsOnClickListener implements OnClickListener {
public void onClick(View v) {
switch (v.getId()) {
case R.id.button1:
System.out.println("点击了按钮1");
break;
case R.id.button2:
System.out.println("点击了按钮2");
break;
case R.id.button3:
System.out.println("点击了按钮3");
break;
case R.id.button4:
System.out.println("点击了按钮4");
break;
default:
break;
}
}
}
//监听Back事件
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode==KeyEvent.KEYCODE_BACK) {
if (popupWindow!=null&&popupWindow.isShowing()) {
popupWindow.dismiss();
} else {
MainActivity.this.finish();
}
}
return super.onKeyDown(keyCode, event);
}
}
Main.xml如下:
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent" >
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="test"
android:layout_centerInParent="true"
/>
</RelativeLayout>
popupwindow.xml如下:
<?xml version="1.0" encoding="utf-8"?>
<!--注意:在RelativeLayout里面是LinearLayout,且是vertical的-->
<!--第一个Button的 layout_marginTop是相对于父控件而言的-->
<!--但是第二个Button的layout_marginTop是相对于第一个Button而言的 -->
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#f0838b8b"
android:orientation="vertical"
>
<LinearLayout
android:id="@+id/linerLayout"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:orientation="vertical"
>
<Button
android:id="@+id/button1"
android:layout_width="200dip"
android:layout_height="wrap_content"
android:text="Button1"
android:textSize="20sp"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dip"
/>
<Button
android:id="@+id/button2"
android:layout_width="200dip"
android:layout_height="wrap_content"
android:text="Button2"
android:textSize="20sp"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dip"
/>
<Button
android:id="@+id/button3"
android:layout_width="200dip"
android:layout_height="wrap_content"
android:text="Button3"
android:textSize="20sp"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dip"
/>
<Button
android:id="@+id/button4"
android:layout_width="200dip"
android:layout_height="wrap_content"
android:text="Button4"
android:textSize="20sp"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dip"
/>
</LinearLayout>
</RelativeLayout>
style.xml如下
<resources xmlns:android="http://schemas.android.com/apk/res/android">
<style name="AppTheme" parent="android:Theme.Light" />
<style name="popupWindowAnimation" mce_bogus="1" parent="android:Animation">
<item name="android:windowEnterAnimation">@anim/enter</item>
<item name="android:windowExitAnimation">@anim/exit</item>
</style>
</resources>
enter.xml动画如下:
<?xml version="1.0" encoding="utf-8"?>
<!-- android:fromYDelta:动画开始的点离当前View X坐标上的差值 -->
<!-- 利用100%p表示该动画在当前View的最下方 -->
<set
xmlns:android="http://schemas.android.com/apk/res/android">
<translate
android:duration="1500"
android:fromYDelta="100%p"
android:interpolator="@android:anim/decelerate_interpolator"
android:toYDelta="0" />
</set>
exit.xml动画如下:
<?xml version="1.0" encoding="utf-8"?>
<!-- Alpha=1.0表示不透明,Alpha=0.0表示透明 -->
<set
xmlns:android="http://schemas.android.com/apk/res/android"
android:interpolator="@android:anim/decelerate_interpolator" >
<alpha
android:duration="1000"
android:fromAlpha="1.0"
android:toAlpha="0.0"
/>
</set>
创建Wi-Fi Direct应用程序
创建Wi-Fi Direct应用程序涉及到给应用程序创建和注册广播接收器、发现对等设备、连接对等设备和把数据传送给对等设备。下面会介绍如何完成这些事情。
初始安装
在使用Wi-Fi Direct API之前，必须确保你的应用程序能够访问硬件，并且该设备要支持Wi-Fi Direct协议。如果支持Wi-Fi Direct，你就可以获得一个WifiP2pManager实例，然后创建和注册你的广播接收器，开始使用Wi-Fi Direct API。
1. 在Android清单中申请使用设备上Wi-Fi硬件的权限，并声明要使用的最小的SDK版本：
<uses-sdkandroid:minSdkVersion="14"/>
<uses-permissionandroid:name="android.permission.ACCESS_WIFI_STATE"/>
<uses-permissionandroid:name="android.permission.CHANGE_WIFI_STATE"/>
<uses-permissionandroid:name="android.permission.CHANGE_NETWORK_STATE"/>
<uses-permissionandroid:name="android.permission.INTERNET"/>
<uses-permissionandroid:name="android.permission.ACCESS_NETWORK_STATE"/>
2. 检查是否支持Wi-Fi Direct。做这项检查的一个好的位置是，接收WIFI_P2P_STATE_CHANGED_ACTION类型的Intent的广播接收器中，把Wi-Fi Direct的状态通知给你的Activity，并作出相应的反应：
@Override
publicvoid onReceive(Context context,Intent intent){
...
String action = intent.getAction();
if(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)){
int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE,-1);
if(state ==WifiP2pManager.WIFI_P2P_STATE_ENABLED){
// Wifi Direct is enabled
}else{
// Wi-Fi Direct is not enabled
}
}
...
}
3. 在你的Activity的onCreate()方法中，获得一个WifiP2pManager的实例，并且要调用initialize()方法把你的应用程序注册到Wi-Fi Direct框架中。这个方法会返回一个WifiP2pManager.Channel对象，它用于把应用程序连接到Wi-Fi Direct框架。你还应该创建一个带有WifiP2pManager和WifiP2pManager.Channel对象以及你的Activity的引用的广播接收器实例。这样就允许你的广播接收器根据变化把你感兴趣的事件通知给你的Activity。如果需要，你还可以维护设备的Wi-Fi状态：
WifiP2pManager mManager;
Channel mChannel;
BroadcastReceiver mReceiver;
...
@Override
protectedvoid onCreate(Bundle savedInstanceState){
...
mManager =(WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
mChannel = mManager.initialize(this, getMainLooper(),null);
mReceiver =newWiFiDirectBroadcastReceiver(manager, channel,this);
...
}
4. 创建一个Intent过滤器，并给这个Intent添加你的广播接收器要检查操作：
IntentFilter mIntentFilter;
...
@Override
protectedvoid onCreate(Bundle savedInstanceState){
...
mIntentFilter =newIntentFilter();
mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
...
}
5. 在你的Activity的onResume()方法中注册广播接收器，并且要在你的Activity的onPause()方法注销它：
/* register the broadcast receiver with the intent values to be matched */
@Override
protectedvoid onResume(){
super.onResume();
registerReceiver(mReceiver, mIntentFilter);
}
/* unregister the broadcast receiver */
@Override
protectedvoid onPause(){
super.onPause();
unregisterReceiver(mReceiver);
}
当你已经获得了一个WifiP2pManager.Channel对象并建立一个广播接收器时，你的应用程序就能够调用Wi-Fi Direct方法和接收Wi-Fi Direct的Intent对象了。
现在，通过调用WifiP2pManager对象中的方法，你能够使用Wi-Fi Direct功能了。接下来向你介绍如何使用发现和连接对等设备等通用操作。
发现对等设备
要发现有效的可连接的对等设备，就要调用discoverPeers()方法，在一定的范围内检查有效的对等设备。这个功能调用是异步的，如果你创建了WifiP2pManager.ActionListener监听器，那么你的应用程序就会使用onSuccess()和onFailure()方法来完成成功或失败的传递。onSuccess()方法只会通知你，发现处理成功了，它并不提供发现的相关实际对等设备的任何信息：
manager.discoverPeers(channel,newWifiP2pManager.ActionListener(){
@Override
publicvoid onSuccess(){
...
}
@Override
publicvoid onFailure(int reasonCode){
...
}
});
如果发现处理成功，并检测到对等设备，系统会广播WIFI_P2P_PEERS_CHANGED_ACTION类型的Intent，你能够在一个广播接收器中监听这个Intent，以便获得对等设备的列表。当你的应用程序接收到这个Intent时，你能够使用requestPeers()方法来请求被发现的对等设备的列表。下列代码显示了如何做这件事：
PeerListListener myPeerListListener;
...
if(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)){
// request available peers from the wifi p2p manager. This is an
// asynchronous call and the calling activity is notified with a
// callback on PeerListListener.onPeersAvailable()
if(manager !=null){
manager.requestPeers(channel, myPeerListListener);
}
}
requestPeers()方法也是异步的，有效的对等设备列表是使用onPeersAvailable()回调来通知你的Activity的，这个回调方法是在WifiP2pManager.PeerListListener接口中定义的。onPeersAvailable()方法会给你提供一个WifiP2pDeviceList对象，通过迭代该对象就能够找到你想要连接的对等设备。
连接对等设备
在获得可能的对等设备列表之后，并从中找到了你想要连接的设备时，就要调用connect()方法来连接设备。调用这个方法需要一个WifiP2pConfig对象，该对象包含了要连接的设备的信息。通过WifiP2pManager.ActionListener监听器，你能够获得连接成功或失败的通知。下列代码显示了如何创建跟期望的设备的连接：
//obtain a peer from the WifiP2pDeviceList
WifiP2pDevice device;
WifiP2pConfig config =newWifiP2pConfig();
config.deviceAddress = device.deviceAddress;
manager.connect(channel, config,newActionListener(){
@Override
publicvoid onSuccess(){
//success logic
}
@Override
publicvoid onFailure(int reason){
//failure logic
}
});
传输数据
一旦建立了连接，就能够使用套接字在设备之间传输数据。基本的步骤如下：
1. 创建一个ServerSocket对象。这个套接字会在指定的端口上等待来自客户端的连接，并且要一直阻塞到连接发生，因此要在后台线程中做这件事。
2. 创建一个客户端的Socket对象。该客户端要使用服务套接字的IP地址和端口来连接服务端设备。
3. 把数据从客户端发送给服务端。当客户端套接字跟服务端套接字成功的建立了连接，你就能够以字节流的形式，把数据从客户端发送给服务端了。
4. 服务套接字等待客户端的连接（用accept()方法）。这个调用会一直阻塞到客户端的连接发生，因此这个调用要放到另外一个线程中。当连接发生时，服务端能够接收来自客户端的数据。并对这个数据执行一些操作，如保存到文件或展现给用户。
下例来自Wi-Fi Direct Demo示例，向你展示了如何创建这种客户-服务套接字的通信，并从客户端把JPEG图片传输给服务端。完整的示例请编译和运行Wi-Fi Direct Demo示例：
public static class FileServerAsyncTask extends AsyncTask {
private Context context;
private TextView statusText;
public FileServerAsyncTask(Context context, View statusText) {
this.context = context;
this.statusText = (TextView) statusText;
}
@Override
protected String doInBackground(Void... params) {
try {
/**
* Create a server socket and wait for client connections. This
* call blocks until a connection is accepted from a client
*/
ServerSocket serverSocket = new ServerSocket(8888);
Socket client = serverSocket.accept();
/**
* If this code is reached, a client has connected and transferred data
* Save the input stream from the client as a JPEG file
*/
final File f = new File(Environment.getExternalStorageDirectory() + "/"
+ context.getPackageName() + "/wifip2pshared-" + System.currentTimeMillis()
+ ".jpg");
File dirs = new File(f.getParent());
if (!dirs.exists())
dirs.mkdirs();
f.createNewFile();
InputStream inputstream = client.getInputStream();
copyFile(inputstream, new FileOutputStream(f));
serverSocket.close();
return f.getAbsolutePath();
} catch (IOException e) {
Log.e(WiFiDirectActivity.TAG, e.getMessage());
return null;
}
}
/**
* Start activity that can handle the JPEG image
*/
@Override
protected void onPostExecute(String result) {
if (result != null) {
statusText.setText("File copied - " + result);
Intent intent = new Intent();
intent.setAction(android.content.Intent.ACTION_VIEW);
intent.setDataAndType(Uri.parse("file://" + result), "image/*");
context.startActivity(intent);
}
}
}
在客户端，客户套接字连接到服务套接字，并传输数据。这个例子是把客户端设备的文件系统上的一个JPEG文件传输给服务端。
Context context =this.getApplicationContext();
String host;
int port;
int len;
Socket socket =newSocket();
byte buf[] =newbyte[1024];
...
try{
/**
* Create a client socket with the host,
* port, and timeout information.
*/
socket.bind(null);
socket.connect((newInetSocketAddress(host, port)),500);
/**
* Create a byte stream from a JPEG file and pipe it to the output stream
* of the socket. This data will be retrieved by the server device.
*/
OutputStream outputStream = socket.getOutputStream();
ContentResolver cr = context.getContentResolver();
InputStream inputStream =null;
inputStream = cr.openInputStream(Uri.parse("path/to/picture.jpg"));
while((len = inputStream.read(buf))!=-1){
outputStream.write(buf,0, len);
}
outputStream.close();
inputStream.close();
}catch(FileNotFoundException e){
//catch logic
}catch(IOException e){
//catch logic
}
/**
* Clean up any open sockets when done
* transferring or if an exception occurred.
*/
finally{
if(socket !=null){
if(socket.isConnected()){
try{
socket.close();
}catch(IOException e){
//catch logic
}
}
}
}