【android_温故知新】常用开发技巧

在项目中我们常常建立一个ActivityCollector来管理程序的所有活动

建立HttpUtil类来管理网络连接

全局获取 Context

使用 Intent 传递对象
Serializable 方式

Parcelable 方式

使用LogUitl

在项目中我们常常建立一个ActivityCollector来管理程序的所有活动

public class ActivityCollector {

private static List<Activity> activities = new ArrayList<Activity>();

public static void addActivity(Activity activity) {
activities.add(activity);
}

public static void removeActivity(Activity activity) {
activities.remove(activity);
}

public static void finishAll() {
for (Activity activity : activities) {
if (!activity.isFinishing()) {
activity.finish();
}
}
}
}

通常我们还须建立一个 BaseActivity 类作为我们程序的基类，重写 onCreate() 和 onDestroy()方法来添加每个活动启动和销毁都需要的操作。

public class BaseActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.d("BaseActivity", getClass().getSimpleName());    //显示处于哪个活动
ActivityCollector.addActivity(this);}
@Override
protected void onDestroy() {
super.onDestroy();
ActivityCollector.removeActivity(this);
}
}

为 Activity 添加静态方法，使其他 Activity 明白调用该活动需要传入的参数在 SecondActivity 类中添加

public static void actionStart(Context context, String data1, String data2) {
Intent intent = new Intent(context, SecondActivity.class);
intent.putExtra("param1", data1);
intent.putExtra("param2", data2);
context.startActivity(intent);
}

在 FirstActivity 中可以这样启动 SecondActivity

SecondActivity.actionStart(FirstActivity.this, "data1", "data2");

建立HttpUtil类来管理网络连接

由于网络请求是耗时操作，防止主线程被阻塞，需要开启子线程，而子线程的数据无法通过return来返回。

因此需要使用回调函数。

public interface HttpCallbackListener {
void onFinish(String response);    //网络操作成功时调用
void onError(Exception e);    //网络操作失败时调用
}

在HttpUtil类中

public class HttpUtil {
public static void sendHttpRequest(final String address,
final HttpCallbackListener listener) {
new Thread(new Runnable() {
@Override
public void run() {
HttpURLConnection connection = null;
try {
URL url = new URL(address);
connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setConnectTimeout(8000);
connection.setReadTimeout(8000);
connection.setDoInput(true);
connection.setDoOutput(true);
InputStream in = connection.getInputStream();
BufferedReader reader = new BufferedReader(
new InputStreamReader(in));
StringBuilder response = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
response.append(line);
}
if (listener != null) {
// 回调onFinish() 方法
listener.onFinish(response.toString());
}
} catch (Exception e) {
if (listener != null) {
// 回调onError() 方法
listener.onError(e);
}
} finally {
if (connection != null) {
connection.disconnect();
}
}
}
}).start();
}
}

**这样我们处理网络数据，只要实现HttpCallbackListener接口就可以了

可以直接写匿名类，两个方法还是在子线程中执行，无法进行UI操作，需要借助异步消息机制**

HttpUtil.sendHttpRequest(address, new HttpCallbackListener() {
@Override
public void onFinish(String response) {
// 在这里根据返回内容执行具体的逻辑
}
@Override
public void onError(Exception e) {
// 在这里对异常情况进行处理
｝
｝

全局获取 Context

Android 提供了一个 Application 类，每当应用程序启动的时候，系统就会自动将这个类进行初始化。

可以定制一个自己的 Application 类， 以便于管理程序内一些全局的状态信息，比如说全局 Context。

public class MyApplication extends Application {
private static Context context;

@Override
public void onCreate() {
context = getApplicationContext();
}

public static Context getContext() {
return context;
}
}

修改配置文件

<application
android:name="com.example.networktest.MyApplication"
…… >
……
</application>

则以后就可以通过 MyApplication.getContext() 获得全局获取 Context

使用 Intent 传递对象

由于putExtra()方法中所支持的数据类型是有限的，可以采用传递对象的方法

Serializable 方式

有一个 Person 类，其中包含了 name 和 age 这两个字段，实现其 getter 和 setter 方法

在第一个活动中

Person person = new Person();
person.setName("Tom");
person.setAge(20);
Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.putExtra("person_data", person);
startActivity(intent);

而接收这个对象的活动中

Person person = (Person)getIntent().getSerializableExtra("person_data");

Parcelable 方式

public class Person implements Parcelable {
private String name;
private int age;
.....

@Override
public int describeContents() {
return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(name); // 写出name
dest.writeInt(age); // 写出age
}

public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {
@Override
public Person createFromParcel(Parcel source) {
Person person = new Person();
person.name = source.readString(); // 读取name
person.age = source.readInt(); // 读取age
return person;
}

@Override
public Person[] newArray(int size) {
return new Person[size];
}
};
}

Person person = (Person)getIntent().getParcelableExtra("person_data");

Parcelable 方式效率更高

使用LogUitl

可以方便我们在完成一个项目后，去掉所有调试时设置的Log

public class LogUtil {
public static final int VERBOSE = 1;
public static final int DEBUG = 2;
public static final int INFO = 3;
public static final int WARN = 4;
public static final int ERROR = 5;
public static final int NOTHING = 6;
public static final int LEVEL = VERBOSE;

public static void v(String tag, String msg) {
if (LEVEL <= VERBOSE) {
Log.v(tag, msg);
}
}

public static void d(String tag, String msg) {
if (LEVEL <= DEBUG) {
Log.d(tag, msg);
}
}

public static void i(String tag, String msg) {
if (LEVEL <= INFO) {
Log.i(tag, msg);
}
}

public static void w(String tag, String msg) {
if (LEVEL <= WARN) {
Log.w(tag, msg);
}
}

public static void e(String tag, String msg) {
if (LEVEL <= ERROR) {
Log.e(tag, msg);
}
}
}

只需要修改 LEVEL 常量的值，就可以自由地控制日志的打印行为了