שרת proxy לממשקי ה-API החדשים
קל לארגן דפים בעזרת אוספים
אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.
בשיעור הזה תלמדו איך ליצור כיתות משנה של הכיתות המופשטות CompatTab
ו-TabHelper
ולהשתמש בממשקי API חדשים. האפליקציה יכולה להשתמש בהטמעה הזו במכשירים עם גרסת פלטפורמה שתומכת בהם.
הטמעת כרטיסיות באמצעות ממשקי API חדשים
המחלקות הממשיות של CompatTab
ו-TabHelper
שמשתמשות בממשקי API חדשים יותר הן הטמעה של שרת proxy. המחלקות המופשטות שהוגדרו בשיעור הקודם משקפים את ממשקי ה-API החדשים (מבנה המחלקה, חתימות השיטה וכו'), ולכן המחלקות הקורנטיות שמשתמשות בממשקי ה-API החדשים האלה פשוט קריאות לשיטות שרת proxy והתוצאות שלהן.
בגלל טעינה מדורגת של כיתות, אפשר להשתמש ישירות בממשקי API חדשים יותר במחלקות הבטון האלו, ולא לקרוס במכשירים קודמים. הכיתות נטענות ומופעלות בגישה הראשונה — להפעיל את הכיתה או לגשת לאחד מהשדות הסטטיים או מהשיטות שלה בפעם הראשונה. לכן, כל עוד לא יוצרים מופע של הטמעות ספציפיות ל-Honeycomb במכשירים לפני Honeycomb, ל-VM של Dalvik לא יוצגו חריגות מסוג VerifyError
.
דרך טובה לתת שמות להטמעה הזו היא להוסיף את רמת ה-API או את שם הקוד של גרסת הפלטפורמה שתואמים לממשקי ה-API שנדרשים על ידי המחלקות הבטון. לדוגמה, את ההטמעה של כרטיסיית הנייטיב אפשר לספק במחלקות CompatTabHoneycomb
ו-TabHelperHoneycomb
, כי הן מסתמכים על ממשקי API שזמינים ב-Android 3.0 (רמת API 11) ואילך.
איור 1. תרשים מחלקה להטמעת Honeycomb של כרטיסיות.
הטמעת CompatTabHoneycomb
CompatTabHoneycomb
הוא היישום של המחלקה המופשטת CompatTab
שבה TabHelperHoneycomb
משתמש כדי להפנות לכרטיסיות נפרדות. CompatTabHoneycomb
פשוט מעביר את כל קריאות ה-method לאובייקט ActionBar.Tab
שמוכל באמצעות שרת proxy.
התחלת ההטמעה של CompatTabHoneycomb
באמצעות ממשקי ה-API החדשים של ActionBar.Tab
:
Kotlin
class CompatTabHoneycomb internal constructor(val activity: Activity, tag: String) :
CompatTab(tag) {
...
// The native tab object that this CompatTab acts as a proxy for.
private var mTab: ActionBar.Tab =
// Proxy to new ActionBar.newTab API
activity.actionBar.newTab()
override fun setText(@StringRes textId: Int): CompatTab {
// Proxy to new ActionBar.Tab.setText API
mTab.setText(textId)
return this
}
...
// Do the same for other properties (icon, callback, etc.)
}
Java
public class CompatTabHoneycomb extends CompatTab {
// The native tab object that this CompatTab acts as a proxy for.
ActionBar.Tab mTab;
...
protected CompatTabHoneycomb(FragmentActivity activity, String tag) {
...
// Proxy to new ActionBar.newTab API
mTab = activity.getActionBar().newTab();
}
public CompatTab setText(int resId) {
// Proxy to new ActionBar.Tab.setText API
mTab.setText(resId);
return this;
}
...
// Do the same for other properties (icon, callback, etc.)
}
הטמעת TabHelperHoneycomb
TabHelperHoneycomb
הוא היישום של המחלקה המופשטת TabHelper
ש-methods מקריאה ל-method ActionBar
בפועל, שמתקבלת מה-Activity
הכלול בה.
הטמעת TabHelperHoneycomb
, קריאות לשיטות שרת proxy ל-API של ActionBar
:
Kotlin
class TabHelperHoneycomb internal constructor(activity: FragmentActivity) : TabHelper(activity) {
private var mActionBar: ActionBar? = null
override fun setUp() {
mActionBar = mActionBar ?: mActivity.actionBar.apply {
navigationMode = ActionBar.NAVIGATION_MODE_TABS
}
}
override fun addTab(tab: CompatTab) {
// Tab is a CompatTabHoneycomb instance, so its
// native tab object is an ActionBar.Tab.
mActionBar?.addTab(tab.getTab() as ActionBar.Tab)
}
}
Java
public class TabHelperHoneycomb extends TabHelper {
ActionBar actionBar;
...
protected void setUp() {
if (actionBar == null) {
actionBar = activity.getActionBar();
actionBar.setNavigationMode(
ActionBar.NAVIGATION_MODE_TABS);
}
}
public void addTab(CompatTab tab) {
...
// Tab is a CompatTabHoneycomb instance, so its
// native tab object is an ActionBar.Tab.
actionBar.addTab((ActionBar.Tab) tab.getTab());
}
// The other important method, newTab() is part of
// the base implementation.
}
כדאי גם לקרוא
דוגמאות התוכן והקוד שבדף הזה כפופות לרישיונות המפורטים בקטע רישיון לתוכן. Java ו-OpenJDK הם סימנים מסחריים או סימנים מסחריים רשומים של חברת Oracle ו/או של השותפים העצמאיים שלה.
עדכון אחרון: 2025-07-27 (שעון UTC).
[[["התוכן קל להבנה","easyToUnderstand","thumb-up"],["התוכן עזר לי לפתור בעיה","solvedMyProblem","thumb-up"],["סיבה אחרת","otherUp","thumb-up"]],[["חסרים לי מידע או פרטים","missingTheInformationINeed","thumb-down"],["התוכן מורכב מדי או עם יותר מדי שלבים","tooComplicatedTooManySteps","thumb-down"],["התוכן לא עדכני","outOfDate","thumb-down"],["בעיה בתרגום","translationIssue","thumb-down"],["בעיה בדוגמאות/בקוד","samplesCodeIssue","thumb-down"],["סיבה אחרת","otherDown","thumb-down"]],["עדכון אחרון: 2025-07-27 (שעון UTC)."],[],[],null,["# Proxy to the new APIs\n\nThis lesson shows you how to subclass the `CompatTab` and `TabHelper` abstract classes and use new APIs. Your application can use this implementation on devices running a platform version that supports them.\n\nImplement tabs using new APIs\n-----------------------------\n\nThe concrete classes for `CompatTab` and `TabHelper` that use newer APIs are a *proxy* implementation. Since the abstract classes defined in the previous lesson mirror the new APIs (class structure, method signatures, etc.), the concrete classes that use these newer APIs simply proxy method calls and their results.\n\nYou can directly use newer APIs in these concrete classes---and not crash on earlier devices---because of lazy class loading. Classes are loaded and initialized on first access---instantiating the class or accessing one of its static fields or methods for the first time. Thus, as long as you don't instantiate the Honeycomb-specific implementations on pre-Honeycomb devices, the Dalvik VM won't throw any [VerifyError](/reference/java/lang/VerifyError) exceptions.\n\nA good naming convention for this implementation is to append the API level or platform version code name corresponding to the APIs required by the concrete classes. For example, the native tab implementation can be provided by `CompatTabHoneycomb` and `TabHelperHoneycomb` classes, since they rely on APIs available in Android 3.0 (API level 11) or later.\n\n**Figure 1.** Class diagram for the Honeycomb implementation of tabs.\n\nImplement CompatTabHoneycomb\n----------------------------\n\n`CompatTabHoneycomb` is the implementation of the `CompatTab` abstract class that `TabHelperHoneycomb` uses to reference individual tabs. `CompatTabHoneycomb` simply proxies all method calls to its contained [ActionBar.Tab](/reference/android/app/ActionBar.Tab) object.\n\nBegin implementing `CompatTabHoneycomb` using the new [ActionBar.Tab](/reference/android/app/ActionBar.Tab) APIs: \n\n### Kotlin\n\n```kotlin\nclass CompatTabHoneycomb internal constructor(val activity: Activity, tag: String) :\n CompatTab(tag) {\n ...\n // The native tab object that this CompatTab acts as a proxy for.\n private var mTab: ActionBar.Tab =\n // Proxy to new ActionBar.newTab API\n activity.actionBar.newTab()\n\n override fun setText(@StringRes textId: Int): CompatTab {\n // Proxy to new ActionBar.Tab.setText API\n mTab.setText(textId)\n return this\n }\n\n ...\n // Do the same for other properties (icon, callback, etc.)\n}\n```\n\n### Java\n\n```java\npublic class CompatTabHoneycomb extends CompatTab {\n // The native tab object that this CompatTab acts as a proxy for.\n ActionBar.Tab mTab;\n ...\n\n protected CompatTabHoneycomb(FragmentActivity activity, String tag) {\n ...\n // Proxy to new ActionBar.newTab API\n mTab = activity.getActionBar().newTab();\n }\n\n public CompatTab setText(int resId) {\n // Proxy to new ActionBar.Tab.setText API\n mTab.setText(resId);\n return this;\n }\n\n ...\n // Do the same for other properties (icon, callback, etc.)\n}\n```\n\nImplement TabHelperHoneycomb\n----------------------------\n\n`TabHelperHoneycomb` is the implementation of the `TabHelper` abstract class that proxies method calls to an actual [ActionBar](/reference/android/app/ActionBar), obtained from its contained [Activity](/reference/android/app/Activity).\n\nImplement `TabHelperHoneycomb`, proxying method calls to the [ActionBar](/reference/android/app/ActionBar) API: \n\n### Kotlin\n\n```kotlin\nclass TabHelperHoneycomb internal constructor(activity: FragmentActivity) : TabHelper(activity) {\n\n private var mActionBar: ActionBar? = null\n\n override fun setUp() {\n mActionBar = mActionBar ?: mActivity.actionBar.apply {\n navigationMode = ActionBar.NAVIGATION_MODE_TABS\n }\n }\n\n override fun addTab(tab: CompatTab) {\n // Tab is a CompatTabHoneycomb instance, so its\n // native tab object is an ActionBar.Tab.\n mActionBar?.addTab(tab.getTab() as ActionBar.Tab)\n }\n}\n```\n\n### Java\n\n```java\npublic class TabHelperHoneycomb extends TabHelper {\n ActionBar actionBar;\n ...\n\n protected void setUp() {\n if (actionBar == null) {\n actionBar = activity.getActionBar();\n actionBar.setNavigationMode(\n ActionBar.NAVIGATION_MODE_TABS);\n }\n }\n\n public void addTab(CompatTab tab) {\n ...\n // Tab is a CompatTabHoneycomb instance, so its\n // native tab object is an ActionBar.Tab.\n actionBar.addTab((ActionBar.Tab) tab.getTab());\n }\n\n // The other important method, newTab() is part of\n // the base implementation.\n}\n```\n\n### You should also read\n\n- [Action Bar](/guide/topics/ui/actionbar)\n- [Action Bar Tabs](/guide/topics/ui/actionbar#Tabs)"]]