本文章用于提供查询GT包中的功能：
GT源码下载网址：https://github.com/1079374315/Android/blob/master/GT.java
package com.gsls.king.gooverandroid.Util;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.media.AudioAttributes;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.SoundPool;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.PowerManager;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.RequiresApi;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.support.v4.app.NotificationCompat;
import android.support.v4.app.NotificationManagerCompat;
import android.support.v7.app.AppCompatActivity;
import android.text.Html;
import android.util.Log;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.webkit.WebView;
import android.widget.Toast;
import com.bumptech.glide.Glide;
import com.bumptech.glide.request.target.SimpleTarget;
import com.bumptech.glide.request.transition.Transition;
import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import com.lzy.okgo.callback.StringCallback;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
/**
* 工具类说明：
* GSLS_Tool
* 须依赖的包：
* implementation 'com.google.code.gson:gson:2.8.5' //JSON 数据解析
* implementation 'com.lzy.net:okgo:3.0.4' //OkGo网络框架
* implementation 'com.github.bumptech.glide:glide:4.8.0' //加载图片的glide
* implementation 'org.jsoup:jsoup:1.10.3' //Jsoup格式化html数据
*
*
* 更新时间:2019.5.4
*
*
* 小提示：(用于 AndroidStudio )
* 收起所有的 方法: Ctrl + Shift + - (减号)
* 展开所有的 方法: Ctrl + Shift + + (加号)
*
*/
@SuppressWarnings("unchecked")
public class GT {
//设置不可实例化
private GT(){}
public static Boolean LOG_TF = true; //控制外部所有的 Log 显示
public static Boolean GT_LOG_TF = false; //控制内部所有的 Log 显示
public static Boolean TOAST_TF = true; //控制外部所有的 toast 显示
public static Boolean GT_TOAST_TF = false; //控制内部所有的 toast 显示
public static Context CONTEXT; //设置 当前动态的 上下文对象
/******************************************** 提示类 *****************************************************/
//提示消息 Log
public static void log_v(Object msg){
if(LOG_TF){
Log.v("GT_v","------- " + msg);
}
}
public static void log_d(Object msg){
if(LOG_TF){
Log.d("GT_d","------- " + msg);
}
}
public static void log_i(Object msg){
if(LOG_TF){
Log.i("GT_i","------- " + msg);
}
}
public static void log_w(Object msg){
if(LOG_TF){
Log.w("GT_w","------- " + msg);
}
}
public static void log_e(Object msg){
if(LOG_TF){
Log.e("GT_e","------- " + msg);
}
}
public static void log_v(Object title, Object msg){
if(LOG_TF){
Log.v("GT_v",
"------- Run" +
"\n\n---------------------" + title + "------------------------\n" +
" " + msg + "\n" +
"---------------------" + title + "-----------------------\n\n" +
"------- Close"
);
}
}
public static void log_d(Object title, Object msg){
if(LOG_TF){
Log.d("GT_d",
"------- Run" +
"\n\n---------------------" + title + "------------------------\n" +
" " + msg + "\n" +
"---------------------" + title + "-----------------------\n\n" +
"------- Close"
);
}
}
public static void log_i(Object title, Object msg){
if(LOG_TF){
Log.i("GT_i",
"------- Run" +
"\n\n---------------------" + title + "------------------------\n" +
" " + msg + "\n" +
"---------------------" + title + "-----------------------\n\n" +
"------- Close"
);
}
}
public static void log_w(Object title, Object msg){
if(LOG_TF){
Log.w("GT_w",
"------- Run" +
"\n\n---------------------" + title + "------------------------\n" +
" " + msg + "\n" +
"---------------------" + title + "-----------------------\n\n" +
"------- Close"
);
}
}
public static void log_e(Object title, Object msg){
if(LOG_TF){
Log.e("GT_e",
"------- Run" +
"\n\n---------------------" + title + "------------------------\n" +
" " + msg + "\n" +
"---------------------" + title + "-----------------------\n\n" +
"------- Close"
);
}
}
public static String getLineInfo(){
StackTraceElement ste = new Throwable().getStackTrace()[1];
return "报错的文件 " + ste.getFileName() + " 行号 " + ste.getLineNumber();
} //报错提示
//消息框 Toast
public static void toast_s(Object msg){
if(TOAST_TF){
if(CONTEXT != null)
Toast.makeText(CONTEXT,msg + "",Toast.LENGTH_SHORT).show();
else
if(LOG_TF)//设置为默认输出日志
log_e("GT_bug","消息框错误日志：你没有为 Context 进行赋值 ，却引用了 Toast 导致该功能无法实现。");
}
}
public static void toast_l(Object msg){
if(TOAST_TF){
if(CONTEXT != null)
Toast.makeText(CONTEXT,msg + "",Toast.LENGTH_SHORT).show();
else
if(LOG_TF)//设置为默认输出日志
log_e("GT_bug","消息框错误日志：你没有为 Context 进行赋值 ，却引用了 Toast 导致该功能无法实现。");
}
}
public static void toast_s(Context context,Object msg){
if(TOAST_TF)
Toast.makeText(context,msg + "",Toast.LENGTH_SHORT).show();
}
public static void toast_l(Context context,Object msg){
if(TOAST_TF)
Toast.makeText(context,msg + "",Toast.LENGTH_LONG).show();
}
//AlertDialog.Builder 对话框类
public static class GT_AlertDialog extends AlertDialog.Builder{
public String resultButtonDialog = null;
public String resultListDialog = null;
public String resultSingleChoiceListDialog = null;
public String[] resultMultiChoiceDialog = null;
public GT_AlertDialog(Context context) {
super(context);
}
//设置按钮的对话框
public AlertDialog.Builder dialogButton(int img, String title, String message, final String[] texts){
setTitle(title).setIcon(img).setMessage(message); //设置 标题、图标、消息
if(texts != null){
resultButtonDialog = null;
if(texts.length >= 1)
setNegativeButton(texts[0], new DialogInterface.OnClickListener() {
// 第一个按钮
@Override
public void onClick(DialogInterface dialog,int which) {
resultButtonDialog = texts[0];
}
});
if(texts.length >= 2)
setPositiveButton(texts[1], new DialogInterface.OnClickListener() {
//第二个按钮
@Override
public void onClick(DialogInterface dialog,int which) {
resultButtonDialog = texts[1];
}
});
if(texts.length >= 3)
setNeutralButton(texts[2], new DialogInterface.OnClickListener() { //中间
//第三个按钮
@Override
public void onClick(DialogInterface dialog,int which) {
resultButtonDialog = texts[2];
}
});
}
return this;
}
//设置列表选项对话框
public AlertDialog.Builder dialogList(int img, String title,final String[] texts){
setIcon(img).setTitle(title);
if(texts != null)
setItems(texts, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
resultListDialog = texts[which];
}
}); //添加列表项
return this;
}
//设置单选列表选项对话框
public AlertDialog.Builder dialogSingleChoiceList(int img, String title,String buttonName, final String[] texts){
setIcon(img).setTitle(title);
if(texts != null)
setSingleChoiceItems(texts, 0, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
resultSingleChoiceListDialog = texts[which];
}
});//添加列表项
if(buttonName != null)
setPositiveButton(buttonName,null);//设置按钮
return this;
}
//设置多选列表对话框
public AlertDialog.Builder dialogMultiChoice(int img, String title,String buttonName,final String[] texts){
final boolean[] checkedItems = new boolean[texts.length]; //初始化选中状态
resultMultiChoiceDialog = new String[texts.length]; //初始化字符串结果
for(int i = 0; i < checkedItems.length; i++) checkedItems[i] = false; //初始化默认选项
setIcon(img).setTitle(title);//设置 图标、标题
if(texts != null)
setMultiChoiceItems(texts, checkedItems, new DialogInterface.OnMultiChoiceClickListener() {
@Override
public void onClick(DialogInterface dialog, int which, boolean isChecked) {
checkedItems[which] = isChecked;//改变被操控列表项的状态
}
});//添加列表项
if(buttonName != null)
setPositiveButton(buttonName, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
for (int i = 0; i < checkedItems.length; i++){
if(checkedItems[i]){
resultMultiChoiceDialog[i] = texts[i];
}
}
}
});
return this;
}
//设置自定义对话框
public AlertDialog dialogView(int img, String title,boolean ShieldngExternal,final int darkDegrees,int x,int y,int layout){
AlertDialog alertDialog = create();// 创建对话框
// 设置参数
if(title != null) alertDialog.setTitle(title);//设置标题
if(img != 0) alertDialog.setIcon(img); //设置图标
if(darkDegrees != -1) alertDialog.getWindow().setDimAmount(darkDegrees);//设置昏暗度为0 则表示为透明， 如果是 -1 则是默认
alertDialog.setCancelable(ShieldngExternal); //设置点击外面不会消失 true为点击外面可以被取消，false 为点击外面不可被取消
// 获取布局
view = View.inflate(getContext(), layout,null);
alertDialog.setView(view);
//修改 自定义对话框的显示位置
android.view.Window dialogWindow = alertDialog.getWindow();/*随意定义个Dialog*/
WindowManager.LayoutParams lp = dialogWindow.getAttributes();/*实例化Window*/
/*实例化Window操作者*/
lp.x = x; // 新位置X坐标
lp.y = y; // 新位置Y坐标
dialogWindow.setAttributes(lp);
return alertDialog;
}
private View view; //定义 View
public View getView(){
return view;
}
}
//Notification 通知类
public static class GT_Notification{
private static int NOTIFYID = 0x1997; //通知id
private static String CHANEL_ID = "com.gsls.king";
private static String CHANEL_DESCRIPTION = "GT_Android 描述";
private static String CHANEL_NAME = "GT_Android复习";
public void setNotifyId(int NotifyId){
NOTIFYID = NotifyId;
}
public void setChanelId(String ChanelId){
CHANEL_ID = ChanelId;
}
public void setChanelDescription(String ChanelDescription){
CHANEL_DESCRIPTION = ChanelDescription;
}
public void setChanelName(String ChanelName){
CHANEL_NAME = ChanelName;
}
private Activity activity;
public GT_Notification(Activity activity){
this.activity = activity;
}
public NotificationManagerCompat sendingNotice(int icon, String title, String text, int time, boolean voiceTF, boolean autoCancel, Class<?> cla){
/**
* 由于 Notification.Builder 仅支持 Android 4.1及之后的版本，为了解决兼容性问题， Notification.Builder 仅支持 API 26 与 26 之前的版本
* Google 在 Android Support v4 中加入了 NotificationCompat.Builder 类
*/
String channelId = createNotificationChannel(activity.getApplicationContext());//创建Notification Channel
NotificationCompat.Builder builder = new NotificationCompat.Builder(activity, channelId);//创建Notification并与Channel关联
builder.setSmallIcon(icon);//设置通知图标
builder.setAutoCancel(autoCancel);//设置通知打开后自动消失
builder.setContentTitle(title);//设置标题
builder.setContentText(text);//设置内容
if(time == 0) builder.setWhen(System.currentTimeMillis());//设置系统当前时间为发送时间
else builder.setWhen(time);//设置用户设置的发送时间
if(voiceTF) builder.setDefaults(Notification.DEFAULT_SOUND | Notification.DEFAULT_VIBRATE);//设置默认的声音与默认的振动
if(cla != null){ //如果 cla 不为空就设置跳转的页面
Intent intent = new Intent(activity, cla);
PendingIntent pi = PendingIntent.getActivity(activity, 0, intent, PendingIntent.FLAG_CANCEL_CURRENT);
builder.setContentIntent(pi);//设置通知栏 点击跳转
}
//发布通知
NotificationManagerCompat notificationManagerCompat = NotificationManagerCompat.from(activity.getApplicationContext());
notificationManagerCompat.notify(NOTIFYID, builder.build());
return notificationManagerCompat;
}
private String createNotificationChannel(Context context) {
// O (API 26)及以上版本的通知需要NotificationChannels。
if (context != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
// 初始化NotificationChannel。
NotificationChannel notificationChannel = new NotificationChannel(CHANEL_ID,CHANEL_NAME, NotificationManager.IMPORTANCE_DEFAULT);
notificationChannel.setDescription(CHANEL_DESCRIPTION);
// 向系统添加 NotificationChannel。试图创建现有通知
// 通道的初始值不执行任何操作，因此可以安全地执行
// 启动顺序
NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.createNotificationChannel(notificationChannel);
return CHANEL_ID;
} else {
return null; // 为pre-O(26)设备返回 null
}
}
}
/******************************************** 数据存储类 *****************************************************/
//数据持久化 SharedPreferences
public static class GT_SharedPreferences{
private Context context;
public boolean commit(){return sp_e.commit();} //手动提交
public void clear(){sp_e.clear();sp_e.commit();}//清空
private SharedPreferences sp; public SharedPreferences getSharedPreferences(){return sp;} //获取 SharedPreferences
private SharedPreferences.Editor sp_e; public SharedPreferences.Editor getEditor(){return sp_e;} //获取 SharedPreferences.Editor
private boolean commit = false; //定义是否自动提交
public static final int PRIVATE = 0; //只有本应用可读写
public static final int PROTECTED = 1; //其他应用可以只读
public static final int PUBLIC = 2; //其他应用可以读写
//初始化
public GT_SharedPreferences(Context context,String SPName,int permissions,boolean commit) {
this.context = context;
this.commit = commit;
sp = context.getSharedPreferences(SPName, permissions);//打开 或 创建 SharedPreferences
sp_e = sp.edit();//让userData处于编辑状态
}
//增
public GT.GT_SharedPreferences save(String key, Object object){
boolean TF = true;//监测保存状态是否正常
if(object instanceof String){
sp_e.putString(key,object.toString());
}else if(object instanceof Integer){
sp_e.putInt(key,(Integer) object);
}else if(object instanceof Long){
sp_e.putLong(key,(Long)object);
}else if(object instanceof Float){
sp_e.putFloat(key,(Float)object);
}else if(object instanceof Boolean){
sp_e.putBoolean(key,(Boolean) object);
}else if(object instanceof Set){
sp_e.putStringSet(key,(Set)object);
}else{
if(GT_LOG_TF) log_v(context,"进行对象保存");
String json = new Gson().toJson(object);
String json_class = object.getClass().toString();
sp_e.putString(key,json); //保存对象的 Json 数据
sp_e.putString(key+"_class",json_class); //保存对象的 class 数据
}
if(commit && TF) sp_e.commit(); //如果设置了自动提交 并且 保存状态正常 即可自定提交
return this;
}
//删
public SharedPreferences.Editor delete(String key){
if(query(key) != null){
sp_e.remove(key);
if(commit)sp_e.commit();
}else {
if(GT_LOG_TF) log_v("删除失败 当前 sp 中无此 key");
}
return sp_e;
}
//改
public GT.GT_SharedPreferences updata(String key, Object object){
if(query(key) != null){
if(GT_LOG_TF)
log_v(context,"进入到 updata 查询的数据不为null");
save(key,object);
}
return this;
}
//查
public Object query(String key){
Object obj = null;
try{
obj = sp.getInt(key,0);
}catch (ClassCastException e1){
if(GT_LOG_TF)
log_v(context,"Int 数据装换异常");
try{
String str_class = sp.getString(key+"_class",null); //获取对象 class 数据
String str = sp.getString(key,null); //获取对象 Json 数据
if(str_class == null){ //如果 class 数据为空
obj = str; //普通的 Json 数据
}else{
Object object_class = getObj(str_class); //通过对象的 class 反射出 实例对象
obj = new Gson().fromJson(str,object_class.getClass()); //通过 Gson 与 实例对象 获取相应的 Object 对象
}
}catch (ClassCastException e2){
if(GT_LOG_TF)
log_v(context,"String 数据装换异常");
try{
obj = sp.getLong(key,0);
}catch (ClassCastException e3){
if(GT_LOG_TF)
log_v(context,"Long 数据装换异常");
try{
obj = sp.getFloat(key,0f);
}catch (ClassCastException e4){
if(GT_LOG_TF)
log_v(context,"Float 数据装换异常");
try{
obj = sp.getBoolean(key,false);
}catch (ClassCastException e5){
if(GT_LOG_TF)
log_v(context,"Boolean 数据装换异常");
try{
obj = sp.getStringSet(key,null);
}catch (ClassCastException e6){
if(GT_LOG_TF)
log_v(context,"StringSet 数据装换异常");
obj = null;
}
}
}
}
}
}
return obj;
}
//通过 对象的.class 属性反射对象
private Object getObj(String objectClass){
Object obj = null;
String[] strs = objectClass.split(" ");
String str = strs[1];
Class<?> clazz = getClass();
try {
clazz = Class.forName(str);
} catch (ClassNotFoundException e1) {
e1.printStackTrace();
}
try {
obj = clazz.newInstance();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
return obj; //返回实例化好的类
}
//获取所有
public Map<String, ?> queryAll(){
return sp.getAll();
}
}
//内部存储 IO
public static class GT_IO{
/**
* 使用实例：
* 第一步：
* GT.GT_IO io = new GT.GT_IO(this);//创建 IO 对象
* 第二步：
* io.save(editText.getText().toString(),"King");//保存数据
* 第三步：
* String king = io.query("King"); //获取数据
*/
private Context context;
public GT_IO(Context context){
this.context = context;
}
public GT_IO save(String saveData,String dataName){
FileOutputStream fos = null;//文件输出流
try {
fos = context.openFileOutput(dataName,context.MODE_PRIVATE);//获取文件输出流对象
fos.write(saveData.getBytes());//保存备忘信息
fos.flush();//清除缓存
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fos != null){
try {
fos.close();//关闭输出流
} catch (IOException e) {
e.printStackTrace();
}
}
}
return this;
}
public String query(String dataName){
FileInputStream fis = null;//文件输入流对象
String data = null;
byte[] buffer = null;
try {
fis = context.openFileInput(dataName);//获得文件输入流对象
buffer = new byte[fis.available()];//实例化字节数组
fis.read(buffer);//从输入流中读取数据
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fis != null){
try {
fis.close();//关闭输入流对象
data = new String(buffer);//把字节数组中的数据转换为字符串
} catch (IOException e) {
e.printStackTrace();
}
}
}
return data;
}
}
//外部存储 File
public static class GT_File{
/**
* 使用实例：
* 第一步：
* GT.GT_File file = new GT.GT_File();//创建 File 对象
* 第二步：
* file.save("第一章:","/我的小说/武侠小说/","斗罗大陆.txt");//保存数据
* 第三步：
* String query = file.query("/我的小说/武侠小说/", "斗罗大陆.txt"); //获取数据
*/
public void save(String saveData,String savePaht, String fileName){
File fileNull = new File(Environment.getExternalStorageDirectory() + savePaht);//实例化文件对象
if(!fileNull.exists()){
fileNull.mkdirs();
}
File file = new File(Environment.getExternalStorageDirectory() + savePaht,fileName);//实例化文件对象
FileOutputStream fos = null;//文件输出流
try {
fos = new FileOutputStream(file);//获取文件输出流对象
fos.write(saveData.getBytes());//保存备忘信息
fos.flush();//清除缓存
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fos != null){
try {
fos.close();//关闭输出流
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public String query(String queryPaht, String fileName){
File fileNull = new File(Environment.getExternalStorageDirectory() + queryPaht);//实例化文件对象
if(!fileNull.exists()){
fileNull.mkdirs();
}
File file = new File(Environment.getExternalStorageDirectory() + queryPaht,fileName);//实例化文件对象
FileInputStream fis = null;//文件输入流对象
byte[] buffer = null;
String data = null;
try {
fis = new FileInputStream(file);//获得文件输入流对象
buffer = new byte[fis.available()];//实例化字节数组
fis.read(buffer);//从输入流中读取数据
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fis != null){
try {
fis.close();//关闭输入流对象
data = new String(buffer);//把字节数组中的数据转换为字符串
} catch (IOException e) {
e.printStackTrace();
}
}
}
return data;
}
}
//Hibernate SQL
public static class Hibernate{
// 增 INSERT INTO ROLE(NAME,AGE,SEX) VALUES(:name,:age,:sex)
// 删 DELETE 表名 WHERE NAME = '陈启申'
// 改 UPDATE 表名 SET NAME = ? WHERE ID = ?
// 查 SELECT * FROM ROLE WHERE id > ?
//str String json = new Gson().toJson(object);
//obj obj = new Gson().fromJson(str,object_class.getClass()); //通过 Gson 与 实例对象 获取相应的 Object 对象
// sp = context.getSharedPreferences(SQLName, AppCompatActivity.MODE_WORLD_WRITEABLE);//打开 sp
// sp_e = sp.edit();//让userData处于编辑状态
private Context context;
private Object password;
private SharedPreferences sp;
private SharedPreferences.Editor sp_e;
private Map<Object,Object> sqlMap = new HashMap<>();
private final static String DATABASE = "GT_DATABASE";
//初始化 Hibernate
public Hibernate(Context context) {
this.context = context;
sp = context.getSharedPreferences(DATABASE, AppCompatActivity.MODE_WORLD_WRITEABLE);//创建最底层的 sql
sp_e = sp.edit(); //让 GT_DATABASE 处于编辑状态
}
//创建数据库
public void createDatabase(String databaseName,Object password){
sqlMap.put(databaseName,new HashMap<>());
String db = new Gson().toJson(sqlMap);
log_e("创建数据库的 json 数据",db);
// db = password;
log_e("加密后的数据库 json 数据",db);
sp_e.putString(databaseName,db);
sp_e.commit();
}
//修改数据库
public void alterDatabase(String formerName,String newName,Object password){
formerName = sp.getString("formerName",null);
if(formerName != null){
}else{
if(GT_LOG_TF) log_e("修改数据库 失败！ 原由：暂未找到需要修改的数据库名称");
}
}
//删除数据库
public void dropDatabase(String databaseName){
}
//打开数据库
public void openDatabase(String databaseName,Object password){
}
}
/******************************************** 网络 类 *****************************************************/
//network 网络类
public class Network{
//监听网络状态 true 网络正常 false 网络异常
public boolean networkMonitoring(Context context) {
boolean buffer = false;
boolean isWifiConn = false, isMobile = false;
//1.获得ConnectivityManager对象
ConnectivityManager cm = (ConnectivityManager) context.getSystemService((Context.CONNECTIVITY_SERVICE));
//2.检查API
if (Build.VERSION.SDK_INT < 23) {
//3.获取信息(WIFI和移动信息)
@SuppressLint("MissingPermission") NetworkInfo infowifi = cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
isWifiConn = infowifi.isConnected();
@SuppressLint("MissingPermission") NetworkInfo infomobile = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
isMobile = infomobile.isConnected();
} else {
//3.获取所有网络连接信息getAllNetworks
@SuppressLint("MissingPermission") android.net.Network[] networks = cm.getAllNetworks();
StringBuffer sb = new StringBuffer();
//遍历取出网络信息
for (int i = 0; i < networks.length; i++) {
@SuppressLint("MissingPermission") NetworkInfo networkInfo = cm.getNetworkInfo(networks[i]);
buffer = networkInfo.isConnected();
}
}
if (buffer || isMobile || isWifiConn) {
return true;
} else {
return false;
}
}
}
//JSON 接口解析
public static class JSON {
private String string;
private int code = 0;
private String msg = null;
private Object data = null;
public int getCode() {
return code;
}
public String getMsg() {
return msg;
}
public String getData() {
return data.toString();
}
//初始化 json 数据
public JSON(String string) {
this.string = string;
try {
JSONObject jsonObject = new JSONObject(string);
code = jsonObject.getInt("code");
data = jsonObject.get("data");
msg = jsonObject.getString("msg");
} catch (JSONException e) {
if(GT_LOG_TF)
log_v("当前 JSON 数据中有些节点并不存在,请谨慎使用! 【" + getLineInfo() + "】");
// e.printStackTrace();
}
}
/********************************* 根据 Bean 获取数据*************************************/
//根据 bean 类获取 bean 对象
public Object getBean(Class<?> aClass){
Object o = null;
try{
o = new Gson().fromJson(string, aClass);
}catch (JsonSyntaxException exception){
log_e(getLineInfo(),"你的 JSON 解析类型不匹配，请检查 " + aClass + " 是否与请求的Json数据一致！");
}
return o;
}
/********************************* 没有 Bean 获取数据*************************************/
/**
*
* 用法:
* 第一步：将请求的数据放入 GT.JSON json = new GT.JSON(“请求的数据”);
* 第二步：初始化 JSON 数据 json.initBeanData(json.getData());
* 第三步：获取 list 集合 JSONArray list = json.getJSONArray("list"); //获取 list 节点
* 第四步：获取 list 内数据 Object author = json.getJSONObject(list, “节点名”, “集合list的索引”);
*
* 注意:
* 如果请求的数据是 "data":{} 就用 get()方法 获取 data 再就进行初始化后 获取里面的值
* 如果请求的数据是 "list": [] 就用 getJSONObject() 获取 List<?>
*
*/
private JSONObject jsonObject;
private JSONArray jsonArray;
public JSON initBeanData(String data){
try {
jsonObject = new JSONObject(data);
} catch (JSONException e) {
e.printStackTrace();
}
return this;
} //初始化 JSON 数据
public Object get(String key){
Object o = null;
if(jsonObject != null){
try {
o = jsonObject.get(key);
} catch (JSONException e) {
e.printStackTrace();
}
}else{
log_e(getLineInfo(),"没有初始化 JSON 数据，无法进行 无 bean 数据解析");
}
// GT.log_e("在转 data 数据之前:" + data);
o = rplStr(o.toString(),"\\","");//忽略掉转义符
// GT.log_e("转 data 数据之后:" + data);
return o;
} //获取普通的值 返回数据前会进行 忽略掉转义符
public String rplStr(String str1,String str2,String str3){
String strtmp="";
int i=0,f;
for(i=0;;i+=str2.length()){
f=str1.indexOf(str2,i);
if (f==-1) {
strtmp+=str1.substring(i);
break;
}else{
strtmp+=str1.substring(i,f);
strtmp+=str3;
i=f;
}
}
return strtmp;
}//去掉转义符
public JSONArray getJSONArray(String string){
try {
jsonArray = new JSONArray(string);
} catch (JSONException e) {
log_e(getLineInfo(),"没有初始化 JSON 数据，无法进行 无 bean 数据解析");
}
return jsonArray;
} //获取 对象数组
public Object getJSONObject(JSONArray list,String key,int index){
JSONObject jsonObject = null;
Object o = null;
try {
jsonObject = (JSONObject) list.get(index); //获取当前索引下
o = jsonObject.get(key); //key 值 的对象
} catch (JSONException e) {
log_e(getLineInfo(),"JSON 数据解析异常，无法通过 没有初始化的 JSON 数据进行解析节点");
}
return o;
} //获取 JSON 对象
public static JSONArray addJSONArray(JSONArray jsonArray,JSONArray new_jsonArray){
for(int i = 0; i < new_jsonArray.length(); i++){
try {
Object o = jsonArray.get(i);
jsonArray.put(o);
} catch (JSONException e) {
e.printStackTrace();
}
}
return jsonArray;
}//添加新的 json 数据
public static JSONArray clear(JSONArray jsonArray){
for (int i = 0, len = jsonArray.length(); i < len; i++) {
JSONObject obj = null;
try {
obj = jsonArray.getJSONObject(i);
} catch (JSONException e) {
e.printStackTrace();
}
obj.remove("key");
}
return jsonArray;
}
}
//OkGo 网络请求框架
public static class OkGo{
private Map<String,String> map;
private String url;
//初始化 map 并进行添加参数
public OkGo addParameter(String key,String value){
if(map == null){
map = new HashMap<>();//初始化 map
}else{
if(!map.containsKey(key)){//如果当前 map 中没有此key
map.put(key,value);
}
}
return this;
}
public OkGo(String url,Map<String,String> map){
this.url = url;
this.map = map;
}
public OkGo(String url){
this.url = url;
}
public void loadData(StringCallback stringCallback){
if(map == null){
GT.log_e(getLineInfo(),"当前 map 为空，会导致 请求数据失败，请检查是否对 map 进行初始化");
}else {
com.lzy.okgo.OkGo.<String>post(url) .params(map).execute(stringCallback);
}
}
}
//okHttp 网络请求框架
public static class OkHttp{}
//将 网页数据 格式化成 可视化的 html 数据
public static class MImageGetter implements Html.ImageGetter {
/**
* 使用案列：
* MImageGetter mImageGetter = new MImageGetter(“TextView 组件”, 上下文对象);
*
* TextView 组件.setText(Html.fromHtml(请求下来的string数据, mImageGetter, null));
*/
Context c;
WebView webView;
public MImageGetter(WebView webView, Context c) {
this.c = c;
this.webView = webView;
}
public Drawable getDrawable(String source) {
final UrlDrawable drawable = new UrlDrawable();
if(c != null)
Glide.with(c)
.asBitmap()
.load(source)
.into(new SimpleTarget<Bitmap>() {
@Override
public void onResourceReady(@NonNull Bitmap resource, @Nullable Transition<? super Bitmap> transition) {
float width = webView.getWidth();
if (resource.getWidth() > width) {
float scale = width / resource.getWidth();
int afterWidth = (int) (resource.getWidth() * scale);
int afterHeight = (int) (resource.getHeight() * scale);
drawable.setBounds(0, 0, afterWidth, afterHeight);
drawable.setBitmap(resizeBitmap(resource, afterWidth, afterHeight));
} else {
drawable.setBounds(0, 0, resource.getWidth(), resource.getHeight());
drawable.setBitmap(resource);
}
webView.invalidate();
// webView.loadData();
}
});
return drawable;
}
private class UrlDrawable extends BitmapDrawable {
private Bitmap bitmap;
@Override
public void draw(Canvas canvas) {
super.draw(canvas);
if (bitmap != null) {
int i = canvas.getWidth() - bitmap.getWidth();
canvas.drawBitmap(bitmap, i / 2, 0, getPaint());
}
}
void setBitmap(Bitmap bitmap) {
this.bitmap = bitmap;
}
}
/**
* 使用Matrix将Bitmap压缩到指定大小
*
* @param bitmap
* @param w
* @param h
* @return
*/
public static Bitmap resizeBitmap(Bitmap bitmap, int w, int h) {
int width = bitmap.getWidth();
int height = bitmap.getHeight();
float scaleWidth = ((float) w) / width;
float scaleHeight = ((float) h) / height;
Matrix matrix = new Matrix();
matrix.postScale(scaleWidth, scaleHeight);
return Bitmap.createBitmap(bitmap, 0, 0, width,
height, matrix, true);
}
}
/******************************************** 小工具 类 *****************************************************/
//data 日期类
public static class GT_Date{
private String time; //定义返回的 时间整体字符串
private String[] times; //定义分割后产生的 年月日 / 时分秒 数组
private String[] ymd; //定义分割后产生的 年月日 数组
private String[] hms; //定义分割后产生的 时分秒 数组
//初始化时间 数据
public GT_Date(){
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
time = df.format(new Date()); //获取当时间
times = time.split(" "); //分割时间 年月日 / 时分秒 数组
ymd = times[0].split("-"); //分割年月日 数组
hms = times[1].split(":"); //分割时分秒 数组
}
//获取当前星期
public String getWeekOfDate() {
String[] weekDays = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
Calendar cal = Calendar.getInstance();
cal.setTime(new Date());
int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
if (w < 0)
w = 0;
return weekDays[w];
}
//获取当前时间
public String getTime(){
return time;
}
//获取当前 年月日
public String getYearMonthDay(){
return times[0];
}
public String getYear(){
return ymd[0];
} //获取年
public String getMonth(){
return ymd[1];
} //获取月
public String getDay(){
return ymd[2];
} //获取日
//获取当前 时分秒
public String getHourMinuteSecond(){
return times[1];
}
public String getHour(){
return hms[0];
} //获取时
public String getMinute(){
return hms[1];
} //获取分
public String getSecond(){
return hms[2];
} //获取秒
//时间戳转 时间
public String toTime(String dataTime){
SimpleDateFormat formatter =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault());
long myTime= Long.parseLong(dataTime);
long lt = new Long(myTime*1000);//返回来的时间戳1476929029是毫秒，这里要乘1000才是正确的北京时间
Date date = new Date(lt);
String time=formatter.format(date);
return time;
}
//时间戳转 年月日
public String toYearMonthDay(String dataTime){
SimpleDateFormat formatter =new SimpleDateFormat("yy-MM-dd", Locale.getDefault());
long myTime= Long.parseLong(dataTime);
long lt = new Long(myTime*1000);//返回来的时间戳1476929029是毫秒，这里要乘1000才是正确的北京时间
Date date = new Date(lt);
String time=formatter.format(date);
return time;
}
//时间戳转 北京时间
public String toBeijingTime(String dataTime){
SimpleDateFormat formatter =new SimpleDateFormat("yyyy-MM-dd", Locale.getDefault());
long myTime= Long.parseLong(dataTime);
long lt = new Long(myTime*1000);//返回来的时间戳1476929029是毫秒，这里要乘1000才是正确的北京时间
Date date = new Date(lt);
String time=formatter.format(date);
return time;
}
}
//分享功能
public static class GT_Share{
private Activity activity;
public GT_Share(Activity activity){
this.activity = activity;
}
public void senText(String title,String content){
Intent shareIntent = new Intent();
shareIntent.setAction(Intent.ACTION_SEND);
shareIntent.setType("text/plain");
shareIntent.putExtra(Intent.EXTRA_TEXT, content);
shareIntent = Intent.createChooser(shareIntent, title);
activity.startActivity(shareIntent);
}
}
/******************************************** UI 类 *****************************************************/
//Window 窗体类
public static class Window{
private WindowManager wm;
private Activity activity;
private View view = null;
private AppCompatActivity appCompatActivity;
//初始化
public Window(AppCompatActivity appCompatActivity){
this.activity = appCompatActivity;
this.appCompatActivity = appCompatActivity;
wm = appCompatActivity.getWindowManager();
}
//获取屏幕 宽度
public int getWindowWidth(){
int width = wm.getDefaultDisplay().getWidth();
return width;
}
//获取屏幕 高度
public int getWindowHeight(){
int height = wm.getDefaultDisplay().getHeight();
return height;
}
//隐藏 ActionBar
public void hideActionBar (){
appCompatActivity.getSupportActionBar().hide();
}
//关闭虚拟按钮,并设置全屏
public View closeVirtualButton() {
/**
* 如果想全部隐藏虚拟按键，只需要在build.prop中增加qemu.hw.mainkeys=1即可。build.prop在你编译出的文件系统的system目录下。前提需要root权限。
* 使用案列:new GT.Window(this).closeVirtualButton();
*/
if (activity != null) view = activity.getWindow().getDecorView();
if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) {
view.setSystemUiVisibility(View.GONE);
} else if (Build.VERSION.SDK_INT >= 19) {
view.setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY | View.SYSTEM_UI_FLAG_FULLSCREEN);
}
/**
* 该方法请在 Activity 中 onCreate 方法里的 super.onCreate(savedInstanceState); 之下 setContentView(R.layout.***); 之前使用
* 使用案列：new GT.Window(this).setFullScreen();
*/
activity.requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);
activity.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
return view;
}
}
//设置按钮触摸放大
public static class ViewTouchMagnify {
private int viewWidth; //保存按钮宽度
private int viewHeight; //保存按钮高度
//为按钮设置触摸事件
@SuppressLint("ClickableViewAccessibility")
public void touchZoomInView(final View view){
//设置按钮触摸事件
view.setOnTouchListener(new View.OnTouchListener() {
public boolean onTouch(View arg0, MotionEvent arg1) {
ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
if(arg1.getAction() == MotionEvent.ACTION_DOWN){//如果用户手指触摸屏幕
viewWidth = view.getWidth(); //保存按钮的宽度
viewHeight = view.getHeight(); //保存按钮的高度
// view.setTextSize(18); //设置按钮放大时字体大小
layoutParams.width = viewWidth + 20; //设置按钮放大时的宽度
layoutParams.height = viewHeight + 10; //设置按钮放大时的高度
}
else if(arg1.getAction() == MotionEvent.ACTION_UP){//如果用户手指离开屏幕
// button.setTextSize(15); //设置按钮为原来字体大小
layoutParams.width = viewWidth; //设置按钮为原来的宽度
layoutParams.height = viewHeight; //设置按钮为原来的高度
}
view.setLayoutParams(layoutParams); //提交事务
return false; //设置为未完成消耗掉的时间 如果将此返回为 true 那么按钮的 单击事件将会被屏蔽掉
}
});
}
}
//封装 Fragment 类
public static class GT_Fragment{
/**
* add(Fragment fragment, String tag) // 调用add(int, Fragment, String),填入为0的containerViewId.
* add(int containerViewId, Fragment fragment) // 调用add(int, Fragment, String),填入为null的tag.
* add(int containerViewId, Fragment fragment, String tag) // 向Activity中添加一个Fragment.
* addSharedElement(View sharedElement, String name) // 添加共享元素
* addToBackStack(String name) // 将事务添加到回退栈
* attach(Fragment fragment) // 重新关联Fragment（当Fragment被detach时）
* commit() // 提交事务
* commitAllowingStateLoss() // 类似commit()，但允许在Activity状态保存之后提交（即允许状态丢失）。
* commitNow() // 同步提交事务
* commitNowAllowingStateLoss() // 类似commitNow()，但允许在Activity状态保存之后提交（即允许状态丢失）。
* detach(Fragment fragment) // 将fragment保存的界面从UI中移除
* disallowAddToBackStack() // 不允许调用addToBackStack(String)操作
* hide(Fragment fragment) // 隐藏已存在的Fragment
* isAddToBackStackAllowed() // 是否允许添加到回退栈
* isEmpty() // 事务是否未包含的任何操作
* remove(Fragment fragment) // 移除一个已存在的Fragment
* replace(int containerViewId, Fragment fragment) // 调用replace(int, Fragment, String)填入为null的tag.
* replace(int containerViewId, Fragment fragment, String tag) // 替换已存在的Fragment
* setBreadCrumbShortTitle(int res) // 为事务设置一个BreadCrumb短标题
* setBreadCrumbShortTitle(CharSequence text) // 为事务设置一个BreadCrumb短标题，将会被FragmentBreadCrumbs使用
* setBreadCrumbTitle(int res) // 为事务设置一个BreadCrumb全标题，将会被FragmentBreadCrumbs使用
* setBreadCrumbTitle(CharSequence text) // 为事务设置一个BreadCrumb全标题
* setCustomAnimations(int enter, int exit, int popEnter, int popExit) // 自定义事务进入/退出以及入栈/出栈的动画效果
* setCustomAnimations(int enter, int exit) // 自定义事务进入/退出的动画效果
* setTransition(int transit) // 为事务设置一个标准动画
* setTransitionStyle(int styleRes) // 为事务标准动画设置自定义样式
* show(Fragment fragment) // 显示一个被隐藏的Fragment
*
*/
private Context context; //定义 Activity
private Bundle savedInstanceState; //定义 Bundle
private static FragmentManager supportFragmentManager; //定义 Fragment 管理器
private FragmentTransaction transaction; //定义 Fragment 事务管理器
private static Object topFragment = null; //定义 最顶层的 Fragment
private static Map<Object, Fragment> fragmentMap = new HashMap<>(); //定义容器 map
private int fragmentLayoutId = 0;
public GT_Fragment(Bundle savedInstanceState, Context context, FragmentManager supportFragmentManager){
if(savedInstanceState != null){
this.savedInstanceState = savedInstanceState;
}
if(context != null){
this.context = context;
}
if(supportFragmentManager != null){
GT_Fragment.supportFragmentManager = supportFragmentManager;
}
}//构造方法 初始化 Activity 与 Bundle
public GT_Fragment initFragment(Map<Object, Fragment> map, int fragmentLayoutId, Object initFragmentLayoutKey){
if(map != null && savedInstanceState == null){ //如果当前map 不为空 且当前的 Activity 活动为第一次创建
fragmentMap = map;
this.fragmentLayoutId = fragmentLayoutId;
transaction = getTransaction();//获取事务
for(Object key : fragmentMap.keySet()){
transaction.add(fragmentLayoutId, fragmentMap.get(key)).hide(fragmentMap.get(key));//添加 页面 并隐藏
}
transaction.show(fragmentMap.get(initFragmentLayoutKey)).commit();//显示 页面1
topFragment = initFragmentLayoutKey;//记录为 最顶层 Fragment
}
return this;
} //初始化 Fragment
public GT_Fragment startFragment(Object fragmentKey){
if(fragmentKey != null && !topFragment.equals(fragmentKey)){ //如果当前要跳转的 Fragment 不是最顶层 且 要跳转的 Fragment 不为空
transaction = getTransaction();//获取事务
transaction.hide(fragmentMap.get(topFragment));//隐藏 当前最顶层的 Fragment
transaction.show(fragmentMap.get(fragmentKey));//显示 当前 Fragment
topFragment = fragmentKey;//记录为 最顶层 Fragment
transaction.commit();
}
return this;
}//启动另外一个 Fragment
//有 bug
/* public GT_Fragment updateFragment(String key,Fragment newFragment){
*//** * replace(int containerViewId, Fragment fragment, String tag) // 替换已存在的Fragment *//*
transaction = getTransaction();//获取事务
for(Object keys : fragmentMap.keySet()){
boolean tf = fragmentMap.containsKey(keys);
if(tf){
transaction.remove(fragmentMap.get(key));//删除旧的 Fragment
fragmentMap.put(key,newFragment);//添加新的 Fragment
transaction.add(fragmentLayoutId, fragmentMap.get(key)).hide(fragmentMap.get(key));//添加 页面 并隐藏
}
}
return this;
}//更新一个 Fragment*/
//获取事务
public FragmentTransaction getTransaction(){
return supportFragmentManager.beginTransaction();
}
}
/******************************************** 设备监听 类 *****************************************************/
//ScreenListener 监听屏幕状态类
public static class ScreenListener {
/**
* 监听
* 手机屏幕点亮
* 手机屏幕锁屏
* 手机屏幕解锁
*
* 使用实例:
* GT.ScreenListener screenListener = new GT.ScreenListener(this); //初始化 ScreenListener
* screenListener.begin(new GT.ScreenListener.ScreenStateListener(){....} //new 一个匿名内部类 即可
* 在销毁该 Activity 时一定要 调用该方法来注销广播
* unregisterListener(); 方法来注销该广播
*/
private Context context2; //联系上下文
private ScreenBroadcastReceiver mScreenReceiver; //定义一个广播
private ScreenStateListener mScreenStateListener; //定义个内部接口
/**
* 初始化
* */
public ScreenListener(Context context) {
this.context2 = context;
mScreenReceiver = new ScreenBroadcastReceiver();//初始化广播
}
/**
* 自定义接口
* */
public interface ScreenStateListener{
void onScreenOn(); //手机屏幕点亮
void onScreenOff(); //手机屏幕锁屏
void onUserPresent(); //手机屏幕解锁
}
/**
* 获取screen的状态
* */
private void getScreenState() {
//初始化powerManager
PowerManager manager = (PowerManager) context2.getSystemService(Context.POWER_SERVICE);
if (manager.isScreenOn()){ //如果监听已经开启
if (mScreenStateListener != null){
mScreenStateListener.onScreenOn();
}
}else { //如果监听没开启
if (mScreenStateListener != null){
mScreenStateListener.onScreenOff();
}
}
}
/**
* 写一个内部的广播
* */
private class ScreenBroadcastReceiver extends BroadcastReceiver {
private String action = null;
@Override
public void onReceive(Context context, Intent intent) {
action = intent.getAction();
if (Intent.ACTION_SCREEN_ON.equals(action)){ //屏幕亮时操作
mScreenStateListener.onScreenOn();
}else if (Intent.ACTION_SCREEN_OFF.equals(action)){ //屏幕关闭时操作
mScreenStateListener.onScreenOff();
}else if (Intent.ACTION_USER_PRESENT.equals(action)) {//解锁时操作
mScreenStateListener.onUserPresent();
}
}
}
/**
* 开始监听广播状态
* */
public void begin(ScreenStateListener listener){
mScreenStateListener = listener;
registerListener(); //注册监听
getScreenState(); //获取监听
}
/**
* 启动广播接收器
* */
private void registerListener() {
IntentFilter filter = new IntentFilter();
filter.addAction(Intent.ACTION_SCREEN_ON); //屏幕亮起时开启的广播
filter.addAction(Intent.ACTION_SCREEN_OFF); //屏幕关闭时开启的广播
filter.addAction(Intent.ACTION_USER_PRESENT); //屏幕解锁时开启的广播
context2.registerReceiver(mScreenReceiver, filter); //发送广播
}
/**
* 解除广播
* */
public void unregisterListener(){
context2.unregisterReceiver(mScreenReceiver); //注销广播
}
}
//HeadsetPlugReceiver 监听耳机是否插入
public static class GT_HeadsetPlugReceiver{
/**
* 监听 耳机
*
* 使用实例:
* GT.GT_HeadsetPlugReceiver gt_headsetPlugReceiver = new GT.GT_HeadsetPlugReceiver(this); //初始化 GT_HeadsetPlugReceiver
* gt_headsetPlugReceiver.isHeadset_TF(); //获取当前耳机的状态 插入则返回 true 否则返回 false
* 在销毁该 Activity 时一定要 调用该方法来注销广播
* unregisterListener(); 方法来注销该广播
*/
private Activity activity;
private static boolean headset_TF;//定义耳机是否插入
private HeadsetPlugReceiver headsetPlugReceiver;//监听手机是否有耳机插入广播
public boolean isHeadset_TF() {
registerHeadsetPlugReceiver();
return headset_TF;
}
public GT_HeadsetPlugReceiver(Activity activity){
this.activity = activity;
}
public void unregisterListener(){
activity.unregisterReceiver(headsetPlugReceiver); //注销广播
}
public void registerHeadsetPlugReceiver() {
headsetPlugReceiver = new HeadsetPlugReceiver();
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction("android.intent.action.HEADSET_PLUG");
activity.registerReceiver(headsetPlugReceiver, intentFilter);
}
private static class HeadsetPlugReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if (intent.hasExtra("state")){
if (intent.getIntExtra("state", 0) == 0){
if(GT_LOG_TF)
log_v("耳机测试: 没插入耳机");
headset_TF = false;
}
else if (intent.getIntExtra("state", 0) == 1){
if(GT_LOG_TF)
log_v("耳机测试: 插入耳机");
headset_TF = true;
}
}
}
}
}
/******************************************** 设备属性 类 *****************************************************/
//AudioManager 安卓手机音量类
public static class GT_AudioManager{
/**
* 提示：再设置音量大小时，请先搞清楚，该音量的最大值
*/
private AudioManager mAudioManager;//定义 AudioManager
private Activity activity;//定义 Activity
private int max;//最大值
private int current;//当前值
public GT_AudioManager(Activity activity){
this.activity = activity;
mAudioManager = (AudioManager) activity.getSystemService(activity.AUDIO_SERVICE);
}//初始化
//获取 通话声音 最大值 与 当前通过的声音值
public int getVoiceCall(){
current = mAudioManager.getStreamVolume( AudioManager.STREAM_VOICE_CALL );
return current;
}
public int getVoiceCallMax(){
max = mAudioManager.getStreamMaxVolume( AudioManager.STREAM_VOICE_CALL );
return max;
}
public void setVoiceCallValue(int value){
mAudioManager.setStreamVolume(AudioManager.STREAM_VOICE_CALL, value, AudioManager.FLAG_PLAY_SOUND);//设置 通话声音 音量大小为 0 静音
}//设置 通话声音 的音量
//获取 系统音量 最大值 与 当前通过的声音值
public int getVoiceSystem(){
max = mAudioManager.getStreamMaxVolume( AudioManager.STREAM_SYSTEM );
current = mAudioManager.getStreamVolume( AudioManager.STREAM_SYSTEM );
return current;
}
public int getVoiceSystemMax(){
max = mAudioManager.getStreamMaxVolume( AudioManager.STREAM_SYSTEM );
return max;
}
public void setVoiceSystemValue(int value){
mAudioManager.setStreamVolume(AudioManager.STREAM_SYSTEM, value, AudioManager.FLAG_PLAY_SOUND);//设置 通话声音 音量大小为 0 静音
}//设置 系统音量 的音量
//获取 铃声音量 最大值 与 当前通过的声音值
public int getVoiceRing(){
current = mAudioManager.getStreamVolume( AudioManager.STREAM_RING );
return current;
}
public int getVoiceRingMax(){
max = mAudioManager.getStreamMaxVolume( AudioManager.STREAM_RING );
return max;
}
public void setVoiceRingValue(int value){
mAudioManager.setStreamVolume(AudioManager.STREAM_RING, value, AudioManager.FLAG_PLAY_SOUND);//设置 铃声音量 音量大小为 0 静音
}//设置 铃声音量 的音量
//获取 音乐音量(多媒体) 最大值 与 当前通过的声音值
public int getVoiceMusic(){
current = mAudioManager.getStreamVolume( AudioManager.STREAM_MUSIC );
return current;
}
public int getVoiceMusicMax(){
max = mAudioManager.getStreamMaxVolume( AudioManager.STREAM_MUSIC );
return max;
}
public void setMusicValue(int value){
mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, value, AudioManager.FLAG_PLAY_SOUND);//设置多媒体音量大小为 0 静音
}//设置 多媒体 的音量
//获取 提示声音 音量 最大值 与 当前通过的声音值
public int getVoiceAlarm(){
current = mAudioManager.getStreamVolume( AudioManager.STREAM_ALARM );
return current;
}
public int getVoiceAlarmMax(){
max = mAudioManager.getStreamMaxVolume( AudioManager.STREAM_ALARM );
return max;
}
public void setVoiceAlarmValue(int value){
mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, value, AudioManager.FLAG_PLAY_SOUND);//设置 铃声音量 音量大小为 0 静音
}//设置 提示声音 的音量
public void gemgMusiceNoSet(){
activity.setVolumeControlStream(AudioManager.STREAM_MUSIC);
}//游戏过程中只允许调整多媒体音量，而不允许调整通话音量。
}
//获取当前手机信息
public static class MobilePhoneAttribute {
//获取手机型号
public String getModel(){
return Build.MODEL;
}
//获取手机SDK版本号
public String getSDK(){
return Build.VERSION.SDK;
}
//获取手机系统版本号
public String getRELEASE(){
return Build.VERSION.RELEASE;
}
}
/******************************************** 多媒体 类 *****************************************************/
// 播放音乐
public static class GT_MediaPlayer{
/**
*
* 本类使用案列：
* GT.GT_MediaPlayer mediaPlayer = new GT.GT_MediaPlayer(this);//实例化对象
* mediaPlayer.loadMusic(R.raw.bg_music); //加载 或 更新 将要播放的 音频， 此方法可用于 更新接下来要播放的音频
* mediaPlayer.play_pause();//暂停 或 播放
* mediaPlayer.stop();//停止播放
* mediaPlayer.close();//释放资源
*
* 相关属性设置
* int getDuration()：获取流媒体的总播放时长，单位是毫秒。
* int getCurrentPosition()：获取当前流媒体的播放的位置，单位是毫秒。
* void seekTo(int msec)：设置当前MediaPlayer的播放位置，单位是毫秒。
* void setLooping(boolean looping)：设置是否循环播放。
* boolean isLooping()：判断是否循环播放。
* boolean isPlaying()：判断是否正在播放。
* void prepare()：同步的方式装载流媒体文件。
* void prepareAsync()：异步的方式装载流媒体文件。
* void release ()：回收流媒体资源。
* void setAudioStreamType(int streamtype)：设置播放流媒体类型。
* void setWakeMode(Context context, int mode)：设置CPU唤醒的状态。
* setNextMediaPlayer(MediaPlayer next)：设置当前流媒体播放完毕，下一个播放的MediaPlayer。
*/
private boolean isPlay = true; //定义是否为可播放状态
private Activity activity;
private MediaPlayer mediaPlayer;
private int resid = 0;
private String url = null;
public GT_MediaPlayer(Activity activity){
this.activity = activity;
}//初始化 上下文
public MediaPlayer loadMusic(int resid){
this.resid = resid;
if(!isPlay){ //停止过播放
if(mediaPlayer.isPlaying()){//如果属于播放状态
mediaPlayer.stop();//停止播放
mediaPlayer.release();//释放资源
}
}
mediaPlayer = null;//清空内存中对象
mediaPlayer = MediaPlayer.create(activity,resid); //初始化 MediaPlayer 对象
isPlay = true;//恢复可播放状态
return mediaPlayer;
}//加载 res 目录下的资源文件
public MediaPlayer loadMusic(String url){
this.url = url;
if(!isPlay){ //停止过播放
if(mediaPlayer.isPlaying()){//如果属于播放状态
mediaPlayer.stop();//停止播放
}
mediaPlayer.release();//释放资源
}
mediaPlayer = null;//清空内存中对象
mediaPlayer = new MediaPlayer();
try {
mediaPlayer.setDataSource(url);
mediaPlayer.prepare();//预加载音频
} catch (IOException e) {
// e.printStackTrace();
GT.log_e(getLineInfo(),"你的音频资源可能 需要添加 网络或访问SD卡的读取权限，否则无法进行有效的获取资源 url:" + url);
}
isPlay = true;//恢复可播放状态
return mediaPlayer;
}//获取 网络 或 SD 上的的音频资源
public MediaPlayer play(){
if(mediaPlayer != null){
recover_play();//如果音频被停止了就恢复音频可播放，在进行 start
mediaPlayer.start();
}
return mediaPlayer;
}//播放
public MediaPlayer pause(){
if(mediaPlayer != null){
mediaPlayer.pause();
}
return mediaPlayer;
}//暂停
public MediaPlayer play_pause(){
recover_play();//如果音频被停止了就恢复音频可播放，在进行 start
if(!mediaPlayer.isPlaying()){ //如果当前的 mediaPlayer 处于暂停状态 且 播放状态为 false 没有在播放
mediaPlayer.start();//继续播放
}else{ //当前处于音乐暂停状态
mediaPlayer.pause();//暂停音乐
}
return mediaPlayer;
}//播放 与 暂停
public MediaPlayer stop(){
isPlay = false;//设置为暂停状态
mediaPlayer.stop();
return mediaPlayer;
}//停止音乐
private MediaPlayer recover_play(){
if(!isPlay){ //停止过播放
if(mediaPlayer.isPlaying()){//如果属于播放状态
mediaPlayer.stop();//停止播放
}
mediaPlayer.release();//释放资源
mediaPlayer = null;//清空内存中对象
if(resid != 0){
mediaPlayer = MediaPlayer.create(activity, resid); //初始化 MediaPlayer 对象
}else if(url != null){
mediaPlayer = new MediaPlayer();
try {
mediaPlayer.setDataSource(url);
mediaPlayer.prepare();//预加载音频
} catch (IOException e) {
GT.log_e(getLineInfo(),"你的音频资源可能 需要添加 网络或访问SD卡的读取权限，否则无法进行有效的获取资源 url:" + url);
}
}
isPlay = true;//恢复可播放状态
}
return mediaPlayer;
}//恢复可播放
public void close(){
if(mediaPlayer.isPlaying()){//如果属于播放状态
mediaPlayer.stop();//停止播放
}
mediaPlayer.release();//释放资源
mediaPlayer = null;
}//释放资源
}
//播放音频
public static class GT_SoundPool{
private Context context;
private static SoundPool soundPool;
private AudioAttributes attr = null;
private static Map<String,Integer> map = new HashMap<>(); //初始化 map 用于存放 音频 key 与 值
private static Map<String,Integer> mapMusic = new HashMap<>(); //初始化 mapMusic 用于存放待播放的音频
//初始化 Content
public GT_SoundPool(Context context){
this.context = context;
}
public GT_SoundPool setAudioAttributes(AudioAttributes attr){
this.attr = attr;
return this;
}//设置音频属性
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public GT_SoundPool loadMusic(Map map){
if(map != null){
this.map = map;
if(attr == null){
//设置音效属性 如果为空,就设置默认的音频属性
attr = new AudioAttributes.Builder()
.setUsage(AudioAttributes.USAGE_GAME)//设置音效的使用场景 为游戏
.setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)//设置音效类型
.build();
}
//初始化
soundPool = new SoundPool.Builder()
.setAudioAttributes(attr)//设置音效池的属性
.setMaxStreams(map.size())//最大容纳 动态添加最大值 个音频
.build();
initMusic();//初始化 音频流
}
return this;
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public GT_SoundPool addMusic(String key,int rawId){
if(map != null){
if(!map.containsKey(key)){ //如果当前 map 中没有此 key
map.put(key,rawId); //将值保存到 map 中
if(attr == null){
//设置音效属性 如果为空,就设置默认的音频属性
attr = new AudioAttributes.Builder()
.setUsage(AudioAttributes.USAGE_GAME)//设置音效的使用场景 为游戏
.setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)//设置音效类型
.build();
}
//初始化
soundPool = new SoundPool.Builder()
.setAudioAttributes(attr)//设置音效池的属性
.setMaxStreams(map.size())//最大容纳 动态添加最大值 个音频
.build();
initMusic();//初始化 音频流
}else{
GT.log_v(getLineInfo(),"添加音频无效，当前已经包含相同的 key，无法再进行装载相同的 key");//提示无效的添加
}
}
return this;
} //添加音频
private void initMusic(){
if(map != null){
for(String key:map.keySet()){
mapMusic.put(key,soundPool.load(context, map.get(key),1));//初始化 待播放的音频
}
}
}//初始化音频
public GT_SoundPool removalMusic(Integer key){
if(map != null){
if(map.containsKey(key)){
map.remove(key);
mapMusic.remove(key);
initMusic();//初始化音频
}else{
log_v(getLineInfo(),"移除音频失败，当前并不存在此 key:" + key);
}
}
return this;
}//移除音频
public GT_SoundPool clear(){
if(map != null){
map.clear();
mapMusic.clear();
}
return this;
}//清空音频
public GT_SoundPool updateMusic(String key,Integer rawId){
if(map != null){
if(map.containsKey(key)){
map.put(key,rawId);
mapMusic.put(key,rawId);
initMusic();//初始化音频
}else{
GT.log_v(getLineInfo(),"修改音频无效，当前并不存在当前 key，无法进行更新操作");//提示无效的更新
}
}
return this;
}//修改音频
//播放音频
public GT_SoundPool play(String key,boolean loop,float rate){
//播放所选音频
soundPool.play(
mapMusic.get(key), //指定播放的音频id
1, //左声道 为0.0 到 1.0
1, //右声道 为0.0 到 1.0
0, //优先级 0
(loop == true ? -1 : 0), //是否循环 0为不循环, -1 为循环
rate //速率 为正常速率 1 最低为 0.5，最高为 2
);
return this;
}
}
//播放视频
public static class GT_Video implements SurfaceHolder.Callback{
/**
* 使用说明：
* 第一步：在 xml 中 定义好 SurfaceView 组件
* 第二步：video = new GT.GT_Video(this,R.raw.lmh,surfaceView);//初始化 GT_Video 视频播放器
* 第三步：播放 video.play();、暂停 video.pause();、 停止 video.stop();、释放资源 video.close();
*/
private MediaPlayer mediaPlayer = null;
private SurfaceView surfaceView;
private SurfaceHolder surfaceHolder;
private Context context;
private int resId;
private static boolean isPlay = true; //定义是否被停止播放过视频
public GT_Video(Context context,int resId,SurfaceView surfaceView){
this.context = context;
this.surfaceView = surfaceView;
this.resId = resId;
surfaceHolder = this.surfaceView.getHolder();
surfaceHolder.addCallback(this);
}
public GT_Video play(){
if(mediaPlayer != null){
recover_play();
mediaPlayer.start();
}
return this;
}
public GT_Video pause(){
if(mediaPlayer != null){
recover_play();
mediaPlayer.pause();
}
return this;
}
public GT_Video stop(){
if(mediaPlayer != null){
mediaPlayer.stop();
isPlay = false;
}
return this;
}
private MediaPlayer recover_play(){
if(!isPlay){ //停止过播放
close();
mediaPlayer = null;//清空内存中对象
if(resId != 0){
mediaPlayer = MediaPlayer.create(context, resId);//设置加载的视频资源
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mediaPlayer.setDisplay(surfaceHolder); //设置显示视频显示在SurfaceView上
}
isPlay = true;//恢复可播放状态
}
return mediaPlayer;
}//恢复可播放
public void close(){
if (mediaPlayer.isPlaying()) {
mediaPlayer.stop();
}
mediaPlayer.release();
}//释放资源
@Override
public void surfaceCreated(SurfaceHolder holder) {
mediaPlayer = MediaPlayer.create(context, resId);//设置加载的视频资源
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mediaPlayer.setDisplay(surfaceHolder); //设置显示视频显示在SurfaceView上
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
}
}
/******************************************** Run GT 的内部注解 *****************************************************/
//注解类
public static class Annotations{
//Toast 注解:用于获取调用 GT.Toast的类对象
@Retention(RetentionPolicy.RUNTIME)
@Target(value={ElementType.TYPE})
public @interface Toast {}
}
//判断注解类
public static class AnnotationAssist {
/**
* 目的：用于判断 当前类是否被 当前的注解注解过
* 用例：new GT.AnnotationAssist(LogActivity.class, GT.Annotations.Toast.class);
* 第一个参数：任意被
* 再打开 GT 内部的 Log 日志
*/
@SuppressWarnings("unchecked")
public AnnotationAssist(Object obj,Object annotation) {
if(GT_LOG_TF){
log_i("obj:" + obj);
log_i("annotation:" + annotation);
}
//获取所有注解
obj = ObjectClassToObject(obj);
Annotation[] annotations = obj.getClass().getAnnotations();
if(GT_LOG_TF) log_i("---------------该类有所的注解---------------------");
for(Annotation annotation1 : annotations) if(GT_LOG_TF) log_i(annotation1);
if(GT_LOG_TF) log_i("-------------------close--------------------------");
/*
* 获取声明注解 [Ljava.lang.annotation.Annotation;@28c97a5
* [Ljava.lang.annotation.Annotation;@28c97a5
*/
Annotation[] deAnnos = obj.getClass().getDeclaredAnnotations();
if(GT_LOG_TF) log_i("被声明式注解标识过:" + deAnnos);
if(annotation != null){
//获取被 SubAnnotation 注解过的类
Annotation subAnnotation = obj.getClass().getAnnotation((Class<Annotation>) annotation);
if(GT_LOG_TF) log_i("该类被 [" + subAnnotation + "] 注解过");
}
}
public Object ObjectClassToObject(Object obj){
String[] strs = obj.toString().split(" ");
String str = strs[1];
Class<?> clazz = getClass();
try {
clazz = Class.forName(str);
} catch (ClassNotFoundException e1) {
e1.printStackTrace();
}
try {
obj = clazz.newInstance();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
return obj;
}
}
}