Android19-高级技巧

2017-04-21  本文已影响0人  figure_ai

1.全局获取Context

Android提供了一个Application类，每当应用启动的，系统就会自动将这个类进行初始化，而我们可以定制一个自己的Application类，以便于管理程序内一些全局的状态信息，比如全局的Context。

1.自定义Application类

>public class MyApplication extends Application {
    private static Context context;
    @Override
    public void onCreate() {
        //重写onCreate()方法，获得context对象
        context = getApplicationContext();
    }
    public static Context getContext() {
        //外界调用，获得context
        return context;
    }
}

2.在AndroidManifest.xml文件中指定加载MyApplication

 <application
        android:name=".MyApplication"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"

3.外界调用的时候

Toast.makeText(MyApplication.getContext(), "点击了头像", Toast.LENGTH_SHORT).show();

2.使用Intent传递对象

Intent使用putExtra()方法传递数据时，所支持的类型是有限的，当需要传递一些自定义对象时，就需要使用Serializable或者Parcelablc的方式来实现了。

一、Serializable方式

Serializable是序列化的意思，表示将一个对象转换成可存储或可传输的状态，序列化后的对象可以在网络上进行传输，也可以存储到本地，至于序列化的方法也很简单，只需要让一个类去实现Serializable这个接口就可以了。

1.1比如一个Person类，其中包含了name和age两个字段，想要将它序列化就可以这样写：

//整个类中跟定义一个实体类大致相同，最最重要的是在第一行，让Person类去实现Serializable接口。
public class Person implements Serializable {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

1.2然后需要传递对象的activity中：

Intent intent = new Intent(mContext, FruitActivity.class);
 Person person = new Person();
 person.setAge(20);
 person.setName("Tom");
 intent.putExtra("person_data", person);    MyApplication.getContext().startActivity(intent);

1.3在需要获取对象的acidity中：

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

二、Parcelabele方式

使用Parcelable同样可以达到跟Serializable相同的效果，不同的是，Parcelabel方式的实现原理是将一个完整的对象进行分解，而分解后的每一部分都是Intent所支持的数据类型。这样也就实现传递对象的功能了。

2.1和Serializable一样，需要使Person实现Parcelable接口。然后重写describeContents()和writeToParcel()这两个方法。其中describeContents()方法中直接返回0就可以了。而writeToParcel()需要调用writeXxx()方法，将Person类中的字段一一写出。然后还要提供一个名为CREATOR的常量。

public class Person implements Parcelable {
    private String name;
    private int age;
    public int getAge() {
        return age;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    //重写describeContents()方法
    @Override
    public int describeContents() {
        return 0;
    }
    //重写writeToParcel()方法
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);//写出name
        dest.writeInt(age);//写出age
    }
    //定义CREATOR常量
    public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {
        @Override
        public Person createFromParcel(Parcel source) {
            Person person = new Person();
            person.setName(source.readString());//读取name
            person.setAge(source.readInt());//读取age
            return person;
        }
        @Override
        public Person[] newArray(int size) {
            return new Person[size];
        }
    };
}

2.2在需要传递对象的activity中,这跟Serializable是一样

Intent intent = new Intent(mContext, FruitActivity.class);
 Person person = new Person();
 person.setAge(20);
 person.setName("Tom");
 intent.putExtra("person_data", person);    MyApplication.getContext().startActivity(intent);

2.3在需要获取对象的activity中

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

3.定制自己的日志工具

定制日志工具，可以让程序处于开发阶段的时候就打印日志，处于上线阶段的时候就不打印日志，便于后期维护，也防止了私密信息的泄漏。

1.1如下，创建LogUtil类

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

1.2外界调用的时候直接通过LogUtil打印信息即可。并且当我们设置LogUtil中的level等于VERBOSE就可以把所有日志都打印出来，等于WARN就可以只打印WARN以上级的日志，在发布之后，将level设置成NOTHING就可以把所有日志都屏蔽掉了。

LogUtil.d("TAG", "Debug log");

4. 创建定时任务

Android中的定时任务一般有两种实现方式，一种是使用JavaAPI提供的Timer类，一种是Android的Alarm机制。两种方式都能实现相同的效果，但是Timer有可能在手机休眠的状态下无法正常运行，而Alarm则具有唤醒CPU的功能，因此在手机休眠的状态下也能保证定时任务的正常执行。

一、Alarm机制

Alarm机制的用法，主要是借助AlarmManager类来实现，这个类和NotificationManager有点类似，都是通过调用Context的getSystemService()方法传入参数Context.ALARM_SERVICE来获取实例。

1.1获取AlarmManager实例

AlarmManager manager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);

1.2调用AlarmManager的set()方法就可以设置一个定时任务了。比如设定一个任务在10秒后执行

set()方法接收3个参数：
第一个：一个整型参数，用于指定AlarmManager的工作类型,有4种值可选:>>1. RTC_WAKEUP : 表示让定时任务的触发时间从1970年1月1日0时开始算起，但会唤醒CPU

  1. RTC : 表示让定时任务的触发时间从1970年1月1日0时开始算起，但不会唤醒CPU
  2. ELAPSED_REALTIME_WAKEUP : 表示让定时任务的触发时间从系统开机算起，但会唤醒CPU。
  3. ELAPSED_REALTIME : 表示让定时任务的处罚时间从系统开机算起，但不会唤醒CPU>
    第二个参数：定时任务出发的时间，加上第一个参数设定值。
    第三个参数：PendingIntent对象。这里一般会调用getService()方法或者getBroadcast()方法来获取一个能够执行服务或广播接收器的onReceive()方法就可以得到执行。
AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
long triggerArTime = SystemClock.elapsedRealtime() + 10*1000;
manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerArTime, pendingIntent);

1.3 如果需要实现一个长时间在后台定时运行的服务，如下代码，每个一小时就会启用一次服务。

public class LongRunningService extends Service {
    public LongRunningService() {
    }
    @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() {
                //这里执行具体的操作逻辑
            }
        });
        AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
        int anHour = 60 * 60 * 1000; //一小时的毫秒数
        long triggerAtTime = SystemClock.elapsedRealtime() + anHour;
        Intent i = new Intent(this, LongRunningService.class);
        PendingIntent pi = PendingIntent.getService(this, 0, i, 0);
        manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);
        return super.onStartCommand(intent, flags, startId);
    }
}

1.4 最后只需要在需要启动服务的时候调用

Intent intent = new Intent(context, LongRunningService.class);
context.startService(intent);

注：从Android4.4开始，因为系统在好点性方面的调整，Alarm使用set()触发任务的时间会变得不准确，如果需要让执行时间变得准确无误，需使用setExact()方法来代替set()方法。

5.多窗口模式的一些设置

1.当应用进入多窗口模式的时候，活动默认会被重新创建，修改这一行为，可以在AndroidManifest.xml中对活动进行如下设置

<activity
  android:name=".FruitActivity"
  android:theme="@style/FruitActivityTheme"
  android:configChanges="orientation|keyboardHidden|screenSize|screenLayout">
</activity>

2.禁用多窗口模式
设置程序禁用多窗口模式，只需在application中把android:resizeableActivity设置为false即可。

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.example.anwser_mac.materialtest">
    <application
        android:resizeableActivity="false"

注：android:resizeableActivity，是在targetSdkVersion大于24才有用的，如果对于一些没有指定到24的项目，想要禁用多窗口模式，需要设置活动不允许横竖屏切换，因为Android规定targetSdkVersion小于24并且活动不允许横竖屏切换的应用也不将不支持多窗口模式。

<activity
  android:screenOrientation="portrait"//landscape只支持横屏，portrait为只支持竖屏。
上一篇下一篇

猜你喜欢

热点阅读