Android源码分析——Looper,Messagequeue,Message,handler初始化及handler机制简介

Handler机制算是我入门源码的第一节。看得比较仔细。体会较多。mark一下。

顺序:先科普一下Handler基本功,然后再细讲下源码

一、Handler目的:

目的:Handler机制来处理了子线程去更新UI线程控件问题。

二、handler,messagequeue,looper,message关系图:

其实各种书籍上都有这么一张图。但是主要是学习源码,所以还是自己手画一张“流程图”。

三、handler知识点总结:

(若以下总结都能理解,那么可以不再看本文后续源码分析;)

1)handler、Looper、Messagequeue初始化总结:在主UI实例化Looper或者子线程手工实例化looper。在Looper中实例化Messagequeue。在handler初始化在主线程或者子线程中,且handler初始化只获取looper对象,获取Messagequeue对象,因此必须先有Looper实例再有handler实例,否则handler无法获取looper、Messagequeue。

2)hanlder中写了操作主UI线程的handlemessage空方法、使用handler实例在子线程中发送消息Message

3)Looper初始化:一个线程只有一个Looper,Looper管理Messagequeue

4)主UI线程(ActivityThread)创建Looper对象,而Looper创建了Messagequeue对象(可通过其他方式创建looper)

5)在handler里使用queue(Messagequeue对象),equeueMessage插入消息到Messagequeue,在Looper的loop()方法里调用handler对象的dispatchMessage()分发消息。并通过handler的handlerMessage()方法使主UI改变。

6)Messagequeue对象和Message对象

四、逐步分析handler源码

1)handler、Looper、Messagequeue初始化:

由于初始化顺序必然是Looper ==> Messagequeue ==> handler。所以我也按照此顺序分析源码。

四、1)Looper获取:

当我启动一个程序。按照如下顺序:

ActivityManager的startActivity()==>ActivityThread的main()==》Looper.prepareMainLooper()实例化主UI线程Looper

以上实例源码,部分如下:

ActivityManager的startActivity()

/**
         * Start an activity in this task.  Brings the task to the foreground.  If this task
         * is not currently active (that is, its id < 0), then a new activity for the given
         * Intent will be launched as the root of the task and the task brought to the
         * foreground.  Otherwise, if this task is currently active and the Intent does not specify
         * an activity to launch in a new task, then a new activity for the given Intent will
         * be launched on top of the task and the task brought to the foreground.  If this
         * task is currently active and the Intent specifies {@link Intent#FLAG_ACTIVITY_NEW_TASK}
         * or would otherwise be launched in to a new task, then the activity not launched but
         * this task be brought to the foreground and a new intent delivered to the top
         * activity if appropriate.
         *
         * <p>In other words, you generally want to use an Intent here that does not specify
         * {@link Intent#FLAG_ACTIVITY_NEW_TASK} or {@link Intent#FLAG_ACTIVITY_NEW_DOCUMENT},
         * and let the system do the right thing.</p>
         *
         * @param intent The Intent describing the new activity to be launched on the task.
         * @param options Optional launch options.
         *
         * @see Activity#startActivity(android.content.Intent, android.os.Bundle)
         */
        public void startActivity(Context context, Intent intent, Bundle options) {
            ActivityThread thread = ActivityThread.currentActivityThread();
            thread.getInstrumentation().execStartActivityFromAppTask(context,
                    thread.getApplicationThread(), mAppTaskImpl, intent, options);
        }
此处ActivityThread.currentActivityThread();

public static ActivityThread currentActivityThread() {
        return sCurrentActivityThread;
    }
一个单例模式的ActivityThread,简单看下定义。
/** Reference to singleton {@link ActivityThread} */
    private static ActivityThread sCurrentActivityThread;

ActivityThread的main()

public static void main(String[] args) {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
        SamplingProfilerIntegration.start();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();

        // Set the reporter for event logging in libcore
        EventLogger.setReporter(new EventLoggingReporter());

        AndroidKeyStoreProvider.install();

        // Make sure TrustedCertificateStore looks in the right place for CA certificates
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);

        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
上面是整个main方法

细心可以发现这么一条主UI线程Looper初始化实例的语句:(这个代码待会儿讲Looper时一起讲,此处知道在这初始化即可)

Looper.prepareMainLooper()

Looper.prepareMainLooper();
当然有实例,还得开启主UI线程Looper的轮询方法。看这句就知道。(这个也一会儿讲Looper讲)

Looper.loop();
讲到这儿我们主线程的Looper已经初始化完事了。接下来讲讲重中之重Looper。

四、2)Messagequeue实例化即Looper源码分析

先不要着急Messagequeue实例化,由于这个Looper是重点,我决定按照传统的办法来看源码。按照如下顺序读源码:
构造方法Looper()==》looper().loop()轮询方法

构造方法Looper()

private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }
直接上源码可见是个private的构造方法。可见单例模式痕迹明显。肯定有对外的实例方法。接着看:
private static Looper sMainLooper;  // guarded by Looper.class
实例在类初始化的时候初始化了。只需要获取即可。看看有哪些能获取实例的方法:

/**
     * Initialize the current thread as a looper, marking it as an
     * application's main looper. The main looper for your application
     * is created by the Android environment, so you should never need
     * to call this function yourself.  See also: {@link #prepare()}
     *///主线程用来实例化Looper的,你应该永远也用不到它。
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }
prepareMainLooper很熟悉吧。对,就是它。主方法里面用的就是它。当然注释里面说了,主线程用来实例化Looper的,你应该永远也用不到它。然后提示你看prepare()

这里第一句代码看看。

prepare(false)
这菊花虽然短,但是千万不要忽略了。它就是那个万恶的深藏着的Looper实例所在。

private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }
如果ThreadLocal.get()不为空,可能你会有疑问sThreadLocal究竟是什么。后面我会认真考虑写关于ThreadLocal的技术博客的。现在只需要立即为一个存储数据的对象,对外公开了set,get方法即可。

sThreadLocal.set(new Looper(quitAllowed));
这里的quitallowed参数明显一直没变,是false会到最开始的私有的初始化函数private looper(boolean quitallowed)。发现其实到这儿我们的Looper实例化已经完事了。quitallowed是给Messagequeue对象实例化传递的一个参数罢了。既然这样子,那就先放放,交给后面的Messagequeue去讲它的实例化方法再提。

绕了一圈,再来谈谈轮询loop()方法。

looper().loop()轮询方法

先把loop()源码奉上。在哪用到就再提一句吧,每次Looper实例化完,必须紧跟着它。因为首先要有这个轮询器(实例化),然后再将轮训器运转起来loop()。

/**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            msg.target.dispatchMessage(msg);

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }
    }
现在可以一行行看代码了,先判断看看有没有轮训器?有则继续,没有就抛异常。所以,当你看到下面这个异常的时候,你就知道,你肯定没写轮训器。

final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
不要问我me是什么,me就是Looper实例。
见myLooper()源码:一目了然。
public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

获取Looper实例全部靠它,然后再看看这一行:简单明了,之前Looper已经实例化了Messagequeue,那么现在拿来用。

final MessageQueue queue = me.mQueue;

看看下面这几行。翻译很明确,确保当前binder调用是否为远程调用。调用这个clear方法,在当前进程中。将会清除之前进程的PID和UID,

重置成当前进程UID,PID。好吧,以后写个IPC文章。

// Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
总算到了轮询的伟大时刻了。一看就知道是个死循环。

for (;;) {

}
里面的内容虽然涉及到Messagequeue这个对象和Message对象。但是其实从源码很好看出来。首先我们简化掉这些打日志的代码,

再看如下:

for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            msg.target.dispatchMessage(msg);
           
            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();          

            msg.recycleUnchecked();
        }

天呐,我对它究竟做了什么!居然只剩下四条了。所以不要害怕,一切源码都是纸老虎。而且其中还有一条是刚刚讲过的Binder重设。

这么一看。居然只剩下三条。但是,我很无耻,我只打算在这个篇章里面讲上面两条。其它都留给messagequeue和message。

 Message msg = queue.next(); // might block
一条是从“队列”中取出一条消息。

msg.target.dispatchMessage(msg);
  另一条是,是讲这个消息分发出去。其中msg.target就是指向我们主线程中的handler对象。问我为什么知道的。一会儿我打算讲Message就知道了。

到这,很明显的每次从“队列”中取出一条,然后分发出去。我们轮询就干了这么间完全无技术含量的事。

Messagequeue和Message对象:

先讲Messagequeue吧:我估计我写的挺累,大家看的也挺累。再忍一忍。成功一大半了!最难的都看完了。就剩下一个操作类handler,

两个对象Messagequeue、Message对象。

Messagequeue对象:

先把遗留问题讲讲:

mQuitAllowed:这个参数传递过来做什么?看源码吧。

PS:以下都是Messagequeue的部分源码:

// True if the message queue can be quit.
    private final boolean mQuitAllowed;
源码注释写的太明白了:就是判断Messagequeue能不能退出的。再深入一点。

void quit(boolean safe) {
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }

        synchronized (this) {
            if (mQuitting) {
                return;
            }
            mQuitting = true;

            if (safe) {
                removeAllFutureMessagesLocked();
            } else {
                removeAllMessagesLocked();
            }

            // We can assume mPtr != 0 because mQuitting was previously false.
            nativeWake(mPtr);
        }
    }
Messagequeue自带退出方法。为什么不能退出?因为我们刚刚传递参数一直都是从主UI线程的Looper给的。主线程不允许Messagequeue退出,就是这么任性!既然都看到了,就简单讲讲吧。mQuitting这个标志:
If the loop is quitting then it must not be idling.
简单来说就是一个loop空转的标志。这个参数从哪来的?从Looper类的方法过来的:
PS:如果Looper是自己实例化的,必须跟这Looper.loop(),之前我们已经说过,而且使用完Looper对象后通过Looper.quit()方法退出。
这个可不是我总结的:SDK说的,原文在Looper源码的prepare方法中:
/** Initialize the current thread as a looper.
      * This gives you a chance to create handlers that then reference
      * this looper, before actually starting the loop. Be sure to call
      * {@link #loop()} after calling this method, and end it by calling
      * {@link #quit()}.
      */
    public static void prepare() {
        prepare(true);
    }
其实也就是说我们自己新建的Looper对象都是可以退出,且需要退出的。而主线程是不允许的。
public void quit() {
        mQueue.quit(false);
    }
还有一个quitSafely()
public void quitSafely() {
        mQueue.quit(true);
    }
涉及到一个是否安全退出的问题。Looper安全退出究竟是什么?
回到Messagequeue源码中来:继续看removeAllFutureMessagesLocked及removeAllMessagesLocked方法。
private void removeAllFutureMessagesLocked() {
        final long now = SystemClock.uptimeMillis();
        Message p = mMessages;
        if (p != null) {
            if (p.when > now) {
                removeAllMessagesLocked();
            } else {
                Message n;
                for (;;) {
                    n = p.next;
                    if (n == null) {
                        return;
                    }
                    if (n.when > now) {
                        break;
                    }
                    p = n;
                }
                p.next = null;
                do {
                    p = n;
                    n = p.next;
                    p.recycleUnchecked();
                } while (n != null);
            }
        }
    }
大概看一眼则知道:
那么我就安全退出 方法,具体分析如:
如果p.when>now,即队首的消息执行时间大于当前时间,则表明队首的消息还没分发。等同于删除所有的消息队列的消息:那么就调用removeAllMessageLocked。删除所有。
否则删除消息执行时间大于当前时间的消息。
private void removeAllMessagesLocked() {
        Message p = mMessages;
        while (p != null) {
            Message n = p.next;
            p.recycleUnchecked();
            p = n;
        }
        mMessages = null;
    }
虽然比较麻烦,可还是简单要讲下MessageQueue的next()方法:主要是一些算法用来取得下一条要执行的Message对象。不打算在此处花费大量篇幅写。下一篇,会优先考虑写下这个算法。有兴趣的可以看看。
之前留下的还剩下一个dispatchMessage方法。这个方法在下面的Message中将提到。

Message对象:

从类的定义来看知道是一个序列化的对象,很明显是用来传输数据的。
public final class Message implements Parcelable 
关键字what用得最多的:描述很清楚的写着每个handler都有自己的独立命名空间。不用担心命名冲突问题。
/**
     * User-defined message code so that the recipient can identify 
     * what this message is about. Each {@link Handler} has its own name-space
     * for message codes, so you do not need to worry about yours conflicting
     * with other handlers.
     */
    public int what;
看看构造方法:官方不推荐直接调用,推荐使用obtain获取handler 对象。性能问题。具体原因:也就是一个新建对象的开销问题。参考这篇文章:http://blog.csdn.net/h3c4lenovo/article/details/7914902
/** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
    */
    public Message() {
    }
其实讲到这,Message日常用到可能也就是what,这儿补充一点内容。关于message对象的target。
/*package*/ Handler target;
这个target是个handler对象,主要目的是用来指向当前使用的handler。从obtain方法可见:
/**
     * Same as {@link #obtain()}, but copies the values of an existing
     * message (including its target) into the new one.
     * @param orig Original message to copy.
     * @return A Message object from the global pool.
     */
    public static Message obtain(Message orig) {
        Message m = obtain();
        m.what = orig.what;
        m.arg1 = orig.arg1;
        m.arg2 = orig.arg2;
        m.obj = orig.obj;
        m.replyTo = orig.replyTo;
        m.sendingUid = orig.sendingUid;
        if (orig.data != null) {
            m.data = new Bundle(orig.data);
        }
        m.target = orig.target;
        m.callback = orig.callback;

        return m;
    }
可能看到这儿大家都看到了m.target = orig.trget。

突然间可能有种懵的感觉?忘了orig这个参数?没关系,温习一下。handler实例的时候我们如何用target就知道了。
----------------此处为分割线------------------------------
讲了这么多总算到了handler机制,前面都是铺垫,是不是简直令人发指。
---此处是基础:-------
Handler有个Callback接口,i m p liments接口,实现方法handleMessage,用来处理子线程发的消息的响应。
/**
     * Callback interface you can use when instantiating a Handler to avoid
     * having to implement your own subclass of Handler.
     *
     * @param msg A {@link android.os.Message Message} object
     * @return True if no further handling is desired
     */
    public interface Callback {
        public boolean handleMessage(Message msg);
    }
    
    /**
     * Subclasses must implement this to receive messages.
     */
    public void handleMessage(Message msg) {
    }
new一个handler实例。直接上源码:
public Handler() {
        this(null, false);
    }
指向多参数的handler构造方法
public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
通过Looper.myLooper()获取实例。myLooper()方法我前面讲没讲?自己翻一翻。
通过前面去获得Looper实例获取queue实例。
拿到所有可以用的东西了。至于Message,那是通过handler的方法obtainMessage方法获得的。
准备工作做好。发送消息====》handler.sendMessage()
public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
可见虽然我没有传入参数最终都是要进入===》sendMessageDelayed(Message msg, long delayMillis)
 public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }
进入===》sendMessageAtTime(Message msg, long uptimeMillis)下面方法为发送消息的唯一方法。所有方法均调用它。
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
    }
调用handler自己的插入消息方法。其实这是一个伪方法。真正调用的Messagequeue的该同名方法。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
说到这,消息也就发送出去了。
当然光发出去还不行,还得由主UI线程或者当前handler接收回来。
当轮询器Looper实例的Looper.loop方法调用msg.target.dispatchMessage(之前我已经讲过,msg.target指向就是当前handler)来,看下handler源码中的该方法:
/**
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
好了,总算到了handleMessage(msg)方法了。此方法,我们实现接口的时候已然重写。那么只需调用该方法即可。
主UI响应,over。

PS:写到这,感谢大家看完。如有错误,欢迎指正。

本页内容版权归属为原作者,如有侵犯您的权益,请通知我们删除。

ART世界探险(5) - 计算指令 - 2016-07-25 18:07:28

ART世界探险(5) - 计算指令 整数运算 Java的整型运算 我们先看看JVM是如何处理这些基本整数运算的吧。 public static long add ( long a, long b){ return a+b; } public static long sub ( long a, long b){ return a-b; } public static long mul ( long a, long b){ return a*b; } public static long div ( long
大部分的软件, 但凡包含登录注册的, 基本都会有选择头像功能, 而其中做的比较有逼格的, 一般会有一个选择框可以裁剪照片。 本文所需要实现的就是这样一种有 逼格 的效果: 右上角加了个图片框,按下确定可以裁剪正方形区域里的图片并显示在右上角。 实现思路: 1:首先需要自定义一个ZoomImageView来显示我们需要的图片,这个View需要让图片能够以合适的位置展现在当前布局的图片展示区域内(合适的位置值的是:如果图片长度大于屏幕,则压缩图片长度至屏幕宽度,高度等比压缩并居中显示,如果图片高度大于屏幕,则

注解使用入门(一) - 2016-07-25 18:07:18

注解使用入门(一) 本篇博客要讲解主要分为以下几个问题 注解的相关知识点 基于运行时的注解的例子解析说明 至于关于编译时的注解,待下篇博客的时候会结合例子讲解一下,目前我也正在学习当中 注解的相关知识点 提到注解,大多数人应该都不默认,在我们程序中见到的@Override,@Deprected,@SupressWarnings等等,这些都是注解,只不过是系统自己封装好的,而我们平时比较少去深入理解是怎样实现的? 1)什么是注解(Annotation): Annotation(注解)就是Java提供了一种元

android-----我眼中的Binder - 2016-07-25 18:07:17

        Binder作为进程间通信方式(IPC)的一种,算Android中比较难理解的部分了,今天计划以自己所认识的framework层的Binder原理来做个总结,好了,我们开始吧!         Android中利用Binder通信,首先肯定需要获得Binder对象了,但是系统服务和我们自定义服务Binder对象的获取方式是不一样的,原因就在于系统服务是在系统启动的时候被注册到ServiceManegr的,我们只需要通过ServiceManager.getService(String nam
使用xml作为数据交互的载体是Android中非常重要的功能,比如天气预报数据、短信备份数据、通讯录数据都可以以xml的格式通过网络传输。 为了演示Xml数据的操作,我模拟了一个短信备份的案例。 需求:界面如图1-10所示。上面是三个Button,前两个分别对应两种不同方式生成xml,第三个Button点击后解析备份的xml文件,然后将数据展现在下面的ScrollView中。短信数据是模拟的假数据。 生成的xml格式如文件1-10。 【文件1-10】 xml文件格式 1. ?xml version="1.
这篇博客我们来介绍一下责任链模式(Chain-of-responsibility Pattern),责任联模式又称为职责链模式,是 行为型设计模式 之一。顾名思义,责任链模式中存在一个链式结构,多个节点首尾相连,每个节点都可以被拆开再连接,因此,链式结构具有很好的灵活性。将这样一种结构应用于编程领域,将每一个节点看作是一个对象,每一个对象拥有不同的处理逻辑,将一个请求从链式的首段发出,沿着链的路径依次传递给每一个节点对象,直至有对象处理这个请求为止,这就是责任链或者职责链的通俗定义。 转载请注明出处: h

GeekBand第十一周笔记 - 2016-07-25 17:07:19

本周的主要内容介绍Gradle,NDK,管理依赖和Git等 一、Gradle Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化建构工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,抛弃了基于XML的各种繁琐配置。 面向Java应用为主。当前其支持的语言限于Java、Groovy和Scala,计划未来将支持更多的语言。 Coding只是软件开发中的一个部分 编译源代码 运行单元测试和集成测试 执行静态代码分析,生成分析报告 创建分布版本 部署到目标环
在安卓开发中,谷歌已经为我们提供了许多原生控件,基本上能够满足我们日常的开发需求,但是某些项目中原生控件可能达不到产品所要求的各式各样的酷炫效果或功能效果,这个时候我们只能自己自定义控件来满足项目需求,我们知道自定义控件包括三种方式: 1继承控件,即继承谷歌提供的原生控件,在此基础上提供一些原生控件不具备的功能,如github上各种酷炫效果的开源组件基本上都是采用的这种方式. 2组合控件:即组合多个原生控件来达到某些单个原生控件原本不具备的功能,这个在日常开发中应该是使用的比较多的,如基本上每个App都存

Android多点触摸交互处理 - 2016-07-25 17:07:15

安卓手机中,多点触摸是是最基本的操作,下面就使用程序进行演示多点触摸操作 一、获取触摸事件中的点击,移动和抬起事件,创建新的安卓项目,如下面代码所示,分别为MainActivity类代码和Layout布局文件,用于实现获取点击事件 1.1、MainActivity类中代码,代码中为布局对象root添加监听事件,使用switch进行对屏幕时间进行判断,用于判断事件的按下还是移动,在代码中      root=(RelativeLayout) findViewById(R.id.content);用于绑定布局
内容是博主照着书敲出来的,博主码字挺辛苦的,转载请注明出处,后序内容陆续会码出。 前言:ListView——列表,它作为一个非常重要的显示方式,不管是在Web中还是移动平台中,都是一个非常好的、不开或缺的展示信息的工具。在Android中,ListView控件接管了这一重担,在大量的场合下,我们都需要使用这个控件。虽然在Android 5.X时代,RecyclerView在很多地方都在逐渐取代ListView,但ListView的使用范围依然非常的广泛,它这万年老大哥的地位也不是轻易就能撼动的。下面就介绍