অ্যান্ড্রয়েড কীভাবে ভিউ আঁকে

যখন Activity ফোকাস পায় তখন অ্যান্ড্রয়েড ফ্রেমওয়ার্ক একটি Activity তার লেআউট আঁকতে বলে। অ্যান্ড্রয়েড ফ্রেমওয়ার্ক অঙ্কন করার পদ্ধতি পরিচালনা করে, কিন্তু Activity অবশ্যই এর লেআউট শ্রেণিবিন্যাসের রুট নোড প্রদান করবে।

অ্যান্ড্রয়েড ফ্রেমওয়ার্ক লেআউটের রুট নোড আঁকে এবং লেআউট ট্রি পরিমাপ করে এবং আঁকে। এটি গাছে হেঁটে এবং অবৈধ অঞ্চলকে ছেদ করে এমন প্রতিটি View রেন্ডার করে আঁকা হয়। প্রতিটি ViewGroup তাদের প্রতিটি শিশুকে draw() পদ্ধতি ব্যবহার করে আঁকার অনুরোধ করার জন্য দায়ী এবং প্রতিটি View নিজেই অঙ্কন করার জন্য দায়ী। যেহেতু গাছটি প্রি-অর্ডার অতিক্রম করেছে, ফ্রেমওয়ার্কটি পিতামাতাদের আগে-অন্য কথায়, তাদের সন্তানদের পিছনে টানে, এবং এটি ভাইবোনদের সেই ক্রমে আঁকে যে তারা গাছে প্রদর্শিত হয়।

দ্রষ্টব্য: ফ্রেমওয়ার্কটি এমন বস্তু View না যেগুলি একটি বৈধ অঞ্চলে নেই। এটি আপনার জন্য View ব্যাকগ্রাউন্ড আঁকারও যত্ন নেয়। আপনি invalidate() কল করে একটি View আঁকতে বাধ্য করতে পারেন।

অ্যান্ড্রয়েড ফ্রেমওয়ার্ক একটি দুই-পাস প্রক্রিয়ায় লেআউটটি আঁকে: একটি পরিমাপ পাস এবং একটি লেআউট পাস। ফ্রেমওয়ার্ক পরিমাপ পাস measure(int, int) এবং View ট্রির একটি টপ-ডাউন ট্রাভার্সাল করে। প্রতিটি View রিকারশনের সময় ডাইমেনশন স্পেসিফিকেশনকে গাছের নিচে ঠেলে দেয়। পরিমাপ পাসের শেষে, প্রতিটি View তার পরিমাপ সংরক্ষণ করে। ফ্রেমওয়ার্কটি layout(int, int, int, int) দ্বিতীয় পাসটি সম্পাদন করে এবং এটিও টপ-ডাউন। এই পাসের সময়, প্রতিটি অভিভাবক পরিমাপ পাসে গণনা করা মাপ ব্যবহার করে তার সমস্ত সন্তানের অবস্থান নির্ধারণের জন্য দায়ী।

লেআউট প্রক্রিয়ার দুটি পাস নিম্নলিখিত বিভাগে আরও বিশদে বর্ণনা করা হয়েছে।

একটি পরিমাপ পাস শুরু করুন

যখন একটি View অবজেক্টের measure() পদ্ধতি ফিরে আসে, তখন এটির getMeasuredWidth() এবং getMeasuredHeight() মানগুলি সেট করুন, সেই সাথে সমস্ত View অবজেক্টের বংশধরের জন্য। একটি View অবজেক্টের পরিমাপ করা প্রস্থ এবং পরিমাপ করা উচ্চতার মানগুলিকে অবশ্যই View অবজেক্টের পিতামাতার দ্বারা আরোপিত সীমাবদ্ধতাকে সম্মান করতে হবে। এটি নিশ্চিত করতে সাহায্য করে যে পরিমাপ পাসের শেষে, সমস্ত পিতামাতা তাদের সন্তানের সমস্ত পরিমাপ গ্রহণ করে।

একটি অভিভাবক View তার সন্তানদের উপর একাধিকবার measure() কল করতে পারে। উদাহরণস্বরূপ, অভিভাবক তাদের পছন্দের মাপ নির্ধারণ করতে একবার অনির্দিষ্ট মাত্রা সহ বাচ্চাদের পরিমাপ করতে পারেন। যদি বাচ্চাদের অনিয়ন্ত্রিত আকারের যোগফল খুব বড় বা খুব ছোট হয়, তাহলে অভিভাবক আবার measure() কল করতে পারেন যে মানগুলি শিশুদের আকারকে সীমাবদ্ধ করে।

পরিমাপ পাস মাত্রা যোগাযোগের জন্য দুটি শ্রেণী ব্যবহার করে। ViewGroup.LayoutParams ক্লাস হল View অবজেক্ট কীভাবে তাদের পছন্দের মাপ এবং অবস্থানের সাথে যোগাযোগ করে। বেস ViewGroup.LayoutParams ক্লাসটি View পছন্দের প্রস্থ এবং উচ্চতা বর্ণনা করে। প্রতিটি মাত্রার জন্য, এটি নিম্নলিখিতগুলির মধ্যে একটি নির্দিষ্ট করতে পারে:

• একটি সঠিক মাত্রা।
• MATCH_PARENT , মানে View এর জন্য পছন্দের মাপ হল এর প্যারেন্টের সাইজ, বিয়োগ প্যাডিং।
• WRAP_CONTENT , যার অর্থ View এর জন্য পছন্দসই আকারটি এর বিষয়বস্তু এবং প্যাডিংকে আবদ্ধ করার জন্য যথেষ্ট বড়।

ViewGroup এর বিভিন্ন সাবক্লাসের জন্য ViewGroup.LayoutParams এর সাবক্লাস রয়েছে। উদাহরণ স্বরূপ, RelativeLayout এর নিজস্ব ViewGroup.LayoutParams এর একটি সাবক্লাস রয়েছে যাতে শিশুকে অনুভূমিকভাবে এবং উল্লম্বভাবে বস্তুগুলিকে View করার ক্ষমতা অন্তর্ভুক্ত করে।

MeasureSpec অবজেক্টগুলি পিতামাতা থেকে শিশু পর্যন্ত প্রয়োজনীয়তাগুলিকে বৃক্ষের নিচে ঠেলে দিতে ব্যবহৃত হয়। একটি MeasureSpec তিনটি মোডের একটিতে হতে পারে:

• UNSPECIFIED : পিতামাতা এটি ব্যবহার করে একটি শিশু View লক্ষ্য মাত্রা নির্ধারণ করতে। উদাহরণস্বরূপ, 240 পিক্সেল প্রস্থে চাইল্ড View কতটা লম্বা হতে চায় তা খুঁজে বের করতে একটি LinearLayout তার চাইল্ডের উচ্চতা UNSPECIFIED ধার্য করে এবং EXACTLY 240 এর প্রস্থের সাথে measure() কল করতে পারে।
• EXACTLY : পিতামাতা সন্তানের উপর একটি সঠিক আকার আরোপ করতে এটি ব্যবহার করেন। শিশুটিকে অবশ্যই এই আকারটি ব্যবহার করতে হবে এবং গ্যারান্টি দিতে হবে যে তার সমস্ত বংশধর এই আকারের মধ্যে মাপসই হবে৷
• AT MOST : পিতামাতা সন্তানের উপর সর্বাধিক আকার চাপানোর জন্য এটি ব্যবহার করেন। শিশুটিকে অবশ্যই গ্যারান্টি দিতে হবে যে এটি এবং তার সমস্ত বংশধর এই আকারের মধ্যে মাপসই।

একটি লেআউট পাস শুরু করুন

একটি লেআউট শুরু করতে, requestLayout() কল করুন। এই পদ্ধতিটিকে সাধারণত একটি View দ্বারা বলা হয় যখন এটি বিশ্বাস করে যে এটি আর তার সীমার মধ্যে ফিট করতে পারে না।

একটি কাস্টম পরিমাপ এবং লেআউট যুক্তি প্রয়োগ করুন

আপনি যদি একটি কাস্টম পরিমাপ বা লেআউট যুক্তি প্রয়োগ করতে চান, যেখানে যুক্তি প্রয়োগ করা হয় সেগুলিকে ওভাররাইড করুন: onMeasure(int, int) এবং onLayout(boolean, int, int, int, int) এই পদ্ধতিগুলিকে যথাক্রমে measure(int, int) এবং layout(int, int, int, int) দ্বারা বলা হয়। measure(int, int) বা layout(int, int) পদ্ধতিগুলিকে ওভাররাইড করার চেষ্টা করবেন না—এই উভয় পদ্ধতিই final , তাই সেগুলি ওভাররাইড করা যাবে না।

নিচের উদাহরণটি উইন্ডো ম্যানেজার নমুনা অ্যাপ থেকে `SplitLayout` ক্লাসে কীভাবে এটি করতে হয় তা দেখায়। যদি SplitLayout দুই বা ততোধিক চাইল্ড ভিউ থাকে এবং ডিসপ্লেতে একটি ভাঁজ থাকে, তাহলে এটি ভাঁজের উভয় পাশে দুটি চাইল্ড ভিউকে অবস্থান করে। নিম্নলিখিত উদাহরণটি পরিমাপ এবং বিন্যাস ওভাররাইড করার জন্য একটি ব্যবহারের ক্ষেত্রে দেখায়, তবে উত্পাদনের জন্য, আপনি যদি এই আচরণটি চান তবে SlidingPaneLayout ব্যবহার করুন৷

কোটলিন

/**
 * 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
}

জাভা

/**
* 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;
      }
   }
}