Android çerçevesi, Activity odaklandığında Activity'ten düzenini çizmesini ister. Android çerçevesi, çizim işlemini yönetir ancak Activity, düzen hiyerarşisinin kök düğümünü sağlamalıdır.
Android çerçevesi, düzenin kök düğümünü çizer ve düzen ağacını ölçer ve çizer. Ağacı dolaşarak ve geçersiz bölgeyle kesişen her View öğesini oluşturarak çizer.
Her ViewGroup, tüm alt öğelerinin draw() yöntemi kullanılarak çizilmesini talep etmekten sorumludur ve her View kendisinin çiziminden sorumludur. Ağaçta ön sipariş yöntemi geçildiğinden çerçeve, ebeveynleri çocuklarından önce (yani arkadan) çeker ve kardeşleri ağaçta göründükleri sırayla çeker.
Android çerçevesi, düzeni iki geçişli bir süreçte çizer: ölçüm geçişi ve düzen geçişi. Çerçeve, measure(int, int) içindeki ölçüm geçişini gerçekleştirir ve View ağacında yukarıdan aşağıya geçiş gerçekleştirir. Her View, yineleme sırasında boyut özelliklerini ağacın aşağısına aktarır. Ölçüm geçişinin sonunda her View, ölçümlerini depolar. Çerçeve, ikinci geçişi layout(int, int, int, int)
yapıyor ve bu da yukarıdan aşağıya doğrudur. Bu geçiş sırasında her üst öğe, ölçüm geçişinde hesaplanan boyutları kullanarak tüm alt öğelerini konumlandırmaktan sorumludur.
Sayfa düzeni sürecinin iki geçişi aşağıdaki bölümlerde daha ayrıntılı olarak açıklanmıştır.
Ölçüm kartı başlatın
Bir View nesnesinin measure() yöntemi döndürüldüğünde, View nesnesinin tüm alt öğeleri ile birlikte getMeasuredWidth() ve getMeasuredHeight() değerlerini ayarlayın. View nesnelerinin ölçülen genişlik ve yükseklik değerleri, View nesnesinin üst öğeleri tarafından uygulanan kısıtlamalara uymalıdır. Bu sayede, ölçüm geçişinin sonunda tüm ebeveynler çocuklarının tüm ölçümlerini kabul eder.
View adlı ebeveyn, alt kuruluşlarında measure() adlı kişiyi birden fazla kez arayabilir. Örneğin, ebeveynler çocuklarının tercih ettikleri boyutları belirlemek için onları bir kez ölçüp boyutları belirtmeyebilir. Alt öğelerin sınırsız boyutlarının toplamı çok büyük veya çok küçükse üst öğe, alt öğelerin boyutlarını kısıtlayan değerlerle measure() işlevini tekrar çağırabilir.
Ölçüm aktarımı, boyutları iletmek için iki sınıf kullanır. ViewGroup.LayoutParams sınıfı, View nesnelerinin tercih ettikleri boyutları ve konumları nasıl ilettiğini belirtir. Temel ViewGroup.LayoutParams sınıfı, View öğesinin tercih edilen genişliğini ve yüksekliğini tanımlar. Her boyut için aşağıdakilerden birini belirtebilir:
- Tam boyut.
MATCH_PARENT, diğer bir deyişleViewiçin tercih edilen boyut, üst öğenin boyutudur ve dolgu çıkarılarak hesaplanır.WRAP_CONTENT,Viewiçin tercih edilen boyutun, içeriğini ve dolguyu kapsayacak kadar büyük olduğu anlamına gelir.
ViewGroup'un farklı alt sınıfları için ViewGroup.LayoutParams alt sınıfları vardır. Örneğin, RelativeLayout, alt View nesneleri yatay ve dikey olarak ortalayabilen kendi ViewGroup.LayoutParams alt sınıfına sahiptir.
MeasureSpec nesneleri, ağaçta üst öğeden alt öğeye gereksinimleri iletmek için kullanılır. MeasureSpec, üç moddan
birinde olabilir:
UNSPECIFIED: Üst öğe, bunu bir altViewöğesinin hedef boyutunu belirlemek için kullanır. Örneğin, birLinearLayout, 240 piksellik alt öğede yüksekliğiUNSPECIFIEDve genişliğiEXACTLY240 olarak ayarlanmış alt öğesi içinmeasure()öğesini çağırabilir.ViewEXACTLY: Ebeveyn, çocuğa tam bir beden eklemek için bunu kullanır. Alt öğe bu boyutu kullanmalıdır ve tüm alt öğelerinin bu boyuta sığmasını sağlamalıdır.AT MOST: üst öğe, alt öğeye maksimum boyutu empoze etmek için bunu kullanır. Alt öğe, kendisinin ve tüm alt öğelerinin bu boyuta uyacağını garanti etmelidir.
Düzen geçişi başlatma
Bir düzen başlatmak için requestLayout() düğmesine basın. Bu yöntem, artık kendi sınırlarına sığmadığını düşündüğünde genellikle kendi üzerinde View tarafından çağrılır.
Özel ölçüm ve düzen mantığı uygulama
Özel bir ölçüm veya düzen mantığı uygulamak istiyorsanız mantığın uygulandığı yöntemleri geçersiz kılın:
onMeasure(int, int)
ve
onLayout(boolean, int, int, int, int).
Bu yöntemler sırasıyla measure(int, int) ve layout(int, int, int, int) tarafından çağrılır. measure(int, int) veya layout(int, int) yöntemlerini geçersiz kılmaya çalışmayın. Bu yöntemlerin ikisi de final olduğundan geçersiz kılınamaz.
Aşağıdaki örnekte, WindowManager örnek uygulamasındaki `SplitLayout` sınıfında bunun nasıl yapılacağı gösterilmektedir. SplitLayout'in iki veya daha fazla alt görünümü varsa ve ekranda kat varsa iki alt görünüm, katlamanın iki tarafına yerleştirilir. Aşağıdaki örnekte, ölçümü ve düzeni geçersiz kılmanın kullanım alanı gösterilmektedir. Ancak üretim için bu davranışı istiyorsanız SlidingPaneLayout değerini kullanın.
Kotlin
/**
* An example of split-layout for two views, separated by a display
* feature that goes across the window. When both start and end views are
* added, it checks whether there are display features that separate the area
* in two—such as a fold or hinge—and places them side-by-side or
* top-bottom.
*/
class SplitLayout : FrameLayout {
private var windowLayoutInfo: WindowLayoutInfo? = null
private var startViewId = 0
private var endViewId = 0
private var lastWidthMeasureSpec: Int = 0
private var lastHeightMeasureSpec: Int = 0
...
fun updateWindowLayout(windowLayoutInfo: WindowLayoutInfo) {
this.windowLayoutInfo = windowLayoutInfo
requestLayout()
}
override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
val startView = findStartView()
val endView = findEndView()
val splitPositions = splitViewPositions(startView, endView)
if (startView != null && endView != null && splitPositions != null) {
val startPosition = splitPositions[0]
val startWidthSpec = MeasureSpec.makeMeasureSpec(startPosition.width(), EXACTLY)
val startHeightSpec = MeasureSpec.makeMeasureSpec(startPosition.height(), EXACTLY)
startView.measure(startWidthSpec, startHeightSpec)
startView.layout(
startPosition.left, startPosition.top, startPosition.right,
startPosition.bottom
)
val endPosition = splitPositions[1]
val endWidthSpec = MeasureSpec.makeMeasureSpec(endPosition.width(), EXACTLY)
val endHeightSpec = MeasureSpec.makeMeasureSpec(endPosition.height(), EXACTLY)
endView.measure(endWidthSpec, endHeightSpec)
endView.layout(
endPosition.left, endPosition.top, endPosition.right,
endPosition.bottom
)
} else {
super.onLayout(changed, left, top, right, bottom)
}
}
/**
* Gets the position of the split for this view.
* @return A rect that defines of split, or {@code null} if there is no split.
*/
private fun splitViewPositions(startView: View?, endView: View?): Array? {
if (windowLayoutInfo == null || startView == null || endView == null) {
return null
}
// Calculate the area for view's content with padding.
val paddedWidth = width - paddingLeft - paddingRight
val paddedHeight = height - paddingTop - paddingBottom
windowLayoutInfo?.displayFeatures
?.firstOrNull { feature -> isValidFoldFeature(feature) }
?.let { feature ->
getFeaturePositionInViewRect(feature, this)?.let {
if (feature.bounds.left == 0) { // Horizontal layout.
val topRect = Rect(
paddingLeft, paddingTop,
paddingLeft + paddedWidth, it.top
)
val bottomRect = Rect(
paddingLeft, it.bottom,
paddingLeft + paddedWidth, paddingTop + paddedHeight
)
if (measureAndCheckMinSize(topRect, startView) &&
measureAndCheckMinSize(bottomRect, endView)
) {
return arrayOf(topRect, bottomRect)
}
} else if (feature.bounds.top == 0) { // Vertical layout.
val leftRect = Rect(
paddingLeft, paddingTop,
it.left, paddingTop + paddedHeight
)
val rightRect = Rect(
it.right, paddingTop,
paddingLeft + paddedWidth, paddingTop + paddedHeight
)
if (measureAndCheckMinSize(leftRect, startView) &&
measureAndCheckMinSize(rightRect, endView)
) {
return arrayOf(leftRect, rightRect)
}
}
}
}
// You previously tried to fit the children and measure them. Since they
// don't fit, measure again to update the stored values.
measure(lastWidthMeasureSpec, lastHeightMeasureSpec)
return null
}
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec)
lastWidthMeasureSpec = widthMeasureSpec
lastHeightMeasureSpec = heightMeasureSpec
}
/**
* Measures a child view and sees if it fits in the provided rect.
* This method calls [View.measure] on the child view, which updates its
* stored values for measured width and height. If the view ends up with
* different values, measure again.
*/
private fun measureAndCheckMinSize(rect: Rect, childView: View): Boolean {
val widthSpec = MeasureSpec.makeMeasureSpec(rect.width(), AT_MOST)
val heightSpec = MeasureSpec.makeMeasureSpec(rect.height(), AT_MOST)
childView.measure(widthSpec, heightSpec)
return childView.measuredWidthAndState and MEASURED_STATE_TOO_SMALL == 0 &&
childView.measuredHeightAndState and MEASURED_STATE_TOO_SMALL == 0
}
private fun isValidFoldFeature(displayFeature: DisplayFeature) =
(displayFeature as? FoldingFeature)?.let { feature ->
getFeaturePositionInViewRect(feature, this) != null
} ?: false
}
Java
/**
* An example of split-layout for two views, separated by a display feature
* that goes across the window. When both start and end views are added, it checks
* whether there are display features that separate the area in two—such as
* fold or hinge—and places them side-by-side or top-bottom.
*/
public class SplitLayout extends FrameLayout {
@Nullable
private WindowLayoutInfo windowLayoutInfo = null;
private int startViewId = 0;
private int endViewId = 0;
private int lastWidthMeasureSpec = 0;
private int lastHeightMeasureSpec = 0;
...
void updateWindowLayout(WindowLayoutInfo windowLayoutInfo) {
this.windowLayoutInfo = windowLayoutInfo;
requestLayout();
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
@Nullable
View startView = findStartView();
@Nullable
View endView = findEndView();
@Nullable
List splitPositions = splitViewPositions(startView, endView);
if (startView != null && endView != null && splitPositions != null) {
Rect startPosition = splitPositions.get(0);
int startWidthSpec = MeasureSpec.makeMeasureSpec(startPosition.width(), EXACTLY);
int startHeightSpec = MeasureSpec.makeMeasureSpec(startPosition.height(), EXACTLY);
startView.measure(startWidthSpec, startHeightSpec);
startView.layout(
startPosition.left,
startPosition.top,
startPosition.right,
startPosition.bottom
);
Rect endPosition = splitPositions.get(1);
int endWidthSpec = MeasureSpec.makeMeasureSpec(endPosition.width(), EXACTLY);
int endHeightSpec = MeasureSpec.makeMeasureSpec(endPosition.height(), EXACTLY);
startView.measure(endWidthSpec, endHeightSpec);
startView.layout(
endPosition.left,
endPosition.top,
endPosition.right,
endPosition.bottom
);
} else {
super.onLayout(changed, left, top, right, bottom);
}
}
/**
* Gets the position of the split for this view.
* @return A rect that defines of split, or {@code null} if there is no split.
*/
@Nullable
private List splitViewPositions(@Nullable View startView, @Nullable View endView) {
if (windowLayoutInfo == null || startView == null || endView == null) {
return null;
}
int paddedWidth = getWidth() - getPaddingLeft() - getPaddingRight();
int paddedHeight = getHeight() - getPaddingTop() - getPaddingBottom();
List displayFeatures = windowLayoutInfo.getDisplayFeatures();
@Nullable
DisplayFeature feature = displayFeatures
.stream()
.filter(item ->
isValidFoldFeature(item)
)
.findFirst()
.orElse(null);
if (feature != null) {
Rect position = SampleToolsKt.getFeaturePositionInViewRect(feature, this, true);
Rect featureBounds = feature.getBounds();
if (featureBounds.left == 0) { // Horizontal layout.
Rect topRect = new Rect(
getPaddingLeft(),
getPaddingTop(),
getPaddingLeft() + paddedWidth,
position.top
);
Rect bottomRect = new Rect(
getPaddingLeft(),
position.bottom,
getPaddingLeft() + paddedWidth,
getPaddingTop() + paddedHeight
);
if (measureAndCheckMinSize(topRect, startView) &&
measureAndCheckMinSize(bottomRect, endView)) {
ArrayList rects = new ArrayList();
rects.add(topRect);
rects.add(bottomRect);
return rects;
}
} else if (featureBounds.top == 0) { // Vertical layout.
Rect leftRect = new Rect(
getPaddingLeft(),
getPaddingTop(),
position.left,
getPaddingTop() + paddedHeight
);
Rect rightRect = new Rect(
position.right,
getPaddingTop(),
getPaddingLeft() + paddedWidth,
getPaddingTop() + paddedHeight
);
if (measureAndCheckMinSize(leftRect, startView) &&
measureAndCheckMinSize(rightRect, endView)) {
ArrayList rects = new ArrayList();
rects.add(leftRect);
rects.add(rightRect);
return rects;
}
}
}
// You previously tried to fit the children and measure them. Since
// they don't fit, measure again to update the stored values.
measure(lastWidthMeasureSpec, lastHeightMeasureSpec);
return null;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
lastWidthMeasureSpec = widthMeasureSpec;
lastHeightMeasureSpec = heightMeasureSpec;
}
/**
* Measures a child view and sees if it fits in the provided rect.
* This method calls [View.measure] on the child view, which updates
* its stored values for measured width and height. If the view ends up with
* different values, measure again.
*/
private boolean measureAndCheckMinSize(Rect rect, View childView) {
int widthSpec = MeasureSpec.makeMeasureSpec(rect.width(), AT_MOST);
int heightSpec = MeasureSpec.makeMeasureSpec(rect.height(), AT_MOST);
childView.measure(widthSpec, heightSpec);
return (childView.getMeasuredWidthAndState() & MEASURED_STATE_TOO_SMALL) == 0 &&
(childView.getMeasuredHeightAndState() & MEASURED_STATE_TOO_SMALL) == 0;
}
private boolean isValidFoldFeature(DisplayFeature displayFeature) {
if (displayFeature instanceof FoldingFeature) {
return SampleToolsKt.getFeaturePositionInViewRect(displayFeature, this, true) != null;
} else {
return false;
}
}
}