उबंटू टच और एंड्रॉइड के बीच बातचीत के सिद्धांतों को जानें

हाय, हैब्र।

कुछ महीने पहले मैं Ubuntu टच को ऑलविनर A10 प्लेटफ़ॉर्म पर पोर्ट कर रहा था,
इस प्रक्रिया में मैंने नोटों के रूप में रख लिया। अब, मेरी राय में, वे अभी भी प्रासंगिक हैं जब तक कि उबंटू टच अंततः अपने मीर ग्राफिक सर्वर और इतने पर स्थानांतरित नहीं हुआ।

यह लेख इच्छुक लोगों को एक प्रारंभिक बिंदु खोजने में मदद करेगा, जहां से UT के साथ घनिष्ठ परिचय शुरू होगा।

प्रस्तुति शैली तकनीकी से बहुत दूर है, लेकिन यदि आप बुरा नहीं मानते हैं, तो
मैं बिल्ली को आमंत्रित करता हूं।

परिचय

कामेच्छा क्या है

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

सरफेसिंगलर क्या है

सरफेसफ्लिंगर - एक देशी एंड्रॉइड सेवा, ग्राफिक परतों का एक संयुक्त प्रबंधक।



बाइंडर आईपीसी और सरफेसफिंगर के बारे में अधिक जानकारी:

• http://www.opersys.com/downloads/inside-androids-ui-130530.pdf
  
• http://0xlab.org/~jserv/android-binder-ipc.pdf
  
• dpolenuk ने एक उत्कृष्ट दस्तावेज़ साझा किया - एंड्रॉइड बाइंडर

उबटन स्पर्श

उबंटू टच डेवलपर पूर्वावलोकन स्वयं एंड्रॉइड पर आधारित है, हार्डवेयर के साथ काम करने के लिए आवश्यक सेवाएं उधार लेता है। निर्भरता का एक सामान्य अवलोकन यहां पाया जा सकता है - उबंटू टच पोर्टिंग या ओपननेट पर एक नोट में ।

बेस ऑपरेटिंग सिस्टम के रूप में, सामान्य एंड्रॉइड जेबी 4.2 का उपयोग किया जाता है , या साइजेनमॉड-10.1 का उपयोग किया जाता है (सीएम सबप्रोजेक्ट्स रिपॉजिटरी - phablet.ubuntu.com/gitweb )। दलविक और जावा से जुड़ी हर चीज को इससे हटा दिया गया है - केवल मूल भाग जिसमें सिस्टम सेवाएं और एचएएल बाकी है। यदि आप चाहें, तो आप एओएसपी 4.1 का उपयोग कर सकते हैं, लेकिन मूल एपीआई को 4.1 से अनुकूलित करने के लिए तैयार रहें, यह किसी भी दस्तावेज या इसके अलावा, विनिर्देश, और रिलीज से रिलीज तक के बदलावों से आच्छादित नहीं है।

यूटी घटक चेरोट में स्थित हैं, एक स्व-लिखित यूक्रोट उपयोगिता का उपयोग किया जाता है , अंश:

static int ubuntum(void *a) { /* Chroot */ chroot("/data/ubuntu"); chdir("/"); /* Set basic env variables */ char *const envp[8] = { "container=aal", "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", "SHELL=/bin/bash", "HOME=/root", "USER=root", "USERNAME=root", "LOGNAME=root", NULL }; /* Exec shell */ execle("/sbin/init", "/sbin/init", "--verbose", NULL, envp); return 0; } 

एंड्रॉइड पर्यावरण और उबंटू के चेरोट पर्यावरण के बीच बातचीत के लिए, लिबायब्रिस तंत्र का उपयोग किया जाता है ।

उबंटू टच घटक

यूटी के विभिन्न घटकों से सूप को ~ फैबलेट-टीम लैनचैड रिपॉजिटरी में देखा जा सकता है।
हम निम्नलिखित दो घटकों में रुचि रखते हैं जो एंड्रॉइड डिवाइस पर प्लेटफॉर्म के लिए जिम्मेदार हैं:

• मंच-api
  
• qtubuntu
  

नवीनतम स्रोत कोड डाउनलोड करें:

 bzr branch lp:platform-api bzr branch lp:qtubuntu 

उबंटू प्लेटफार्म एपीआई

उबंटू प्लेटफ़ॉर्म एपीआई प्लेटफॉर्म (एंड्रॉइड) की क्षमताओं का उपयोग करके बुनियादी संचालन करने के लिए एक निम्न-स्तरीय एपीआई है।

तरीकों के उदाहरण:

• ubuntu_application_ui_show_surface
• ubuntu_application_ui_hide_surface
• ubuntu_application_ui_move_surface_to
• ubuntu_application_ui_resize_surface_to

Doc / mainpage.md दस्तावेज़ीकरण फ़ाइल से, हमें पता चलता है कि प्लेटफ़ॉर्म-एपी स्रोत के पेड़ को दो भागों में विभाजित किया जा सकता है:

• शामिल - सार घोषणा मंच एपीआई
• Android - Android के लिए प्लेटफ़ॉर्म API कार्यान्वयन (मैं स्पष्ट करूँगा - Android 4.2 के लिए)

और केवल एक चीज जो तीसरे पक्ष के डेवलपर पर भरोसा कर सकती है जब इस एपीआई के साथ काम करना है
/ ubuntu / आवेदन निर्देशिकाएं शामिल हैं, और बाकी सब कुछ समय के साथ बदलने की उम्मीद करता है।

डेबियन / नियंत्रण फ़ाइल से हम सीखते हैं कि:

 Package: libplatform-api1-hybris Depends: libhybris Description: Hybris implementation of the Platform API (runtime) This package provides the hybris implementation of the Platform API. The produced library should be used via libhybris, to communicate with the Android userspace, which is where the Ubuntu Application Manager lives. 

हाँ, इसका अर्थ है कि एंड्रॉइड / हाइब्रिस / एंड्रॉइड.mk द्वारा देखते हुए, प्लेटफ़ॉर्म एपीआई कार्यान्वयन को एक libubuntu_application_api लाइब्रेरी के रूप में इकट्ठा किया जाता है, जिसमें मूल एंड्रॉइड लिबास के साथ एक लिंक होता है और एंड्रॉइड यूजर्स के लिए रखा जाता है:

 LOCAL_SRC_FILES := \ ubuntu_application_api_for_hybris.cpp \ ubuntu_application_gps_for_hybris.cpp \ ubuntu_application_sensors_for_hybris.cpp \ ../default/default_ubuntu_application_sensor.cpp \ ../default/default_ubuntu_application_ui.cpp \ ../default/default_ubuntu_ui.cpp \ application_manager.cpp LOCAL_MODULE := libubuntu_application_api LOCAL_SHARED_LIBRARIES := \ libandroidfw \ libbinder \ libutils \ libgui \ libEGL \ libGLESv2 \ libhardware \ libhardware_legacy 

प्लेटफ़ॉर्म-एपीआई / src / एंड्रॉइड डायरेक्टरी को अप्राप्य छोड़ दिया गया था, हम इस पर विस्तार से विचार करेंगे। CMakeLists.txt फ़ाइल की उपस्थिति से देखते हुए, विधानसभा पहले से ही glibc के लिए चल रही है।

कोड के साथ एक एकल फ़ाइल है - ubuntu_application_api.cpp , जिसे हमने देखा है:

 extern void *android_dlopen(const char *filename, int flag); extern void *android_dlsym(void *handle, const char *symbol); 

- एंड्रॉइड यूजरस्पेस से साझा लाइब्रेरी से गतिशील रूप से वर्णों को लोड करने के लिए लिबायब्रिस प्रक्रियाओं का उपयोग करना ।

 struct Bridge { static const char* path_to_library() { return "/system/lib/libubuntu_application_api.so"; } Bridge() : lib_handle(android_dlopen(path_to_library(), RTLD_LAZY)) { assert(lib_handle && "Error loading ubuntu_application_api"); } ....... void* resolve_symbol(const char* symbol) const { return android_dlsym(lib_handle, symbol); } void* lib_handle; }; 

- libubuntu_application_api.so से पात्रों को लोड करने के लिए एक सरल पुल, जो देशी एंड्रॉइड सेवाओं के साथ मिलता है, और जिसे हमने हाल ही में "मानसिक रूप से" एंड्रॉइड / हाइब्रिस / एंड्रॉइडएमके का उपयोग करके इकट्ठा किया है।

 #define IMPLEMENT_VOID_FUNCTION3(symbol, arg1, arg2, arg3) \ void symbol(arg1 _1, arg2 _2, arg3 _3) { \ static void (*f)(arg1, arg2, arg3) = NULL; \ DLSYM(&f, #symbol); \ f(_1, _2, _3); } ....... IMPLEMENT_VOID_FUNCTION2(ubuntu_application_ui_init, int, char**); IMPLEMENT_FUNCTION0(StageHint, ubuntu_application_ui_setup_get_stage_hint); IMPLEMENT_FUNCTION0(FormFactorHint, ubuntu_application_ui_setup_get_form_factor_hint); IMPLEMENT_VOID_FUNCTION1(ubuntu_application_ui_start_a_new_session, SessionCredentials*); IMPLEMENT_VOID_FUNCTION2(ubuntu_application_ui_set_clipboard_content, void*, size_t); ....... 

- libubuntu_application_api.so में कार्यान्वित एपीआई वर्णों के लिए रैपर का एक गुच्छा।

तो, भ्रम से बचने के लिए:

• libubuntu_application_api.so - बायोनिक के तहत एक पुस्तकालय, एंड्रॉइड उपयोगकर्ताओं में रहता है;
• libubuntu_application_api.so - glibc के तहत एक पुस्तकालय, linux userpace (chroot) में रहता है, libhybris के माध्यम से पहले से वर्ण लोड करता है।

डेवलपर्स ने एक ही नाम के पुस्तकालयों का निर्माण करके ब्रह्मांड के एन्ट्रापी को कम करने का फैसला किया।
यदि आप मर्ज-153874 चर्चा घटकों के नामकरण पर उनकी बहस को देखते हैं, तो आपके कान फीका पड़ जाएंगे।

Ubuntu आवेदन प्रबंधक

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

 LOCAL_SRC_FILES:= \ application_manager.cpp \ default_application_manager.cpp \ LOCAL_MODULE:= ubuntuappmanager LOCAL_MODULE_TAGS := optional LOCAL_SHARED_LIBRARIES := \ libbinder \ libinput \ libgui \ libskia \ libandroidfw \ libutils \ libEGL \ libGLESv2 \ libubuntu_application_api 

यह एप्लिकेशन और सत्र प्रबंधन कार्यों का एक गुच्छा हल करता है, default_application_manager.h पर एक त्वरित नज़र डालता है :

  void update_app_lists(); void binderDied(const android::wp<android::IBinder>& who); void register_a_surface(...); void request_fullscreen(...); int get_session_pid(const android::sp<android::IApplicationManagerSession>& session); void focus_running_session_with_id(int id); void unfocus_running_sessions(); int32_t query_snapshot_layer_for_session_with_id(int id); android::IApplicationManagerSession::SurfaceProperties query_surface_properties_for_session_id(int id); void switch_focused_application_locked(size_t index_of_next_focused_app); void switch_focus_to_next_application_locked(); void kill_focused_application_locked(); void start_a_new_session( int32_t session_type, int32_t stage_hint, const android::String8& app_name, const android::String8& desktop_file, const android::sp<android::IApplicationManagerSession>& session, int fd); 

QtUbuntu

हम यूबीटी प्लेटफ़ॉर्म एपीआई और क्यूटी / क्यूएमएल अनुप्रयोगों के बीच बातचीत के लिए जिम्मेदार यूटी के हिस्से से निपटते हैं।

यदि आप Qt Platform Abstraction से परिचित नहीं हैं, तो, संक्षेप में, यह मंच से सार करने का एक अवसर है, जिस पर Qt अनुप्रयोगों को विशेष रूप से लिखित QPA प्लगइन्स का उपयोग करके लॉन्च किया जाता है।

QPA प्लगइन createPlatformWindow जैसे बुनियादी तरीकों को लागू करता है , और फिर Qt एप्लिकेशन, जब यह एक विंडो बनाना चाहता है, तो abstraction प्लगइन से createPlatformWindow प्रतीक का उपयोग करता है और वहां से चला गया था।

इस मामले में, हम उबंटू एप्लिकेशन एपीआई के साथ काम करने के लिए क्यूपीए प्लगइन के साथ काम करेंगे।

 ~/ubuntu/qtubuntu $ tree . ├── qtubuntu.pro ├── src │ ├── modules │ │ ├── application <------------------ QML plugin    │ │ │ ├── application.cc | Ubuntu Application Manager │ │ │ ├── application.h |  QtQuick │ │ │ ├── application.pro | │ │ │ ├── application_image.cc | │ │ │ ├── application_image.h | │ │ │ ├── application_list_model.cc | │ │ │ ├── application_list_model.h | │ │ │ ├── application_manager.cc | │ │ │ ├── application_manager.h | │ │ │ ├── application_window.cc | │ │ │ ├── application_window.h | │ │ │ ├── input_filter_area.cc | │ │ │ ├── input_filter_area.h | │ │ │ ├── logging.h | │ │ │ ├── plugin.cc | │ │ │ └── qmldir | │ │ ├── ---------------------------------- │ │ └── modules.pro │ ├── platforms │ │ ├── base │ │ ├── platforms.pro │ │ └── ubuntu <-------------- QPA   │ │ ├── clipboard.cc │ │ ├── clipboard.h │ │ ├── input.cc │ │ ├── input.h │ │ ├── integration.cc <--   `createPlatformWindow`  │ │ ├── integration.h │ │ ├── main.cc │ │ ├── screen.cc │ │ ├── screen.h │ │ ├── ubuntu.json │ │ ├── ubuntu.pro │ │ ├── window.cc │ │ └── window.h │ └── src.pro └── tests 

Ubuntu.pro की सामग्री को देखते हुए, मंच libubuntu_application_api.so के ग्लिब संस्करण के साथ जोड़ रहा है
एकीकरण में उपयोग किए गए प्लेटफ़ॉर्म API सेट से निम्न विधि कॉल पर ध्यान दें ।cc और window.cc :

 #include <ubuntu/application/ui/ubuntu_application_ui.h> ubuntu_application_ui_start_a_new_session(&credentials); ubuntu_application_ui_destroy_surface(surface_); ubuntu_application_ui_create_surface(&surface_, "QUbuntuWindow", geometry.width(), geometry.height(), static_cast<SurfaceRole>(role), flags, eventCallback, this); ubuntu_application_ui_move_surface_to(surface_, geometry.x(), geometry.y()); ubuntu_application_ui_request_fullscreen_for_surface(surface_); ubuntu_application_ui_move_surface_to(surface_, rect.x(), rect.y()); ubuntu_application_ui_resize_surface_to(surface_, rect.width(), rect.height()); ubuntu_application_ui_request_fullscreen_for_surface(surface_); ubuntu_application_ui_show_surface(surface_); ubuntu_application_ui_hide_surface(surface_); 

अब यह स्पष्ट है कि जब हमारा Qt एप्लिकेशन एक विंडो बनाना चाहता है, तो वह क्वबंटू प्लेटफॉर्म के QPA से विधि को कॉल करेगा - QUbuntuIntegration :: createPlatformWindow एकीकरण. cc फ़ाइल से:

 QPlatformWindow* QUbuntuIntegration::createPlatformWindow(QWindow* window) { ....... // Create the window. QPlatformWindow* platformWindow = new QUbuntuWindow(.......); ....... } 

Window.cc फ़ाइल में qubuntuWindow कंस्ट्रक्टर को देखते हुए, हम qubuntuWindow :: createWindow () विधि से कॉल पाते हैं:

 void QUbuntuWindow::createWindow() { ....... ubuntu_application_ui_create_surface( &surface_, "QUbuntuWindow", geometry.width(), geometry.height(), static_cast<SurfaceRole>(role), flags, eventCallback, this); ....... ubuntu_application_ui_move_surface_to(surface_, geometry.x(), geometry.y()); ....... } 

यह बेहद अलग- थलग कोड है, लेकिन सार स्पष्ट है - कॉल उबंटू प्लेटफॉर्म एपीआई के लिए किए जाते हैं, जिसे हमने libubuntu_application_api.so के ग्लिबेक संस्करण में लागू किया है, जो वास्तव में, libubuntu_application_api.so के बायोनिक संस्करण का एक पुल है, जिसका कोड प्लेटफ़ॉर्म में निहित है। एपीआई / एंड्रॉयड ।

क्या हम कूद रहे हैं?

इच्छित फ़ाइल के लिए grep के साथ कूदते हुए, हम प्लेटफ़ॉर्म-एपीआई / एंड्रॉइड / डिफ़ॉल्ट / default_ubuntu_application_ui.cpp पर आते हैं :

 //   ubuntu_application_ui_create_surface ubuntu::application::ui::Surface::Ptr surface = session->create_surface(props, ubuntu::application::ui::input::Listener::Ptr(new CallbackEventListener(cb, ctx))); //   ubuntu_application_ui_move_surface_to auto s = static_cast<Holder<ubuntu::application::ui::Surface::Ptr>*>(surface); s->value->move_to(x, y); 

हमें बस matryoshka खोलना है और यह पता लगाना है कि ubuntu :: application :: ui :: सत्र और, तदनुसार, ubuntu :: application :: ui :: भूतल लागू किए जाते हैं। और वे इस फ़ाइल में कार्यान्वित किए गए हैं - ubuntu_application_api_for_hybris.cpp :

 namespace android { ....... struct Session : public ubuntu::application::ui::Session, public UbuntuSurface::Observer { ....... Session(.....) { ...... ubuntu::application::ui::Surface::Ptr create_surface( const ubuntu::application::ui::SurfaceProperties& props, const ubuntu::application::ui::input::Listener::Ptr& listener) { ....... // ,     .        UbuntuSurface UbuntuSurface* surface = new UbuntuSurface(client, client_channel, looper, props, listener,this); ....... // 100%   ,    UbuntuSurface return ubuntu::application::ui::Surface::Ptr(surface); ....... 

पुरस्कृत करें, UbuntuSurface खोजें :

 struct UbuntuSurface : public ubuntu::application::ui::Surface { ....... UbuntuSurface(const sp<SurfaceComposerClient>& client, .......) : ubuntu::application::ui::Surface(listener) { //    -    Android API surface_control = client->createSurface( String8(props.title), props.width, props.height, PIXEL_FORMAT_RGBA_8888, props.flags & .......); surface = surface_control->getSurface(); ....... 

हमें एक प्रकार की वस्तु मिलती है android :: SurfaceControl , जो android के लिए कॉल का परिणाम है :: SurfaceComposerClient () -> createSurface () ।
Android के लिए सभी कॉल :: SurfaceComposerClient ( चौखटे / मूल / libs / gui / Surface.cpp ) इसके माध्यम से गुजरते हैं, जैसे आकार बदलना, हिलना, परतों के क्रम को बदलना और इसी तरह।

श्रृंखला में वापस आते हुए, हम समझते हैं कि वास्तव में तब क्या होता है जब हम अगले क्यूटी एप्लिकेशन को क्यूपीए प्लेटफॉर्म उबंटू के साथ लॉन्च करते हैं।

निष्कर्ष

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

एक हफ्ते बाद फोन फ़ायरफ़ॉक्स ओएस पर आ जाएगा, यह पता है ...