android开发工程师_专业技能_知识架构

android os下的phone、pad、TV都是pc的衍生品，那么要做android开发，要了解什么，熟练什么，精通什么呢？

需要了解的：

android开发的分类：

1.设备管理类，如腾讯的手机管家，360的360手机卫士，金山手机卫士；

特定：与操作系统交互，对程序、进程、电池、短信等进行管理；

2.网络应用类，如淘宝的淘宝客户端，优酷的优酷客户端，京东的京东商城客户端；

特定：与服务端交互，比管理类应用更容易出现问题；

网络应用可以分两大类：

1.消费类：购物、旅游、酒店等等；

2.体验类：视频、音频、图片、图书的欣赏等等；

需要熟练的：

android开发的主流：

1.本地应用：四大组件的使用，本地应用最常用的就是广播接，因为需要调用的service比较多，所以通常通过BroadcastReceiver来响应其他组件的提示和请求；

2.网络应用：如何搭建一个好的框架？线程管理，请求管理，数据解析，消息处理，回调设计；

框架接口：

1.请求数据 RequestBean 每一个界面请求的数据都不一样，有不同的url，不同的Parser，不同的context；

2.处理数据 DataCallBack 每一个界面对数据的适配都是不一样的，不同的AbsListView对象，有不同的Adapter，把服务器返回的json数据解析成对象之后，需要把数据适配到AbsListView上；

那么如何传人这两个参数呢（RequestBean 和 DataCallBack ）？

任务管理，线程管理：创建一个ThreadPoolManager单列，提供一个ExecutorsService，用于执行RunnAble；

任务封装，任务设计：创建一个RunnAble 实现类 BaseTask，以Context、RequestBean和Handler为构造参数；

消息处理，消息管理：当msg.what == Constant.SUCCESS时，拿到msg,obj，并调用回调对象的回调函数，进行数据处理，callBack.processData(msg.obj, true);

回调设计，回调管理：给DataCallback接口定义一个方法，以返回对象为参数；在实现类中实现功能，通过自定义适配器把object数据适配到界面上；

public static abstract interface DataCallback<T> {

public abstract void processData(T paramT, boolean paramBoolean);

}

Activity框架，BaseActivity，如何去启动新线程去获取数据？

getDataFromServer(RequestVo reqVo, DataCallback callBack)；

该方法，对RequestVo 和 DataCallback进行处理：

1.通过这两个参数创建BaseHandler；

2.以BaseHandler为参数创建BaseTask；

3.把BaseTask传入ThreadPoolManager的addTask()方法，执行任务；

protected void getDataFromServer(RequestVo reqVo, DataCallback callBack) {

showProgressDialog();

BaseHandler handler = new BaseHandler(this, callBack, reqVo);// 数据得到后使用

BaseTask taskThread = new BaseTask(this, reqVo, handler);// 获取数据

this.threadPoolManager.addTask(taskThread);

}

线程管理：如何封装线程池，如何提供线程去执行任务？

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ThreadPoolManager {

private ExecutorService service;

/**

* 线程池管理器，拥有一个执行员服务，服务中包含cpu核数*2条线程；

* 1.Runtime 单例类Runtime，获取实例，获取可用处理器数目；

* 2.Executors 工厂类Executors，创建固定线程池ExecutorService，

*/

private ThreadPoolManager(){

int num = Runtime.getRuntime().availableProcessors();

service = Executors.newFixedThreadPool(num*2);

}

private static final ThreadPoolManager manager= new ThreadPoolManager();

/**

* 获取线程池管理器；

* @return

*/

public static ThreadPoolManager getInstance(){

return manager;

}

/**

* 执行新线程任务；

* @param runnable

*/

public void addTask(Runnable runnable){

service.execute(runnable);

}

}

总结：Requestvo --->DataCallBack--->getDataFromServer--->new BaseHandler--->newBaseTask--->ThreadPoolManager.addTask(Runnable);

package com.itcast.activity;

import com.itcast.R;
import com.itcast.util.CommonUtil;
import com.itcast.util.Constant;
import com.itcast.util.NetUtil;
import com.itcast.util.ThreadPoolManager;
import com.itcast.vo.RequestVo;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.ImageView;
import android.widget.TextView;

/**
* Activity框架类，BaseActivity：
* 1.把固定的内容具体化，封装起来，把复杂变简单；
* 2.把个性的内容抽象化，暴露出去，让子类实现；
* @author xiaoo
*
*/
public abstract class BaseActivity extends Activity implements
View.OnClickListener {
protected int activityCase;
private ImageView classify;
private ImageView home;
private ImageView more;
protected ProgressDialog progressDialog;
private ImageView search;
private ImageView shopCar;
protected TextView textShopCarNum;
protected Context context;
private ThreadPoolManager threadPoolManager;

public BaseActivity() {
threadPoolManager = ThreadPoolManager.getInstance();
}

@Override
public void onCreate(Bundle paramBundle) {
super.onCreate(paramBundle);
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
context = getApplicationContext();
initView();//初始化视图对象；
}

/**
* 初始化视图对象；
* 对所有相关的view对象都加载、获取和设置监听；
*/
private void initView() {
loadViewLayout();//子类加载布局文件
if (isLoadBottomTab()) {
loadBottomTab();//本类加载底标签，并设置标签点击监听器；
selectedBottomTab(Constant.defaultIndex);//默认选中底标签
}
findViewById();//获取视图对象
setListener();//设置监听器
processLogic();//处理逻辑
}

/**
* 子类加载布局文件
*/
protected abstract void loadViewLayout();

/**
* 是否加载底部tab
* @return
*/
protected Boolean isLoadBottomTab() {
return true;
}

/**
* 本类加载底标签，并设置标签点击监听器；
*/
private void loadBottomTab() {
this.home = (ImageView) findViewById(R.id.imgHome);
this.classify = (ImageView) findViewById(R.id.imgClassify);
this.search = (ImageView) findViewById(R.id.imgSearch);
this.shopCar = (ImageView) findViewById(R.id.imgShoppingCar);
this.more = (ImageView) findViewById(R.id.imgMore);
this.textShopCarNum = (TextView) findViewById(R.id.textShopCarNum);
this.home.setOnClickListener(this);
this.classify.setOnClickListener(this);
this.search.setOnClickListener(this);
this.shopCar.setOnClickListener(this);
this.more.setOnClickListener(this);
}

/**
* tab条图片切换（默认选中首页）
* @param paramViewId
*/
protected void selectedBottomTab(int paramViewId) {
this.home.setBackgroundResource(R.drawable.bar_home_normal);
this.classify.setBackgroundResource(R.drawable.bar_class_normal);
this.search.setBackgroundResource(R.drawable.bar_search_normal);
this.shopCar.setBackgroundResource(R.drawable.bar_shopping_normal);
this.more.setBackgroundResource(R.drawable.bar_more_normal);
switch (paramViewId) {
case Constant.HOME:
this.home.setBackgroundResource(R.drawable.bar_home_selected);
Constant.defaultIndex = Constant.HOME;
break;
case Constant.CLASSIFY:
this.classify.setBackgroundResource(R.drawable.bar_class_selected);
Constant.defaultIndex = Constant.CLASSIFY;
break;
case Constant.SEARCH:
this.search.setBackgroundResource(R.drawable.bar_search_selected);
Constant.defaultIndex = Constant.SEARCH;
break;
case Constant.SHOPCAR:
this.shopCar
.setBackgroundResource(R.drawable.bar_shopping_selected);
Constant.defaultIndex = Constant.SHOPCAR;
break;
case Constant.MORE:
this.more.setBackgroundResource(R.drawable.bar_more_selected);
Constant.defaultIndex = Constant.MORE;
break;
}
}

/**
* 获取视图对象
*/
protected abstract void findViewById();

/**
* 设置监听器
*/
protected abstract void setListener();

/**
* 处理逻辑：向后台请求数据,用于调用getDataFromServer(RequestVo reqVo, DataCallback callBack)；
*/
protected abstract void processLogic();

/**
* 从服务器上获取数据，并回调处理
* 1.在run方法请求解析生成object，并通过发送message，让Handler 去HandleMessage；
* 2.在HandleMessage方法中调用DataCallback.processData（）方法
* @param reqVo
* @param callBack
*/
protected void getDataFromServer(RequestVo reqVo, DataCallback<Object> callBack) {
showProgressDialog();
BaseHandler handler = new BaseHandler(this, callBack, reqVo);// 数据得到后使用
BaseTask taskThread = new BaseTask(this, reqVo, handler);// 获取数据
this.threadPoolManager.addTask(taskThread);
}

/**
* 显示提示框
*/
protected void showProgressDialog() {
if ((!isFinishing()) && (this.progressDialog == null)) {
this.progressDialog = new ProgressDialog(this);
}
this.progressDialog.setTitle(getString(R.string.loadTitle));
this.progressDialog.setMessage(getString(R.string.LoadContent));
this.progressDialog.show();
}

/**
* 关闭提示框
*/
protected void closeProgressDialog() {
if (this.progressDialog != null)
this.progressDialog.dismiss();
}

public void onClick(View paramView) {
if (!onClickBottmBarEvent(paramView))
onClickEvent(paramView);//子类点击事件处理
}

/**
* 响应底部tab点击事件
* @param paramView
* @return
*/
private boolean onClickBottmBarEvent(View paramView) {
boolean isBar = true;
Intent intent = new Intent();
switch (paramView.getId()) {
case R.id.imgHome: {
intent.setClass(this, HomeActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
Log.e("TAB1", "Home");
startActivity(intent);
}
break;
case R.id.imgClassify: {
intent.setClass(this, HomeActivity.class);
Log.e("TAB2", "Classify");
startActivity(intent);
}
break;
case R.id.imgSearch: {
intent.setClass(this, HomeActivity.class);
Log.e("TAB3", "Search");
startActivity(intent);
}
break;
case R.id.imgShoppingCar: {
intent.setClass(this, HomeActivity.class);
Log.e("TAB4", "ShoppingCar");
startActivity(intent);
}
break;
case R.id.imgMore: {
intent.setClass(this, HomeActivity.class);
Log.e("TAB5", "More");
startActivity(intent);
}
break;
default:
isBar = false;
Log.e("TAB6", "DEFAULT");
break;
}
return isBar;
}

/**
* 子类响应view点击事件
* @param paramView
*/
protected abstract void onClickEvent(View paramView);

class BaseTask implements Runnable {
private Context context;
private RequestVo reqVo;
private Handler handler;

public BaseTask(Context context, RequestVo reqVo, Handler handler) {
this.context = context;
this.reqVo = reqVo;
this.handler = handler;
}

@Override
public void run() {
Object obj = null;
Message msg = new Message();
if (NetUtil.hasNetwork(context)) {
obj = NetUtil.post(reqVo);// 真正和后台服务器交互的类
msg.what = Constant.SUCCESS;
msg.obj = obj;
handler.sendMessage(msg);
} else {
msg.what = Constant.NET_FAILED;
msg.obj = obj;
handler.sendMessage(msg);
}
}

}

/**
* 基本处理器：
* @author xiaoo
*/
class BaseHandler extends Handler {
private Context context;
private /*BaseActivity.*/DataCallback<Object> callBack;//回调类，负责数据的适配；
//private RequestVo reqVo;

public BaseHandler(Context context, DataCallback<Object> callBack,
RequestVo reqVo) {
this.context = context;
this.callBack = callBack;
//	this.reqVo = reqVo;
}

public void handleMessage(Message msg) {
closeProgressDialog();
if (msg.what == Constant.SUCCESS) {
if (msg.obj == null) {
CommonUtil.showInfoDialog(context,
getString(R.string.net_error));
} else {
callBack.processData(msg.obj, true);
}
} else if (msg.what == Constant.NET_FAILED) {
CommonUtil.showInfoDialog(context,
getString(R.string.net_error));
}
}
}

/**
* 回调类，负责数据的适配；
* @author xiaoo
* @param <T>
*/
public static abstract interface DataCallback<T> {
public abstract void processData(T paramT, boolean paramBoolean);
}
}