Có trong Android 9 (API cấp 28) trở lên, tiện ích phóng to là một
kính lúp ảo cho thấy bản sao phóng to của View thông qua một
ngăn lớp phủ thể hiện ống kính. Tính năng này cải thiện tính năng chèn văn bản
và lựa chọn trải nghiệm người dùng. Khi áp dụng trình phóng to cho văn bản, người dùng có thể
định vị chính xác con trỏ hoặc các ô điều khiển lựa chọn bằng cách xem phóng to
trong ngăn theo dõi ngón tay của họ.
Hình 1 cho thấy cách kính lúp hỗ trợ việc chọn văn bản. API trình phóng to
không gắn liền với văn bản và bạn có thể sử dụng tiện ích này trong nhiều trường hợp sử dụng, chẳng hạn như
như đọc văn bản nhỏ hoặc phóng to tên địa điểm khó nhìn thấy trên bản đồ.
Hình 1. Đang phóng to văn bản. Khi người dùng kéo lựa chọn phù hợp
ô điều khiển, trình phóng to sẽ bật lên để giúp xác định vị trí chính xác.
Trình phóng to đã được tích hợp với các tiện ích nền tảng như TextView,
EditText và WebView. Giúp thao tác văn bản nhất quán trên các ứng dụng.
Tiện ích này đi kèm một API đơn giản và có thể dùng để phóng to bất kỳ View nào
tuỳ thuộc vào ngữ cảnh của ứng dụng.
Sử dụng API
Bạn có thể dùng trình phóng to theo phương thức lập trình ở chế độ xem tuỳ ý như sau:
Giả sử hệ phân cấp chế độ xem có bố cục đầu tiên, trình phóng to sẽ hiển thị trên
màn hình chứa một khu vực tập trung vào toạ độ đã cho trong khung hiển thị.
Ngăn này xuất hiện phía trên điểm giữa của nội dung đang được sao chép. Chiến lược phát hành đĩa đơn
Kính lúp vẫn hoạt động vô thời hạn cho đến khi người dùng đóng.
Đoạn mã sau đây cho biết cách thay đổi nền của tính năng phóng to
chế độ xem:
Kotlin
view.setBackgroundColor(...)
Java
view.setBackgroundColor(...);
Giả sử màu nền có thể nhìn thấy trong kính lúp, thì
nội dung đã lỗi thời do một khu vực của chế độ xem vẫn có nền cũ
màn hình. Để làm mới nội dung, hãy sử dụng
update() như sau:
Kotlin
view.post{magnifier.update()}
Java
view.post(magnifier::update);
Khi hoàn tất, hãy đóng kính lúp bằng cách gọi phương thức dismiss():
Kotlin
magnifier.dismiss()
Java
magnifier.dismiss();
Phóng to khi người dùng tương tác
Một trường hợp sử dụng phổ biến của kính lúp là cho phép người dùng phóng to khu vực xem bằng cách
chạm vào thiết bị đó, như minh hoạ trong hình 2.
Hình 2. Kính lúp tuân theo thao tác chạm của người dùng. Đó là
đã áp dụng cho một ViewGroup có chứa "ImageView" ở bên trái
và một TextView ở bên phải.
Bạn có thể thực hiện việc này bằng cách cập nhật kính lúp theo sự kiện chạm nhận được
theo chế độ xem, như sau:
imageView.setOnTouchListener(newView.OnTouchListener(){@OverridepublicbooleanonTouch(Viewv,MotionEventevent){switch(event.getActionMasked()){caseMotionEvent.ACTION_DOWN:// Fall through.caseMotionEvent.ACTION_MOVE:{finalint[]viewPosition=newint[2];v.getLocationOnScreen(viewPosition);magnifier.show(event.getRawX()-viewPosition[0],event.getRawY()-viewPosition[1]);break;}caseMotionEvent.ACTION_CANCEL:// Fall through.caseMotionEvent.ACTION_UP:{magnifier.dismiss();}}returntrue;}});
Những cân nhắc khác khi phóng to văn bản
Đối với các tiện ích văn bản trên nền tảng, bạn cần phải hiểu được tính năng phóng to cụ thể
và để bật tính năng phóng to cho chế độ xem văn bản tuỳ chỉnh một cách nhất quán
trên nền tảng Android. Hãy cân nhắc thực hiện những bước sau:
Kính lúp sẽ được kích hoạt ngay lập tức khi người dùng tóm lấy phần chèn hoặc ô điều khiển lựa chọn.
Kính lúp luôn di chuyển mượt mà theo chiều ngang ngón tay của người dùng, trong khi
theo chiều dọc nó được cố định vào chính giữa của dòng văn bản hiện tại.
Khi di chuyển theo chiều ngang, kính lúp chỉ di chuyển giữa bên trái và
ranh giới bên phải của dòng hiện tại. Hơn nữa, khi thao tác chạm của người dùng rời khỏi
các giới hạn này và khoảng cách theo chiều ngang giữa điểm chạm và điểm gần nhất
giới hạn lớn hơn một nửa chiều rộng ban đầu của nội dung phóng to.
trình phóng to bị đóng vì con trỏ không còn hiển thị bên trong
phóng to.
Không thể kích hoạt kính lúp khi phông chữ văn bản quá lớn. Văn bản là
được coi là quá lớn khi sự khác biệt giữa độ lệch chuẩn của phông chữ và
độ cao lớn hơn chiều cao của nội dung vừa với trình phóng to.
Việc kích hoạt trình phóng to trong trường hợp này không làm tăng thêm giá trị.
Nội dung và mã mẫu trên trang này phải tuân thủ các giấy phép như mô tả trong phần Giấy phép nội dung. Java và OpenJDK là nhãn hiệu hoặc nhãn hiệu đã đăng ký của Oracle và/hoặc đơn vị liên kết của Oracle.
Cập nhật lần gần đây nhất: 2025-07-27 UTC.
[[["Dễ hiểu","easyToUnderstand","thumb-up"],["Giúp tôi giải quyết được vấn đề","solvedMyProblem","thumb-up"],["Khác","otherUp","thumb-up"]],[["Thiếu thông tin tôi cần","missingTheInformationINeed","thumb-down"],["Quá phức tạp/quá nhiều bước","tooComplicatedTooManySteps","thumb-down"],["Đã lỗi thời","outOfDate","thumb-down"],["Vấn đề về bản dịch","translationIssue","thumb-down"],["Vấn đề về mẫu/mã","samplesCodeIssue","thumb-down"],["Khác","otherDown","thumb-down"]],["Cập nhật lần gần đây nhất: 2025-07-27 UTC."],[],[],null,["# Implement a text magnifier\n\nTry the Compose way \nJetpack Compose is the recommended UI toolkit for Android. Learn how to use text in Compose. \n[Modifier.magnifier() →](/reference/kotlin/androidx/compose/foundation/package-summary#(androidx.compose.ui.Modifier).magnifier(kotlin.Function1,kotlin.Function1,kotlin.Float,androidx.compose.foundation.MagnifierStyle,kotlin.Function1)) \n\n\u003cbr /\u003e\n\nAvailable in Android 9 (API level 28) and later, the magnifier widget is a\nvirtual magnifying glass that displays an enlarged copy of a `View` through an\noverlay pane that represents the lens. The feature improves the text insertion\nand selection user experience. When applying the magnifier to text, a user can\nprecisely position the cursor or the selection handles by viewing the magnified\ntext in a pane that follows their finger.\n\nFigure 1 shows how the magnifier facilitates selecting text. The magnifier APIs\naren't tied to text, and you can use this widget in a variety of use cases, such\nas reading small text or enlarging hard-to-see place names on maps.\n**Figure 1.** Magnifying text. When the user drags the right selection handle, the magnifier pops up to help with accurate placement.\n\nThe magnifier is already integrated with platform widgets such as `TextView`,\n`EditText`, and `WebView`. It provides consistent text manipulation across apps.\nThe widget comes with a simple API and can be used to magnify any `View`\ndepending on your app's context.\n\nAPI usage\n---------\n\nYou can use the magnifier programmatically on an arbitrary view as follows: \n\n### Kotlin\n\n```kotlin\nval view: View = findViewById(R.id.view)\nval magnifier = Magnifier.Builder(view).build()\nmagnifier.show(view.width / 2.0f, view.height / 2.0f)\n```\n\n### Java\n\n```java\nView view = findViewById(R.id.view);\nMagnifier magnifier = new Magnifier.Builder(view).build();\nmagnifier.show(view.getWidth() / 2, view.getHeight() / 2);\n```\n\nAssuming the view hierarchy has the first layout, the magnifier displays on the\nscreen and contains a region centered on the given coordinates within the view.\nThe pane appears above the center point of the content being copied. The\nmagnifier persists indefinitely until the user dismisses it.\n| **Note:** The arguments of [`show()`](/reference/android/widget/Magnifier#show(float,%20float)) are relative to the top-left corner of the view being magnified.\n\nThe following code snippet shows how to change the background of the magnified\nview: \n\n### Kotlin\n\n```kotlin\nview.setBackgroundColor(...)\n```\n\n### Java\n\n```java\nview.setBackgroundColor(...);\n```\n\nAssuming the background color is visible within the magnifier, the magnifier's\ncontent is stale, as a region of the view with the old background still\ndisplays. To refresh the content, use the\n[`update()`](/reference/android/widget/Magnifier#update()) method, as follows: \n\n### Kotlin\n\n```kotlin\nview.post { magnifier.update() }\n```\n\n### Java\n\n```java\nview.post(magnifier::update);\n```\n| **Note:** Post the update operation to make sure that by the time this executes, the view with the new background color is already drawn. This is because the magnifier content always stays a frame behind the magnified view.\n\nWhen finished, close the magnifier by calling the\n[`dismiss()`](/reference/android/widget/Magnifier#dismiss()) method: \n\n### Kotlin\n\n```kotlin\nmagnifier.dismiss()\n```\n\n### Java\n\n```java\nmagnifier.dismiss();\n```\n\nMagnify on user interaction\n---------------------------\n\nA common use case for the magnifier is to let the user enlarge a view region by\ntouching it, as shown in figure 2.\n**Figure 2.** The magnifier follows the user's touch. It is applied to a `ViewGroup` that contains an \\`ImageView\\` to the left and a `TextView` to the right.\n\nYou can do this by updating the magnifier according to the touch events received\nby the view, as follows: \n\n### Kotlin\n\n```kotlin\nimageView.setOnTouchListener { v, event -\u003e\n when (event.actionMasked) {\n MotionEvent.ACTION_DOWN, MotionEvent.ACTION_MOVE -\u003e {\n val viewPosition = IntArray(2)\n v.getLocationOnScreen(viewPosition)\n magnifier.show(event.rawX - viewPosition[0], event.rawY - viewPosition[1])\n }\n MotionEvent.ACTION_CANCEL, MotionEvent.ACTION_UP -\u003e {\n magnifier.dismiss()\n }\n }\n true\n}\n```\n\n### Java\n\n```java\nimageView.setOnTouchListener(new View.OnTouchListener() {\n @Override\n public boolean onTouch(View v, MotionEvent event) {\n switch (event.getActionMasked()) {\n case MotionEvent.ACTION_DOWN:\n // Fall through.\n case MotionEvent.ACTION_MOVE: {\n final int[] viewPosition = new int[2];\n v.getLocationOnScreen(viewPosition);\n magnifier.show(event.getRawX() - viewPosition[0],\n event.getRawY() - viewPosition[1]);\n break;\n }\n case MotionEvent.ACTION_CANCEL:\n // Fall through.\n case MotionEvent.ACTION_UP: {\n magnifier.dismiss();\n }\n }\n return true;\n }\n});\n```\n| **Note:** The magnifier never displays magnified content that doesn't belong to the view, even when the view is included in scrollable containers and partially masked. When the coordinates passed to `show()` imply copying outside content, they are coerced inside the visible region of the view.\n\nAdditional considerations when magnifying text\n----------------------------------------------\n\nFor the platform text widgets, it's important to understand specific magnifier\nbehaviors and to enable the magnifier for your custom text view consistently\nacross the Android platform. Consider the following:\n\n- The magnifier is triggered immediately when the user grabs an insertion or selection handle.\n- The magnifier always smoothly follows the user's finger horizontally, while vertically it is fixed to the center of the current text line.\n- When moving horizontally, the magnifier moves only between the left and right bounds of the current line. Moreover, when the user's touch leaves these bounds and the horizontal distance between the touch and the closest bound is larger than half of the original width of the magnifier content, the magnifier is dismissed, as the cursor is no longer visible inside the magnifier.\n- The magnifier is never triggered when the text font is too large. Text is considered too large when the difference between the font's descent and ascent is larger than the height of the content that fits in the magnifier. Triggering the magnifier in this case doesn't add value."]]
