Android के लिए Aibolit

एंड्रॉइड एप्लिकेशन को विकसित करते समय UI को आरंभीकृत करने की प्रक्रिया कितनी कठिन है। बार-बार आपको टेम्प्लेट कोड के पहाड़ों को लिखना होगा: findViewbyId, setOnClickListener, getources ()। GetDrawable, ... इस काम को AOP के कंधों पर शिफ्ट करने की स्वाभाविक इच्छा है। एंड्रॉइड के लिए तैयार किए गए समाधानों के लिए एक त्वरित खोज, शायद केवल रोबोग्यूइस पर, जो पहले से ही हब पर उल्लिखित था हालाँकि, लाइब्रेरी में एक महत्वपूर्ण आकार (~ 0.5 mb) है, जो कई अनुप्रयोगों के लिए अस्वीकार्य है, और इसके लिए RoboApplication और RoboActivity से आपके एप्लिकेशन और गतिविधि वर्गों की विरासत की भी आवश्यकता होती है, जो आप हमेशा नहीं करना चाहते हैं। यही कारण है कि ऐबोलिट दिखाई दिया, एक आसान (~ 40kb), उपयोग करने में आसान और कार्यात्मक पुस्तकालय जो एंड्रॉइड पर यूआई को आरंभीकृत करने के लिए निर्भरता इंजेक्शन का उपयोग करता है।

अवसरों

• आरंभीकरण देखें;
• देखने के लिए ईवेंट लाइसेंसर्स जोड़ना;
• अनुप्रयोग संसाधनों का आरंभ: ड्रॉबल, स्ट्रिंग, एनीमेशन, बूलियन, आयाम, पूर्णांक, सरणी, रंग, सरणी एडाप्टर;
• सिस्टम सेवाओं का आरंभीकरण;
• आवेदन की आवेदन सेवाओं का आरंभीकरण।

उदाहरण का उपयोग करें

हम निर्भरता को जोड़ते हैं:

repositories { maven { url 'https://dl.bintray.com/alexeydanilov/maven' } } dependencies { compile 'com.danikula:aibolit:1.0' } 

और इंजेक्शन

 public class AibolitChatActivity extends Activity { // annotate fields to be injected... @InjectView(R.id.messageEditText) private EditText messageEditText; @InjectView(R.id.historyListView) private ListView historyListView; @InjectResource(R.string.symbols_count) private String symbolsCountPattern; @InjectSystemService(Context.NOTIFICATION_SERVICE) private NotificationManager notificationManager; @InjectService private HttpManager httpManager; @InjectResource(R.layout.content) private View content; ... @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.chat_activity); // initialize annotated fields and methods Aibolit.doInjections(this); // or just Aibolit.setInjectedContentView(this); ... } // annotate event handlers... @InjectOnClickListener(R.id.sendButton) private void onSendButtonClick(View v) { // handle onClick event } @InjectOnClickListener(R.id.clearHistoryButton) private void onClearHistoryButtonClick(View v) { // handle onClick event } @InjectOnTextChangedListener(R.id.messageEditText) public void onMessageTextChanged(CharSequence s, int start, int before, int count) { // handle text changed event } ... } 

कोड बहुत सरल है, यह कॉल करने के लिए पूरी तरह से राहत मिली है देखने के लिए देखने के लिए, setOnClickListener तरीकों और पसंद है। इसके बजाय:

1. हम उस दृश्य को चिह्नित करते हैं जिसे InjectView एनोटेशन के माध्यम से आरंभ किया जाना चाहिए;
2. हम ईवेंट हैंडलर को परिभाषित करते हैं और उन्हें इसी InjectOn * एनोटेशन के साथ चिह्नित करते हैं। इस उदाहरण में, बटन पर क्लिक करने और टेक्स्ट बदलने के लिए ईवेंट हैंडलर परिभाषित किए गए थे। Aibolit आपको सभी प्रमुख घटनाओं के लिए हैंडलर जोड़ने की अनुमति देता है:
   OnClick, OnLongClick, OnTouch, OnKey, OnTextChanged, OnCheckedChange, OnFocusChange, OnItemClick, OnItemSelected, OnEditor.ction, OnCreateContextMenu;
3. हम Aibolit.doInjections(this); विधि कहते हैं Aibolit.doInjections(this); सक्रियण के लिए सामग्री स्थापित करने के बाद।

2 तरीकों की कॉल

 setContentView(layoutId); Aibolit.doInjections(this); 

एक द्वारा प्रतिस्थापित किया जा सकता है:

 Aibolit.setInjectedContentView(this); 

Aibolit आपको एप्लिकेशन एप्लिकेशन सेवाओं को इंजेक्ट करने की भी अनुमति देता है, जैसा कि ऊपर दिए गए उदाहरण में किया गया है:

 @InjectService private HttpManager httpManager; 

आप ऐबोलिट वर्ग के लिए प्रलेखन से इसके बारे में अधिक जान सकते हैं।

यह कैसे काम करता है

कोड स्रोत खुले और प्रलेखित हैं। पर्दे के पीछे क्या चल रहा है? Aibolit फ़ील्ड्स और विधियों के लिए वर्ग का विश्लेषण करता है जिसे Inject * annotations के साथ चिह्नित किया गया है। प्रत्येक एनोटेशन का अपना इंजेक्टर वर्ग होता है, जो एक या किसी अन्य संसाधन के साथ क्षेत्र को आरम्भ करने के लिए जिम्मेदार होता है। इस तरह के इंजेक्टर का एक उदाहरण दृश्य को शुरू करने के लिए जिम्मेदार है:

 class ViewInjector extends AbstractFieldInjector<InjectView> { @Override public void doInjection(Object fieldOwner, InjectionContext injectionContext, Field field, InjectView annotation) { int viewId = annotation.value(); View view = injectionContext.getRootView().findViewById(viewId); if (view == null) { // throw exception... } if (!field.getType().isAssignableFrom(view.getClass())) { // throw exception... } try { field.setAccessible(true); field.set(fieldOwner, view); } catch (IllegalArgumentException e) { // throw exception... } catch (IllegalAccessException e) { // throw exception... } } } 

उत्पादकता

होलीवर्स के लिए कारण नहीं देने के लिए, मैं सिर्फ सूखे नंबर दूंगा। माप एक एमुलेटर पर किए गए थे। 35 तत्वों (दृश्य, लाइसेंसधारियों, अनुप्रयोग संसाधनों) को प्रारंभ करना आवश्यक था। शास्त्रीय दृष्टिकोण का उपयोग करते समय, एक गतिविधि से दूसरे आवश्यक 40-50 एमएस में संक्रमण होता है, जबकि आइबोलिट - 90-100 एमएस का उपयोग करते हुए। जैसा कि अपेक्षित था, प्रतिबिंब-आधारित दृष्टिकोण अधिक समय लेने वाला है, लेकिन प्राप्त अंतर, IMHO, महत्वपूर्ण नहीं है।

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

UPD 0:
इसी तरह के पुस्तकालय
roboguice
androidannotations