本文介绍了一个基于Android的应用程序如何实现Wi-Fi热点的开启及服务器功能。应用通过启动服务监听客户端连接并处理数据交换，同时提供了心跳机制维持连接稳定。
权限申请，代码开启热点，开启服务器
package com.example.administrator.wifitrainingclothes.service;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.os.Message;
import android.support.annotation.Nullable;
import android.util.Log;
import com.example.administrator.wifitrainingclothes.data.Socketdata;
import com.example.administrator.wifitrainingclothes.data.StaticDatas;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Handler;
/**
* Created by Administrator on 2017/11/3 0003.
*/
public class WifiService extends Service {
static String TGA="WifiService";
ArrayList<Socketdata> sockets = new ArrayList<>();
private int timeCount;
private ServerSocket server = null;
public interface wifiDataReturn {
void wifiReturn_1( int flag,Boolean b);
void wifiReturn_2( int flag,String ip,String mac);
void wifiReturn_3( int flag,String ip,String data);
}
private wifiDataReturn mWifiDataReturn;
public void getWifiDataReturn(wifiDataReturn wifiDataReturn){
this.mWifiDataReturn = wifiDataReturn;
}
public class LocalBinder extends Binder {
public WifiService getService() {
return WifiService.this;
}
}
private final IBinder mBinder = new LocalBinder();
@Override
public void onCreate()
{
// The service is being created
Log.e(TGA,"onCreate");
sockets.clear();
timeCount=0;
handler.removeMessages(1);
handler.sendEmptyMessageDelayed(1,1000);
}
@Override
public IBinder onBind(Intent intent) {
Log.e(TGA,"onBind");
return mBinder;
}
@Override
public boolean onUnbind(Intent intent) {
Log.e(TGA,"onUnbind");
return super.onUnbind(intent);
}
@Override
public void onDestroy()
{
Log.e(TGA,"onDestroy");
// The service is no longer used and is being destroyed
}
public void startServer(){
Thread thread = new Thread(){
@Override
public void run() {
super.run();
/*指明服务器端的端口号*/
try {
server = new ServerSocket(9999);
mWifiDataReturn.wifiReturn_1(StaticDatas.WIFISERVICE_RETURN_OPEN,true);
} catch (IOException e) {
e.printStackTrace();
mWifiDataReturn.wifiReturn_1(StaticDatas.WIFISERVICE_RETURN_OPEN,false);
if (server!=null){
try {
server.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
while (true){
Socket socket = null;
try {
socket = server.accept();
mWifiDataReturn.wifiReturn_2(StaticDatas.WIFISERVICE_RETURN_LINK,
socket.getInetAddress().getHostAddress(),
"");
Socketdata socketdata = new Socketdata();
socketdata.socket=socket;
socketdata.ip=socket.getInetAddress().getHostAddress();
if(sockets.size()>0){
int c=sockets.size();
for(int i=0;i<c;i++){
if(sockets.get(i).ip.equals(socketdata.ip)){
sockets.remove(i);
sockets.add(socketdata);
break;
}else{
sockets.add(socketdata);
}
}
}else{
sockets.add(socketdata);
}
Log.e(TGA,"客户端数量："+sockets.size());
} catch (IOException e) {
e.printStackTrace();
mWifiDataReturn.wifiReturn_1(StaticDatas.WIFISERVICE_RETURN_OPEN,false);
}
new ServerThread(socket).start();
}
}
};
thread.start();
}
class ServerThread extends Thread{
private Socket socket;
InputStream inputStream;
public ServerThread(Socket socket){
this.socket = socket;
try {
inputStream=socket.getInputStream();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
byte[] h = new byte[1];
int size ;
while (inputStream!= null) {
try {
if(inputStream.read(h)!=-1){
size = inputStream.available();
if(size>0){
System.out.println("客户端发送字节数："+size+1);
byte[] b = new byte[size];
inputStream.read(b);
mWifiDataReturn.wifiReturn_3(StaticDatas.WIFISERVICE_RETURN_DATA,
socket.getInetAddress().getHostAddress(),
byte2hex(h)+byte2hex(b));
}else{
mWifiDataReturn.wifiReturn_3(StaticDatas.WIFISERVICE_RETURN_DATA,
socket.getInetAddress().getHostAddress(),
byte2hex(h));
}
}else{
Log.e(TGA,"客户端断开连接1："+ socket.getInetAddress().getHostAddress());
inputStream.close();
socket.close();
for(int i=0;i<sockets.size();i++){
if(sockets.get(i).ip.equals(socket.getInetAddress().getHostAddress())){
sockets.remove(i);
break;
}
}
break;
}
// try {
// socket.sendUrgentData(0);
// } catch (IOException e) {
// //如果抛出了异常，那么就是断开连接了
// Log.e(TGA,"客户端断开连接："+ socket.getInetAddress().getHostAddress());
// break;
// }
} catch (IOException e) {
e.printStackTrace();
Log.e(TGA,"客户端断开连接2："+ socket.getInetAddress().getHostAddress());
for(int i=0;i<sockets.size();i++){
if(sockets.get(i).ip.equals(socket.getInetAddress().getHostAddress())){
sockets.remove(i);
break;
}
}
try {
inputStream.close();
socket.close();
} catch (IOException e1) {
e1.printStackTrace();
}
break;
}
}
}
}
public static String byte2hex(byte[] b) {
StringBuffer hs = new StringBuffer(b.length);
String stmp = "";
int len = b.length;
for (int n = 0; n < len; n++) {
stmp = Integer.toHexString(b[n] & 0xFF);
if (stmp.length() == 1)
hs = hs.append("0").append(stmp);
else {
hs = hs.append(stmp);
}
}
return String.valueOf(hs);
}
public android.os.Handler handler = new android.os.Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
timeCount++;
if(timeCount>=StaticDatas.WIFISERVICE_OUT_TIME){
timeCount=0;
int c=sockets.size();
Log.e(TGA,"客户端现有数量："+ c);
for(int i=0;i<c;i++){
try {
Log.e(TGA,"发送心跳包："+ sockets.get(i).socket.getInetAddress().getHostAddress());
sockets.get(i).socket.sendUrgentData(0);
} catch (IOException e) {
e.printStackTrace();
//如果抛出了异常，那么就是断开连接了
Log.e(TGA,"客户端断开连接3："+ sockets.get(i).socket.getInetAddress().getHostAddress());
try {
sockets.get(i).socket.getInputStream().close();
sockets.get(i).socket.close();
} catch (IOException e1) {
e1.printStackTrace();
}
sockets.remove(i);
i--;
c--;
}
}
}
handler.removeMessages(1);
handler.sendEmptyMessageDelayed(1,1000);
break;
}
}
};
}
package com.example.administrator.wifitrainingclothes.data;
import java.net.Socket;
/**
* Created by Administrator on 2017/10/10 0010.
*/
public class Socketdata {
public Socket socket;
public String ip;
public String data=null;
}
package com.example.administrator.wifitrainingclothes.data;
/**
* Created by Administrator on 2017/11/14 0014.
*/
public class StaticDatas {
public static final int WIFISERVICE_RETURN_OPEN = 101;
public static final int WIFISERVICE_RETURN_LINK = 201;
public static final int WIFISERVICE_RETURN_DATA = 301;
public static final int WIFISERVICE_OUT_TIME = 20;
}
package com.example.administrator.wifitrainingclothes;
import android.app.Activity;
import android.app.Application;
import android.os.Bundle;
import android.util.Log;
/**
* Created by Administrator on 17-5-25.
*/
public class SysAPP extends Application {
static String TAG="SysAPP";
int mCount;
public static int CODE=-1;
@Override
public void onCreate() {
Log.e(TAG,"onCreate");
Log.e(TAG,CODE+"");
super.onCreate();
mCount = 0;
registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
}
@Override
public void onActivityStarted(Activity activity) {
mCount++;
//如果mCount==1，说明是从后台到前台
if (mCount == 1){
//执行app跳转到前台的逻辑
Log.e(TAG,"app跳转到前台");
}
}
@Override
public void onActivityResumed(Activity activity) {
}
@Override
public void onActivityPaused(Activity activity) {
}
@Override
public void onActivityStopped(Activity activity) {
mCount--;
//如果mCount==0，说明是前台到后台
if (mCount == 0){
//执行应用切换到后台的逻辑
Log.e(TAG,"app跳转到后台");
}
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
}
@Override
public void onActivityDestroyed(Activity activity) {
}
});
}
@Override
public void onLowMemory() {
super.onLowMemory();
System.gc();
Log.e("onLowMemory","onLowMemory");
}
@Override
public void onTerminate() {
super.onTerminate();
Log.e("onTerminate","onTerminate");
}
@Override
public void onTrimMemory(int level) {
super.onTrimMemory(level);
Log.e("onTrimMemory","onTrimMemory");
}
}
package com.example.administrator.wifitrainingclothes.UI;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.system.ErrnoException;
import android.util.Log;
import android.view.KeyEvent;
import com.example.administrator.wifitrainingclothes.R;
import com.example.administrator.wifitrainingclothes.SysAPP;
import com.example.administrator.wifitrainingclothes.service.WifiService;
public class MainActivity extends AppCompatActivity {
private static String TAG ="MainActivity";
private WifiService mWifiService;
//创建ServiceConnection类型的实例
private ServiceConnection conn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mWifiService = ((WifiService.LocalBinder) service).getService();
Log.e(TAG,"绑定服务成功");
mWifiService.getWifiDataReturn(new WifiService.wifiDataReturn() {
@Override
public void wifiReturn_1(int flag, Boolean b) {
}
@Override
public void wifiReturn_2(int flag, String ip, String mac) {
Log.e(TAG,"有客户端连接:ip:"+ip+";mac:"+mac);
}
@Override
public void wifiReturn_3(int flag, String ip, String data) {
Log.e(TAG,"收到"+ip+"发来的数据:"+data);
}
});
}
//client 和service连接意外丢失时，会调用该方法
@Override
public void onServiceDisconnected(ComponentName name) {
Log.e(TAG,"和service连接意外丢失");
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
if(SysAPP.CODE == -1){
Log.e(TAG,"应用被强杀");
//重启
Intent intent = getBaseContext().getPackageManager()
.getLaunchIntentForPackage(getBaseContext().getPackageName());
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
}
Intent gattServiceIntent = new Intent(this, WifiService.class);
bindService(gattServiceIntent, conn, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
super.onDestroy();
try {
unbindService(conn);
}catch (Exception e){
}
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK) {
Intent home = new Intent(Intent.ACTION_MAIN);
home.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
home.addCategory(Intent.CATEGORY_HOME);
startActivity(home);
return true;
}
return super.onKeyDown(keyCode, event);
}
}
package com.example.administrator.wifitrainingclothes.UI;
import android.Manifest;
import android.annotation.TargetApi;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.location.LocationManager;
import android.net.Uri;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.annotation.RequiresApi;
import android.support.design.widget.Snackbar;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.util.Log;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Toast;
import com.example.administrator.wifitrainingclothes.R;
import com.example.administrator.wifitrainingclothes.SysAPP;
import com.example.administrator.wifitrainingclothes.service.WifiService;
import java.lang.reflect.Method;
public class SplashActivity extends Activity {
private WifiManager wifiManager;
private final int SPLASH_DISPLAY_LENGHT = 300;
private static final int REQUEST_CODE_LOCATION_SETTINGS = 212;
private static String TAG = "SplashActivity";
private WifiService mWifiService;
//创建ServiceConnection类型的实例
private ServiceConnection conn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mWifiService = ((WifiService.LocalBinder) service).getService();
Log.e(TAG,"绑定服务成功");
mWifiService.getWifiDataReturn(new WifiService.wifiDataReturn() {
@Override
public void wifiReturn_1(int flag, Boolean b) {
if(b){
Log.e(TAG,"服务器开启，进入主界面");
Intent mainIntent = new Intent(SplashActivity.this,MainActivity.class);
SplashActivity.this.startActivity(mainIntent);
SplashActivity.this.finish();
}else{
Log.e(TAG,"服务器开启失败，重启");
//重启
Intent intent = getBaseContext().getPackageManager()
.getLaunchIntentForPackage(getBaseContext().getPackageName());
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
}
}
@Override
public void wifiReturn_2(int flag, String ip, String mac) {
}
@Override
public void wifiReturn_3(int flag, String ip, String data) {
}
});
}
//client 和service连接意外丢失时，会调用该方法
@Override
public void onServiceDisconnected(ComponentName name) {
Log.e(TAG,"和service连接意外丢失");
}
};
View view;
// 要申请的权限
private String[] permissions = {
Manifest.permission.ACCESS_FINE_LOCATION,
Manifest.permission.ACCESS_COARSE_LOCATION,
Manifest.permission.BLUETOOTH,
Manifest.permission.BLUETOOTH_ADMIN,
Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS,
Manifest.permission.CHANGE_CONFIGURATION,
Manifest.permission.WRITE_EXTERNAL_STORAGE,
};
private AlertDialog dialog;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
if(Build.VERSION.SDK_INT>= Build.VERSION_CODES.LOLLIPOP){
setStatusBarUpperAPI21();
}
setContentView(R.layout.activity_splash);
view=findViewById(R.id.view);
SysAPP.CODE = 1;
wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
Intent gattServiceIntent = new Intent(this, WifiService.class);
bindService(gattServiceIntent, conn, Context.BIND_AUTO_CREATE);
// 版本判断。当手机系统大于 23 时，才有必要去判断权限是否获取
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
Log.e(TAG,"系统大于23");
// 检查该权限是否已经获取
for(int m=0;m<permissions.length;m++){
int i = ContextCompat.checkSelfPermission(this, permissions[m]);
// 权限是否已经 授权 GRANTED---授权 DINIED---拒绝
if (i != PackageManager.PERMISSION_GRANTED) {
// 如果没有授予该权限，就去提示用户请求
showDialogTipUserRequestPermission();
}else{
new Handler().postDelayed(new Runnable(){
@Override
public void run() {
if(!isLocationEnable(getApplication())){
new AlertDialog.Builder(SplashActivity.this)
.setTitle("提示")
.setMessage("Android6.0或以上版本需要打开GPS才能使用蓝牙功能，是否打开GPS?")
.setPositiveButton("立即开启", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
setLocationService();
}
})
.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
finish();
}
}).setCancelable(false).show();
}else {
startToMainActivity();
}
}
}, SPLASH_DISPLAY_LENGHT);
}
}
}else{
startToMainActivity();
}
}
// 提示用户该请求权限的弹出框
private void showDialogTipUserRequestPermission() {
new AlertDialog.Builder(this)
.setTitle("权限不可用")
.setMessage("Android6.0以上蓝牙需要GPS权限；\n否则，您将无法正常使用该蓝牙。")
.setPositiveButton("立即开启", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
startRequestPermission();
}
})
.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
finish();
}
}).setCancelable(false).show();
}
// 开始提交请求权限
private void startRequestPermission() {
ActivityCompat.requestPermissions(this, permissions, 321);
}
// 用户权限 申请 的回调方法
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (requestCode == 321) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (grantResults[0] != PackageManager.PERMISSION_GRANTED) {
// 判断用户是否 点击了不再提醒。(检测该权限是否还可以申请)
boolean b = shouldShowRequestPermissionRationale(permissions[0]);
if (!b) {
// 用户还是想用我的 APP 的
// 提示用户去应用设置界面手动开启权限
showDialogTipUserGoToAppSettting();
} else
finish();
} else {
Toast.makeText(this, "权限获取成功", Toast.LENGTH_SHORT).show();
// showSnackbar("权限获取成功");
if(!isLocationEnable(getApplication())){
new AlertDialog.Builder(SplashActivity.this)
.setTitle("提示")
.setMessage("Android6.0或以上版本需要打开GPS才能使用蓝牙功能，是否打开GPS?")
.setPositiveButton("立即开启", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
setLocationService();
}
})
.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
finish();
}
}).setCancelable(false).show();
}else {
startToMainActivity();
}
}
}
}
}
// 提示用户去应用设置界面手动开启权限
private void showDialogTipUserGoToAppSettting() {
dialog = new AlertDialog.Builder(this)
.setTitle("权限不可用")
.setMessage("请在-应用设置-权限-中，允许该应用使用蓝牙、位置等权限。")
.setPositiveButton("立即开启", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// 跳转到应用设置界面
goToAppSetting();
}
})
.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
finish();
}
}).setCancelable(false).show();
}
// 跳转到当前应用的设置界面
private void goToAppSetting() {
Intent intent = new Intent();
intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
Uri uri = Uri.fromParts("package", getPackageName(), null);
intent.setData(uri);
startActivityForResult(intent, 123);
}
//设置界面的回调
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == 123) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
// 检查该权限是否已经获取
int i = ContextCompat.checkSelfPermission(this, permissions[0]);
// 权限是否已经 授权 GRANTED---授权 DINIED---拒绝
if (i != PackageManager.PERMISSION_GRANTED) {
// 提示用户应该去应用设置界面手动开启权限
showDialogTipUserGoToAppSettting();
} else {
if (dialog != null && dialog.isShowing()) {
dialog.dismiss();
}
Toast.makeText(this, "权限获取成功", Toast.LENGTH_SHORT).show();
if(!isLocationEnable(getApplication())){
new AlertDialog.Builder(SplashActivity.this)
.setTitle("提示")
.setMessage("Android6.0或以上版本需要打开GPS才能使用蓝牙功能，是否打开GPS?")
.setPositiveButton("立即开启", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
setLocationService();
}
})
.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
finish();
}
}).setCancelable(false).show();
}else {
startToMainActivity();
}
}
}
}
else if (requestCode == REQUEST_CODE_LOCATION_SETTINGS) {
if (isLocationEnable(this)) {
//Toast.makeText(getApplicationContext(), "定位已打开！", Toast.LENGTH_LONG).show();
showSnackbar("GPS已打开！");
startToMainActivity();
//定位已打开的处理
} else {
//定位依然没有打开的处理
// Toast.makeText(getApplicationContext(), "定位未打开！", Toast.LENGTH_LONG).show();
showSnackbar("GPS未打开！");
handler.removeMessages(999);
handler.sendEmptyMessageDelayed(999,1000);
}
}
}
public static final boolean isLocationEnable(Context context) {
LocationManager locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
boolean networkProvider = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
boolean gpsProvider = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
if (networkProvider || gpsProvider) return true;
return false;
}
private void setLocationService() {
Intent locationIntent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
this.startActivityForResult(locationIntent, REQUEST_CODE_LOCATION_SETTINGS);
}
public void showSnackbar(String str){
final Snackbar snackbar = Snackbar.make(view, str, Snackbar
.LENGTH_LONG);
snackbar.show();
snackbar.setAction("确定", new View.OnClickListener() {
@Override
public void onClick(View view) {
snackbar.dismiss();
}
});
}
Handler handler = new Handler() {
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (msg.what == 999) {
if(!isLocationEnable(getApplication())){
new AlertDialog.Builder(SplashActivity.this)
.setTitle("提示")
.setMessage("Android6.0或以上版本需要打开GPS才能使用蓝牙功能，是否打开GPS?")
.setPositiveButton("立即开启", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
setLocationService();
}
})
.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
finish();
}
}).setCancelable(false).show();
}else {
startToMainActivity();
}
}
}
};
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private void setStatusBarUpperAPI21(){
Window window =getWindow();
window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS
|WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
|View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
|View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
window.setStatusBarColor(Color.TRANSPARENT);
window.setNavigationBarColor(Color.TRANSPARENT);
}
/**
* 判断WIFI热点是否开启
*/
public boolean isApOn() {
try {
Method method = wifiManager.getClass().getDeclaredMethod("isWifiApEnabled");
method.setAccessible(true);
return (Boolean) method.invoke(wifiManager);
}
catch (Throwable ignored) {}
return false;
}
/**
* 设置热点名称及密码，并创建热点
* @param mSSID
* @param mPasswd
*/
private Boolean stratWifiAp(String mSSID, String mPasswd,Boolean onoff) {
Method method1 ;
if(onoff){
wifiManager.setWifiEnabled(false);
}
try {
//通过反射机制打开热点
method1 = wifiManager.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);
return (Boolean)method1.invoke(wifiManager, netConfig, onoff);
} catch (Exception e) {
return false;
}
}
private void startToMainActivity(){
if(isApOn()){
Log.e(TAG,"WiFi热点已开启，将关闭热点 ");
stratWifiAp("bbbbbb","123456789",false);
}
new Handler().postDelayed(new Runnable(){
@Override
public void run() {
Boolean backWifi= stratWifiAp("aaaaaa","123456789",true);
Log.e(TAG,"启动WiFi "+backWifi);
if(backWifi){
mWifiService.startServer();
}else{
Log.e(TAG,"启动WiFi 热点 失败 ");
}
}
}, SPLASH_DISPLAY_LENGHT);
}
@Override
protected void onDestroy() {
super.onDestroy();
try {
unbindService(conn);
}catch (Exception e){
}
}
}
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
>
<View
android:id="@+id/view"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
</View>
</LinearLayout>
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
