Android——实用小技巧

一、获取全局Context——解决Toast找不到可用Contex的尴尬

Application类，当应用程序启动的时候，系统将会对这个类初始化，可以定制一个Application类，管理程序全局状态信息，如Context

定制Application

package com.example.contexttest;

import android.app.Application;
import android.content.Context;
public class MyApplication extends Application {
    private static Context context;

    @Override
    public void onCreate() {
        context = getApplicationContext();
    }
    
    public static Context getContext(){
        return context;
    }
    
}

 

使用全局Context

package com.example.contexttest;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

import android.widget.Toast;

public class HttpUtil {
    public static void sendHttp(final String address,
            final HttpListener listener) {
        // 在这里我们判断一下网络是否可用，如果不可用，则弹出提示
        // 问题来了，Toast需要传递Context，在哪里去找一个Context？——通过自定义application
        if(!isNetWorkAvailable()){
            Toast.makeText(MyApplication.getContext(), "network is unavailable", Toast.LENGTH_SHORT).show();
        }
        
        new Thread(new Runnable() {
            HttpURLConnection connection = null;

            @Override
            public void run() {
                try {
                    // 获取HttpURLConnection对象
                    URL url = new URL(address);
                    connection = (HttpURLConnection) url.openConnection();
                    
                    // 设置请求方式和延迟
                    connection.setRequestMethod("GET");
                    connection.setConnectTimeout(8000);
                    connection.setReadTimeout(8000);
                    connection.setDoInput(true);
                    connection.setDoOutput(true);
                    
                    // 请求数据，疯狂的读
                    StringBuilder response = new StringBuilder();
                    InputStream in = connection.getInputStream();
                    BufferedReader bufr = new BufferedReader(new InputStreamReader(in));
                    String line = null;
                    while((line=bufr.readLine())!=null){
                        response.append(line);
                    }
                    
                    // 读完之后通过监听器操作数据
                    if(listener!=null){
                        listener.onFinish(response.toString());
                    }
                    
                    
                } catch (Exception e) {
                    listener.onError(e);
                } finally {
                    if (connection != null) {
                        connection.disconnect();
                    }
                }
            }
        }).start();
    }
}

有时候会java.lang.ClassCastException: android.app.Application cannot be cast to  XXXX.xxApplication的错误

需要在AndroidManifest中注册 一下application，在原有的application中添加一项

<application
        android:name="XXXX.xxApplication"

 

二、Inten传递对象

intent除了可以传递常见的数据类型如int，boolean等等，但是不能直接传递对象，要传递对象，通常有两种做法

1.序列化——Serializable

序列化很简单，只需要让类实现Serializable接口就可以了，并且这个接口一个方法都没有！！！仅仅相当于是添加一个标记一样！

package com.example.intenttest;

import java.io.Serializable;

public class People implements Serializable {
    private String Name;

    public People() {
    }

    public People(String name) {
        super();
        Name = name;
    }

    public String getName() {
        return Name;
    }

}

 

传入：

                Intent intent = new Intent(MainActivity.this,SecondActivity.class);
                People people = new People("秋香");
                intent.putExtra("people", people);
                startActivity(intent);

 

取出：

People people = (People) getIntent().getSerializableExtra("people");
textView.setText("Serializable："+people.getName()+"\n");

 

Serializable方式会将整个对象序列化，效率上会比parcelable稍低

 

2.Parcelable方式

package com.example.intenttest;

import android.os.Parcel;
import android.os.Parcelable;

public class Dog implements Parcelable {
    private String name;
    private int age;

    public Dog() {}
    public Dog(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    /**
     * 返回0即可
     */
    @Override
    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }

    /**
     * 将字段一一写出
     */
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);

    }

    /**
     * Parcelable方式必须提供一个CREATOR常量,传入泛型类名
     */
    public static final Parcelable.Creator<Dog> CREATOR = new Creator<Dog>() {

        /**
         * 指定数组大小
         */
        @Override
        public Dog[] newArray(int size) {
            // TODO Auto-generated method stub
            return new Dog[size];
        }

        /**
         * 按照写入的顺序一一读取
         */
        @Override
        public Dog createFromParcel(Parcel source) {
            // TODO Auto-generated method stub
            Dog dog = new Dog();
            dog.name = source.readString();
            dog.age = source.readInt();
            return dog;
        }
    };
}

 

 

存入：

        Intent intent = new Intent(MainActivity.this,SecondActivity.class);
        Dog dog = new Dog("旺财", 8);
        intent.putExtra("dog", dog);
        startActivity(intent);

 

取出：

Dog dog = getIntent().getParcelableExtra("dog");
textView.setText("Parcelable："+dog.getName()+"::"+dog.getAge()+"\n");

 

Parcelable稍微复杂一点，不过效率稍微高一点，更推荐使用

 三、定制自己的Log工具

为了是正式发布的软件不输出Log，开发测试时才输出Log，可以定义一个LogUtil工具类来控制！！

很简单，很强大！！

package com.example.utils;

import android.util.Log;

/**
 * 
 * 在开发阶段，可以将Level设置成1，这样就和Log功能一样.<br/>
 * 在发布时，Level设置成NOTHING，这样就不会有任何Log了.<br/>
 */
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);
        }
    }

}

 

四、eclipse调试Android程序

1.设置断点——在需要调试的开始行双击——取消也是双击

　　

2.将程序跑起来，到需要调试的位置为止

3.进入DDMS

　　

4.选中测试机器的包名进程——最下面一行，点击上方绿色小蜘蛛，成功后包名前面会多出一个小蜘蛛

　　

5.继续执行程序，就会出现Debug了

　　

　　

6.F6逐行执行

　　

7.查看变量值

　　

8.停止调试——点击红框按钮即可

　　

 

这样做的好处在于，可以随时进入程序调试。所以并没用Debug as 来执行程序，而是直接run as

 五、编写测试用例

必要性在于：当开发的项目规模大的时候，测试用例格外重要，每当修改增加了某功能后，都应该把测试用例跑一遍！！！

测试用例也不过是一段代码而已，一般一个用例测试一个小单元的功能。

 

1.创建测试工程

File->New->Other->Android Test Project

　　

　　

工程名直接为要测试的工程加个Test后缀即可，路径也是该工程目录下新建tests文件即可

　　

选择已存在的该工程，finish即可　　

　　

创建成功之后，就会多出一个工程，这就是测试工程了！！

在这个工程里面编写测试用例即可！

　　

2.编写测试用例进行单元测试

下面定义一个AndroidControllerTest 类，用于对BroadcastBestPractice项目中AndroidController类测试

　　需要继承AndroidTestCast方法

　　需要重写setUp和tearDown方法，可对测试用例执行初始化和资源回收操作

　　要对AndroidController的addActivity方法测试，只需要创建一个方法，testaddActivity（对！就是在这个方法前面加一个test即可！）

　　在测试方法中，通过断言assert，来判断期望的值和结果是否一致，一致则跑通，不一致，则说明程序有需要修改的地方

 

AndroidController.java

 

/**
 * 活动控制器 1.添加活动 2.删除活动 3.销毁所有活动
 */
public class ActivityController {
    public 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) {
            activity.finish();
        }
    }
}

 

 

 

AndroidControllerTest.java

package com.example.broadcastbestpractic.test;

import com.example.broadcastbestpractic.ActivityController;
import com.example.broadcastbestpractic.LoginActivity;

import android.test.AndroidTestCase;
/**
 * 
 * BroadcastBestPractice中的AndroidController类测试用例.<br/>
 * 需要重写setUp和tearDown方法
 */
public class AndroidControllerTest extends AndroidTestCase {

    /**
     * 测试用例调用前执行，可以在这里进行初始化操作
     */
    @Override
    protected void setUp() throws Exception {
        // TODO Auto-generated method stub
        super.setUp();
    }
    
    /**
     * 在需要测试的方法前面加上test，系统就会自动测试该方法.</br>
     * 通过assert进行断言.<br/>
     * Run as Android JUit Test运行测试用例.<br/>
     */
    public void testaddActivity(){
        // 断言activity结合的数量初始为0
        assertEquals(0, ActivityController.activities.size());
        LoginActivity loginActivity = new LoginActivity();
        ActivityController.addActivity(loginActivity);
        // 断言经过addActivity方法操作之后，活动个数增加成为1，被认为是正确的
        assertEquals(1, ActivityController.activities.size());
        
    }
    

    /**
     * 测试用例执行完成时执行，可以在这里进行资源的释放
     */
    @Override
    protected void tearDown() throws Exception {
        // TODO Auto-generated method stub
        super.tearDown();
    }
    
}

 

 

Run as Android JUit Test , 发现能够跑通，说明满足测试用例（绿色）

然后，对AndroidControllerTest.java这个类进行一下修改

    public void testaddActivity(){
        // 断言activity结合的数量初始为0
        assertEquals(0, ActivityController.activities.size());
        LoginActivity loginActivity = new LoginActivity();
        ActivityController.addActivity(loginActivity);
        // 断言经过addActivity方法操作之后，活动个数增加成为1，被认为是正确的
        assertEquals(1, ActivityController.activities.size());
        
        ActivityController.addActivity(loginActivity);
        // 断言再次执行addActivity时，活动个数仍然是1，即不重复加载
        assertEquals(1, ActivityController.activities.size());
        
    }

 

在此Run一下，发现不能跑通，

提示期望是1，但是结果是2

发现AndroidController不符合测试用例

修改AndroidController的代码

        if (!activities.contains(activity)) {
            activities.add(activity);
        }

 

然后在Run一下，发现能够跑通了！！

 

 六、在服务中Toast

 直接写则:RuntimeException:Can't creat handler inside thread that has not called Looper.prepare()

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 输出当前时间
        new Thread(new Runnable() {

            @Override
            public void run() {
                Looper.prepare();
                Toast.makeText(LongRunningService.this, "executed at:"
                                + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()), Toast.LENGTH_SHORT).show();
                Looper.loop();  
            }
        }).start();

 

完整：

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent service = new Intent(this, LongRunningService.class);
        startService(service);
    }

}

public class LongRunningService extends Service {

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 输出当前时间
        new Thread(new Runnable() {

            @Override
            public void run() {
                Looper.prepare();
                Toast.makeText(LongRunningService.this, "executed at:"
                                + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()), Toast.LENGTH_SHORT).show();
                Looper.loop();  
            }
        }).start();
        // 定时打开广播接收器——10s一次
        AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
        /*
         * type还可以用RTC，RTC_WAKEUP，对应的触发时间应该使用System.currenTimetMillis()
         */
        // (int type, long triggerAtMillis, PendingIntent operation)
        int type = AlarmManager.ELAPSED_REALTIME_WAKEUP; // 从系统开机时累积的总时间
        long triggerAtMillis = SystemClock.elapsedRealtime() + 10 * 1000;
        intent = new Intent(this, ServiceReceiver.class);
        PendingIntent operation = PendingIntent.getBroadcast(this, 0, intent, 0);

        // 通过set定时执行可能会延迟，4.4之后，因为手机会有省电设计，如果要准确无误，用setExact()
        alarmManager.set(type, triggerAtMillis, operation);

        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

}

public class ServiceReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        // 被激活则直接开启服务
        Intent service = new Intent(context, LongRunningService.class);
        context.startService(service);
    }

}

七、知晓当前是在哪一个活动

思路是：写一个BaseActivity类继承Activity，新增活动创建时打印日志功能，让所有需要关注的活动继承BaseActivity即可，当不在需要知晓当前活动时，去掉log即可获继承回Activity

public class BaseActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        LogUtil.d("BaseActivity", getClass().getSimpleName());
        ActivityCollector.addActivity(this);
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityCollector.removeActivity(this);
    }
    
}

 

public class ActivityCollector {

    public 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();
            }
        }
    }

}

 

ActivityCollector用来管理活动——随时退出程序