Android應用坐標系統(tǒng)全面詳解

原文鏈接：CSDN@工匠若水，http://blog.csdn.net/yanbober/article/details/50419117

1. 背景

去年有很多人私信告訴我讓說說自定義控件，其實通觀網(wǎng)絡上的很多博客都在講各種自定義控件，但是大多數(shù)都是授之以魚，卻很少有較為系統(tǒng)性授之于漁的文章，同時由于自己也遲遲沒有時間規(guī)劃這一系列文章，最近想將這一系列文章重新提起來，所以就來先總結一下自定義控件的一個核心知識點——坐標系。

很多人可能不屑一顧Android的坐標系，但是如果你想徹底學會自定義控件，我想說了解Android各種坐標系及一些API的坐標含義絕對算一個小而不可忽視的技能；所謂Android自定義View那幾大主要onXXX()方法的重寫實質(zhì)其實大多數(shù)都是在處理坐標邏輯運算，所以我們就先來就題重談一下Android坐標系。

2. Android坐標系

說到Android坐標系其實就是一個三維坐標，Z軸向上，X軸向右，Y軸向下。這三維坐標的點處理就能構成Android豐富的界面或者動畫等效果，所以Android坐標系在整個Android界面中算是蓋樓房的尺寸草圖，下面我們就來看看這些相關的概念。

2-1 Android屏幕區(qū)域劃分

我們先看一副圖來了解一下Android屏幕的區(qū)域劃分（關于這個東西的深入探討你可以看下《Android應用setContentView與LayoutInflater加載解析機制源碼分析 》一文，那兒給出了部分原理的解釋），如下：

通過上圖我們可以很直觀的看到Android對于屏幕的劃分定義。下面我們就給出這些區(qū)域里常用區(qū)域的一些坐標或者度量方式。如下：

//獲取屏幕區(qū)域的寬高等尺寸獲取 DisplayMetrics metrics = new DisplayMetrics(); getWindowManager().getDefaultDisplay().getMetrics(metrics); int widthPixels = metrics.widthPixels; int heightPixels = metrics.heightPixels; //應用程序App區(qū)域寬高等尺寸獲取 Rect rect = new Rect(); getWindow().getDecorView().getWindowVisibleDisplayFrame(rect); //獲取狀態(tài)欄高度 Rect rect= new Rect(); getWindow().getDecorView().getWindowVisibleDisplayFrame(rect); int statusBarHeight = rectangle.top; //View布局區(qū)域寬高等尺寸獲取 Rect rect = new Rect(); getWindow().findViewById(Window.ID_ANDROID_CONTENT).getDrawingRect(rect);

特別注意：上面這些方法最好在Activity的onWindowFocusChanged ()方法或者之后調(diào)運，因為只有這時候才是真正的顯示OK，不懂的可以看我之前關于setContentView相關的博客。

2-2 Android View絕對相對坐標系

上面我們分析了Android屏幕的劃分，可以發(fā)現(xiàn)我們平時開發(fā)的重點其實都在關注View布局區(qū)域，那么下面我們就來細說一下View區(qū)域相關的各種坐標系。先看下面這幅圖：

通過上圖我們可以很直觀的給出View一些坐標相關的方法解釋，不過必須要明確的是上面這些方法必須要在layout之后才有效，如下：

View的靜態(tài)坐標方法解釋

getLeft()	返回View自身左邊到父布局左邊的距離
getTop()	返回View自身頂邊到父布局頂邊的距離
getRight()	返回View自身右邊到父布局左邊的距離
getBottom()	返回View自身底邊到父布局頂邊的距離
getX()	返回值為getLeft()+getTranslationX()，當setTranslationX()時getLeft()不變，getX()變。
getY()	返回值為getTop()+getTranslationY()，當setTranslationY()時getTop()不變，getY()變。

同時也可以看見上圖中給出了手指觸摸屏幕時MotionEvent提供的一些方法解釋，如下：

MotionEvent坐標方法解釋

getX()	當前觸摸事件距離當前View左邊的距離
getY()	當前觸摸事件距離當前View頂邊的距離
getRawX()	當前觸摸事件距離整個屏幕左邊的距離
getRawY()	當前觸摸事件距離整個屏幕頂邊的距離

上面就解釋了你在很多代碼中看見各種getXXX方法進行數(shù)學邏輯運算判斷的含義。不過上面只是說了一些相對靜止的Android坐標點關系，下面我們來看看幾個和上面方法緊密相關的View方法。如下：

View寬高方法解釋

getWidth()	layout后有效，返回值是mRight-mLeft，一般會參考measure的寬度（measure可能沒用），但不是必須的。
getHeight()	layout后有效，返回值是mBottom-mTop，一般會參考measure的高度（measure可能沒用），但不是必須的。
getMeasuredWidth()	返回measure過程得到的mMeasuredWidth值，供layout參考，或許沒用。
getMeasuredHeight()	返回measure過程得到的mMeasuredHeight值，供layout參考，或許沒用。

上面解釋了自定義View時各種獲取寬高的一些含義，下面我們再來看看關于View獲取屏幕中位置的一些方法，不過這些方法需要在Activity的onWindowFocusChanged ()方法之后才能使用。如下圖：

下面我們就給出上面這幅圖涉及的View的一些坐標方法的結果（結果采用使用方法返回的實際坐標，不依賴上面實際絕對坐標轉換，上面絕對坐標只是為了說明例子中的位置而已），如下：

View的方法上圖View1結果上圖View2結果結論描述

getLocalVisibleRect()	(0, 0 - 410, 100)	(0, 0 - 410, 470)	獲取View自身可見的坐標區(qū)域，坐標以自己的左上角為原點(0,0)，另一點為可見區(qū)域右下角相對自己(0,0)點的坐標，其實View2當前height為550，可見height為470。
getGlobalVisibleRect()	(30, 100 - 440, 200)	(30, 250 - 440, 720)	獲取View在屏幕絕對坐標系中的可視區(qū)域，坐標以屏幕左上角為原點(0,0)，另一個點為可見區(qū)域右下角相對屏幕原點(0,0)點的坐標。
getLocationOnScreen()	(30, 100)	(30, 250)	坐標是相對整個屏幕而言，Y坐標為View左上角到屏幕頂部的距離。
getLocationInWindow()	(30, 100)	(30, 250)	如果為普通Activity則Y坐標為View左上角到屏幕頂部（此時Window與屏幕一樣大）；如果為對話框式的Activity則Y坐標為當前Dialog模式Activity的標題欄頂部到View左上角的距離。

到此常用的相關View的靜態(tài)坐標獲取處理的方法和含義都已經(jīng)敘述完了，下面我們看看動態(tài)的一些解釋（所謂動靜只是我個人稱呼而已）。

2-3 Android View動畫相關坐標系

其實在我們使用動畫時，尤其是補間動畫時，你會發(fā)現(xiàn)其中涉及很多坐標參數(shù)，一會兒為相對的，一會兒為絕對的，你可能會各種蒙圈。那么不妨看下《Android應用開發(fā)之所有動畫使用詳解 》這篇博客，這里面詳細介紹了關于Android動畫相關的坐標系統(tǒng)，這里不再累贅敘述。

2-4 Android View滑動相關坐標系

關于View提供的與坐標息息相關的另一組常用的重要方法就是滾動或者滑動相關的，下面我們給出相關的解釋（特別注意：View的scrollTo()和scrollBy()是用于滑動View中的內(nèi)容，而不是改變View的位置；改變View在屏幕中的位置可以使用offsetLeftAndRight()和offsetTopAndBottom()方法，他會導致getLeft()等值改變。），如下：

View的滑動方法效果及描述

offsetLeftAndRight(int offset)	水平方向挪動View，offset為正則x軸正向移動，移動的是整個View，getLeft()會變的，自定義View很有用。
offsetTopAndBottom(int offset)	垂直方向挪動View，offset為正則y軸正向移動，移動的是整個View，getTop()會變的，自定義View很有用。
scrollTo(int x, int y)	將View中內(nèi)容（不是整個View）滑動到相應的位置，參考坐標原點為ParentView左上角，x，y為正則向xy軸反方向移動，反之同理。
scrollBy(int x, int y)	在scrollTo()的基礎上繼續(xù)滑動xy。
setScrollX(int value)	實質(zhì)為scrollTo()，只是只改變Y軸滑動。
setScrollY(int value)	實質(zhì)為scrollTo()，只是只改變X軸滑動。
getScrollX()/getScrollY()	獲取當前滑動位置偏移量。

關于Android View的scrollBy()和scrollTo()參數(shù)傳遞正數(shù)卻向坐標系負方向移動的特性可能很多人都有疑惑，甚至是死記結論，這里我們簡單給出產(chǎn)生這種特性的真實原因—-源碼分析，如下：

public void scrollTo(int x, int y) {if (mScrollX != x || mScrollY != y) {int oldX = mScrollX;int oldY = mScrollY;mScrollX = x;mScrollY = y;invalidateParentCaches();onScrollChanged(mScrollX, mScrollY, oldX, oldY);if (!awakenScrollBars()) {postInvalidateOnAnimation();}} }

View的該方法注釋里明確說明了調(diào)運他會觸發(fā)onScrollChanged()和invalidated()方法，那我們就將矛頭轉向invalidated()方法觸發(fā)的draw()過程，draw()過程中最終其實會觸發(fā)下面的invalidate()方法，如下：

public void invalidate(int l, int t, int r, int b) {final int scrollX = mScrollX;final int scrollY = mScrollY;//scroller時為何參數(shù)和坐標反向的真實原因invalidateInternal(l - scrollX, t - scrollY, r - scrollX, b - scrollY, true, false); }

核心就在這里，相信不用我解釋大家也知道咋回事了，自行腦補。

scrollTo()和scrollBy()方法特別注意：如果你給一個ViewGroup調(diào)用scrollTo()方法滾動的是ViewGroup里面的內(nèi)容，如果想滾動一個ViewGroup則再給他嵌套一個外層，滾動外層即可。

3. 總結

可以發(fā)現(xiàn)，上面只是說明了一些View里常用的與坐標相關的概念，關于自定義控件了解學習這些坐標概念只是一個基礎，也是一個后續(xù)內(nèi)容的鋪墊，所以有必要先完全吃透此部分內(nèi)容才能繼續(xù)拓展學習新的東東。

View中還有一些其他與坐標獲取相關的方法，但是一般都比較不常用，所以用到時可以現(xiàn)查API或者Debug看現(xiàn)象進行學習即可，這里篇幅和時間有限就不一一道來了。

Android View的getLeft()、getRight()、getTop()、getBottom()

原文鏈接：http://www.cnblogs.com/zhengbeibei/archive/2013/05/07/3065999.html

引起疑惑

分析視圖invalidate流程的過程中發(fā)現(xiàn)view的left， right， top， bottom跟自己理解的不一樣，現(xiàn)在想分析一下這幾個值具體的含義

理解Android坐標，位置概念

坐標系在二維視圖中通過X軸和Y軸兩個數(shù)字為組合表示某個點的絕對坐標。 例如(30, 100) 通常表示X軸30， Y軸100交叉的一個點。 在Android中以左上角為原點（0,0），水平方向是X軸，從左到右，垂直方向是Y軸，從上到下，可以把left相當于X軸值， top相當于Y軸值， 通過這兩個值Android系統(tǒng)可以知道視圖的繪制起點，在通過Wdith 和 Height 可以得到視圖上下左右具體值，就可以在屏幕上絕對位置繪制視圖。right 與 bottom計算如下：

right = left + width; bottom = top + height;

View中相應API

view.getLeft();//表示的是view左側以其父View的左上角為原點的水平坐標位置 view.getRight();//表示的view右側以其父View的左上角為原點的水平坐標位置 view.getTop();//表示的是view頂部以父View的左上角為原點的垂直坐標位置 view.getBottom();//表示的是view底部以父View的左上角為原點的垂直坐標位置 view.getWidth();//表示view寬度 view.getHeight();//表示view高度

實例分析

按照我的理解：

藍色區(qū)域位置 left = 0， top = 0 坐標(0, 0 )

黃色區(qū)域位置 left = 60， top = 115 坐標(60, 115)

綠色區(qū)域位置 left = 115， top = 170 坐標(115, 170)

綠色區(qū)域，這里理解錯誤，我認為綠色區(qū)域的位置是針對于藍色區(qū)域的(0, 0)坐標的值，從上圖的右下角打印出的坐標值就可以看出與下方我列出的值不一致，看看下面的圖就明白了

總結： 視圖的left ， top ， right ， bottom 的值是針對其父視圖的相對位置， 綠色區(qū)域是針對其父視圖(即黃色區(qū)域為(0, 0)點)的坐標，不應該是(115, 170 ) 而是 (55, 55)

獲取坐標值的各種方法

你真的了解View的坐標嗎？

原文鏈接：http://blog.csdn.net/gdutxiaoxu/article/details/53700020

閑聊

View，對我們來說在熟悉不過了，從接觸Android開始，我們就一直在接觸View，界面當中到處都是 View，比如我們經(jīng)常用到的TextView，Button，LinearLayout等等，但是我們真的了解View嗎？尤其是View的坐標。mLeft,mRight,mY,mX,mTranslationY,mScoollY,相對于屏幕的坐標等等這些概念你真的清楚了嗎？如果真的清楚了，那你沒有必要度這篇博客，如果你還是有一些模糊，建議花上幾分鐘的時間讀一下，這篇博客較短，花個幾分鐘的時間就可以閱讀完。

為什么要寫這一篇博客呢？

因為掌握View的坐標很重要，尤其是對于自定義View，學習動畫有重大的意義。

這篇博客主要講解一下問題

• View 的 getLeft() , getRight() , getTop() , getBottom()
• View 的 getY() , getTranslationY() , getTop() 之間的聯(lián)系
• View 的 getScroolY 和 View 的 scrollTo() 和 scrollBy()
• event.getY 和 event.getRawY()
• 擴展，怎樣獲取狀態(tài)欄（StatusBar）和標題欄（titleBar）的高度

基本概念

簡單說明一下（上圖Activity采用默認Style，狀態(tài)欄和標題欄都會顯示）：最大的草綠色區(qū)域是屏幕界面，紅色次大區(qū)域我們稱之為“應用界面區(qū)域”，最小紫色的區(qū)域我們稱之為“View繪制區(qū)域”；屏幕頂端、應用界面區(qū)之外的那部分顯示手機電池網(wǎng)絡運營商信息的為“狀態(tài)欄”，應用區(qū)域頂端、View繪制區(qū)外部顯示Activity名稱的部分我們稱為“標題欄”。

從這張圖片我們可以看到

在Android中，當ActionBar存在的情況下，屏幕的高度=狀態(tài)欄+應用區(qū)域的高度=狀態(tài)欄的高度+（標題欄的高度+View繪制區(qū)域的高度）

當ActionBar不存在的情況下，屏幕的高度=狀態(tài)欄+應用區(qū)域的高度=狀態(tài)欄的高度+（View繪制區(qū)域的高度）

View 的 getLeft()和getRight()和 getTop() 和getBottom()

View.getLeft() ; View.getTop() ; View.getBottom(); View.getRight() ;

top是左上角縱坐標，left是左上角橫坐標，right是右下角橫坐標，bottom是右下角縱坐標,都是相對于它的直接父View而言的，而不是相對于屏幕而言的。這一點要區(qū)分清楚。那那個坐標是相對于屏幕而言的呢，以及要怎樣獲取相對于屏幕的坐標呢？

目前View里面的變量還沒有一個是相對于屏幕而言的，但是我們可以獲取到相對于屏幕的坐標。一般來說，我們要獲取View的坐標和高度 等，都必須等到View繪制完畢以后才能獲取的到，在Activity 的 onCreate()方法 里面 是獲取不到的，必須 等到View繪制完畢以后才能獲取地到View的響應的坐標，一般來說，主要 有以下兩種方法。

第一種方法，onWindowFocusChanged()方法里面進行調(diào)用

@Override public void onWindowFocusChanged(boolean hasFocus) {super.onWindowFocusChanged(hasFocus); //確保只會調(diào)用一次if(first){first=false;final int[] location = new int[2]; mView.getLocationOnScreen(location);int x1 = location[0] ;int y1 = location[1] ;Log.i(TAG, "onCreate: x1=" +x1);Log.i(TAG, "onCreate: y1=" +y1);} }

第二種方法，在視圖樹繪制完成的時候進行測量

mView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {@Overridepublic void onGlobalLayout() {// 移除監(jiān)聽器，確保只會調(diào)用一次，否則在視圖樹發(fā)揮改變的時候又會調(diào)用mView.getViewTreeObserver().removeGlobalOnLayoutListener(this);final int[] location = new int[2];mView.getLocationOnScreen(location);int x1 = location[0];int y1 = location[1];Log.i(TAG, "onCreate: x1=" + x1);Log.i(TAG, "onCreate: y1=" + y1);} });

View的getY()，getTranslationY() 和 getTop() 之間的聯(lián)

getY()

Added in API level 14
The visual y position of this view, in pixels.(返回的是View視覺上的圖標，即我們眼睛看到位置的Y坐標，默認值跟getTop()相同，別急，下面會解釋）

getTranslationY()

Added in API level 14
The vertical position of this view relative to its top position, in pixels.(豎直方向上相對于top的偏移量，默認值為0）

那 getY() 和 getTranslationY() 和 getTop () 到底有什么關系呢？

@ViewDebug.ExportedProperty(category = "drawing") public float getY() {return mTop + getTranslationY(); }@ViewDebug.ExportedProperty(category = "drawing")public float getTranslationY() {return mRenderNode.getTranslationY();}@ViewDebug.CapturedViewPropertypublic final int getTop() {return mTop;}

從以上的源碼我們可以知道 getY()= getTranslationY()+ getTop ()，而 getTranslationY() 的默認值是0，除非我們通過 setTranlationY() 來改變它，這也就是我們上面上到的 getY 默認值跟 getTop()相同

那我們要怎樣改變 top值 和 Y 值呢？ 很明顯就是調(diào)用相應的set方法 ，即 setY() 和setTop() ，就可以改變他們 的值。

View的getScroolY 和 View 的 scrollTo() 和 scrollBy()

getScrollY是一個比較特別的函數(shù)，因為它涉及一個值叫mScrollY，簡單說，getScrollY一般得到的都是0，除非你調(diào)用過scrollTo或scrollBy這兩個函數(shù)來改變它。

scrollTo() 和 scrollBy()

從字面意思我們可以知道 scrollTo() 是滑動到哪里的意思 ，scrollBy()是相對當前的位置滑動了多少。當然這一點在源碼中也是可以體現(xiàn)出來的

public void scrollTo(int x, int y) {if (mScrollX != x || mScrollY != y) {int oldX = mScrollX;int oldY = mScrollY;mScrollX = x;mScrollY = y;invalidateParentCaches();onScrollChanged(mScrollX, mScrollY, oldX, oldY);if (!awakenScrollBars()) {postInvalidateOnAnimation();}} } public void scrollBy(int x, int y) {scrollTo(mScrollX + x, mScrollY + y); }

有幾點需要注意的是

• 不論是scrollTo或scrollBy，其實都是對View的內(nèi)容進行滾動而不是對View本身，你可以做個小實驗，一個LinearLayouy背景是黃色，里面放置一個子LinearLayout背景是藍色，調(diào)用scrollTo或scrollBy，移動的永遠是藍色的子LinearLayout。
• 還有就是scrollTo和scrollBy函數(shù)的參數(shù)和坐標系是“相反的”，比如scrollTo(-100,0)，View的內(nèi)容是向X軸正方向移動的，這個相反打引號是因為并不是真正的相反，具體可以看源碼，關于這兩個函數(shù)的源碼分析大家可以看Android——源碼角度分析View的scrollBy()和scrollTo()的參數(shù)正負問題，一目了然。

View 的 width 和 height

@ViewDebug.ExportedProperty(category = "layout") public final int getHeight() {return mBottom - mTop; }

我們可以看到 Android的 height 是由 mBottom 和 mTop 共同得出的，那我們要怎樣設置Android的高度呢？有人會說直接在xml里面設置 android:height=”” 不就OK了，那我們?nèi)绻獎討B(tài)設置height的高度呢，怎么辦？你可能會想到 setWidth()方法？但是我們找遍了View的所有方法，都沒有發(fā)現(xiàn) setWidth()方法，那要怎樣動態(tài)設置height呢？其實有兩種方法

int width=50; int height=100; ViewGroup.LayoutParams layoutParams = view.getLayoutParams(); if(layoutParams==null){layoutParams=new ViewGroup.LayoutParams(width,height); }else{layoutParams.height=height; } view.setLayoutParams(layoutParams);

第二種方法，單獨地改變top或者bottom的值，這種方法不推薦使用

至于width，它跟height基本一樣，只不過它是有mRight 和mLeft 共同決定而已。

需要注意的是，平時我們在執(zhí)行動畫的過程，不推薦使用LayoutParams來改變View的狀態(tài)，因為改變LayoutParams會調(diào)用requestLayout()方法，會標記當前View及父容器，同時逐層向上提交，直到ViewRootImpl處理該事件，ViewRootImpl會調(diào)用三大流程，從measure開始，對于每一個含有標記位的view及其子View都會進行測量、布局、繪制，性能較差，源碼體現(xiàn)如下：關于requestLayout ()方法的更多分析可以查看這一篇博客Android View 深度分析requestLayout、invalidate與postInvalidate

public void setLayoutParams(ViewGroup.LayoutParams params) {if (params == null) {throw new NullPointerException("Layout parameters cannot be null");}mLayoutParams = params;resolveLayoutParams();if (mParent instanceof ViewGroup) {((ViewGroup) mParent).onSetLayoutParams(this, params);}requestLayout(); }

因此我們?nèi)绻赼pi 14 以后 ，在動畫執(zhí)行過程中，要改變View的狀態(tài)，推薦使用setTranslationY()和setTranslationX（0等方法，而 盡量避免改變LayoutParams.因為性能嫌貴來說較差。

event.getY 和 event.getRawY()

要區(qū)分于MotionEvent.getRawX() 和MotionEvent.getX();,

在public boolean onTouch(View view, MotionEvent event) 中，當你觸到控件時，x,y是相對于該控件左上點（控件本身）的相對位置。 而rawx,rawy始終是相對于屏幕的位置。getX()是表示W(wǎng)idget相對于自身左上角的x坐標,而getRawX()是表示相對于屏幕左上角的x坐標值 (注意:這個屏幕左上角是手機屏幕左上角,不管activity是否有titleBar或是否全屏幕)。

擴展，怎樣獲取狀態(tài)欄（StatusBar）和標題欄（titleBar）的高度

public void onWindowFocusChanged(boolean hasFocus) {super.onWindowFocusChanged(hasFocus);//屏幕DisplayMetrics dm = new DisplayMetrics();getWindowManager().getDefaultDisplay().getMetrics(dm);Log.e(TAG, "屏幕高:" + dm.heightPixels);//應用區(qū)域Rect outRect1 = new Rect();getWindow().getDecorView().getWindowVisibleDisplayFrame(outRect1);//這個也就是狀態(tài)欄的 高度Log.e(TAG, "應用區(qū)頂部" + outRect1.top);Log.e(TAG, "應用區(qū)高" + outRect1.height());// 這個方法必須在有actionBar的情況下才能獲取到狀態(tài)欄的高度//View繪制區(qū)域Rect outRect2 = new Rect();getWindow().findViewById(Window.ID_ANDROID_CONTENT).getDrawingRect(outRect2);Log.e(TAG, "View繪制區(qū)域頂部-錯誤方法：" + outRect2.top); //不能像上邊一樣由outRect2.top獲取，這種方式獲得的top是0，可能是bug吧Log.e(TAG, "View繪制區(qū)域高度：" + outRect2.height());int viewTop = getWindow().findViewById(Window.ID_ANDROID_CONTENT).getTop(); //要用這種方法Log.e(TAG, "View繪制區(qū)域頂部-正確方法：" + viewTop);int titleBarHeight=viewTop;Log.d(TAG, "onWindowFocusChanged: 標題欄高度titleBarHeight=" +titleBarHeight); }

這里我們需要注意的 是在ActionBar存在的情況下，通過這種方法我們才能夠得出titleBar的高度，否則是無法得到的，因為viewTop 為0.

這篇博客到此為止，關于更多自定義View 的一些例子，可以看我以下的博客

常用的自定義View例子一(FlowLayout)

自定義View常用例子二（點擊展開隱藏控件，九宮格圖片控件）

常用的自定義View例子三（MultiInterfaceView多界面處理）

常用的自定義控件四（QuickBarView）

源碼角度分析View的scrollBy()和scrollTo()的參數(shù)正負問題

原文鏈接：http://blog.csdn.net/xplee0576/article/details/24242383

為什么要寫這篇博客？

以前在使用View的scrollBy()或者scrollTo()的時候，發(fā)現(xiàn)它們的參數(shù)在正的時候是反方向移動，負的時候是正方向移動。于是就google了下，發(fā)現(xiàn)好多博客都要么是轉摘、要么是直接抄襲然后美起名曰原創(chuàng)，更惡劣的是這些博文由于是轉摘抄襲的關系，竟然都說View在scrollBy()或者scrollTo()的時候，它們的直角坐標系是相反的，這明顯是一個錯誤的觀念。
好了，廢話不多說進入正題。

Android設備平面直角坐標系

在做分析之前，首先要建立起Android設備屏幕的平面直角坐標系概念。在Android手機中，屏幕的直角坐標系概念簡單來說：
屏幕左上角為直角坐標系的原點(0,0)
從原點出發(fā)向左為X軸負方向，向右為X軸正方向
從原點出發(fā)向上為Y軸負方向，向下為Y軸正方向

上述概念可通過如下圖總結：

在Android中，我們通常說View在屏幕上的坐標，其實就是view的左上的坐標。調(diào)用View的invalidate()方法會促使View重繪。
View的scrollBy()和scrollTo()

在分析scrollBy()和scrollTo()之前，先上一段源碼片段：

/** * Set the scrolled position of your view. This will cause a call to * {@link #onScrollChanged(int, int, int, int)} and the view will be * invalidated. * @param x the x position to scroll to * @param y the y position to scroll to */ public void scrollTo(int x, int y) { if (mScrollX != x || mScrollY != y) { int oldX = mScrollX; int oldY = mScrollY; mScrollX = x; mScrollY = y; invalidateParentCaches(); onScrollChanged(mScrollX, mScrollY, oldX, oldY); if (!awakenScrollBars()) { invalidate(true); } } } /** * Move the scrolled position of your view. This will cause a call to * {@link #onScrollChanged(int, int, int, int)} and the view will be * invalidated. * @param x the amount of pixels to scroll by horizontally * @param y the amount of pixels to scroll by vertically */ public void scrollBy(int x, int y) { scrollTo(mScrollX + x, mScrollY + y); }

scrollBy()和scrollTo()的滾動不同點

scrollTo(x, y)：通過invalidate使view直接滾動到參數(shù)x和y所標定的坐標
scrollBy(x, y)：通過相對于當前坐標的滾動。從上面代碼中，很容以就能看出scrollBy()的方法體只有調(diào)用scrollTo()方法的一行代碼，scrollBy()方法先對屬性mScollX加上參數(shù)x和屬性mScrollY加上參數(shù)y，然后將上述結果作為參數(shù)傳入調(diào)用方法scrollTo()

scrollBy()和scrollTo()的參數(shù)正負影響滾動問題

scrollBy()和scrollTo()在參數(shù)為負的時候，向坐標軸正方向滾動；當參數(shù)為正的時候，向坐標軸負方向滾動。而作為我們的認知，應該是參數(shù)為負的時候，向坐標軸負方向滾動；當參數(shù)為正的時候，向坐標軸正方向滾動。
那為什么這兩個方法傳入?yún)?shù)和引起的滾動方向和我們平常的認知不同呢？
下面就讓我們帶著這個問題跟隨源碼分析。如果不想從它的執(zhí)行過程一步步的去分析，可以直接看本文的最后一段源碼。

源碼執(zhí)行過程分析

因為scrollBy(x, y)方法體只有一行，并且是調(diào)用scrollTo(x, y)，所以我們只要通過scrollTo(x, y)來進行分析就可以了。
在scrollTo(x, y)中，x和y分別被賦值給了mScrollX和mScrollY，最后調(diào)用了方法invalidate(true)。貌似到了這里就無路可走了，其實不然，我們知道invalidate這個方法會通知View進行重繪。
那么接下來，我們就可以跳過scrollTo(x, y)去分析View的draw()方法了。照例，在分析onDraw方法之前上一段源碼片段：

/** * Manually render this view (and all of its children) to the given Canvas. * The view must have already done a full layout before this function is * called. When implementing a view, implement * {@link #onDraw(android.graphics.Canvas)} instead of overriding this method. * If you do need to override this method, call the superclass version. * * @param canvas The Canvas to which the View is rendered. */ public void draw(Canvas canvas) { if (ViewDebug.TRACE_HIERARCHY) { ViewDebug.trace(this, ViewDebug.HierarchyTraceType.DRAW); } final int privateFlags = mPrivateFlags; final boolean dirtyOpaque = (privateFlags & DIRTY_MASK) == DIRTY_OPAQUE && (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState); mPrivateFlags = (privateFlags & ~DIRTY_MASK) | DRAWN; /* * Draw traversal performs several drawing steps which must be executed * in the appropriate order: * * 1. Draw the background * 2. If necessary, save the canvas' layers to prepare for fading * 3. Draw view's content * 4. Draw children * 5. If necessary, draw the fading edges and restore layers * 6. Draw decorations (scrollbars for instance) */ // Step 1, draw the background, if needed int saveCount; if (!dirtyOpaque) { final Drawable background = mBGDrawable; if (background != null) { final int scrollX = mScrollX; final int scrollY = mScrollY; if (mBackgroundSizeChanged) { background.setBounds(0, 0, mRight - mLeft, mBottom - mTop); mBackgroundSizeChanged = false; } if ((scrollX | scrollY) == 0) { background.draw(canvas); } else { canvas.translate(scrollX, scrollY); background.draw(canvas); canvas.translate(-scrollX, -scrollY); } } } // skip step 2 & 5 if possible (common case) final int viewFlags = mViewFlags; boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0; boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0; if (!verticalEdges && !horizontalEdges) { // Step 3, draw the content if (!dirtyOpaque) onDraw(canvas); // Step 4, draw the children dispatchDraw(canvas); // Step 6, draw decorations (scrollbars) onDrawScrollBars(canvas); // we're done... return; } /* * Here we do the full fledged routine... * (this is an uncommon case where speed matters less, * this is why we repeat some of the tests that have been * done above) */ boolean drawTop = false; boolean drawBottom = false; boolean drawLeft = false; boolean drawRight = false; float topFadeStrength = 0.0f; float bottomFadeStrength = 0.0f; float leftFadeStrength = 0.0f; float rightFadeStrength = 0.0f; // Step 2, save the canvas' layers int paddingLeft = mPaddingLeft; final boolean offsetRequired = isPaddingOffsetRequired(); if (offsetRequired) { paddingLeft += getLeftPaddingOffset(); } int left = mScrollX + paddingLeft; int right = left + mRight - mLeft - mPaddingRight - paddingLeft; int top = mScrollY + getFadeTop(offsetRequired); int bottom = top + getFadeHeight(offsetRequired); if (offsetRequired) { right += getRightPaddingOffset(); bottom += getBottomPaddingOffset(); } final ScrollabilityCache scrollabilityCache = mScrollCache; final float fadeHeight = scrollabilityCache.fadingEdgeLength; int length = (int) fadeHeight; // clip the fade length if top and bottom fades overlap // overlapping fades produce odd-looking artifacts if (verticalEdges && (top + length > bottom - length)) { length = (bottom - top) / 2; } // also clip horizontal fades if necessary if (horizontalEdges && (left + length > right - length)) { length = (right - left) / 2; } if (verticalEdges) { topFadeStrength = Math.max(0.0f, Math.min(1.0f, getTopFadingEdgeStrength())); drawTop = topFadeStrength * fadeHeight > 1.0f; bottomFadeStrength = Math.max(0.0f, Math.min(1.0f, getBottomFadingEdgeStrength())); drawBottom = bottomFadeStrength * fadeHeight > 1.0f; } if (horizontalEdges) { leftFadeStrength = Math.max(0.0f, Math.min(1.0f, getLeftFadingEdgeStrength())); drawLeft = leftFadeStrength * fadeHeight > 1.0f; rightFadeStrength = Math.max(0.0f, Math.min(1.0f, getRightFadingEdgeStrength())); drawRight = rightFadeStrength * fadeHeight > 1.0f; } saveCount = canvas.getSaveCount(); int solidColor = getSolidColor(); if (solidColor == 0) { final int flags = Canvas.HAS_ALPHA_LAYER_SAVE_FLAG; if (drawTop) { canvas.saveLayer(left, top, right, top + length, null, flags); } if (drawBottom) { canvas.saveLayer(left, bottom - length, right, bottom, null, flags); } if (drawLeft) { canvas.saveLayer(left, top, left + length, bottom, null, flags); } if (drawRight) { canvas.saveLayer(right - length, top, right, bottom, null, flags); } } else { scrollabilityCache.setFadeColor(solidColor); } // Step 3, draw the content if (!dirtyOpaque) onDraw(canvas); // Step 4, draw the children dispatchDraw(canvas); // Step 5, draw the fade effect and restore layers final Paint p = scrollabilityCache.paint; final Matrix matrix = scrollabilityCache.matrix; final Shader fade = scrollabilityCache.shader; if (drawTop) { matrix.setScale(1, fadeHeight * topFadeStrength); matrix.postTranslate(left, top); fade.setLocalMatrix(matrix); canvas.drawRect(left, top, right, top + length, p); } if (drawBottom) { matrix.setScale(1, fadeHeight * bottomFadeStrength); matrix.postRotate(180); matrix.postTranslate(left, bottom); fade.setLocalMatrix(matrix); canvas.drawRect(left, bottom - length, right, bottom, p); } if (drawLeft) { matrix.setScale(1, fadeHeight * leftFadeStrength); matrix.postRotate(-90); matrix.postTranslate(left, top); fade.setLocalMatrix(matrix); canvas.drawRect(left, top, left + length, bottom, p); } if (drawRight) { matrix.setScale(1, fadeHeight * rightFadeStrength); matrix.postRotate(90); matrix.postTranslate(right, top); fade.setLocalMatrix(matrix); canvas.drawRect(right - length, top, right, bottom, p); } canvas.restoreToCount(saveCount); // Step 6, draw decorations (scrollbars) onDrawScrollBars(canvas); }

在這段代碼片中，我們直接定位到onDrawScrollBars(canvas)方法，找到了這個方法離真相就不遠了。上源碼：

/** * <p>Request the drawing of the horizontal and the vertical scrollbar. The * scrollbars are painted only if they have been awakened first.</p> * * @param canvas the canvas on which to draw the scrollbars * * @see #awakenScrollBars(int) */ protected final void onDrawScrollBars(Canvas canvas) { // scrollbars are drawn only when the animation is running final ScrollabilityCache cache = mScrollCache; if (cache != null) { int state = cache.state; if (state == ScrollabilityCache.OFF) { return; } boolean invalidate = false; if (state == ScrollabilityCache.FADING) { // We're fading -- get our fade interpolation if (cache.interpolatorValues == null) { cache.interpolatorValues = new float[1]; } float[] values = cache.interpolatorValues; // Stops the animation if we're done if (cache.scrollBarInterpolator.timeToValues(values) == Interpolator.Result.FREEZE_END) { cache.state = ScrollabilityCache.OFF; } else { cache.scrollBar.setAlpha(Math.round(values[0])); } // This will make the scroll bars inval themselves after // drawing. We only want this when we're fading so that // we prevent excessive redraws invalidate = true; } else { // We're just on -- but we may have been fading before so // reset alpha cache.scrollBar.setAlpha(255); } final int viewFlags = mViewFlags; final boolean drawHorizontalScrollBar = (viewFlags & SCROLLBARS_HORIZONTAL) == SCROLLBARS_HORIZONTAL; final boolean drawVerticalScrollBar = (viewFlags & SCROLLBARS_VERTICAL) == SCROLLBARS_VERTICAL && !isVerticalScrollBarHidden(); if (drawVerticalScrollBar || drawHorizontalScrollBar) { final int width = mRight - mLeft; final int height = mBottom - mTop; final ScrollBarDrawable scrollBar = cache.scrollBar; final int scrollX = mScrollX; final int scrollY = mScrollY; final int inside = (viewFlags & SCROLLBARS_OUTSIDE_MASK) == 0 ? ~0 : 0; int left, top, right, bottom; if (drawHorizontalScrollBar) { int size = scrollBar.getSize(false); if (size <= 0) { size = cache.scrollBarSize; } scrollBar.setParameters(computeHorizontalScrollRange(), computeHorizontalScrollOffset(), computeHorizontalScrollExtent(), false); final int verticalScrollBarGap = drawVerticalScrollBar ? getVerticalScrollbarWidth() : 0; top = scrollY + height - size - (mUserPaddingBottom & inside); left = scrollX + (mPaddingLeft & inside); right = scrollX + width - (mUserPaddingRight & inside) - verticalScrollBarGap; bottom = top + size; onDrawHorizontalScrollBar(canvas, scrollBar, left, top, right, bottom); if (invalidate) { invalidate(left, top, right, bottom); } } if (drawVerticalScrollBar) { int size = scrollBar.getSize(true); if (size <= 0) { size = cache.scrollBarSize; } scrollBar.setParameters(computeVerticalScrollRange(), computeVerticalScrollOffset(), computeVerticalScrollExtent(), true); switch (mVerticalScrollbarPosition) { default: case SCROLLBAR_POSITION_DEFAULT: case SCROLLBAR_POSITION_RIGHT: left = scrollX + width - size - (mUserPaddingRight & inside); break; case SCROLLBAR_POSITION_LEFT: left = scrollX + (mUserPaddingLeft & inside); break; } top = scrollY + (mPaddingTop & inside); right = left + size; bottom = scrollY + height - (mUserPaddingBottom & inside); onDrawVerticalScrollBar(canvas, scrollBar, left, top, right, bottom); if (invalidate) { invalidate(left, top, right, bottom); } } } } }

上述代碼，我們直接定位到if (drawVerticalScrollBar || drawHorizontalScrollBar)結構語句塊。在水平方向滾動與垂直方向滾動語句塊中，能夠找到一行關鍵性代碼invalidate(left, top, right, bottom)，接著上源碼：

/** * Mark the area defined by the rect (l,t,r,b) as needing to be drawn. * The coordinates of the dirty rect are relative to the view. * If the view is visible, {@link #onDraw(android.graphics.Canvas)} * will be called at some point in the future. This must be called from * a UI thread. To call from a non-UI thread, call {@link #postInvalidate()}. * @param l the left position of the dirty region * @param t the top position of the dirty region * @param r the right position of the dirty region * @param b the bottom position of the dirty region */ public void invalidate(int l, int t, int r, int b) { if (ViewDebug.TRACE_HIERARCHY) { ViewDebug.trace(this, ViewDebug.HierarchyTraceType.INVALIDATE); } if (skipInvalidate()) { return; } if ((mPrivateFlags & (DRAWN | HAS_BOUNDS)) == (DRAWN | HAS_BOUNDS) || (mPrivateFlags & DRAWING_CACHE_VALID) == DRAWING_CACHE_VALID || (mPrivateFlags & INVALIDATED) != INVALIDATED) { mPrivateFlags &= ~DRAWING_CACHE_VALID; mPrivateFlags |= INVALIDATED; mPrivateFlags |= DIRTY; final ViewParent p = mParent; final AttachInfo ai = mAttachInfo; //noinspection PointlessBooleanExpression,ConstantConditions if (!HardwareRenderer.RENDER_DIRTY_REGIONS) { if (p != null && ai != null && ai.mHardwareAccelerated) { // fast-track for GL-enabled applications; just invalidate the whole hierarchy // with a null dirty rect, which tells the ViewAncestor to redraw everything p.invalidateChild(this, null); return; } } if (p != null && ai != null && l < r && t < b) { final int scrollX = mScrollX; final int scrollY = mScrollY; final Rect tmpr = ai.mTmpInvalRect; tmpr.set(l - scrollX, t - scrollY, r - scrollX, b - scrollY); p.invalidateChild(this, tmpr); } } }

invalidate(left, top, right, bottom)方法體中，倒數(shù)第5行tmpr.set(l - scrollX, t - scrollY, r - scrollX, b - scrollY)設置一個view需要繪制的臟矩形，這個方法的傳入?yún)?shù)不覺得很奇怪嗎？
mScrollX和mScrollY都是作為參數(shù)的減數(shù)（負負得正，負正得負），再結合開頭的Android屏幕直角坐標系的概念，通過簡單的邏輯分析或者計算就可以證明：當scrollTo()的傳入?yún)?shù)為負的時候，view就向坐標軸正方向滾動；當為正的時候，view就向坐標軸負方向滾動。

總結

以上是生活随笔為你收集整理的Android应用坐标系统全面详解的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。