android小知识

打开软件安装页面

一般下载完APK文件之后，都要打开软件安装页面，提示用户进行安装，可以用以下方法（固定写法）

Intent intent = new Intent();
intent.setAction("android.intent.action.VIEW");
intent.addCategory("android.intent.category.DEFAULT");
intent.setDataAndType(Uri.fromFile(new File("apk在手机中的路径/要安装的软件.apk")), "application/vnd.android.package-archive");
startActivityForResult(intent, 0);

分享软件信息

如果想要分享软件，需要写好预定要分享出去的信息，可用以下方法：

Intent intent = new Intent();
intent.setAction("android.intent.action.SEND");
intent.addCategory("android.intent.category.DEFAULT");
intent.setType("text/plain");
intent.putExtra(Intent.EXTRA_TEXT, "（自定义内容）这是一个很牛逼的软件，你信不信");
startActivity(intent);

卸载软件

卸载软件一般都是使用Android内置的卸载工具来卸载的，只需要传入要卸载的软件的包名，便可以打开其卸载页面：

    Intent intent = new Intent();
    intent.setAction("android.intent.action.DELETE");
    intent.addCategory("android.intent.category.DEFAULT");
    intent.setData(Uri.parse("package:" + "卸载软件的包名"));
    startActivityForResult(intent, 0);

打开软件详情页

此方法打开Android内关于软件的详情页，需要传入软件报名

Intent intent = new Intent();
intent.setAction("android.settings.APPLICATION_DETAILS_SETTINGS");
intent.setData(Uri.parse("package:" + "要打开软件的包名"));
startActivity(intent);

打开其他软件

在自己的app中打开其他应用可以使用这个方法

PackageManager manager = getPackageManager();
Intent launchIntentForPackage = manager.getLaunchIntentForPackage("要打开软件的包名");
if (launchIntentForPackage != null) {
    startActivity(launchIntentForPackage);
}

跳转到从应用直接跳转到主界面的方法

    //跳转到主界面
    Intent intent = new Intent();
    intent.setAction("android.intent.action.MAIN");
    intent.addCategory("android.intent.category.HOME");
    startActivity(intent);

注册开屏锁屏的广播接收者

注册开屏锁屏的广播的IntentFliter所要添加的action是

Intent.ACTION_SCREEN_OFF // 锁屏时添加
Intent.ACTION_SCREEN_ON  // 开屏是添加

获取app信息的方法

获取app信息（报名、版本名、应用图标、应用名称、是用户程序还是系统程序、安装在SD卡中还是手机内存中）

public class AppEnging {
public static List getAppInfos(Context context){
List list = new ArrayList();
//获取应用程序信息
//包的管理者
PackageManager pm = context.getPackageManager();
//获取系统中安装到所有软件信息
List installedPackages = pm.getInstalledPackages(0);
for (PackageInfo packageInfo : installedPackages) {
    //获取包名
    String packageName = packageInfo.packageName;
    //获取版本号
    String versionName = packageInfo.versionName;
    //获取application
    ApplicationInfo applicationInfo = packageInfo.applicationInfo;
    int uid = applicationInfo.uid;
    //获取应用程序的图标
    Drawable icon = applicationInfo.loadIcon(pm);
    //获取应用程序的名称
    String name = applicationInfo.loadLabel(pm).toString();
    //是否是用户程序
    //获取应用程序中相关信息,是否是系统程序和是否安装到SD卡
    boolean isUser;
    int flags = applicationInfo.flags;
    if ((applicationInfo.FLAG_SYSTEM & flags) == applicationInfo.FLAG_SYSTEM) {
        //系统程序
        isUser = false;
    }else{
        //用户程序
        isUser = true;
    }
    //是否安装到SD卡
    boolean isSD;
    if ((applicationInfo.FLAG_EXTERNAL_STORAGE & flags) == applicationInfo.FLAG_EXTERNAL_STORAGE) {
        //安装到了SD卡
        isSD = true;
    }else{
        //安装到手机中
        isSD = false;
    }
    //添加到bean中
    AppInfo appInfo = new AppInfo(name, icon, packageName, versionName, isSD, isUser);
    //将bean存放到list集合
    list.add(appInfo);
}
return list;
}
}

// 封装软件信息的bean类

class AppInfo {
//名称
private String name;
//图标
private Drawable icon;
//包名
private String packagName;
//版本号
private String versionName;
//是否安装到SD卡
private boolean isSD;
//是否是用户程序
private boolean isUser;

public AppInfo() {
    super();
}
public AppInfo(String name, Drawable icon, String packagName,
        String versionName, boolean isSD, boolean isUser) {
    super();
    this.name = name;
    this.icon = icon;
    this.packagName = packagName;
    this.versionName = versionName;
    this.isSD = isSD;
    this.isUser = isUser;
}
}

获取系统中所有进程信息的方法

public class TaskEnging {
            /**
                 * 获取系统中所有进程信息
                 * @return
                 */
            public static List getTaskAllInfo(Context context){
                    List list = new ArrayList();
                    //1.进程的管理者
                    ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
                    PackageManager pm = context.getPackageManager();
                    //2.获取所有正在运行的进程信息
                    List runningAppProcesses = activityManager.getRunningAppProcesses();
                    //遍历集合
                    for (RunningAppProcessInfo runningAppProcessInfo : runningAppProcesses) {
                        TaskInfo taskInfo = new TaskInfo();
                            //3.获取相应的信息
                            //获取进程的名称,获取包名
                            String packagName = runningAppProcessInfo.processName;
                            taskInfo.setPackageName(packagName);
                            //获取进程所占的内存空间,int[] pids : 输入几个进程的pid,就会返回几个进程所占的空间
                            MemoryInfo[] memoryInfo = activityManager.getProcessMemoryInfo(new int[]{runningAppProcessInfo.pid});
                            int totalPss = memoryInfo[0].getTotalPss();
                            long ramSize = totalPss*1024;
                            taskInfo.setRamSize(ramSize);
        try {
            //获取application信息
            //packageName : 包名     flags:指定信息标签
            ApplicationInfo applicationInfo = pm.getApplicationInfo(packagName, 0);
            //获取图标
            Drawable icon = applicationInfo.loadIcon(pm);
            taskInfo.setIcon(icon);
            //获取名称
            String name = applicationInfo.loadLabel(pm).toString();
            taskInfo.setName(name);
            //获取程序的所有标签信息,是否是系统程序是以标签的形式展示
            int flags = applicationInfo.flags;
            boolean isUser;
            //判断是否是用户程序
            if ((applicationInfo.FLAG_SYSTEM & flags) == applicationInfo.FLAG_SYSTEM) {
                //系统程序
                isUser = false;
                }else{
                    //用户程序
                    isUser = true;
                }
                //保存信息
                taskInfo.setUser(isUser);
                } catch (NameNotFoundException e) {
                    e.printStackTrace();
                }
                //taskinfo添加到集合
                list.add(taskInfo);
            }
    return list;
}

}


class TaskInfo {

//名称
private String name;
//图标
private Drawable icon;
//占用的内存空间
private long ramSize;
//包名
private String packageName;
//是否是用户程序
private boolean isUser;
//checkbox是否被选中
private boolean isChecked = false;
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public Drawable getIcon() {
    return icon;
}
public void setIcon(Drawable icon) {
    this.icon = icon;
}
public long getRamSize() {
    return ramSize;
}
public void setRamSize(long ramSize) {
    this.ramSize = ramSize;
}
public String getPackageName() {
    return packageName;
}
public void setPackageName(String packageName) {
    this.packageName = packageName;
}
public boolean isUser() {
    return isUser;
}
public void setUser(boolean isUser) {
    this.isUser = isUser;
}
public TaskInfo() {
    super();
    // TODO Auto-generated constructor stub
}
public TaskInfo(String name, Drawable icon, long ramSize,
        String packageName, boolean isUser) {
            super();
            this.name = name;
            this.icon = icon;
            this.ramSize = ramSize;
            this.packageName = packageName;
            this.isUser = isUser;
        }
@Override
public String toString() {
    return "TaskInfo [name=" + name + ", icon=" + icon + ", ramSize="
            + ramSize + ", packageName=" + packageName + ", isUser="
            + isUser + "]";
        }
        public boolean isChecked() {
            return isChecked;
        }
        public void setChecked(boolean isChecked) {
            this.isChecked = isChecked;
        }
    }

清理所有空进程的方法

ActivityManager am = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
//获取正在运行进程
List runningAppProcesses = am.getRunningAppProcesses();
for (RunningAppProcessInfo runningAppProcessInfo : runningAppProcesses) {
    //判断我们的应用进程不能被清理
    if (!runningAppProcessInfo.processName.equals(getPackageName())) {
        am.killBackgroundProcesses(runningAppProcessInfo.processName);
    }
}

动态获取服务是否开启的方法

查看服务是否在后台开启，当用户直接停止服务的时候也能够检测得到

public static boolean isRunningService(String className,Context context){
//进程的管理者,活动的管理者
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
//获取正在运行的服务
List runningServices = activityManager.getRunningServices(1000);//maxNum 返回正在运行的服务的上限个数,最多返回多少个服务
//遍历集合
for (RunningServiceInfo runningServiceInfo : runningServices) {
    //获取控件的标示
    ComponentName service = runningServiceInfo.service;
    //获取正在运行的服务的全类名
    String className2 = service.getClassName();
    //将获取到的正在运行的服务的全类名和传递过来的服务的全类名比较,一直表示服务正在运行  返回true,不一致表示服务没有运行  返回false
    if (className.equals(className2)) {
        return true;
    }
}
return false;

}

获取内存卡和SD卡可用空间的方法

/**
  * 获取SD卡可用空间
  */
public static long getAvailableSD(){
 //获取SD卡路径
 File path = Environment.getExternalStorageDirectory();
 //硬盘的API操作
         StatFs stat = new StatFs(path.getPath());
         long blockSize = stat.getBlockSize();//获取每块的大小
         long totalBlocks = stat.getBlockCount();//获取总块数
         long availableBlocks = stat.getAvailableBlocks();//获取可用的块数
         return availableBlocks*blockSize;
    }
    /**
 *获取内存可用空间
 * @return
 */
public static long getAvailableROM(){
    //获取内存路径
    File path = Environment.getDataDirectory();
    //硬盘的API操作
        StatFs stat = new StatFs(path.getPath());
        long blockSize = stat.getBlockSize();//获取每块的大小
        long totalBlocks = stat.getBlockCount();//获取总块数
        long availableBlocks = stat.getAvailableBlocks();//获取可用的块数
        return availableBlocks*blockSize;
    }

简单的MD5加密

进行简单的MD5加密，传入一个String，输出经过MD5加密后的密码

public static String passwordMD5(String password){
        StringBuilder sb = new StringBuilder();
        try {
            //1.获取数据摘要器
            //arg0 : 加密的方式
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            //2.将一个byte数组进行加密,返回的是一个加密过的byte数组,二进制的哈希计算,md5加密的第一步
            byte[] digest = messageDigest.digest(password.getBytes());
            //3.遍历byte数组
            for (int i = 0; i < digest.length; i++) {
                //4.MD5加密
                //byte值    -128-127
                int result = digest[i] & 0xff;
                //将得到int类型转化成16进制字符串
                //String hexString = Integer.toHexString(result)+1;//不规则加密,加盐
                String hexString = Integer.toHexString(result);
                if (hexString.length() < 2) {
                    //                    System.out.print("0");
                    sb.append("0");
                }
                //System.out.println(hexString);
                //e10adc3949ba59abbe56e057f20f883e
                sb.append(hexString);
            }
            return sb.toString();
} catch (NoSuchAlgorithmException e) {
    //找不到加密方式的异常
    e.printStackTrace();
}
return null;
}

获取剩余内存和总内存的方法

    /**
     * 获取剩余内存
     * @return
     */
public static long getAvailableRam(Context context){
    ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    //获取内存的信息,保存到memoryinfo中
    MemoryInfo outInfo = new MemoryInfo();
    am.getMemoryInfo(outInfo);
    //获取空闲的内存
    //outInfo.availMem;
    //        //获取总的内存
    //        outInfo.totalMem;
    return outInfo.availMem;
}

/**
     * 获取总的内存
     * @return
     * @deprecated
     */
public static long getTotalRam(Context context){
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
//获取内存的信息,保存到memoryinfo中
MemoryInfo outInfo = new MemoryInfo();
am.getMemoryInfo(outInfo);
//获取空闲的内存
//outInfo.availMem;
//        //获取总的内存
//        outInfo.totalMem;
return outInfo.totalMem;//16版本之上才有,之下是没有的
}

dp与px之间的简单转换

/**
* 根据手机的分辨率从 dip 的单位 转成为 px(像素)
* @return
*/
public static int dip2qx(Context context, float dpValue) {
final float scale = context.getResources().getDisplayMetrics().density; //获取屏幕的密度
return (int) (dpValue * scale + 0.5f); //+0.5f四舍五入 3.7 3 3.7+0.5 = 4.2 4
}

/**
 * 根据手机的分辨率从 px(像素) 的单位 转成为 dp
 */  
public static int px2dip(Context context, float pxValue) {  
    final float scale = context.getResources().getDisplayMetrics().density;  
    return (int) (pxValue / scale + 0.5f);  
}

获得系统联系人的方法

public static List> getAllContactInfo(Context context) {
    SystemClock.sleep(3000);
    ArrayList> list = new ArrayList>();
    // 1.获取内容解析者
    ContentResolver resolver = context.getContentResolver();
    // 2.获取内容提供者的地址:com.android.contacts
    // raw_contacts表的地址 :raw_contacts
    // view_data表的地址 : data
    // 3.生成查询地址
    Uri raw_uri = Uri.parse("content://com.android.contacts/raw_contacts");
    Uri date_uri = Uri.parse("content://com.android.contacts/data");
    // 4.查询操作,先查询raw_contacts,查询contact_id
    // projection : 查询的字段
    Cursor cursor = resolver.query(raw_uri, new String[] { "contact_id" },
    null, null, null);
    // 5.解析cursor
    while (cursor.moveToNext()) {
        // 6.获取查询的数据
        String contact_id = cursor.getString(0);
        // cursor.getString(cursor.getColumnIndex("contact_id"));//getColumnIndex
        // : 查询字段在cursor中索引值,一般都是用在查询字段比较多的时候
        // 判断contact_id是否为空
        if (!TextUtils.isEmpty(contact_id)) {//null   ""
        // 7.根据contact_id查询view_data表中的数据
        // selection : 查询条件
        // selectionArgs :查询条件的参数
        // sortOrder : 排序
        // 空指针: 1.null.方法 2.参数为null
        Cursor c = resolver.query(date_uri, new String[] { "data1",
        "mimetype" }, "raw_contact_id=?",
        new String[] { contact_id }, null);
        HashMap map = new HashMap();
        // 8.解析c
        while (c.moveToNext()) {
                // 9.获取数据
                String data1 = c.getString(0);
                String mimetype = c.getString(1);
                // 10.根据类型去判断获取的data1数据并保存
                if (mimetype.equals("vnd.android.cursor.item/phone_v2")) {
                    // 电话
                    map.put("phone", data1);
                    } else if (mimetype.equals("vnd.android.cursor.item/name")) {
                        // 姓名
                        map.put("name", data1);
                    }
                }
                // 11.添加到集合中数据
                list.add(map);
                // 12.关闭cursor
                c.close();
            }
        }
        // 12.关闭cursor
        cursor.close();
        return list;
    }

直接打开系统联系人界面，并且获取联系人号码的方法

使用startActivityForResult()开启Activity，然后再onActivityResult()方法中获取返回的联系人号码

// 在按钮点击事件中设置Intent，
Intent intent = new Intent();
intent.setAction("android.intent.action.PICK");
intent.addCategory("android.intent.category.DEFAULT");
intent.setType("vnd.android.cursor.dir/phone_v2");
startActivityForResult(intent, 1);

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if(data !=null){
    Uri uri = data.getData();
    String num = null;
    // 创建内容解析者
            ContentResolver contentResolver = getContentResolver();
            Cursor cursor = contentResolver.query(uri,
                    null, null, null, null);
                    while(cursor.moveToNext()){
                        num = cursor.getString(cursor.getColumnIndex("data1"));                    
                    }
                    cursor.close();
                    num = num.replaceAll("-", "");//替换的操作,555-6 -> 5556
                }
            }

获取短信并保存到XML文件中的方法（备份短信）

获取手机中的短信信息，并保存为XML文件，路径为：/mnt/sdcard/backupsms.xml

/**
 * 获取短信
 */
public static void getAllSMS(Context context){
//1.获取短信
//1.1获取内容解析者
ContentResolver resolver = context.getContentResolver();
//1.2获取内容提供者地址   sms,sms表的地址:null  不写
//1.3获取查询路径
Uri uri = Uri.parse("content://sms");
//1.4.查询操作
//projection : 查询的字段
//selection : 查询的条件
//selectionArgs : 查询条件的参数
//sortOrder : 排序
Cursor cursor = resolver.query(uri, new String[]{"address","date","type","body"}, null, null, null);
//设置最大进度
int count = cursor.getCount();//获取短信的个数


//2.备份短信
//2.1获取xml序列器
XmlSerializer xmlSerializer = Xml.newSerializer();
try {
    //2.2设置xml文件保存的路径
    //os : 保存的位置
    //encoding : 编码格式
    xmlSerializer.setOutput(new FileOutputStream(new File("/mnt/sdcard/backupsms.xml")), "utf-8");
    //2.3设置头信息
    //standalone : 是否独立保存
    xmlSerializer.startDocument("utf-8", true);
    //2.4设置根标签
    xmlSerializer.startTag(null, "smss");
    //1.5.解析cursor
    while(cursor.moveToNext()){
        SystemClock.sleep(1000);
        //2.5设置短信的标签
        xmlSerializer.startTag(null, "sms");
        //2.6设置文本内容的标签
        xmlSerializer.startTag(null, "address");
        String address = cursor.getString(0);
        //2.7设置文本内容
        xmlSerializer.text(address);
        xmlSerializer.endTag(null, "address");

        xmlSerializer.startTag(null, "date");
        String date = cursor.getString(1);
        xmlSerializer.text(date);
        xmlSerializer.endTag(null, "date");

        xmlSerializer.startTag(null, "type");
        String type = cursor.getString(2);
        xmlSerializer.text(type);
        xmlSerializer.endTag(null, "type");

        xmlSerializer.startTag(null, "body");
        String body = cursor.getString(3);
        xmlSerializer.text(body);
        xmlSerializer.endTag(null, "body");

        xmlSerializer.endTag(null, "sms");
        System.out.println("address:"+address+"   date:"+date+"  type:"+type+"  body:"+body);

    }
    xmlSerializer.endTag(null, "smss");
    xmlSerializer.endDocument();
    //2.8将数据刷新到文件中
    xmlSerializer.flush();
} catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
}

获取手机屏幕高度和宽度的方法

    // 获取屏幕的宽度
    WindowManager windowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
        // windowManager.getDefaultDisplay().getWidth();
    DisplayMetrics outMetrics = new DisplayMetrics();// 创建了一张白纸
    windowManager.getDefaultDisplay().getMetrics(outMetrics);// 给白纸设置宽高
    width = outMetrics.widthPixels;
    height = outMetrics.heightPixels;