📭 😇 🦔 अनुप्रयोग विकसित करते समय कार्यक्षमता और अनुकूलता के बीच संतुलन बनाए रखें 🚣🏿 👸 🍳

Android एप्लिकेशन डेवलपर्स जो सभी जारी किए गए उपकरणों पर विकास द्वारा निर्देशित हैं, संभवतः इस योजना से परिचित हैं:

1 जुलाई 2010 को, यह एंड्रॉइड संस्करण चलाने का एक आंकड़ा था। एंड्रॉइड के नए संस्करणों को जारी करने के साथ, डेवलपर्स ने सोचना शुरू किया: नए संस्करण द्वारा प्रदान किए गए एप्लिकेशन में नए कार्यों को जोड़ना, या इसे यथासंभव अधिक उपकरणों पर उपलब्ध कराना।

अनुभवी डेवलपर्स ने पहले ही सुनिश्चित कर लिया है कि ये दो विकल्प पारस्परिक रूप से अनन्य हैं, और उनके बीच संतुलन बनाए रखना दर्दनाक हो सकता है। इस लेख में, मैं आपको दिखाऊंगा कि ऐसा नहीं है।

कुछ सप्ताह पहले, हमारे लेख में, हमने जांच की कि एंड्रॉइड 2.0 (ईक्लेयर) और उच्चतर पर मल्टीटच को कैसे संभालना है, अंत में एक सरल डेमो एप्लिकेशन प्राप्त करना। इस लेख में, हम अपने एप्लिकेशन को फिर से करेंगे ताकि यह एंड्रॉइड 1.5 तक सभी संस्करणों पर सही ढंग से काम करे। आप Google कोड पर पुराने एप्लिकेशन का स्रोत कोड ले सकते हैं।

प्रकट में मुद्दे

AndroidManifest.xml में उपयोग- sdk टैग को दो मापदंडों के साथ निर्दिष्ट किया जा सकता है: minSdkVersion और targetSdkVersion । इसके द्वारा आप कह सकते हैं कि एप्लिकेशन पुराने संस्करणों पर काम करने के लिए तैयार है, लेकिन साथ ही यह नए लोगों पर भी काम कर सकता है। अब आप विकास के लिए नए एसडीके का उपयोग कर सकते हैं। लेकिन अगर आप सीधे नए प्लेटफ़ॉर्म की कार्यक्षमता का उपयोग करते हैं, तो यह वही है जो आप सिस्टम लॉग में देख सकते हैं:

E/dalvikvm( 792): Could not find method android.view.MotionEvent.getX, referenced from method com.example.android.touchexample.TouchExampleView.onTouchEvent W/dalvikvm( 792): VFY: unable to resolve virtual method 17: Landroid/view/MotionEvent;.getX (I)F W/dalvikvm( 792): VFY: rejecting opcode 0x6e at 0x0006 W/dalvikvm( 792): VFY: rejected Lcom/example/android/touchexample/TouchExampleView;.onTouchEvent (Landroid/view/MotionEvent;)Z W/dalvikvm( 792): Verifier rejected class Lcom/example/android/touchexample/TouchExampleView; D/AndroidRuntime( 792): Shutting down VM W/dalvikvm( 792): threadid=3: thread exiting with uncaught exception (group=0x4000fe70)

हमने गलत तरीके से minSdkVersion निर्दिष्ट किया है, और यहाँ यह परिणाम है। हमने SDK 8 (Froyo) पर अपना एप्लिकेशन विकसित किया, लेकिन minSdkVersion = ”3” (कपकेक) पैरामीटर को छोड़ते हुए, हमने एप्लिकेशन को इस तरह का बताया कि हम अपने इरादों से अवगत थे और असंभव के लिए नहीं पूछेंगे। यदि हम इसे वैसे ही छोड़ देते हैं, तो एसडीके के पुराने संस्करणों वाले हमारे उपयोगकर्ताओं को एक बदसूरत त्रुटि संदेश दिखाई देगा। बेशक, नाराज उपयोगकर्ताओं की भीड़ 1 स्टार के लिए बाज़ार में आपके आवेदन को रेट करेगी। इससे बचने के लिए, हमें सिस्टम के पुराने संस्करणों पर क्रोधित जांच के बिना नए प्लेटफ़ॉर्म के कार्यों तक सुरक्षित पहुंच बनाना चाहिए।

परावर्तन विधि

कई डेवलपर्स पहले से ही प्रतिबिंब का उपयोग करके इस समस्या को हल करने के अभ्यास से परिचित हैं। परावर्तन कोड को रनटाइम के साथ बातचीत करने और निर्धारित करने की अनुमति देता है कि लक्ष्य के तरीके या कक्षाएं मौजूद हैं या उन्हें कॉल करें, या उन्हें सीधे स्पर्श किए बिना एक उदाहरण बनाएं।

जानबूझकर या सशर्त रूप से प्रतिबिंबों का संदर्भ देने वाले अन्य प्लेटफार्मों से सुविधा अनुरोधों की संभावना अच्छी नहीं है। यह बदसूरत है। यह धीमा है। यह बोझिल है। सबसे पहले, कोड में इसका भारी उपयोग इसे आगे के समर्थन के लिए असुविधाजनक कचरे में बदल देगा। क्या होगा यदि मैं कहता हूं कि 2.2 (फ़्रोयो) का उपयोग करके एंड्रॉइड 1.5 (कपरेक) के लिए उन्मुख अनुप्रयोगों को लिखने का एक तरीका है, एक कोड का उपयोग करके और प्रतिबिंबों का उपयोग नहीं करना?

विलंबित लोडिंग

रिसर्चर बिल पुघ ने ClassLoader आलसी लोडिंग का उपयोग करने के सभी लाभों के साथ जावा में सिंगलनेट लिखने के लिए एक विधि प्रकाशित और वितरित की है। इस विधि की व्याख्या करने वाली विकिपीडिया सामग्री । कोड इस तरह दिखता है:

public class Singleton { // Private constructor prevents instantiation from other classes private Singleton ( ) { } /** * SingletonHolder Singleton.getInstance() * SingletonHolder.INSTANCE, . */ private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton ( ) ; } public static Singleton getInstance ( ) { return SingletonHolder. INSTANCE ; } }

उनके काम का एक बहुत महत्वपूर्ण हिस्सा टिप्पणी में वर्णित है। जावा क्लासेस को पहली पहुँच में लोड और इनिशियलाइज़ किया जाता है - यह पहली बार क्लास के उदाहरण बनाता है या विधि या इसके किसी एक स्टैटिक फ़ील्ड तक पहुँच प्राप्त करता है। यह हमारे लिए महत्वपूर्ण है क्योंकि कक्षाओं को वर्चुअल मशीन द्वारा तभी चेक किया जाता है जब वे लोड किए जाते हैं, पहले नहीं। अब हमारे पास प्रतिबिंब विधि का उपयोग किए बिना Android एप्लिकेशन लिखने के लिए सब कुछ है।

संगतता डिजाइन

जैसा कि यह निकला, व्यवहार में यह काफी सरल है। एक नियम के रूप में, आप चाहते हैं कि आपका एप्लिकेशन प्लेटफ़ॉर्म के पुराने संस्करणों को सही ढंग से नीचा दिखाए, कुछ कार्यों को हटाए या वैकल्पिक लोगों को विकसित करे। चूंकि एंड्रॉइड की कार्यक्षमता केवल एपीआई के संस्करण के साथ जुड़ी हुई है, इसलिए आपके पास केवल एक चीज है जिसे आपको संगतता डिजाइन करते समय पालन करना चाहिए।

ज्यादातर मामलों में, यह समर्थन विकल्प एक साधारण वर्ग पदानुक्रम के रूप में लागू किया जा सकता है। आप संस्करण-संवेदनशील फ़ंक्शंस या अमूर्त कक्षाओं का उपयोग करके संस्करण-संवेदनशील कार्यों तक पहुंचने के लिए अपने एप्लिकेशन को डिज़ाइन कर सकते हैं। प्लेटफ़ॉर्म के नए संस्करणों पर चलने के लिए डिज़ाइन किए गए इंटरफ़ेस में एक उपवर्ग नई प्रणाली क्षमताओं का समर्थन कर सकता है, और प्लेटफ़ॉर्म के पुराने संस्करणों पर चलने के लिए डिज़ाइन किए गए उपवर्ग वैकल्पिक तरीकों से आवेदन की कार्यक्षमता प्रदान करना चाहिए।

सिद्धांतों को व्यवहार में लाना

इस लेख की शुरुआत में, मैंने कहा था कि हम एपीआई संस्करण 3 (कपकेक) से 8 संस्करण (फ्रायो) के लिए पहले से बनाए गए मल्टी-टच एप्लिकेशन को फिर से करेंगे। पहले प्रकाशित लेख में, मैंने नोट किया कि गेस्ट्यूरेटेटर्स सेंसर इवेंट प्रोसेसिंग को अमूर्त करने के लिए एक उपयोगी संदर्भ है। तब मुझे समझ नहीं आया कि यह कितनी जल्दी लागू और परीक्षण किया जाता है। हम डेमो एप्लिकेशन के संस्करण-विशिष्ट तत्वों को फिर से कर सकते हैं और अमूर्त GestureDetector का उपयोग करके यह सब लागू कर सकते हैं ।

आरंभ करने से पहले, हमें API-s 3 के उपयोग के लिए minSdkVersion का उपयोग करते हुए एपीआई संस्करण 3 के लिए समर्थन की घोषणा करने के लिए अपनी उपस्थिति को संशोधित करने की आवश्यकता है। ध्यान रखें कि हम अभी भी संस्करण 8 पर ध्यान केंद्रित कर रहे हैं, यह आपके प्रकट होने के targetSdkVersion पैरामीटर में भी ध्यान दिया जाना चाहिए। अब हमारी उपस्थिति इस तरह दिखाई देगी:

<?xml version = "1.0" encoding = "utf-8" ?> <manifest xmlns:android = "schemas.android.com/apk/res/android" package = "com.example.android.touchexample" android:versionCode = "1" android:versionName = "1.0" > <application android:icon = "@drawable/icon" android:label = "@string/app_name" > <activity android:name = ".TouchExampleActivity" android:label = "@string/app_name" > <intent-filter > <action android:name = "android.intent.action.MAIN" /> <category android:name = "android.intent.category.LAUNCHER" /> </intent-filter > </activity > </application > <uses-sdk android:minSdkVersion = "3" android:targetSdkVersion = "8" /> </manifest >

हमारा TouchExampleView वर्ग ScaleGestureDetector के उपयोग के कारण Froyo तक एंड्रॉइड संस्करणों के साथ संगत नहीं है, और नए MotionEvent पद्धति के उपयोग के कारण Eclair के नीचे संस्करणों के साथ संगत नहीं है जो मल्टीटच के डेटा को पढ़ता है। हमें इस कार्यक्षमता को उन कक्षाओं में अमूर्त करना चाहिए जो ऐसे संस्करणों पर लोड नहीं होंगे जो इस कार्यक्षमता का समर्थन नहीं करते हैं। ऐसा करने के लिए, हम एक नया वर्ग बनाएंगे, इसे वर्स्डग्रेचरडेक्टर कहेंगे।

सैंपल एप्लीकेशन में यूजर के 2 जेस्चर, ड्रैग और स्केल होते हैं। इसलिए, VersionedGestureDetector को दो घटनाओं को परिभाषित करना चाहिए: onDrag और onScale । TouchExampleView को प्लेटफ़ॉर्म संस्करण के अनुरूप वर्स्डग्रेचरडेक्टर वर्ग का एक उदाहरण प्राप्त करना चाहिए, इसके माध्यम से आने वाली घटनाओं को फ़िल्टर करें, और तदनुसार ऑनड्रैग और ऑनस्केल का जवाब दें।

पहला संस्करणः संस्करणDDestureDetector होगा:

public abstract class VersionedGestureDetector { OnGestureListener mListener ; public abstract boolean onTouchEvent ( MotionEvent ev ) ; public interface OnGestureListener { public void onDrag ( float dx, float dy ) ; public void onScale ( float scaleFactor ) ; } }

सबसे पहले, आवेदन सरलतम कपकेक-उन्मुख कार्यक्षमता के साथ शुरू होता है। सादगी के लिए, इस उदाहरण में हम प्रत्येक संस्करण के लिए समर्थन को कार्यान्वित करेंगे जो वर्जनगैस्ट्योरटेक्टर में स्थिर आंतरिक वर्ग का उपयोग करेगा। बेशक, आप इसे अपनी पसंद के अनुसार लागू कर सकते हैं, जबकि ऊपर दिखाए गए लोडिंग तकनीक का उपयोग करते हुए, या इसके बराबर। उन कक्षाओं को स्पर्श न करें जो सीधे कार्यक्षमता का उपयोग करते हैं जो प्लेटफ़ॉर्म के इस संस्करण द्वारा समर्थित नहीं हैं।

private static class CupcakeDetector extends VersionedGestureDetector { float mLastTouchX ; float mLastTouchY ; @Override public boolean onTouchEvent ( MotionEvent ev ) { switch ( ev. getAction ( ) ) { case MotionEvent. ACTION_DOWN : { mLastTouchX = ev. getX ( ) ; mLastTouchY = ev. getY ( ) ; break ; } case MotionEvent. ACTION_MOVE : { final float x = ev. getX ( ) ; final float y = ev. getY ( ) ; mListener. onDrag ( x - mLastTouchX, y - mLastTouchY ) ; mLastTouchX = x ; mLastTouchY = y ; break ; } } return true ; } }

स्क्रीन के चारों ओर पॉइंटर को ले जाने पर ऑनड्रैग इवेंट के आयोजन का यह एक सरल कार्यान्वयन है। मान जो लेता है वह X के साथ Y के साथ पॉइंटर द्वारा तय किए गए पथ के बराबर होता है।

एक्लेयर संस्करण के साथ शुरू, हमें स्क्रीन से दूर जाने वाले अतिरिक्त बिंदुओं की उपस्थिति को रोकने के लिए सूचक की पहचानकर्ता को स्पष्ट रूप से ट्रैक करना चाहिए। CupcakeDetector में मूल onTouchEvent कार्यान्वयन सूचक आंदोलनों को ट्रैक कर सकता है, लेकिन दो तरकीबों के साथ। हमें संबंधित निर्देशांक प्राप्त करने के लिए getActiveX और getActiveY विधियों को जोड़ना होगा और उन्हें सही पॉइंटर निर्देशांक प्राप्त करने के लिए EclairDetector में पुनर्परिभाषित करना होगा।

private static class CupcakeDetector extends VersionedGestureDetector { float mLastTouchX ; float mLastTouchY ; float getActiveX ( MotionEvent ev ) { return ev. getX ( ) ; } float getActiveY ( MotionEvent ev ) { return ev. getY ( ) ; } @Override public boolean onTouchEvent ( MotionEvent ev ) { switch ( ev. getAction ( ) ) { case MotionEvent. ACTION_DOWN : { mLastTouchX = getActiveX ( ev ) ; mLastTouchY = getActiveY ( ev ) ; break ; } case MotionEvent. ACTION_MOVE : { final float x = getActiveX ( ev ) ; final float y = getActiveY ( ev ) ; mListener. onDrag ( x - mLastTouchX, y - mLastTouchY ) ; mLastTouchX = x ; mLastTouchY = y ; break ; } } return true ; } }

अब EclairDetector , नए तरीकों getActiveX और getActiveY से आगे निकल गया । इस कोड के अधिकांश आपको लेख की शुरुआत में वर्णित मूल उदाहरण से परिचित होना चाहिए।

private static class EclairDetector extends CupcakeDetector { private static final int INVALID_POINTER_ID = - 1 ; private int mActivePointerId = INVALID_POINTER_ID ; private int mActivePointerIndex = 0 ; @Override float getActiveX ( MotionEvent ev ) { return ev. getX ( mActivePointerIndex ) ; } @Override float getActiveY ( MotionEvent ev ) { return ev. getY ( mActivePointerIndex ) ; } @Override public boolean onTouchEvent ( MotionEvent ev ) { final int action = ev. getAction ( ) ; switch ( action & MotionEvent. ACTION_MASK ) { case MotionEvent. ACTION_DOWN : mActivePointerId = ev. getPointerId ( 0 ) ; break ; case MotionEvent. ACTION_CANCEL : case MotionEvent. ACTION_UP : mActivePointerId = INVALID_POINTER_ID ; break ; case MotionEvent. ACTION_POINTER_UP : final int pointerIndex = ( ev. getAction ( ) & MotionEvent. ACTION_POINTER_INDEX_MASK ) >> MotionEvent. ACTION_POINTER_INDEX_SHIFT ; final int pointerId = ev. getPointerId ( pointerIndex ) ; if ( pointerId == mActivePointerId ) { // This was our active pointer going up. Choose a new // active pointer and adjust accordingly. final int newPointerIndex = pointerIndex == 0 ? 1 : 0 ; mActivePointerId = ev. getPointerId ( newPointerIndex ) ; mLastTouchX = ev. getX ( newPointerIndex ) ; mLastTouchY = ev. getY ( newPointerIndex ) ; } break ; } mActivePointerIndex = ev. findPointerIndex ( mActivePointerId ) ; return super. onTouchEvent ( ev ) ; } }

EclairDetector सूचक की पहचानकर्ता का निर्धारण करने के बाद super.onTouchEvent कहता है, ड्रैग ईवेंट निर्धारित करने के लिए CupcakeDetector चलाता है। मल्टी-प्लेटफ़ॉर्म कोड के दोहराव का कारण नहीं होना चाहिए।

अंत में, आइए एक ScaleGestureDetector जोड़ें जो Froyo के लिए ज़ूम जेस्चर समर्थन को लागू करेगा। स्केलिंग के दौरान आंदोलन से बचने के लिए, हमें कपकेकडेक्टर में कुछ बदलाव करने होंगे। कुछ टचस्क्रीन में स्केलिंग की समस्या है, इसलिए हमें इसे ध्यान में रखना चाहिए।
हम CupDakeDetector में कंधे की विधि जोड़ेंगे जो onDrag घटना भेजने से पहले जाँच करेगा।

कपकेकडेक्टर का अंतिम संस्करण:

private static class CupcakeDetector extends VersionedGestureDetector { float mLastTouchX ; float mLastTouchY ; float getActiveX ( MotionEvent ev ) { return ev. getX ( ) ; } float getActiveY ( MotionEvent ev ) { return ev. getY ( ) ; } boolean shouldDrag ( ) { return true ; } @Override public boolean onTouchEvent ( MotionEvent ev ) { switch ( ev. getAction ( ) ) { case MotionEvent. ACTION_DOWN : { mLastTouchX = getActiveX ( ev ) ; mLastTouchY = getActiveY ( ev ) ; break ; } case MotionEvent. ACTION_MOVE : { final float x = getActiveX ( ev ) ; final float y = getActiveY ( ev ) ; if ( shouldDrag ( ) ) { mListener. onDrag ( x - mLastTouchX, y - mLastTouchY ) ; } mLastTouchX = x ; mLastTouchY = y ; break ; } } return true ; } }

EclairDetector अपरिवर्तित रहता है। नीचे FroyoDetector । स्केलिंग निष्क्रिय होने के दौरान डैड्रैग को एक सकारात्मक मूल्य वापस करना चाहिए।

private static class FroyoDetector extends EclairDetector { private ScaleGestureDetector mDetector ; public FroyoDetector ( Context context ) { mDetector = new ScaleGestureDetector ( context, new ScaleGestureDetector. SimpleOnScaleGestureListener ( ) { @Override public boolean onScale ( ScaleGestureDetector detector ) { mListener. onScale ( detector. getScaleFactor ( ) ) ; return true ; } } ) ; } @Override boolean shouldDrag ( ) { return ! mDetector. isInProgress ( ) ; } @Override public boolean onTouchEvent ( MotionEvent ev ) { mDetector. onTouchEvent ( ev ) ; return super. onTouchEvent ( ev ) ; } }

अब हमारे पास एक जेस्चर डिटेक्टर कार्यान्वयन है, अब हमें इसे बनाने का एक तरीका खोजना होगा। चलो एक VersionedGestureDetector विधि बनाते हैं।

public static VersionedGestureDetector newInstance ( Context context, OnGestureListener listener ) { final int sdkVersion = Integer. parseInt ( Build. VERSION . SDK ) ; VersionedGestureDetector detector = null ; if ( sdkVersion < Build. VERSION_CODES . ECLAIR ) { detector = new CupcakeDetector ( ) ; } else if ( sdkVersion < Build. VERSION_CODES . FROYO ) { detector = new EclairDetector ( ) ; } else { detector = new FroyoDetector ( context ) ; } detector. mListener = listener ; return detector ; }

चूंकि हम कपकेक पर ध्यान केंद्रित करते हैं, हमारे पास अभी भी Build.VERSION.SDK_INT तक पहुंच नहीं है। इसके बजाय, हमें अब अप्रचलित Build.VERSION.SDK का उपयोग करना चाहिए।

हमारा VersionedGestureDetector तैयार है, अब हमें इसे TouchExampleView के साथ मिलाना होगा , जो बहुत छोटा हो गया है।

public class TouchExampleView extends View { private Drawable mIcon ; private float mPosX ; private float mPosY ; private VersionedGestureDetector mDetector ; private float mScaleFactor = 1. f ; public TouchExampleView ( Context context ) { this ( context, null, 0 ) ; } public TouchExampleView ( Context context, AttributeSet attrs ) { this ( context, attrs, 0 ) ; } public TouchExampleView ( Context context, AttributeSet attrs, int defStyle ) { super ( context, attrs, defStyle ) ; mIcon = context. getResources ( ) . getDrawable ( R. drawable . icon ) ; mIcon. setBounds ( 0 , 0 , mIcon. getIntrinsicWidth ( ) , mIcon. getIntrinsicHeight ( ) ) ; mDetector = VersionedGestureDetector. newInstance ( context, new GestureCallback ( ) ) ; } @Override public boolean onTouchEvent ( MotionEvent ev ) { mDetector. onTouchEvent ( ev ) ; return true ; } @Override public void onDraw ( Canvas canvas ) { super. onDraw ( canvas ) ; canvas. save ( ) ; canvas. translate ( mPosX, mPosY ) ; canvas. scale ( mScaleFactor, mScaleFactor ) ; mIcon. draw ( canvas ) ; canvas. restore ( ) ; } private class GestureCallback implements VersionedGestureDetector. OnGestureListener { public void onDrag ( float dx, float dy ) { mPosX + = dx ; mPosY + = dy ; invalidate ( ) ; } public void onScale ( float scaleFactor ) { mScaleFactor * = scaleFactor ; // Don't let the object get too small or too large. mScaleFactor = Math. max ( 0.1f , Math. min ( mScaleFactor, 5.0f ) ) ; invalidate ( ) ; } } }

निष्कर्ष

इसलिए हमने प्लेटफ़ॉर्म द्वारा प्रदान की गई सर्वश्रेष्ठ नवीनतम विशेषताओं के माध्यम से और प्रतिबिंबों के एक भी उपयोग के बिना एंड्रॉइड 1.5 पर सही ढंग से काम करने के लिए हमारे आवेदन को अनुकूलित किया। उसी सिद्धांत को किसी भी नई Android सुविधा पर लागू किया जा सकता है, जिससे आपका एप्लिकेशन Android के पुराने संस्करणों पर चल सकता है:

ClassLoader कक्षाओं को पहली बार में सुरक्षित रूप से जाँच कर लोड करता है।
प्लेटफ़ॉर्म के संस्करण के आधार पर कार्यक्षमता और इंटरफ़ेस।
रनटाइम पर परिभाषित प्लेटफॉर्म के संस्करण के आधार पर एक संस्करण-विशिष्ट कार्यान्वयन। यह ClassLoader को उन वर्गों का उपयोग करने से बचाता है जिन्हें सही तरीके से निष्पादित नहीं किया जा सकता है।

अंतिम संस्करण देखने के लिए, Google कोड पर कपकेक अनुभाग पर जाएं।

अतिरिक्त जानकारी

इस उदाहरण में, हमने Froyo से पहले जारी OSes का उपयोग करते हुए उपयोगकर्ता के लिए एक वैकल्पिक मार्ग का प्रस्ताव नहीं किया, क्योंकि ScaleGestureDetector केवल 2.2 में उपलब्ध हुआ। वास्तविक अनुप्रयोगों के लिए, हम एक वैकल्पिक तरीका सुझाना चाहेंगे। परंपरागत रूप से, एंड्रॉइड फोन में हार्डवेयर जूम बटन होते हैं। ZoomControls और ZoomButtonsController क्लासेस आपको इस रास्ते को लागू करने में मदद करेंगे। इसे लागू करना पाठक के लिए एक अभ्यास होगा।

अनुप्रयोग विकसित करते समय कार्यक्षमता और अनुकूलता के बीच संतुलन बनाए रखें