Android开发使用AndBase框架实现多功能标题栏
本教程的学习内容:
1.使用AndBase实现多功能标题栏...
AndBase框架内部提供了许多的方式能够使我们去设置一个更好的标题栏,进行动态的改变,而并非静态的将标题栏界面写死...能够使得标题栏更加的美观...总体就是动态的获取布局然后通过对布局的操作来自定义一个良好的标题栏...
使用AndBase框架的时候我们的主函数就不是继承于Acticity了,而是继承于AbActivity,万变不离其宗还是Activity...
public class MainActivity extends AbActivity
继承了AbActivity这样就使得自己的Activity拥有一个框架...我们就可以使用内部包含的一些变量...就拿我们的标题栏变量来说吧...mAbTitleBar就是内在的一个标题栏变量...凡是继承了AbActivity的Activity就可以使用这个变量,这个变量会作为当前Activity中的标题栏变量..我们就直接可以对其进行一些相关属性的设定..从而书写我们自己的标题栏...
1.1 设置标题栏的有无...
标题栏的有无设置其实就是设置当前的mAbTitleBar是否进行显示...通过调用SetVisiable函数来进行相关的设置...
public void setVisiable(boolean b){
if(b){
titleBar.setVisibility(View.VISIBLE); //设置标题栏显示在视图上..
}else{
titleBar.setVisibility(View.GONE);//设置标题栏不显示在视图上..
}
}
1.2 为标题栏添加新的控件...
无论是在标题栏还是Activity中如果想要动态的添加控件,那么必然是添加View的过程...添加View之前,我们需要把控件添加到View当中,然后再把View添加在Activity上,这样就完成了动态添加视图的效果...View其实只是一个空的架子,更形象的来说是一个没有打起的气球一样..光有外壳,没有东西,那么如果想要有东西,那么我们需要为其进行充气,只有充了气之后的View才是我们想要去进行加载的...否则是没什么用的..
充气的过程就是使用LayoutInflater.inflater(R.layout.XXX,root);函数来完成的...对ListView使用熟悉的那么想必也就非常清楚这个过程了...使用ListView时,我们只是对ListView中的Item进行布局的书写,但是绝对不会在布局中写死Item布局中的东西..因为Item中的东西一般都是进行动态添加的...所以我们一般是获取ListView的ID,然后对每一个Item进行动态的加载...这一般是对ListView进行操作...其实都一样...添加视图都是进行动态添加...添加了View之后,我们仍然可以通过获取控件然后绑定监听,从而做更多的操作...
这个函数是我自定义的一个函数...arg0和arg1是通过Inflater.inflate获取到的视图...
public void setRightview(int resid0,int resid1){
ClearRightView();
titleBar.addRightView(arg0); //为标题栏添加视图...
titleBar.addRightView(arg1);
moreview=(Button) arg0.findViewById(resid0);//通过当前视图获取控件...
moreapp=(Button) arg1.findViewById(resid1);
//通过获取控件之后,设置相关监听,从而完成更多的操作...
moreview.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Toast.makeText(context, "点击", Toast.LENGTH_LONG).show();
}
});
moreapp.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Toast.makeText(context, "继续点击", Toast.LENGTH_LONG).show();
}
});
}
这样就完成了视图的添加...其实标题栏的操作基本都是这个过程...最重要的还是需要清楚其中的函数到底怎么用,如何为标题栏设置相关的属性,比如说背景颜色,标题栏的文本,标题栏的Logo以及一些相关属性的设置,其实说白了就是把xml那种布局方式通过Java代码来更加灵活的进行运用...可以使得布局上的控件更加的灵活...
1.3 操作栏变换...
我们通过一个函数来看一看mAbTitleBar到底有哪些函数可以动态设置View视图...这里是为了介绍一些相关的函数的应用...并没有完整的代码过程...源代码过程我会最后进行给出..
btn5.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {//以下函数的调用时不存在函数顺序的问题的...不同的调用顺序显示的结果是一样的,,,
mAbTitleBar.setLogo(R.drawable.button_selector_delete); //为标题栏设置logo..
mAbTitleBar.setLogo2(R.drawable.button_selector_app); //为标题栏设置第二个Logo..这个setLogo只有这两个函数..没有Logo3...如果想设置更多的Logo..只能去写xml布局...
mAbTitleBar.clearRightView(); //清除标题栏右边的视图..
View rightViewOk = mInflater.inflate(R.layout.ok_btn, null); //为一个View视图充气...
mAbTitleBar.addRightView(rightViewOk); //在标题栏右边添加当前充气后的视图..
mAbTitleBar.setTitleText("正在修改"); //设置标题栏的文字属性..
mAbTitleBar.setTitleBarBackground(R.drawable.top_bg2);//设置文字的背景..
mAbTitleBar.setTitleBarGravity(Gravity.LEFT,Gravity.CENTER);//设置标题栏的对其方式...
mAbTitleBar.setLogoOnClickListener(new OnClickListener() {
//为Logo图片设置监听...
@Override
public void onClick(View v) {
//改变相关的属性... mAbTitleBar.setTitleBarBackground(R.drawable.top_bg);
mAbTitleBar.setTitleText("多功能标题栏");
mAbTitleBar.clearRightView();
mAbTitleBar.setLogo(R.drawable.button_selector_back);
mAbTitleBar.setTitleBarGravity(Gravity.LEFT,Gravity.RIGHT);
mAbTitleBar.setTitleTextMargin(20, 0, 0, 0);
mAbTitleBar.getLogoView2().setVisibility(View.GONE); //设置可见性...
mAbTitleBar.setLogoOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
finish();
}
});
}
});
}
});
1.4 标题栏的下拉效果...
标题栏的下拉其实就是点击标题形成下拉菜单..每个下拉菜单都是一个子选项...通过这些子选项我们可以做更多的事情...效果如上...其实每一个这样类似的菜单都是一个ListView..通过对ListView的每一个Item进行初始化,那么也就自然而然的形成这样的效果了...其实总体还是进行动态布局...
btn7.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mAbTitleBar.setTitleTextBackgroundResource(R.drawable.drop_down_title_btn);
View popView = mInflater.inflate(R.layout.list_pop, null); //先获取一个视图..
ListView popListView = (ListView) popView.findViewById(R.id.pop_list); //获取ListView的ID..
List<AbMenuItem> list = new ArrayList<AbMenuItem>(); //定义一个列表项...这个类只保存ID和Text属性..
list.add(new AbMenuItem("蔡文姬"));
list.add(new AbMenuItem("貂蝉"));
list.add(new AbMenuItem("紫罂粟"));
list.add(new AbMenuItem("孙尚香"));
ListPopAdapter mListPopAdapter = new ListPopAdapter(TitleBarActivity.this, list,R.layout.list_pop_item); //定义一个适配器...
popListView.setAdapter(mListPopAdapter); //为ListView设置一个适配器...
mAbTitleBar.setTitleTextDropDown(popView); //设置TitleBar上的TextView被点击的监听..
}
});
通过这样的设置,很容易形成这样的效果..这里使用了AbMenuItem类...通过源码我们可以知道这个类有两个构造函数,一个是对int ID 和String Text两个属性进行保存,一个则是仅仅保存一个String Text属性...这样也就使得ListView显示的东西比较的简单...并且一般这种小型的ListView一般也就一个Text值..因此使用AbMenuItem还是比较方便的...这样也就完成了一个下拉菜单...
1.5 适配器...
再简单的说一下适配器这个东西吧...适配器主要还是用于为ListView中的每一个Item进行动态的设置,使得ListView的布局能够更加的灵活...说白了就是定义了一种样式,ListView中的每一个Item都需要按照这个样式来进行显示...非常的简单...
/*
*
* CopyRight@ By Darker 2015-10-30
* 多功能菜单...
*
* */
package com.example.andbasetitlebar;
import java.util.List;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.TextView;
import com.ab.global.AbMenuItem;
public class Adapter extends BaseAdapter { //继承BaseAdapter
private Context context;
private List<AbMenuItem> list;
private int itemResource;
public Adapter(Context context, List<AbMenuItem> list,int itemResource) {
this.context = context;
this.list = list;
this.itemResource = itemResource;
}
@Override
public int getCount() {
return list.size();
}
@Override
public Object getItem(int position) {
return list.get(position);
}
@Override
public long getItemId(int position) {
return position;
}
//由于我们的ListView中的Item显示的方式都非常的简单,因此ViewHolder类中也就仅仅定义了一个TextView属性...
@Override
public View getView(int position, View convertView, ViewGroup viewGroup) {
ViewHolder holder;
/*这个判断其实是为了复用而定义的...因为ListView都是动态进行加载的.. *如果ListView中的Item超过了屏幕的大小,那么势必就需要进行下拉... *下拉就代表原来的那些ListView就需要被销毁...
* 那么总不能每一次滑动我们都新建立一个ViewHolder对象..我们可以把这些被销毁的ViewHolder进行复用...
* 有了复用之后,再次滑动的时候ViewHolder会自动调用那些被销毁掉的进行复用...从而使得资源得到重新加载...
* 说白了就是提高了复用性...
*/
if (convertView == null) {
convertView = LayoutInflater.from(context).inflate(itemResource, null); //定义一个视图对象View...
holder = new ViewHolder();
holder.itemText = (TextView) convertView.findViewById(R.id.pop_item); //在当前的View中获取ListView的ID..
convertView.setTag(holder);//设置标志..
} else {
holder = (ViewHolder) convertView.getTag();//这里可以直接获取标志,对holder进行复用,减少了内存的分配和开销...
}
AbMenuItem item = list.get(position);
holder.itemText.setText(item.getText()); //为每一个Item中的TextView设置值...
return convertView;
}
static class ViewHolder {
TextView itemText;
}
}
实现多功能菜单其实非常的简单,大部分的函数都是写好的函数,我们只需要调用就可以设置标题栏的相关样式...实现多功能的菜单...最后附加上我自己书写的代码..还是完整的代码能够使我们进步的更加迅速...从而可以理解其中的调用过程和原理...
Android快速开发框架andbase
andbase是为Android开发者量身打造的一款开源类库产品,您可以在本站中获取到最新的代码,示例以及开发文档。
andbase能做什么?
1.andbase中包含了大量的开发常用手段。
如网络下载数据的方法,多线程,线程池的管理,图片缓存管理,图片文件下载上传,对常用工具类入字符串,日期,文件处理,图片处理等进行了进一步的封装,能够使您的应用在团队开发中减少冗余代码,很大的提高了代码的维护性与开发高效行,能很好的规避由于开发疏忽而导致常犯的错误。
2.andbase封装了大量的常用且系统本身没有的控件。
如list分页,下拉刷新,图片轮播,多线程支持断点续传的下载器,左右侧边栏,图片多张上传,iphone中比较流行的轮子选择,在achart基础上进行改进与精简的图表,日历选择器等。
2.强大的AbActivity,您没有理由不继承它。
继承它你能够获得一个简单强大可设置的标题栏,以及一系列的简单调用,如弹出框,提示框,进度框等。
3.提供效率较高图片缓存管理策略,使内存大幅度节省,利用率提高,效率提高。
程序中要管理大量的图片资源,还要从网络下载,andbase提供简单的方法,几步完成下载与显示,并支持缩放,裁剪,缓存功能。
4.日期处理代码,项目中的格式很多,一个一个从网上找吗,多麻烦,andbase都能解决。
日期处理各种函数,你懂的。
5.用andbase再也不需要handler了,线程里直接toast,都没问题。
handler会产生大量代码,并且不好维护,andbase对handler进行了封装,忘了它吧。
6.简单轻量支持注解自动建表的ORM框架(1.5.2新增,多谢小胖提供源码)。
是否感觉写sql写字段,建表很麻烦呢,用注解吧,一句话完成增删改查。
Android RecyclerView 是Android5.0推出来的,导入support-v7包即可使用。
个人体验来说,RecyclerView绝对是一款功能强大的控件。
首先总结下RecyclerView的特点:
1.支持不同方向,不同排版模式,实现多种展现数据的形式,涵盖了ListView,GridView,瀑布流等数据表现的形式
2.内部实现了回收机制,无需我们考虑View的复用情况
3.取消了onItemClick等点击事件,需要自己手动去写
------------------------------------------------------------------------------------
那么让我们通过一些Demo来了解RecyclerView的基本使用
首先,要导入support-v7 包
import android.support.v7.widget.RecyclerView;
RecyclerView和ListView的使用一样,都需要有对应的Adapter,列表项布局,数据源
1.先写主Activity布局
可以看到RecyclerView的标签
<android.support.v7.widget.RecyclerView>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools" xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context="com.xqx.superapp.app.Android5Activity">
<Button
android:text="添加一个数据"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="btnAddItem"
/>
<Button
android:text="删除第一个"
android:onClick="btnRemoveItem"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<android.support.v7.widget.RecyclerView
android:id="@+id/recycle_view"
android:layout_width="match_parent"
android:layout_height="match_parent"
>
</android.support.v7.widget.RecyclerView>
</LinearLayout>
菜单项布局,标准的上面图片,下面文字
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:gravity="center"
android:layout_width="match_parent"
android:layout_height="match_parent">
<ImageView
android:id="@+id/item_icon"
android:src="@mipmap/machao_moqi"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<TextView
android:id="@+id/item_title"
android:text="名称"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
/>
</LinearLayout>
2.接下来就看Activity代码了
首先看成员变量,与ListView,GridView一样 标准三样, 控件,数据源,适配器
private List<String> data;
private RecyclerView recyclerView;
private MyRecycleAdapter adapter; //自定义适配器,继承RecyclerView.Adapter
接着我们必须要自定义一个ViewHolder,这个ViewHolder 必须要继承 RecyclerView.ViewHolder
注意RecyclerView不再提供onItemClick事件监听,所以需要我们自己手工写监听事件的方法
private static class ViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener {
public ImageView imageView;
public TextView textView;
public ViewHolder(View itemView) {
super(itemView);
// 通常ViewHolder的构造,就是用于获取控件视图的
imageView = (ImageView) itemView.findViewById(R.id.item_icon);
textView = (TextView) itemView.findViewById(R.id.item_title);
// TODO 后续处理点击事件的操作
itemView.setOnClickListener(this);
}
@Override
public void onClick(View v) {
int position = getAdapterPosition();
Context context = imageView.getContext();
Toast.makeText(context,"显示第"+position+"个项",Toast.LENGTH_SHORT).show();
}
}
再让我们看自定义适配器,注意这里的参数是ViewHolder,这个ViewHodler是我们自己的,不要导入v7包下的ViewHolder,
之后要重写三个方法
private class MyRecycleAdapter extends RecyclerView.Adapter<ViewHolder>{
@Override
public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
return null;
}
@Override
public void onBindViewHolder(ViewHolder viewHolder, int i) {
}
@Override
public int getItemCount() {
return 0;
}
}
在自定义适配器MyRecycleAdapter中,首先要写一个构造方法,因为有数据源,所有构造方法里必然有List
private List<String> strings;
public MyRecycleAdapter(List<String> strings) {
this.strings = strings;
}
然后就要重写三个方法了,
@Override
public int getItemCount() {
int ret = 0;
if (strings != null) {
ret = strings.size();
}
return ret;
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
ViewHolder ret = null;
// 不需要检查是否复用,因为只要进入此方法,必然没有复用
// 因为RecyclerView 通过Holder检查复用
View v = LayoutInflater.from(Android5Activity.this).inflate(R.layout.item_recycler, viewGroup, false);
ret = new ViewHolder(v);
return ret;
}
@Override
public void onBindViewHolder(ViewHolder viewHolder, int i) {
// 1.这里进行图片的加载
viewHolder.textView.setText(strings.get(i));
int resId = R.mipmap.ic_launcher;
int index = i%5;
switch (index){
case 0:
resId = R.mipmap.a11;
break;
case 1:
resId = R.mipmap.a33;
break;
case 2:
resId = R.mipmap.a22;
break;
}
viewHolder.imageView.setImageResource(resId);
}
---------------------------------------------------------------------------------------------------------------
完成自定义适配器和自定义ViewHolder的代码 就要进行RecyclerView的使用了
首先 要了解 RecyclerView.LayoutManager 这个属性
用于进行一个布局的设置,可以设置显示模式,ListView或者GridView或者瀑布流
1.ListView显示模式
// 1.线性布局
LinearLayoutManager layoutManager =
new LinearLayoutManager(this, // 上下文
LinearLayout.VERTICAL, //垂直布局,
false);
2.GridView显示模式
// 2.Grid布局
RecyclerView.LayoutManager layoutManager =
new GridLayoutManager(this,
2, // 每行显示item项数目
GridLayoutManager.HORIZONTAL, //水平排列
false
);
3.瀑布流显示模式
// 3.瀑布流
RecyclerView.LayoutManager layoutManager =
new StaggeredGridLayoutManager(3, // 每行显示的item项数目
StaggeredGridLayoutManager.VERTICAL); // 垂直排列
以上三种显示模式任意设置一种 就可以继续下面的代码
recyclerView.setLayoutManager(layoutManager);
// 设置 RecyclerView的Adapter
// 注意一定在设置了布局管理器之后调用
adapter = new MyRecycleAdapter(data);
recyclerView.setAdapter(adapter);
最后记得加上“添加一个数据”,“删除第一个数据”的按钮响应事件
public void btnAddItem(View view) {
data.add(0,"Time:"+System.currentTimeMillis());
adapter.notifyDataSetChanged();
}
public void btnRemoveItem(View view) {
if (!data.isEmpty()) {
data.remove(0);
}
adapter.notifyItemRemoved(0);
}
完整代码:
package com.xqx.superapp.app;
import android.app.Activity;
import android.content.Context;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.StaggeredGridLayoutManager;
import android.util.Log;
import android.view.*;
import android.widget.*;
import java.util.LinkedList;
import java.util.List;
public class Android5Activity extends Activity {
private List<String> data;
private RecyclerView recyclerView;
private MyRecycleAdapter adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_android5);
data = new LinkedList<String>();
recyclerView = (RecyclerView) findViewById(R.id.recycle_view);
// 设置布局管理器
// 支持 单列线性排列,支持GridView模式,瀑布流模式
// 1.线性布局
LinearLayoutManager layoutManager =
new LinearLayoutManager(this, // 上下文
LinearLayout.VERTICAL, //垂直布局,
false);
// // 2.Grid布局
// RecyclerView.LayoutManager layoutManager =
// new GridLayoutManager(this,
// 2,
// GridLayoutManager.HORIZONTAL,
// false
// );
//
// // 3.瀑布流
// RecyclerView.LayoutManager layoutManager =
// new StaggeredGridLayoutManager(3,
// StaggeredGridLayoutManager.VERTICAL);
recyclerView.setLayoutManager(layoutManager);
// 设置 RecyclerView的Adapter
// 注意一定在设置了布局管理器之后调用
adapter = new MyRecycleAdapter(data);
recyclerView.setAdapter(adapter);
}
public void btnAddItem(View view) {
data.add(0,"Time:"+System.currentTimeMillis());
adapter.notifyDataSetChanged();
}
public void btnRemoveItem(View view) {
if (!data.isEmpty()) {
data.remove(0);
}
adapter.notifyItemRemoved(0);
}
/**
* 继承RecyclerView.Adapter,用于显示数据
* 需要定义并且使用 ViewHolder ,必须要使用
*/
private class MyRecycleAdapter extends RecyclerView.Adapter<ViewHolder>{
private List<String> strings;
public MyRecycleAdapter(List<String> strings) {
this.strings = strings;
}
@Override
public int getItemCount() {
int ret = 0;
if (strings != null) {
ret = strings.size();
}
return ret;
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
ViewHolder ret = null;
// 不需要检查是否复用,因为只要进入此方法,必然没有复用
// 因为RecyclerView 通过Holder检查复用
View v = LayoutInflater.from(Android5Activity.this).inflate(R.layout.item_recycler, viewGroup, false);
ret = new ViewHolder(v);
return ret;
}
@Override
public void onBindViewHolder(ViewHolder viewHolder, int i) {
viewHolder.textView.setText(strings.get(i));
int resId = R.mipmap.ic_launcher;
int index = i%5;
switch (index){
case 0:
resId = R.mipmap.a11;
break;
case 1:
resId = R.mipmap.a33;
break;
case 2:
resId = R.mipmap.a22;
break;
}
viewHolder.imageView.setImageResource(resId);
}
}
/**
* 创建自己的ViewHolder ,必须要继承RecyclerView.ViewHolder
*/
private static class ViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener {
public ImageView imageView;
public TextView textView;
public ViewHolder(View itemView) {
super(itemView);
// 通常ViewHolder的构造,就是用于获取控件视图的
imageView = (ImageView) itemView.findViewById(R.id.item_icon);
textView = (TextView) itemView.findViewById(R.id.item_title);
// TODO 后续处理点击事件的操作
itemView.setOnClickListener(this);
}
@Override
public void onClick(View v) {
int position = getAdapterPosition();
Context context = imageView.getContext();
Toast.makeText(context,"显示第"+position+"个项",Toast.LENGTH_SHORT).show();
}
}
}
最近在做一个Android的项目,其包含一个消息推送的后台服务。由于该服务可能会有重要的信息推送,因此并不希望当APP程序退出、APP程序被一键清理、APP被强制停止等用户操作发生时,这个后台服务也随之被杀死。这个问题也就是所谓的“内存永驻”。关于这个问题,网上有很多说法,如调用startforehand函数以提高service的优先级、在service中创建一个不能被删掉的notification(或者产生一个其他的与用户界面交互的UI控件)、在service的onDestroy函数中重启这个服务、修改onstartcommand函数的返回值等等。这些方法,笔者都一一试过,但都没有效果。但是,我们可以看到市面上也确实存在一些App在一定的时间后可以自动重启,说明仍然是存在方法可以完成这项任务的。
文章中介绍的方法涉及到Android的JNI编程,主要思想就是通过调用native函数创建一个子进程。父子进程相互监听,若子进程死去,父进程妥善处理后重新创建新的子进程;若父进程死去,子进程使用AM命令重启父进程。这种思想唯一的缺陷就是如何保证父子进程不被同时杀死的情况。子进程能不能被杀死,只能用实验来证明。
首先笔者按照文章介绍的,整理了代码,并将相关代码植入到自己的项目中。
步骤1)编写Watcher类。它为上面的Java程序调用提供必要的接口,声明需要native语言实现的的具体函数。native语言主要是指C/C++语言。上层的Java程序只需要创建一个Watcher类并调用它的createAppMonitor(String userId)函数即可。
public class Watcher { private static final String PACKET = "com.example.dameonservice"; private String mMonitoredService = "com.example.mqtt.MQTTSubscribeService"; private volatile boolean bHeartBreak = false; private Context mContext; private boolean mRunning = true; public void createAppMonitor(String userId) { if(!createWatcher(userId)) { Log.e("Watcher", "<<Monitor created failed>>"); } } public Watcher(Context context) { mContext = context; } /*创建一个监视子进程 *userId 当前进程的用户ID,子进程重启当前进程时需要用到当前进程的用户ID *return 若子进程创建成功返回TRUE,否则返回FALSE */ private native boolean createWatcher(String userId); /* 让当前进程连接到监视进程 * return 连接成功返回TRUE,否则返回FALSE */ private native boolean connectToMonitor(); /*向监视进程发送任意信息 * msg 发给monitor的信息 * return 实际发送的字节数 */ private native int sendMsgToMonitor(String msg); static { System.loadLibrary("monitor"); //这里要和后面的Android.mk中模块名对应 } }
2)编译上面的文件会在bin/classes 目录下生成相对应的Watcher.class文件,通过DOs界面进入该bin/classes 目录下,通过javah命令生成C/C++对应的头文件。
“javah 包名+类名” 得到以下头文件:
#include <jni.h>
/* Header for class
com_example_dameonservice_Watcher */
#ifndef _Included_com_example_dameonservice_Watcher
#define
_Included_com_example_dameonservice_Watcher
#ifdef __cplusplus
extern "C"
{
#endif
/*
* Class: com_example_dameonservice_Watcher
*
Method: createWatcher
* Signature:
(Ljava/lang/String;)Z
*/
JNIEXPORT jboolean JNICALL
Java_com_example_dameonservice_Watcher_createWatcher
(JNIEnv *, jobject,
jstring);
/*
* Class: com_example_dameonservice_Watcher
* Method:
connectToMonitor
* Signature: ()Z
*/
JNIEXPORT jboolean JNICALL
Java_com_example_dameonservice_Watcher_connectToMonitor
(JNIEnv *,
jobject);
/*
* Class: com_example_dameonservice_Watcher
* Method:
sendMsgToMonitor
* Signature: (Ljava/lang/String;)I
*/
JNIEXPORT jint
JNICALL Java_com_example_dameonservice_Watcher_sendMsgToMonitor
(JNIEnv *,
jobject, jstring);
#ifdef __cplusplus
}
#endif
#endif
3)创建JNI文件夹,将得到的头文件移到该文件夹下,继续在该文件夹下创建与上面得到的头文件同名的C/C++文件,然后实现头文件中提到的方法。(具体实现太多,这里就不再贴出来了)
4)添加Android.mk文件。这个文件的格式基本是统一的。只需要修改LOCAL_MODULE和LOCAL_SRC_FILES两处即可。如果你还有添加Log打印函数,还要在这里添加 “LOCAL_LDLIBS := -lm -llog”。
下面一张图来说明整体的文件结构分布:
其中com_example_dameonservice_Watcher.c和com_example_dameonservice_Watcher.cpp内容相同。process.cpp定义一些辅助类。
实验结果:
这当然是大家最关心的。测试的手机选用的小米,感觉 小米在这一块的优化还是很不错的,所以用它来试试。最终的测试结果是:被杀死的服务概率性地可以重启成功,且失败的概率更大。通过Log分析,不能重启的时候是因为子进程也死掉了。截止到笔者写下这篇文章,还没有抓住其中的规律。一键清理和子进程的被杀死没有绝对的对应关系。而且即使是在App运行的时候,也会发现子进程会被杀死,然后又被父进程重启。子进程被杀死是重启失败的主要原因。但现在的现象无法确定子进程被杀死的确切原因,有一种可能是被系统杀死了,但这样的不确定性太大,对效果也不能有很好的保证。
虽然没有完美解决问题,但至少比前面的办法强很多,至少它也重启成功过。这个方法感觉继续优化一下还是可以做好的。
Android实现双进程守护
做过android开发的人应该都知道应用会在系统资源匮乏的情况下被系统杀死!当后台的应用被系统回收之后,如何重新恢复它呢?网上对此问题有很多的讨论。这里先总结一下网上流传的各种解决方案,看看这些办法是不是真的可行。
1.提高优先级
这个办法对普通应用而言,应该只是降低了应用被杀死的概率,但是如果真的被系统回收了,还是无法让应用自动重新启动!
2.让service.onStartCommand返回START_STICKY
通过实验发现,如果在adb shell当中kill掉进程模拟应用被意外杀死的情况(或者用360手机卫士进行清理操作),如果服务的onStartCommand返回START_STICKY,在eclipse的进程管理器中会发现过一小会后被杀死的进程的确又会出现在任务管理器中,貌似这是一个可行的办法。但是如果在系统设置的App管理中选择强行关闭应用,这时候会发现即使onStartCommand返回了START_STICKY,应用还是没能重新启动起来!
3.android:persistent="true"
网上还提出了设置这个属性的办法,通过实验发现即使设置了这个属性,应用程序被kill之后还是不能重新启动起来的!
4.让应用成为系统应用
实验发现即使成为系统应用,被杀死之后也不能自动重新启动。但是如果对一个系统应用设置了persistent="true",情况就不一样了。实验表明对一个设置了persistent属性的系统应用,即使kill掉会立刻重启。一个设置了persistent="true"的系统应用,在android中具有core service优先级,这种优先级的应用对系统的low memory killer是免疫的!
OK,说了半天,只有core service优先级的应用才能保证在被意外杀死之后做到立刻满血复活。而普通应用要想成为系统应用就必须要用目标机器的签名文件进行签名,但这样又造成了应用无法保证兼容所有不同厂商的产品。那么该怎么办呢?这里就来说一说双进程守护。网上也有人提到过双进程守护的办法,但是很少能搜索到类似的源码!如果从进程管理器重观察会发现新浪微博或者360卫视都有两个相关的进程,其中一个就是守护进程,由此可以猜到这些商业级的软件也采用了双进程守护的办法。
什么是双进程守护呢?顾名思义就是两个进程互相监视对方,发现对方挂掉就立刻重启!不知道应该把这样的一对进程是叫做相依为命呢还是难兄难弟好呢,但总之,双进程守护的确是一个解决问题的办法!相信说到这里,很多人已经迫切的想知道如何实现双进程守护了。这篇文章就介绍一个用NDK来实现双进程保护的办法,不过首先说明一点,下面要介绍的方法中,会损失不少的效率,反应到现实中就是会使手机的耗电量变大!但是这篇文章仅仅是抛砖引玉,相信看完之后会有更多高人指点出更妙的实现办法。
需要了解些什么?
这篇文章中实现双进程保护的方法基本上是纯的NDK开发,或者说全部是用C++来实现的,需要双进程保护的程序,只需要在程序的任何地方调用一下JAVA接口即可。下面几个知识点是需要了解的:
1.linux中多进程;
2.unix domain套接字实现跨进程通信;
3.linux的信号处理;
4.exec函数族的用法;
其实这些东西本身并不是多复杂的技术,只是我们把他们组合起来实现了一个双进程守护而已,没有想象中那么神秘!在正式贴出代码之前,先来说说几个实现双进程守护时的关键点:
1.父进程如何监视到子进程(监视进程)的死亡?
很简单,在linux中,子进程被终止时,会向父进程发送SIG_CHLD信号,于是我们可以安装信号处理函数,并在此信号处理函数中重新启动创建监视进程;
2.子进程(监视进程)如何监视到父进程死亡?
当父进程死亡以后,子进程就成为了孤儿进程由Init进程领养,于是我们可以在一个循环中读取子进程的父进程PID,当变为1就说明其父进程已经死亡,于是可以重启父进程。这里因为采用了循环,所以就引出了之前提到的耗电量的问题。
3.父子进程间的通信
有一种办法是父子进程间建立通信通道,然后通过监视此通道来感知对方的存在,这样不会存在之前提到的耗电量的问题,在本文的实现中,为了简单,还是采用了轮询父进程PID的办法,但是还是留出了父子进程的通信通道,虽然暂时没有用到,但可备不时之需!
OK, 下面就贴上代码!首先是Java部分,这一部分太过简单,只是一个类,提供了给外部调用的API接口用于创建守护进程,所有的实现都通过native方法在C++中完成!
package com.example.dameonservice;
import java.util.ArrayList;
import android.app.ActivityManager;
import android.app.ActivityManager.RunningServiceInfo;
import android.content.Context;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.util.Log;
/**
* 监视器类,构造时将会在Native创建子进程来监视当前进程,
* @author wangqiang
* @date 2014-04-24
*/
public class Watcher
{
//TODO Fix this according to your service
private static final String PACKAGE = "com.example.dameonservice/";
private String mMonitoredService = "";
private volatile boolean bHeartBreak = false;
private Context mContext;
private boolean mRunning = true;
public void createAppMonitor(String userId)
{
if( !createWatcher(userId) )
{
Log.e("Watcher", "<<Monitor created failed>>");
}
}
public Watcher( Context context)
{
mContext = context;
}
private int isServiceRunning()
{
ActivityManager am=(ActivityManager)mContext.getSystemService(Context.ACTIVITY_SERVICE);
ArrayList<RunningServiceInfo> runningService = (ArrayList<RunningServiceInfo>)am.getRunningServices(1024);
for( int i = 0; i < runningService.size(); ++i )
{
if( mMonitoredService.equals(runningService.get(i).service.getClassName().toString() ))
{
return 1;
}
}
return 0;
}
/**
* Native方法,创建一个监视子进程.
* @param userId 当前进程的用户ID,子进程重启当前进程时需要用到当前进程的用户ID.
* @return 如果子进程创建成功返回true,否则返回false
*/
private native boolean createWatcher(String userId);
/**
* Native方法,让当前进程连接到监视进程.
* @return 连接成功返回true,否则返回false
*/
private native boolean connectToMonitor();
/**
* Native方法,向监视进程发送任意信息
* @param 发给monitor的信息
* @return 实际发送的字节
*/
private native int sendMsgToMonitor(String msg);
static
{
System.loadLibrary("monitor");
}
}
代码中很多属性都是测试时用的,懒得去掉,其实有些都没用到。只需要关心createAppMonitor这个对外接口就可以了,它要求传入一个当前进程的用户ID,然后会调用createWatcher本地方法来创建守护进程。还有两个方法connectToMonitor用于创建和监视进程的socket通道,sendMsgToMonitor用于通过socket向子进程发送数据。由于暂时不需要和子进程进行数据交互,所以这两个方法就没有添加对外的JAVA接口,但是要添加简直是轻而易举的事!
Ok,JAVA只是个壳,内部的实现还得是C++,为了让程序更加的面向对象,在实现native时,我们用一个ProcessBase基类来对父子进程进行一个抽象,把父子进程都会有的行为抽象出来,而父子进程可以根据需要用自己的方式去实现其中的接口,先来看看这个抽象了父子进程共同行为的ProcessBase基类:
#ifndef _PROCESS_H
#define _PROCESS_H
#include <jni.h>
#include <sys/select.h>
#include <unistd.h>
#include <sys/socket.h>
#include <pthread.h>
#include <signal.h>
#include <sys/wait.h>
#include <android/log.h>
#include <sys/types.h>
#include <sys/un.h>
#include <errno.h>
#include <stdlib.h>
#include "constants.h"
#define LOG_TAG "Native"
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
/**
* 功能:对父子进程的一个抽象
* @author wangqiang
* @date 2014-03-14
*/
class ProcessBase
{
public:
ProcessBase( );
/**
* 父子进程要做的工作不相同,留出一个抽象接口由父子进程
* 自己去实现.
*/
virtual void do_work() = 0;
/**
* 进程可以根据需要创建子进程,如果不需要创建子进程,可以给
* 此接口一个空实现即可.
*/
virtual bool create_child() = 0;
/**
* 捕捉子进程死亡的信号,如果没有子进程此方法可以给一个空实现.
*/
virtual void catch_child_dead_signal() = 0;
/**
* 在子进程死亡之后做任意事情.
*/
virtual void on_child_end() = 0;
/**
* 创建父子进程通信通道.
*/
bool create_channel();
/**
* 给进程设置通信通道.
* @param channel_fd 通道的文件描述
*/
void set_channel(int channel_fd);
/**
* 向通道中写入数据.
* @param data 写入通道的数据
* @param len 写入的字节数
* @return 实际写入通道的字节数
*/
int write_to_channel( void* data, int len );
/**
* 从通道中读数据.
* @param data 保存从通道中读入的数据
* @param len 从通道中读入的字节数
* @return 实际读到的字节数
*/
int read_from_channel( void* data, int len );
/**
* 获取通道对应的文件描述符
*/
int get_channel() const;
virtual ~ProcessBase();
protected:
int m_channel;
};
只是很简单的一个类,相信看看注释就知道是什么意思了,比如父子进程可能都需要捕获他的子孙死亡的信号,于是给一个catch_child_dead_signal函数,如果对子进程的死活不感兴趣,可以给个空实现,忽略掉就可以了,谁叫他大逆不道呢?由于用了纯虚函数,所以ProcessBase是一个抽象类,也就是说它不能有自己的实例,只是用来继承的,它的子孙后代可以用不同的方式实现它里面的接口从而表现出不一样的行为,这里父进程和子进程的行为就是有区别的,下面就先为诸君奉上父进程的实现:
/**
* 功能:父进程的实现
* @author wangqiang
* @date 2014-03-14
*/
class Parent : public ProcessBase
{
public:
Parent( JNIEnv* env, jobject jobj );
virtual bool create_child( );
virtual void do_work();
virtual void catch_child_dead_signal();
virtual void on_child_end();
virtual ~Parent();
bool create_channel();
/**
* 获取父进程的JNIEnv
*/
JNIEnv *get_jni_env() const;
/**
* 获取Java层的对象
*/
jobject get_jobj() const;
private:
JNIEnv *m_env;
jobject m_jobj;
};
以上是定义部分,其实JNIEnv和jobject基本上没用到,完全可以给剃掉的,大家就当这两个属性不存在就是了!实现部分如下:
#include "process.h"
#include "Utils.h"
extern ProcessBase *g_process;
extern const char* g_userId;
extern JNIEnv* g_env;
//子进程有权限访问父进程的私有目录,在此建立跨进程通信的套接字文件
static const char* PATH = "/data/data/com.example.dameonservice/my.sock";
//服务名称
static const char* SERVICE_NAME = "com.example.dameonservice/com.example.dameonservice.MyService";
bool ProcessBase::create_channel( )
{
}
int ProcessBase::write_to_channel( void* data, int len )
{
return write( m_channel, data, len );
}
int ProcessBase::read_from_channel( void* data, int len )
{
return read( m_channel, data, len );
}
int ProcessBase::get_channel() const
{
return m_channel;
}
void ProcessBase::set_channel( int channel_fd )
{
m_channel = channel_fd;
}
ProcessBase::ProcessBase()
{
}
ProcessBase::~ProcessBase()
{
close(m_channel);
}
Parent::Parent(JNIEnv *env, jobject jobj) : m_env(env)
{
LOGE("<<new parent instance>>");
m_jobj = env->NewGlobalRef(jobj);
}
Parent::~Parent()
{
LOGE( "<<Parent::~Parent()>>" );
g_process = NULL;
}
void Parent::do_work()
{
}
JNIEnv* Parent::get_jni_env() const
{
return m_env;
}
jobject Parent::get_jobj() const
{
return m_jobj;
}
/**
* 父进程创建通道,这里其实是创建一个客户端并尝试
* 连接服务器(子进程)
*/
bool Parent::create_channel()
{
int sockfd;
sockaddr_un addr;
while( 1 )
{
sockfd = socket( AF_LOCAL, SOCK_STREAM, 0 );
if( sockfd < 0 )
{
LOGE("<<Parent create channel failed>>");
return false;
}
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_LOCAL;
strcpy( addr.sun_path, PATH );
if( connect( sockfd, (sockaddr*)&addr, sizeof(addr)) < 0 )
{
close(sockfd);
sleep(1);
continue;
}
set_channel(sockfd);
LOGE("<<parent channel fd %d>>", m_channel );
break;
}
return true;
}
/**
* 子进程死亡会发出SIGCHLD信号,通过捕捉此信号父进程可以
* 知道子进程已经死亡,此函数即为SIGCHLD信号的处理函数.
*/
static void sig_handler( int signo )
{
pid_t pid;
int status;
//调用wait等待子进程死亡时发出的SIGCHLD
//信号以给子进程收尸,防止它变成僵尸进程
pid = wait(&status);
if( g_process != NULL )
{
g_process->on_child_end();
}
}
void Parent::catch_child_dead_signal()
{
LOGE("<<process %d install child dead signal detector!>>", getpid());
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = sig_handler;
sigaction( SIGCHLD, &sa, NULL );
}
void Parent::on_child_end()
{
LOGE("<<on_child_end:create a new child process>>");
create_child();
}
bool Parent::create_child( )
{
pid_t pid;
if( (pid = fork()) < 0 )
{
return false;
}
else if( pid == 0 ) //子进程
{
LOGE("<<In child process,pid=%d>>", getpid() );
Child child;
ProcessBase& ref_child = child;
ref_child.do_work();
}
else if( pid > 0 ) //父进程
{
LOGE("<<In parent process,pid=%d>>", getpid() );
}
return true;
}
这里先要说明一下三个全局变量:
g_process是父进程的指针;
g_userId是父进程用户ID,由Java侧传递过来,我们需要把它用全局变量保存起来,因为子进程在重启父进程的时候需要用到用户ID,否则会有问题,当然这里也得益于子进程能够继承父进程的全局变量这个事实!
g_env是JNIEnv的指针,把这个变量也作为一个全局变量,是保留给子进程用的;
父进程在create_child中用fork创建了子进程,其实就是一个fork调用,然后父进程什么都不做,子进程创建一个Child对象并调用其do_work开始做自己该做的事!
父进程实现了catch_child_dead_signal,在其中安装了SIG_CHLD信号处理函数,因为他很爱他的儿子,时刻关心着他。而在信号处理函数sig_handler中,我们留意到了wait调用,这是为了防止子进程死了以后变成僵尸进程,由于我们已经知道父进程最多只会创建一个子监视进程,所以wait就足够了,不需要waitpid函数亲自出马!而信号处理函数很简单,重新调用一下on_child_end,在其中再次create_child和他亲爱的夫人在make一个小baby就可以了!
最后要说说create_channel这个函数,他用来创建和子进程的socket通道,这个编程模型对于有网络编程经验的人来说显得非常亲切和熟悉,他遵循标准的网络编程客户端步骤:创建socket,connect,之后收发数据就OK了,只是这里的协议用的是AF_LOCAL,表明我们是要进行跨进程通信。由于域套接字用的不是IP地址,而是通过指定的一个文件来和目标进程通信,父子进程都需要这个文件,所以这个文件的位置指定在哪里也需要注意一下:在一个没有root过的手机上,几乎所有的文件都是没有写入权限的,但是很幸运的是linux的子进程共享父进程的目录,所以把这个位置指定到/data/data/下应用的私有目录就可以做到让父子进程都能访问这个文件了!
接下来是子进程的实现了,它的定义如下:
/**
* 子进程的实现
* @author wangqiang
* @date 2014-03-14
*/
class Child : public ProcessBase
{
public:
Child( );
virtual ~Child();
virtual void do_work();
virtual bool create_child();
virtual void catch_child_dead_signal();
virtual void on_child_end();
bool create_channel();
private:
/**
* 处理父进程死亡事件
*/
void handle_parent_die();
/**
* 侦听父进程发送的消息
*/
void listen_msg();
/**
* 重新启动父进程.
*/
void restart_parent();
/**
* 处理来自父进程的消息
*/
void handle_msg( const char* msg );
/**
* 线程函数,用来检测父进程是否挂掉
*/
void* parent_monitor();
void start_parent_monitor();
/**
* 这个联合体的作用是帮助将类的成员函数做为线程函数使用
*/
union
{
void* (*thread_rtn)(void*);
void* (Child::*member_rtn)();
}RTN_MAP;
};
#endif
注意到里面有个union,这个联合体的作用是为了辅助把一个类的成员函数作为线程函数来传递给pthread_create,很多时候我们都希望线程能够像自己人一样访问类的私有成员,就像一个成员函数那样,用friend虽然可以做到这一点,但总感觉不够优美,由于成员函数隐含的this指针,使我们完全可以将一个成员函数作为线程函数来用。只是由于编译器堵死了函数指针的类型转换,所以这里就只好用一个结构体。
废话不多说,看看子进程的实现:
bool Child::create_child( )
{
//子进程不需要再去创建子进程,此函数留空
return false;
}
Child::Child()
{
RTN_MAP.member_rtn = &Child::parent_monitor;
}
Child::~Child()
{
LOGE("<<~Child(), unlink %s>>", PATH);
unlink(PATH);
}
void Child::catch_child_dead_signal()
{
//子进程不需要捕捉SIGCHLD信号
return;
}
void Child::on_child_end()
{
//子进程不需要处理
return;
}
void Child::handle_parent_die( )
{
//子进程成为了孤儿进程,等待被Init进程收养后在进行后续处理
while( getppid() != 1 )
{
usleep(500); //休眠0.5ms
}
close( m_channel );
//重启父进程服务
LOGE( "<<parent died,restart now>>" );
restart_parent();
}
void Child::restart_parent()
{
LOGE("<<restart_parent enter>>");
/**
* TODO 重启父进程,通过am启动Java空间的任一组件(service或者activity等)即可让应用重新启动
*/
execlp( "am",
"am",
"startservice",
"--user",
g_userId,
"-n",
SERVICE_NAME, //注意此处的名称
(char *)NULL);
}
void* Child::parent_monitor()
{
handle_parent_die();
}
void Child::start_parent_monitor()
{
pthread_t tid;
pthread_create( &tid, NULL, RTN_MAP.thread_rtn, this );
}
bool Child::create_channel()
{
int listenfd, connfd;
struct sockaddr_un addr;
listenfd = socket( AF_LOCAL, SOCK_STREAM, 0 );
unlink(PATH);
memset( &addr, 0, sizeof(addr) );
addr.sun_family = AF_LOCAL;
strcpy( addr.sun_path, PATH );
if( bind( listenfd, (sockaddr*)&addr, sizeof(addr) ) < 0 )
{
LOGE("<<bind error,errno(%d)>>", errno);
return false;
}
listen( listenfd, 5 );
while( true )
{
if( (connfd = accept(listenfd, NULL, NULL)) < 0 )
{
if( errno == EINTR)
continue;
else
{
LOGE("<<accept error>>");
return false;
}
}
set_channel(connfd);
break;
}
LOGE("<<child channel fd %d>>", m_channel );
return true;
}
void Child::handle_msg( const char* msg )
{
//TODO How to handle message is decided by you.
}
void Child::listen_msg( )
{
fd_set rfds;
int retry = 0;
while( 1 )
{
FD_ZERO(&rfds);
FD_SET( m_channel, &rfds );
timeval timeout = {3, 0};
int r = select( m_channel + 1, &rfds, NULL, NULL, &timeout );
if( r > 0 )
{
char pkg[256] = {0};
if( FD_ISSET( m_channel, &rfds) )
{
read_from_channel( pkg, sizeof(pkg) );
LOGE("<<A message comes:%s>>", pkg );
handle_msg( (const char*)pkg );
}
}
}
}
void Child::do_work()
{
start_parent_monitor(); //启动监视线程
if( create_channel() ) //等待并且处理来自父进程发送的消息
{
listen_msg();
}
}
子进程在他的do_work中先创建了一个线程轮询其父进程的PID,如果发现变成了1,就会调用restart_parent,在其中调用execlp,执行一下am指令启动JAVA侧的组件,从而实现父进程的重启!这里请留意一下execlp中给am传入的参数,带了--user并加上了之前我们在全局变量中保存的user id,如果不加这个选项,就无法重启父进程,我在这花费了好长时间哦!
子进程剩余的工作很简单,创建通道,监听来自父进程的消息,这里我们用select来监听,由于实际上只有一个客户端(父进程),所以用select有点脱裤子放屁,把简单问题复杂化的嫌疑,但是实际上也没啥太大影响!
有了以上的实现,JNI的实现就相当的简单了:
#include "process.h"
#include "Utils.h"
/**
* 全局变量,代表应用程序进程.
*/
ProcessBase *g_process = NULL;
/**
* 应用进程的UID.
*/
const char* g_userId = NULL;
/**
* 全局的JNIEnv,子进程有时会用到它.
*/
JNIEnv* g_env = NULL;
extern "C"
{
JNIEXPORT jboolean JNICALL Java_com_example_dameonservice_Watcher_createWatcher( JNIEnv*, jobject, jstring);
JNIEXPORT jboolean JNICALL Java_com_example_dameonservice_Watcher_connectToMonitor( JNIEnv*, jobject );
JNIEXPORT jint JNICALL Java_com_example_dameonservice_Watcher_sendMsgToMonitor( JNIEnv*, jobject, jstring );
JNIEXPORT jint JNICALL JNI_OnLoad( JavaVM* , void* );
};
JNIEXPORT jboolean JNICALL Java_com_example_dameonservice_Watcher_createWatcher( JNIEnv* env, jobject thiz, jstring user )
{
g_process = new Parent( env, thiz );
g_userId = (const char*)jstringTostr(env, user);
g_process->catch_child_dead_signal();
if( !g_process->create_child() )
{
LOGE("<<create child error!>>");
return JNI_FALSE;
}
return JNI_TRUE;
}
JNIEXPORT jboolean JNICALL Java_com_example_dameonservice_Watcher_connectToMonitor( JNIEnv* env, jobject thiz )
{
if( g_process != NULL )
{
if( g_process->create_channel() )
{
return JNI_TRUE;
}
return JNI_FALSE;
}
}
把上面这些代码整合起来,一个双进程守护的实现就完成了,只需要调用一下Watcher.java的createAppMonitor,你的应用就会有一个守护进程来监视,被杀死后也会立刻重新启动起来!是不是很有意思呢?
一、认识Android的IPC主板模式
系统架构设计最关键的任务就是组合(或称整合),而且最好是能与众不同、深具创新性组合。Android就擅用了主板模式,以通用性接口实践跨进程的IPC通信机制。由于Android是开源开放的系统,其源代码可成为大家观摩的范本。首先,其主板模式提供了IBinder通用性接口。如下图:
Android定义一个Binder父类来实现<通用性>的IBinder接口。如下图:
然后,以Java来撰写这个实现类,其Java代码如下:
// Android的源代码 // Binder.java // ------------------------------------------------------------- public class Binder implements IBinder { // .......... private int mObject; public Binder() { init(); // 其它代码 } public final boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException { // 其它代码 boolean r = onTransact(code, data, reply, flags); return r; } private boolean execTransact(int code, int dataObj, int replyObj, int flags) { Parcel data = Parcel.obtain(dataObj); Parcel reply = Parcel.obtain(replyObj); boolean res; res = onTransact(code, data, reply, flags); // 其它代码 return res; } protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException { } private native final void init(); } // End
这个Binder抽象父类的主要函数:
transact()函数-- 用来实作IBinder的transact()函数接口。
execTransact()函数-- 其角色与transact()函数是相同的,只是这是用来让C/C++本地程序来调用的。
onTransact()函数-- 这是一个抽象函数,让应用子类来覆写(Override)的。上述的transact()和execTransact()两者都是调用onTransact()函数来实现反向调用(IoC, Inversion of Control)的。
init()函数-- 这是一个本地(Native)函数,让JNI模块来实现这个函数。Binder()构造函数(Constructor)会调用这个init()本地函数。
这Binder.java是抽象类,它含有一个抽象)函数:onTransact()。于是,这个软件主板提供了两个接口:CI和接口。如下图:
这是标准型的主板模式。此图里的Binder抽象父类和两个接口,整合起来成为一个典型的软件主板。如下图:
这个Binder软件主板是用来整合两个进程里的软件模块(如类),所以我们称之为:。如下图:
基于这个主板,我们就能开始进行组合了。此时,可设计一个子类,并且装配到主板的接口上。如下图:
图 1 Binder进程间通信模型
Client和Server均通过函数ioctl与Binder驱动进行数据交互。ioctl是Linux中用于控制I/O设备的函数,提供了一种同时向设备发送控制参数和数据的手段。它是一个可变参数的函数,原型为:
<??#65533;"http://www.2cto.com/kf/ware/vc/" target="_blank" class="keylink">vcD4KPHByZSBjbGFzcz0="brush:java;">int ioctl(int fd, int cmd, ...);
fd是打开/dev/binder设备后得到的文件描述符,cmd是对设备的控制命令。该函数执行成功返回0,否则返回-1。
3.相关数据结构
当函数ioctl的第二个参数cmd为BINDER_WRITE_READ时,表示向Binder驱动发送一条读取或者写入/dev/binder设备的命令,Binder驱动会将对设备的读写“翻译”为对共享
内存区的读写。这条命令是Client和Server进行进程间通信时最重要、使用最频繁的控制命令。
传入BINDER_WRITE_READ的同时,会传入一个binder_write_read结构体的指针作为ioctl的第三个参数,该结构中的read_buffer和write_buffer字段分别指向将要读取或者写入的缓冲区。这两个缓冲区中的数据都是以“数据类型+数据内容”的格式顺序存放的,而且多条不同类型的数据连续存放,如图2所示。write_buffer中数据类型以“BC_”开头,而read_buffer中数据类型以 “BR_”开头,图2中以write_buffer中的数据为例。在所有的数据类型中,又以BC(R)_REPLY和BC(R)_TRANSACTION 最为重要:通过BC_TRANSACTION/BC_REPLY这对命令,发送方将数据发往接受方;通过BR_TRANSACTION /BR_REPLY,接收方读取发送方发来的数据。
数据的内容是一个binder_transaction_data结构。
图2 Binder IPC中各数据结构的关系
binder_transaction_data结构是对进程间通信数据的封装,可以看作网络通信中的一个数据包。其中的 sender_uid,sender_pid成员变量指明了此数据发送方的用户ID和进程ID,buffer成员变量指向进程间通信最核心的有效负载数据,data_size是有效负载数据的长度。在Binder机制中,sender_uid和sender_pid是在内核中由Binder驱动填入的,无法被伪造,保证了身份标记的可靠性,由此可见Binder进程间通信机制进行是安全的。
4.Binder之间的数据行为关系
Client和Server使用Binder机制进行进程间通信时,通过分析Client发往Server的数据或者分析Server读取的Client的请求数据,便可以识别出Client的具体行为。
例如,当Client想要得到定位信息,请求LocationServer获取定位数据时,会访问LocationServer的ILocationManager接口,发往LocationServer中的有效负载数
据中包含“android.location.ILocationManager”字符串。所以我们分析LocationServer读取的Client发来的请求数据,判断其中是否包含“android.location.ILocationManager”,
我们就可以知道Client是否正在试图访问用户的地理位置信息。
由于Android系统中每个应用程序都有自己唯一的UID,因此根据binder_transaction_data中的sender_uid,我们就可以获取Client具体代表的应用程序。这样
就获得了具体软件的具体行为。
通过对Android系统的分析,我们发现:虽然系统提供的服务多达几十种,但是实际上只有三个Server进程负责管理
Android系统Server进程与管理的服务
服务进程 管理的服务
com.android.phone 与通信功能相关的短信、电话服务
mediaserver 与媒体功能相关的视频、音频服务
system_server 其他服务,如地理位置、蓝牙、网络连接、程序安装卸载等
一、创建SQLite数据库和表
我们可以通过SQLiteDatabase.openOrCreateDatabase()来创建一个数据库实例。
SQLiteDatabase db = openOrCreateDatabase(dbName, MODE_PRIVATE, null);
// openOrCreateDatabase(String name, int mode, CursorFactory factory)
// 第一个参数为创建数据库的名称
// 第二个参数为创建数据库的权限,其权限同内部文件存储数据权限相同。默认为MODE_PRIVATE。
// 第三个参数为CursorFactory对象,用于查询时返回Cursor的子类对象;或者传入null使用默认的factory构造。
在创建表的时候,我们可以使用一条SQL语句来完成。
cmd = "CREATE TABLE IF NOT EXISTS " + tableName + " (name VARCHAR, passwd VARCHAR)";
db.execSQL(cmd);
这样,我们可以发现在“/data/data/[PACKAGE_NAME]/databases”目录下生成了一个“myDB.db”数据库文件。
完整代码:
import android.database.sqlite.SQLiteDatabase;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {
private Button btnDB;
private Button btnTable;
private String dbName = "myDB";
private String cmd = "";
private SQLiteDatabase db;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnDB = (Button)findViewById(R.id.btnDB);
btnTable = (Button)findViewById(R.id.btnTable);
btnDB.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
db = openOrCreateDatabase(dbName,MODE_PRIVATE,null);
}
});
btnTable.setOnClickListener(new View.OnClickListener() {
String tableName = "User";
@Override
public void onClick(View view) {
cmd = "CREATE TABLE IF NOT EXISTS " + tableName + " (name VARCHAR, passwd VARCHAR)";
db.execSQL(cmd);
}
});
}
}
二、添加、删除、修改
(1)SQL语句方法
cmd = "INSERT INTO " + tableName + " values ('Amy','123456')";
db.execSQL(cmd);
cmd = "UPDATE " + tableName + " SET passwd='654321' WHERE name='AMY')";
db.execSQL(cmd);
cmd = "DELETE FROM " + tableName + " WHERE name='Amy'";
db.execSQL(cmd);
(2)另一种方法
db.insert(String table, String nullColumnHack, ContentValues values);
db.update(String table, Contentvalues values, String whereClause, String whereArgs);
db.delete(String table, String whereClause, String whereArgs);
以上三个方法的第一个参数都是表示要操作的表名;insert中的第二个参数表示如果插入的数据每一列都为空的话,需要指定此行中某一列的名称,系统将此列设置为NULL,不至于出现错误;insert中的第三个参数是ContentValues类型的变量,是键值对组成的Map,key代表列名,value代表该列要插入的值;update的第二个参数也很类似,只不过它是更新该字段key为最新的value值,第三个参数whereClause表示WHERE表达式,比如“age > ? and age < ?”等,最后的whereArgs参数是占位符的实际参数值;delete方法的参数也是一样。
实例:
btnTable.setOnClickListener(new View.OnClickListener() {
String tableName = "User";
@Override
public void onClick(View view) {
cmd = "CREATE TABLE IF NOT EXISTS " + tableName + " (name VARCHAR, passwd VARCHAR)";
db.execSQL(cmd);
ContentValues cv = new ContentValues();
cv.put("name", "Amy");
cv.put("passwd", "123456");
db.insert(dbName, null, cv);
// cmd = "INSERT INTO " + tableName + " values ('Amy','123456')";
// db.execSQL(cmd);
cv = new ContentValues();
cv.put("passwd", "654321");
db.update(dbName, cv, "name=?", new String[]{"Amy"});
// cmd = "UPDATE " + tableName + " SET passwd='654321' WHERE name='AMY')";
// db.execSQL(cmd);
db.delete(dbName, "name=?", new String[]{"Amy"});
// cmd = "DELETE FROM " + tableName + " WHERE name='Amy'";
// db.execSQL(cmd);
}
});
三、数据库查询
对数据库的查询可以通过db.query()来实现,query方法一般包含8个参数:
db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);
// table为查询表的名称
// columns为查询的字段名
// selection为查询的条件
// selectionArgs为查询条件的值
// groupBy为分组字段值
// having为分组后筛选条件
// orderBy为排序字段名
// limit为查询结果返回记录条数
查询的的结果通过Cursor返回。代表数据集的游标。
Cursor cursor = db.query(tableName, null, null, null, null, null, null);
String str = "";
if(cursor.getCount()!=0){ // 查询符合条件的记录个数
cursor.moveToFirst(); // 移动到第一个记录
for(int i=0; i<cursor.getCount();i++){
str += cursor.getString(0)+" "+cursor.getString(1)+"\n";
cursor.moveToNext(); // 移动到下一个记录
}
}
new AlertDialog.Builder(MainActivity.this).setTitle("Query")
.setMessage(str).setNegativeButton("OK",null).show();
四、SQLiteOpenHelper
除了常规的管理方法之外,Android SDK还提供了另外一种管理数据库的方法,SQLiteOpenHelper。它提供了一套自动执行的机制来创建、更新、打开数据库。
首先,我们继承SQLiteOpenHelper类,创建MyDBHelper类。
public class MyDBHelper extends SQLiteOpenHelper {
private String tableName = "User";
public MyDBHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
super(context, name, factory, version);
}
public void onCreate(SQLiteDatabase db) {
String cmd = "CREATE TABLE IF NOT EXISTS " + tableName + " (name VARCHAR, passwd VARCHAR)";
db.execSQL(cmd);
}
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
String cmd = "UPDATE " + tableName + " SET passwd='654321' WHERE name='AMY')";
db.execSQL(cmd);
}
public String showTable(){
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.query(tableName, null, null, null, null, null, null);
String str = "";
if(cursor.getCount()!=0){ // 查询符合条件的记录个数
cursor.moveToFirst(); // 移动到第一个记录
for(int i=0; i<cursor.getCount();i++){
str += cursor.getString(0)+" "+cursor.getString(1)+"\n";
cursor.moveToNext(); // 移动到下一个记录
}
}
return str;
}
}
然后,我们便可以在MainActivity内使用我们定义的SQLiteOpenHelper类的方法。
btnShow = (Button) findViewById(R.id.btnShow);
btnShow.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
dbHelper = new MyDBHelper(MainActivity.this, dbName, null, 1);
new AlertDialog.Builder(MainActivity.this).setTitle("MyDBHelper")
.setMessage(dbHelper.showTable()).setNegativeButton("OK", null).show();
}
});
完整代码如下:
MainActivity.java
import android.app.AlertDialog;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {
private Button btnShow;
private String dbName = "myDB";
private MyDBHelper dbHelper;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnShow = (Button) findViewById(R.id.btnShow);
btnShow.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
dbHelper = new MyDBHelper(MainActivity.this, dbName, null, 1);
new AlertDialog.Builder(MainActivity.this).setTitle("MyDBHelper")
.setMessage(dbHelper.showTable()).setNegativeButton("OK", null).show();
}
});
}
}
MyDBHelper.java
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
public class MyDBHelper extends SQLiteOpenHelper {
private String tableName = "User";
public MyDBHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
super(context, name, factory, version);
}
public void onCreate(SQLiteDatabase db) {
String cmd = "CREATE TABLE IF NOT EXISTS " + tableName + " (name VARCHAR, passwd VARCHAR)";
db.execSQL(cmd);
}
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
String cmd = "UPDATE " + tableName + " SET passwd='654321' WHERE name='AMY')";
db.execSQL(cmd);
}
public String showTable(){
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.query(tableName, null, null, null, null, null, null);
String str = "";
if(cursor.getCount()!=0){ // 查询符合条件的记录个数
cursor.moveToFirst(); // 移动到第一个记录
for(int i=0; i<cursor.getCount();i++){
str += cursor.getString(0)+" "+cursor.getString(1)+"\n";
cursor.moveToNext(); // 移动到下一个记录
}
}
return str;
}
}
另一篇 android开发之使用SQLite数据库存储
Android 集成了 SQLite 数据库
Android 在运行时(run-time)集成了 SQLite,所以每个 Android 应用程序都可以使用 SQLite 数据库。对于熟悉 SQL 的开发人员来时,在 Android 开发中使用 SQLite 相当简单。但是,由于 JDBC 会消耗太多的系统资源,所以 JDBC 对于手机这种内存受限设备来说并不合适。因此,Android 提供了一些新的 API 来使用 SQLite 数据库,Android 开发中,程序员需要学使用这些 API。
数据库存储在 data/< 项目文件夹 >/databases/ 下。
Android 开发中使用 SQLite 数据库
Activites 可以通过 Content Provider 或者 Service 访问一个数据库。下面会详细讲解如果创建数据库,添加数据和查询数据库。
创建数据库
Android 不自动提供数据库。在 Android 应用程序中使用 SQLite,必须自己创建数据库,然后创建表、索引,填充数据。Android 提供了 SQLiteOpenHelper 帮助你创建一个数据库,你只要继承 SQLiteOpenHelper 类,就可以轻松的创建数据库。SQLiteOpenHelper 类根据开发应用程序的需要,封装了创建和更新数据库使用的逻辑。SQLiteOpenHelper 的子类,至少需要实现三个方法:
构造函数,调用父类 SQLiteOpenHelper 的构造函数。这个方法需要四个参数:上下文环境(例如,一个 Activity),数据库名字,一个可选的游标工厂(通常是 Null),一个代表你正在使用的数据库模型版本的整数。
onCreate()方法,它需要一个 SQLiteDatabase 对象作为参数,根据需要对这个对象填充表和初始化数据。
onUpgrage() 方法,它需要三个参数,一个 SQLiteDatabase 对象,一个旧的版本号和一个新的版本号,这样你就可以清楚如何把一个数据库从旧的模型转变到新的模型。
下面示例代码展示了如何继承 SQLiteOpenHelper 创建数据库:
public class DatabaseHelper extends SQLiteOpenHelper {
DatabaseHelper(Context context, String name, CursorFactory cursorFactory, int version)
{
super(context, name, cursorFactory, version);
}
@Override
public void onCreate(SQLiteDatabase db) {
// TODO 创建数据库后,对数据库的操作
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// TODO 更改数据库版本的操作
}
@Override
public void onOpen(SQLiteDatabase db) {
super.onOpen(db);
// TODO 每次成功打开数据库后首先被执行
}
}
接下来讨论具体如何创建表、插入数据、删除表等等。调用 getReadableDatabase() 或 getWriteableDatabase() 方法,你可以得到 SQLiteDatabase 实例,具体调用那个方法,取决于你是否需要改变数据库的内容:
db=(new DatabaseHelper(getContext())).getWritableDatabase();
return (db == null) ? false : true;
上面这段代码会返回一个 SQLiteDatabase 类的实例,使用这个对象,你就可以查询或者修改数据库。
当你完成了对数据库的操作(例如你的 Activity 已经关闭),需要调用 SQLiteDatabase 的 Close() 方法来释放掉数据库连接。
创建表和索引
为了创建表和索引,需要调用 SQLiteDatabase 的 execSQL() 方法来执行 DDL 语句。如果没有异常,这个方法没有返回值。
例如,你可以执行如下代码:
db.execSQL("CREATE TABLE mytable (_id INTEGER PRIMARY KEY
AUTOINCREMENT, title TEXT, value REAL);");
这条语句会创建一个名为 mytable 的表,表有一个列名为 _id,并且是主键,这列的值是会自动增长的整数(例如,当你插入一行时,SQLite 会给这列自动赋值),另外还有两列:title( 字符 ) 和 value( 浮点数 )。 SQLite 会自动为主键列创建索引。
通常情况下,第一次创建数据库时创建了表和索引。如果你不需要改变表的 schema,不需要删除表和索引 . 删除表和索引,需要使用 execSQL() 方法调用 DROP INDEX 和 DROP TABLE 语句。
给表添加数据
上面的代码,已经创建了数据库和表,现在需要给表添加数据。有两种方法可以给表添加数据。
像上面创建表一样,你可以使用 execSQL() 方法执行 INSERT, UPDATE, DELETE 等语句来更新表的数据。execSQL() 方法适用于所有不返回结果的 SQL 语句。例如:
db.execSQL("INSERT INTO widgets (name, inventory)"+
VALUES ('Sprocket', 5)");
另一种方法是使用 SQLiteDatabase 对象的 insert(), update(), delete() 方法。这些方法把 SQL 语句的一部分作为参数。示例如下:
ContentValues cv=new ContentValues();
cv.put(Constants.TITLE, "example title");
cv.put(Constants.VALUE, SensorManager.GRAVITY_DEATH_STAR_I);
db.insert("mytable", getNullColumnHack(), cv);
update()方法有四个参数,分别是表名,表示列名和值的 ContentValues 对象,可选的 WHERE 条件和可选的填充 WHERE 语句的字符串,这些字符串会替换 WHERE 条件中的“?”标记。update() 根据条件,更新指定列的值,所以用 execSQL() 方法可以达到同样的目的。
WHERE 条件和其参数和用过的其他 SQL APIs 类似。例如:
String[] parms=new String[] {"this is a string"};
db.update("widgets", replacements, "name=?", parms);
delete() 方法的使用和 update() 类似,使用表名,可选的 WHERE 条件和相应的填充 WHERE 条件的字符串。
查询数据库
类似 INSERT, UPDATE, DELETE,有两种方法使用 SELECT 从 SQLite 数据库检索数据。
1 .使用 rawQuery() 直接调用 SELECT 语句;
使用 query() 方法构建一个查询。
Raw Queries
正如 API 名字,rawQuery() 是最简单的解决方法。通过这个方法你就可以调用 SQL SELECT 语句。例如:
Cursor c=db.rawQuery(
"SELECT name FROM sqlite_master WHERE type='table' AND name='mytable'", null);
在上面例子中,我们查询 SQLite 系统表(sqlite_master)检查 table 表是否存在。返回值是一个 cursor 对象,这个对象的方法可以迭代查询结果。
如果查询是动态的,使用这个方法就会非常复杂。例如,当你需要查询的列在程序编译的时候不能确定,这时候使用 query() 方法会方便很多。
Regular Queries
query() 方法用 SELECT 语句段构建查询。SELECT 语句内容作为 query() 方法的参数,比如:要查询的表名,要获取的字段名,WHERE 条件,包含可选的位置参数,去替代 WHERE 条件中位置参数的值,GROUP BY 条件,HAVING 条件。
除了表名,其他参数可以是 null。所以,以前的代码段可以可写成:
String[] columns={"ID", "inventory"};
String[] parms={"snicklefritz"};
Cursor result=db.query("widgets", columns, "name=?",parms, null, null, null);
使用游标
不管你如何执行查询,都会返回一个 Cursor,这是 Android 的 SQLite 数据库游标,使用游标,你可以:
通过使用 getCount() 方法得到结果集中有多少记录;
通过 moveToFirst(), moveToNext(), 和 isAfterLast() 方法遍历所有记录;
通过 getColumnNames() 得到字段名;
通过 getColumnIndex() 转换成字段号;
通过 getString(),getInt() 等方法得到给定字段当前记录的值;
通过 requery() 方法重新执行查询得到游标;
通过 close() 方法释放游标资源;
例如,下面代码遍历 mytable 表
Cursor result=db.rawQuery("SELECT ID, name, inventory FROM mytable");
result.moveToFirst();
while (!result.isAfterLast()) {
int id=result.getInt(0);
String name=result.getString(1);
int inventory=result.getInt(2);
// do something useful with these
result.moveToNext();
}
result.close();
结束语
如果你想要开发 Android 应用程序,一定需要在 Android 上存储数据,使用 SQLite 数据库是一种非常好的选择。本文介绍了如何在 Android 应用程序中使用 SQLite 数据库 ,主要介绍了在 Android 应用程序中使用 SQLite 创建数据库和表、添加数据、更新和检索数据,还介绍了比较常用的 SQLite 管理工具,通过阅读本文,你可以在 Android 中轻松操作 SQLite 数据库。
相关文章
- 有时为了网站安全和版权问题,会对自己写的php源码进行加密,在php加密技术上最常用的是zend公司的zend guard 加密软件,现在我们来图文讲解一下。 下面就简单说说如何...2016-11-25
- 下面我们来看一篇关于Android子控件超出父控件的范围显示出来方法,希望这篇文章能够帮助到各位朋友,有碰到此问题的朋友可以进来看看哦。 <RelativeLayout xmlns:an...2016-10-02
- ps软件是现在很多人都会使用到的,HSL面板在ps软件中又有着非常独特的作用。这次文章就给大家介绍下ps怎么使用HSL面板,还不知道使用方法的下面一起来看看。  ...2017-07-06
基于BootStrap Metronic开发框架经验小结【八】框架功能总体界面介绍
这篇文章主要介绍了基于BootStrap Metronic开发框架经验小结【八】框架功能总体界面介绍 的相关资料,需要的朋友可以参考下...2016-05-14- 许多的朋友对于Plesk控制面板应用不是非常的了解特别是英文版的Plesk控制面板,在这里小编整理了一些关于Plesk控制面板常用的使用方案整理,具体如下。 本文基于Linu...2016-10-10
使用insertAfter()方法在现有元素后添加一个新元素
复制代码 代码如下: //在现有元素后添加一个新元素 function insertAfter(newElement, targetElement){ var parent = targetElement.parentNode; if (parent.lastChild == targetElement){ parent.appendChild(newEl...2014-05-31Android开发中findViewById()函数用法与简化
findViewById方法在android开发中是获取页面控件的值了,有没有发现我们一个页面控件多了会反复研究写findViewById呢,下面我们一起来看它的简化方法。 Android中Fin...2016-09-20- 如果我们的项目需要做来电及短信的功能,那么我们就得在Android模拟器开发这些功能,本来就来告诉我们如何在Android模拟器上模拟来电及来短信的功能。 在Android模拟...2016-09-20
jQuery 1.9使用$.support替代$.browser的使用方法
jQuery 从 1.9 版开始,移除了 $.browser 和 $.browser.version , 取而代之的是 $.support 。 在更新的 2.0 版本中,将不再支持 IE 6/7/8。 以后,如果用户需要支持 IE 6/7/8,只能使用 jQuery 1.9。 如果要全面支持 IE,并混合...2014-05-31使用percona-toolkit操作MySQL的实用命令小结
1.pt-archiver 功能介绍: 将mysql数据库中表的记录归档到另外一个表或者文件 用法介绍: pt-archiver [OPTION...] --source DSN --where WHERE 这个工具只是归档旧的数据,不会对线上数据的OLTP查询造成太大影响,你可以将...2015-11-24- 大概有如下步骤 新建项目Bejs 新建文件package.json 新建文件Gruntfile.js 命令行执行grunt任务 一、新建项目Bejs源码放在src下,该目录有两个js文件,selector.js和ajax.js。编译后代码放在dest,这个grunt会...2014-06-07
如何使用php脚本给html中引用的js和css路径打上版本号
在搜索引擎中搜索关键字.htaccess 缓存,你可以搜索到很多关于设置网站文件缓存的教程,通过设置可以将css、js等不太经常更新的文件缓存在浏览器端,这样访客每次访问你的网站的时候,浏览器就可以从浏览器的缓存中获取css、...2015-11-24- C#注释的一些使用方法浅谈,需要的朋友可以参考一下...2020-06-25
- 夜神android模拟器如何设置代理呢?对于这个问题其实操作起来是非常的简单,下面小编来为各位详细介绍夜神android模拟器设置代理的方法,希望例子能够帮助到各位。 app...2016-09-20
- 一、下载 mysqlsla [root@localhost tmp]# wget http://hackmysql.com/scripts/mysqlsla-2.03.tar.gz--19:45:45-- http://hackmysql.com/scripts/mysqlsla-2.03.tar.gzResolving hackmysql.com... 64.13.232.157Conn...2015-11-24
- 为了增强android应用的用户体验,我们可以在一些Button按钮上自定义动态的设置一些样式,比如交互时改变字体、颜色、背景图等。 今天来看一个通过重写Button来动态实...2016-09-20
- 如果我们要在Android应用APP中加载html5页面,我们可以使用WebView,本文我们分享两个WebView加载html5页面实例应用。 实例一:WebView加载html5实现炫酷引导页面大多...2016-09-20
安装和使用percona-toolkit来辅助操作MySQL的基本教程
一、percona-toolkit简介 percona-toolkit是一组高级命令行工具的集合,用来执行各种通过手工执行非常复杂和麻烦的mysql和系统任务,这些任务包括: 检查master和slave数据的一致性 有效地对记录进行归档 查找重复的索...2015-11-24- 深入理解Android中View和ViewGroup从组成架构上看,似乎ViewGroup在View之上,View需要继承ViewGroup,但实际上不是这样的。View是基类,ViewGroup是它的子类。本教程我们深...2016-09-20
- 下面我们来看一篇关于Android自定义WebView网络视频播放控件开发例子,这个文章写得非常的不错下面给各位共享一下吧。 因为业务需要,以下代码均以Youtube网站在线视...2016-10-02