🤛🏾 🛶 🕘 Xamarin का उपयोग करके पावेल डुरोव की प्रतियोगिता के लिए IM का विकास 🚊 👨🏼‍💻 🏠

शुभ दोपहर

जैसा कि बहुत से लोग जानते हैं कि, पावेल ड्यूरोव व्हाट्स ऐप और अपने लोकप्रिय एमटीटीपीआरओ प्रोटोकॉल के आधार पर अन्य लोकप्रिय इंस्टैंट मैसेंजर का एक नया क्लोन विकसित कर रहा है।

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

कई प्रतिभागियों के विपरीत, मैंने विकास के लिए C # भाषा और Xamarin का उपयोग किया, और मैं आपको इसके बारे में और नीचे बताना चाहता हूं, क्योंकि Xamarin पर हम RuNet में थोड़ी सी जानकारी कहते हैं।

प्रवेश के बदले

मैं एक सहयोगी हूं। मैं दूसरे संस्करण के बाद से बच्चों के साथ काम कर रहा हूं, जब मैं अभी भी एक छात्र था, मुझे इस मंच की क्षमताओं और विशेषताओं को अच्छी तरह से पता है। बहुत पहले नहीं, मैं मोबाइल उपकरणों पर "Android C #" अनुरोध विकसित करना चाहता था और मुझे Xamarin - MonoDroid पर लाया। लेकिन अभी तक मैंने केवल इसके साथ खेलते हुए लिखा था, यह पहली बड़ी एंड्रॉइड परियोजना थी, मैं इसके बारे में बात करना चाहता हूं। इस लेख को समझने के लिए C #, .NET और कम से कम Android की एक आदिम समझ का ज्ञान आवश्यक है।

यह क्या है - संक्षेप में

Xamarin एक कंपनी है (साथ ही एक मोबाइल प्लेटफ़ॉर्म) जो Nat Friedman और Miguel de Icaza द्वारा बनाई गई है, जो GNOME और मोनो के लेखक हैं। इस प्रकार, ज़मारिन मोनो का तार्किक विकास है।
Xamarin आपको C # में Anroid और iOS के लिए देशी एप्लिकेशन लिखने की अनुमति देता है और यह बढ़िया है। मेरा व्यक्तिगत रूप से मानना है कि भविष्य हाइब्रिड क्रॉस-प्लेटफॉर्म के साथ है। और एक मैक भी। और वे सक्रिय रूप से मोनोबेरी के लिए मतदान कर रहे हैं, जो किसी दिन ज़ामरीन का हिस्सा बन सकता है।

कार्य

प्रतियोगिता के कार्य प्रदान किए गए MTProto प्रोटोकॉल (पहले चरण) का कार्यान्वयन और एक पूर्ण अनुप्रयोग (दूसरा चरण) का निर्माण थे। तीसरे चरण में, संशोधन।

एक पूरे के रूप में प्रोटोकॉल RPC का कार्यान्वयन है जिसमें सभी प्रकार की अच्छाइयों जैसे उन्नत एन्क्रिप्शन और विभिन्न प्रकार की सभी चीजें शामिल हैं।

निर्णय

इसके बाद मैं बात करूंगा कि मैंने इन समस्याओं को कैसे हल किया। तो चलिए शुरू करते हैं।

Xamarin प्राप्त करना

Xamarin की लागत $ 2000 है। हाँ यह है यदि आप अपने पसंदीदा स्टूडियो में लिखना चाहते हैं, तो इसकी कीमत $ 999 प्रति प्लेटफ़ॉर्म है। यदि आपके पास काफी अच्छा वातावरण है मोनोडेवलप - इसकी लागत $ 299 प्रति प्लेटफॉर्म है। लेखकों के साथ पत्राचार में, मैं प्रति प्लेटफॉर्म $ 799 तक की छूट के लिए भीख माँगने में सक्षम था।
मैं xamarin कैसे प्राप्त कर सकता हूं? खैर, शुरुआत के लिए, आप ~~इसे टॉरेंट से डाउनलोड~~ कर सकते हैं। Xamarin एक मंच के लिए $ 99 शैक्षणिक लाइसेंस प्रदान करता है जो मेल समर्थन को छोड़कर सभी व्यावसायिक सुविधाएँ प्रदान करता है। और हां, अगर आपकी पत्नी ग्रेजुएट स्टूडेंट है, तो यह भी काम करती है।

समाधान संरचना बनाना

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

सभी फाइलें लिंक के रूप में जुड़ी हुई हैं, मुख्य परियोजना में कोई भी परिवर्तन सभी लिंक की गई परियोजनाओं में प्रदर्शित किया जाएगा।

उपयोगिता "एक्सटेंशन मैनेजर" स्टूडियो से स्थापित की गई है।

समाधान संरचना

मुख्य असेंबली MTProto.Core और Talks.Backend हैं । ये .net 4.5 के लिए सामान्य असेंबली हैं और यूनिट परीक्षणों से आच्छादित हैं।
Mono.Stub , मोनो से कुछ विशिष्ट वर्ग हैं, विशेष रूप से मैं वहां से BigInteger का उपयोग करता हूं।
Droid फ़ोल्डर - में प्रोजेक्ट के Android क्लोन होते हैं, Dataflow - ये Github से TPL.Dataflow के स्रोत हैं। मैं अपनी परियोजना में C # 5.0 की अतुल्यकालिक सुविधाओं का सक्रिय रूप से उपयोग करता हूं।
प्लेटफ़ॉर्म फ़ोल्डर में - प्रत्येक प्लेटफ़ॉर्म के लिए विशिष्ट कार्यान्वयन। अभी तक यह केवल एंड्रॉइड है।

MTProto.Core

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

सुविधाओं में से: सभी तरह से और डेटाफ़्लो async।

सभी तरह से async

C # 5.0 ने कुछ ऐसे कीवर्ड पेश किए, जो टास्क एसिंक्रोनस पैटर्न (TAP) के आधार पर एसिंक्रोनस कोड के विकास को सरल बनाते हैं। वे MSDN पर बहुत अच्छी तरह से वर्णित हैं।
सभी IO ऑपरेशन अतुल्यकालिक होने चाहिए, यह एक कमांड की तरह होना चाहिए।

public async Task RunAsync() { await _cl.LoadSettings().ConfigureAwait(false); if (await _cl.CheckAndGenerateAuth().ConfigureAwait(false)) { await _cl.RunAsync().ConfigureAwait(false); } if ((_cl.Settings.DataCenters == null) || (_cl.Settings.DataCenters.Count == 0)) { await _cl.GetConfig().ConfigureAwait(false); } _db = await TalksDatabase.GetDatabase().ConfigureAwait(false); _ldm = new LocalDataManager(_db); _cl.ProcessUpdateAsync = ProcessUpdateAsync; }

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

"Async सभी तरह से" दृष्टिकोण का सार यह है कि कॉल ट्री पर सभी विधियाँ अतुल्यकालिक हैं, घटना से शुरू होती हैं और सीधे IO ऑपरेशन (इस मामले में) के साथ समाप्त होती हैं।

उदाहरण के लिए, यदि आपको एसिंक्रोनस रूप से एक बटन पर क्लिक करने की आवश्यकता है:

 async void button_Click(object sender, EventArgs e) { _button.Enabled = false; await _presenter.SendMessage(); }

तब आप प्रस्तुतकर्ता एसिंक्रोनस में कॉल ट्री पर सभी तरीके बनाते हैं:

कोड

 public Task<bool> SendMessage() { return SendMessageToUser(); }

 public async Task<bool> SendMessageToUser() { ... try { _imv.AddMineMessage(msg); string msgText = _imv.PendingMessage; _imv.PendingMessage = ""; // messages.sendMessage#4cde0aab peer:InputPeer message:string random_id:long = messages.SentMessage; var result = await _model.PerformRpcCall("messages.sendMessage", InputPeerFactory.CreatePeer(_model, PeerType.inputPeerContact, _imv.ChatId), msgText, LongRandom(r)); if (result.Success) { // messages.sentMessage#d1f4d35c id:int date:int pts:int seq:int = messages.SentMessage; msg.Id = result.Answer.ExtractValue<int>("id"); ... msg.State = BL.Messages.MessageState.Sent; _imv.IvalidateList(); await _model.ProcessSentMessage(result.Answer, _imv.ChatId, msg); return true; } else { msg.State = BL.Messages.MessageState.Failed; _imv.SendSmallMessage("Problem sending message: " + result.Error.ToString()); return false; } } catch (Exception ex) { ... } }

और कोर में:

 public Task<RpcAnswer> PerformRpcCall(string combinatorName, params object[] pars) { return _cl.PerformRpcCall(combinatorName, pars); }

 public async Task<RpcAnswer> PerformRpcCall(string combinatorName, params object[] pars) { try { /*...*/ var confirm = CreateConfirm(); //    WriteOnceBlock<RpcAnswer> answer = new WriteOnceBlock<RpcAnswer>(e => e); IOutputCombinator oc; if (confirm != null) { var cntrn = new MsgContainer(); cntrn.Add(rpccall); //   RPC Call    cntrn.Add(confirm); cntrn.Combinator = _tlc.Decompose(0x73f1f8dc); //     oc = new OutputMsgContainer(uniqueId, cntrn); } else //    { oc = new OutputTLCombinatorInstance(uniqueId, rpccall); } var uhoo = await SendRpcCallAsync(oc).ConfigureAwait(false); _inputAnswersBuffer.LinkTo(answer, new DataflowLinkOptions { MaxMessages = 1 }, i => i.SessionId == _em.SessionId); return await answer.ReceiveAsync(TimeSpan.FromSeconds(60)).ConfigureAwait(false); //       } catch (Exception ex) { ... } }

जैसा कि आप देख सकते हैं, सभी तरीके async-wait कीवर्ड के साथ चिह्नित नहीं हैं। सामान्य अभ्यास यह है: यदि आपको एक एसिंक्रोनस कॉल के बाद कुछ भी करने की आवश्यकता नहीं है और यदि आपके पास एक एसिंक्रोनस कॉल है, तो यह बस विधि से कार्य के रूप में इसे वापस करने के लिए समझ में आता है।
एक और प्रथा (क्लीयर के लेख में भी वर्णित है) यह है कि पुस्तकालयों के अंदर अतुल्यकालिक तरीकों को संदर्भ पर कब्जा नहीं करना चाहिए और निष्पादन के बाद इसे वापस करने की कोशिश करनी चाहिए। यानी सभी अतुल्यकालिक कॉल में .ConfigureAwait(false) होना चाहिए। .ConfigureAwait(false) गतिरोध को रोकने के लिए किया .ConfigureAwait(false) है। आप इसके बारे में ऊपर के लेख में पढ़ सकते हैं।

dataflow

TPL.Dataflow एक लाइब्रेरी है जिसे डेटा फ्लो डिज़ाइन पैटर्न या प्रोसेसिंग पाइपलाइन को लागू करने के लिए डिज़ाइन किया गया है। पुस्तकालय का स्रोत कोड जीथब पर उपलब्ध है , जो आपको मोबाइल उपकरणों पर इसका उपयोग करने की अनुमति देता है। जो लोग इस पुस्तकालय की क्षमताओं के बारे में अधिक जानना चाहते हैं, उन्हें MSDN को भेजा जाता है।

संक्षेप में, पुस्तकालय आपको डेटा भंडारण या प्रसंस्करण इकाइयों से मिलकर एक पाइपलाइन बनाने की अनुमति देता है, उन्हें कुछ शर्त के तहत जोड़ता है। प्रारंभ में, मेरी परियोजना में दो ऐसी पाइपलाइनें थीं: इनपुट और आउटपुट पैकेट के लिए। रिफैक्टरिंग के बाद, मैंने आने वाले पैकेजों के लिए केवल एक को छोड़ने का फैसला किया।

यह इस तरह दिखता है:

और निर्माण प्रक्रिया इस तरह दिखती है:

 BufferBlock<byte[]> _inputBufferBytes = new BufferBlock<byte[]>(); BufferBlock<InputTLCombinatorInstance> _inputBuffer = new BufferBlock<InputTLCombinatorInstance>(); ActionBlock<byte[]> _inputBufferParcer; ActionBlock<TLCombinatorInstance> _inputUpdates; ActionBlock<TLCombinatorInstance> _inputSystemMessages; TransformBlock<InputTLCombinatorInstance, RpcAnswer> _inputAnswers; BufferBlock<RpcAnswer> _inputAnswersBuffer = new BufferBlock<RpcAnswer>(); BufferBlock<RpcAnswer> _inputRejectedBuffer = new BufferBlock<RpcAnswer>(); BufferBlock<InputTLCombinatorInstance> _inputUnsorted = new BufferBlock<InputTLCombinatorInstance>(); // -- //   _inputBufferParcer = new ActionBlock<byte[]>(bytes => ProcessInputBuffer(bytes)); _inputSystemMessages = new ActionBlock<TLCombinatorInstance>(tlci => ProcessSystemMessage(tlci)); _inputUpdates = new ActionBlock<TLCombinatorInstance>(tlci => ProcessUpdateAsync(tlci)); _inputAnswers = new TransformBlock<InputTLCombinatorInstance, RpcAnswer>(tlci => ProcessRpcAnswer(tlci)); // from [_inputBufferBytes] to [_inputBufferTransformer] _inputBufferBytes.LinkTo(_inputBufferParcer); // from [_inputBufferTransformer] to [_inputBuffer] //_inputBufferTransformer.LinkTo(_inputBuffer); // if System then from [_inputBuffer] to [_inputSystemMessages] _inputBuffer.LinkTo(_inputSystemMessages, tlciw => _systemCalls.Contains(tlciw.Combinator.Name)); // if Updates then from [_inputBuffer] to [_inputUpdates] _inputBuffer.LinkTo(_inputUpdates, tlciw => tlciw.Combinator.ValueType.Equals("Updates")); // if rpc_result then from [_inputBuffer] to [_inputRpcAnswers] _inputBuffer.LinkTo(_inputAnswers, tlciw => tlciw.Combinator.Name.Equals("rpc_result")); // if rpc_result then from [_inputBuffer] to [_inputRpcAnswers] //_inputBuffer.LinkTo(_inputUnsorted); // and store it [_inputAnswers] to [_inputAnswersBuffer] to process it _inputAnswers.LinkTo(_inputAnswersBuffer); _inputRejectedBuffer.LinkTo(_inputAnswersBuffer);

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

पद्धति को कॉल करने के तुरंत बाद, हम WriteOnceBlock बनाते हैं - एक ब्लॉक जहां आप केवल 1 मान लिख सकते हैं:

 WriteOnceBlock<RpcAnswer> answer = new WriteOnceBlock<RpcAnswer>(e => e);

और इसे RPC प्रतिक्रिया बफ़र से लिंक करें:

 _inputAnswersBuffer.LinkTo(answer, new DataflowLinkOptions { MaxMessages = 1 }, i => i.SessionId == _em.SessionId);

और फिर हम उत्तर आने तक अतुलनीय रूप से प्रतीक्षा करते हैं:

 return await answer.ReceiveAsync(TimeSpan.FromSeconds(60)).ConfigureAwait(false); //

मैं यह भी अलग से नोट करना चाहूंगा कि इस क्षण तक मैंने एंड्रॉइड के लिए कोड की एक भी पंक्ति नहीं लिखी है। सभी विकास और परीक्षण .net 4.5 के तहत सामान्य विधानसभा के लिए किए गए थे

Talks.Backend

ग्राहक बैकएंड। मैंने IoC के साथ MVP डिज़ाइन पैटर्न के अनुसार क्लाइंट को लागू करने का निर्णय लिया, और शुरू में मैंने पैसिव व्यू वेरिएशन का लक्ष्य रखा जब दृश्य में कोई तर्क नहीं होता है, लेकिन अंत में मैं इस निष्कर्ष पर पहुंचा कि सुपरवाइजिंग कंट्रोलर बहुत बेहतर काम करेगा।

बैकएंड बनाते समय आपको क्या समस्याएं हुईं? नोटबुक तक पहुंच, डेटाबेस तक पहुंच, फ़ाइल सिस्टम तक पहुंच (फोटो संग्रहीत करने के लिए)। बैकएंड का बाकी एक सामान्य एमवीपी कार्यान्वयन है: प्रस्तुतकर्ता और आईवीवाईई का एक सेट

नोटबुक तक पहुंच

नोटबुक तक पहुंचने के लिए, ज़ामरीन टीम पहले ही हमारे लिए सब कुछ लेकर आ चुकी है। उन्होंने Xamarin.Mobile लाइब्रेरी विकसित की है, जो एक मोबाइल डिवाइस पर एक फ़ंक्शन का एक सेट encapsulate करता है - एक नोटबुक, जीपीएस, कैमरा, क्रॉस-प्लेटफॉर्म तरीके से। इसके अलावा async-wait के लिए पूर्ण समर्थन के साथ।

इस प्रकार, नोटबुक तक पहुंच बेहद सरल है:

 #if __ANDROID__ public async Task GetAddressbook(Android.Content.Context context) { contacts = new AddressBook(context); #else public async Task GetAddressbook() { contacts = new AddressBook(); #endif if (!await contacts.RequestPermission()) { Trace.WriteLineIf(clientSwitch.TraceInfo, "Permission for contacts denied", "[ContactsPresenter.PopulateAddressbook]"); _view.SendSmallMessage("CONTACTS PERMISSON DENIED"); return; } else { _icv.PlainContacts = new ListItemCollection<ListItemValue>( (from c in contacts where (c.Phones.Count() > 0) select new ListItemValue(c)).ToList()); } }

__ANDROID__ संकलन __ANDROID__ पेश किया __ANDROID__ था क्योंकि संदर्भ को एंड्रॉइड पर संपर्कों की एक सूची की आवश्यकता होती है, लेकिन अन्य ओएस पर नहीं।

यहां आप क्रॉस-प्लेटफॉर्म समाधान के लिए पैसिव व्यू के नुकसान में से एक देख सकते हैं। असाइनमेंट पर, हमें उपनाम के पहले अक्षर द्वारा समूह संपर्कों की आवश्यकता थी। Android के लिए, यह ListItemCollection वर्ग बनाकर किया जाता है, जो समूहीकरण को लागू करता है, इसका एक उत्कृष्ट उदाहरण इंटरनेट पर उपलब्ध है। IOS पर, इस तरह के समूह बनाने के लिए एक पूरी तरह से अलग दृष्टिकोण यह है कि WinPhone पर - मुझे नहीं पता। इसलिए यह सीधे व्यू में ग्रुप कॉन्टैक्ट्स को रिसीव और ग्रुप करना उचित है

मेरी राय में हाइब्रिड क्रॉस-प्लेटफॉर्म विकास में यह मुख्य समस्या है। आपको स्पष्ट रूप से समझने की आवश्यकता है कि आपको प्लेटफ़ॉर्म से अमूर्त करने की आवश्यकता कहां है, और इसके लायक नहीं है। मुझे लगता है कि यह अनुभव के साथ आता है।

डेटाबेस तक पहुँच

ज़ामरीन एक साधारण ORM SQLite.Net के माध्यम से डेटाबेस तक पहुंच की सिफारिश करता है। एक बार मैंने ड्राइवर के माध्यम से इन सिफारिशों को अनदेखा करने और डेटाबेस के साथ सीधे काम करने की कोशिश की, लेकिन अंत में मैंने महसूस किया कि अधिक अनुभवी डेवलपर्स की सलाह को सुनना बेहतर था।

मुझे SQLite.Net के साथ काम करने के तरीके के बारे में बताने में बहुत कुछ दिखाई नहीं दे रहा है, मैं सिर्फ इतना कहूंगा कि SQlite.Net के साथ असेंबली का परीक्षण करने के लिए, आपको प्रोजेक्ट में sqlite बायनेरी रखने की आवश्यकता है, जो आधिकारिक वेबसाइट www.sqlite.org/download.html पर उपलब्ध है।

अलग-अलग, मैं ध्यान देता हूं कि SQLite.Net पूरी तरह से TAP और async-wait का समर्थन करता है।
मैं SQLite.SQLiteAsyncConnection वर्ग का विस्तार करने की अनुशंसा करता हूं, ताकि डेटाबेस तक पहुंच को आसान बनाया जा सके।

 #region Public Methods public Task<List<T>> GetItemsAsync<T>() where T : IBusinessEntity, new() { return Table<T>().ToListAsync(); } public Task<T> GetItemAsync<T>(int id) where T : IBusinessEntity, new() { return GetAsync<T>(id); } public async Task<bool> CheckRowExistAsync<T>(int id) where T : IBusinessEntity, new() { string tblName = typeof(T).Name; return await ExecuteScalarAsync<int>("select 1 from " + tblName + " where Id = ?", id).ConfigureAwait(false) == 1; } public async Task<int> SaveItemAsync<T>(T item) where T : IBusinessEntity, new() { if (await CheckRowExistAsync<T>(item.Id)) { return await base.UpdateAsync(item).ConfigureAwait(false); } else { return await base.InsertAsync(item).ConfigureAwait(false); } } public Task<int> DeleteItemAsync<T>(int id) where T : IBusinessEntity, new() { return DeleteAsync(new T() { Id = id }); } #endregion

यह भी याद रखने योग्य है कि प्रत्येक ओएस पर फ़ाइल सिस्टम तक पहुंचने के नियम अलग-अलग हैं।

इसलिए, डेटाबेस के लिए पथ निम्नानुसार प्राप्त किया जा सकता है:

 public static string DatabaseFilePath { get { var sqliteFilename = "TalksDb.db3"; #if SILVERLIGHT // Windows Phone expects a local path, not absolute var path = sqliteFilename; #else #if __ANDROID__ // Just use whatever directory SpecialFolder.Personal returns string libraryPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal); #else // we need to put in /Library/ on iOS5.1 to meet Apple's iCloud terms // (they don't want non-user-generated data in Documents) string documentsPath= Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); // Documents folder string libraryPath = Path.Combine(documentsPath, "..", "Library"); // Library folder #endif var path = Path.Combine(libraryPath, sqliteFilename); #endif return path; } }

फ़ाइल सिस्टम एक्सेस

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

Talks.Droid

एप्लिकेशन का Android संस्करण। आदर्श रूप से, जब तक आप एक विशिष्ट मंच पर एक परियोजना बनाते हैं, तब तक आपके पास पूरी तरह से काम करने और परीक्षण किए गए बैकएंड हो सकते हैं। मेरे संस्करण में, यह काम नहीं करता था, लेकिन भविष्य में मैं इसके लिए प्रयास करूंगा।
मुख्य कठिनाइयाँ यहाँ से शुरू होती हैं।

एप्लिकेशन बाउंड सेवा पर आधारित है, जिसके लिए ऐप क्लास बाध्य है - एक सिंगलटन जो "एप्लिकेशन" को लागू करता है। ऐसा इसलिए किया जाता है ताकि कोई भी गतिविधि App.Current.MainService का उपयोग करके सेवा तक पहुंच सके।

सेवा के अंदर, एक अलग थ्रेड में एक मॉडल बनाया जाता है, एक ऐसा वर्ग भी है जिसके साथ गतिविधियाँ अपने प्रेजेंटर्स को उठाती हैं, कुछ इस तरह से:

 _presenter = App.Current.MainService.CreatePresenter<ChatListPresenter>(typeof(ChatListPresenter), this);

यह याद रखना चाहिए कि ज़ामरीन स्वतंत्र रूप से AndroidManifest बनाता है और इसे सीधे संपादित करने की अनुमति नहीं देता है। सभी गतिविधि मापदंडों को विशेषताओं के रूप में दर्ज किया गया है:

  [Activity(Label = "Settings", Theme = "@style/Theme.TalksTheme")] [MetaData("android.support.PARENT_ACTIVITY", Value = "talks.ChatListActivity")] public class SettingsActivity : SherlockActivity, IView

असल में, गतिविधि कोड जावा संस्करण से ज्यादा भिन्न नहीं है, CamelCase, और कुछ गेटर्स / सेटर गुणों में लिपटे हुए हैं

  protected override void OnCreate(Bundle bundle) { base.OnCreate(bundle); // Set our view from the "main" layout resource SetContentView(Resource.Layout.MessagesScreen); AndroidUtils.SetRobotoFont(this, (ViewGroup)Window.DecorView); _presenter = App.Current.MainService.CreatePresenter<MessagePresenter>(typeof(MessagePresenter), this); _presenter.PlatformSpecificImageResize = AndroidResizeImage; this.ChatId = Intent.GetIntExtra("userid", 0); userName = Intent.GetStringExtra("username"); _button = FindViewById<ImageButton>(Resource.Id.bSendMessage); _button.Click += button_Click; _button.Enabled = false; _message = FindViewById<EditText>(Resource.Id.etMessageToSend); _message.TextChanged += message_TextChanged; _lv = FindViewById<ListView>(Resource.Id.lvMessages); _lv.Adapter = new Adapters.MessagesScreenAdapter(this, this.Messages); }

गतिविधि लॉगिन करें

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

ऐसा करने का सबसे आसान तरीका टुकड़ों के साथ है। हालाँकि, टुकड़ों और MVP का उपयोग पूरी तरह से स्पष्ट नहीं है !

नतीजतन, मैं इस निष्कर्ष पर पहुंचा कि मैंने एक प्रस्तुतकर्ता बनाया, और लॉगिनएक्टिविटी ने सिर्फ IVIV अंशों के कार्यान्वयन को लपेटा:

 PhoneFragment _pf = null; CodeFragment _cf = null; SignUpFragment _suf = null; public string PhoneNumber { get { if (_pf != null) { return _pf.Phone; } else { return ""; } } } public string AuthCode { get { return _cf.Code; } } public string Name { get { return _suf.FirstName; } } public string Surname { get { return _suf.Surname; } }

शूटिंग फोटो / वीडियो

एक दिलचस्प और स्पष्ट बात नहीं है। एक कार्य यह था कि कैमरे से फोटो / वीडियो दूसरे व्यक्ति को भेजा जाए या उसे अवतार के रूप में प्राप्त किया जाए।

यह Xamarin.Mobile का उपयोग करके मेनू के माध्यम से किया जाता है।

  public override bool OnMenuItemSelected(int featureId, Xamarin.ActionbarSherlockBinding.Views.IMenuItem item) { switch (item.ItemId) { // Respond to the action bar's Up/Home button case Android.Resource.Id.Home: NavUtils.NavigateUpFromSameTask(this); return true; case Resource.Id.messages_action_takephoto: _presenter.TakePhoto(this); return true; case Resource.Id.messages_action_gallery: _presenter.PickPhoto(this); return true; case Resource.Id.messages_action_video: _presenter.TakeVideo(this); return true; } return base.OnMenuItemSelected(featureId, item); }

हालाँकि, मेनू आइटम का चयन करने के लिए जिम्मेदार ईवेंट बूल है, इसलिए हम इसके लिए async-wait कंस्ट्रक्शन लागू नहीं कर सकते हैं। यह बहुत ही सरल रूप से हल किया गया है, यह याद रखना चाहिए कि एसिंक्स्ट-वेट सिर्फ सिंटैक्टिक चीनी है जो अंततः एक ही निरंतरता उत्पन्न करता है। और कुछ भी हमें पहले की तरह लिखने से रोकता है:

 #if __ANDROID__ /// <summary> ///     /// </summary> /// <param name="context"></param> /// <returns></returns> public bool TakePhoto(Android.Content.Context context) { var picker = new MediaPicker(context); #else public bool TakePhoto() { var picker = new MediaPicker(); #endif if (picker.IsCameraAvailable) { picker.TakePhotoAsync(new StoreCameraMediaOptions { Name = String.Format("{0:dd_MM_yyyy_HH_mm}.jpg", DateTime.Now), Directory = "TalksPictures" }) .ContinueWith((prevTask) => { if (prevTask.IsCanceled) { _imv.SendSmallMessage("User canceled"); return; } if (PlatformSpecificImageResize != null) { string path = PlatformSpecificImageResize(prevTask.Result); //   DomainModel.Message msg = new DomainModel.Message(r.Next(Int32.MaxValue), 0, _imv.ChatId, _imv.PendingMessage, "", 0); _imv.AddMineMessage(msg); } }) .ContinueWith((prevTask) => { if (!prevTask.IsCanceled) { Console.WriteLine("User ok"); } }, TaskScheduler.FromCurrentSynchronizationContext()); return true; } return false; }

Xamarin, क्रॉस-प्लेटफॉर्म के अलावा, कॉम्पोनेंट स्टोर प्रदान करता है, जहां लोकप्रिय एंड्रॉइड और / या आईओएस लाइब्रेरी और घटकों के पोर्ट हैं, दोनों मुफ्त और भुगतान किए गए हैं। विशेष रूप से, ActionBar.Scherlok वहां मौजूद है और Android.Support.v7 हाल ही में दिखाई दिया है, और घटकों को पर्यावरण से सीधे स्थापित किया जा सकता है, जैसे NuGet में, जो बहुत सुविधाजनक है

इस प्रकार, दो क्लिक में, आप Android 2.3 और उच्चतर वाले उपकरणों पर ActionBar समर्थन प्राप्त कर सकते हैं।

प्रकाशन

आपके आवेदन को प्रकाशित करना Google द्वारा अनुमोदित है।

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

और किया

सच है, मैं तुरंत इस विज़ार्ड का उपयोग करके एक KeyStore नहीं बना सकता। कुंजी के जीवनकाल के साथ कुछ था। मुझे पेन बनाना था।

परीक्षण

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

IOS के लिए परीक्षण और विकास के लिए, यह अधिक कठिन है। बेशक, सबसे अच्छा विकल्प सबसे सस्ता मैकबुक लेना है, यह पर्याप्त होगा।
लेकिन परीक्षण के लिए iPhone और iPAD की एक जोड़ी खरीदने के लिए ... मुझे नहीं पता, सबसे अच्छा विकल्प नहीं। अब मैं MacInCloud की संभावना पर विचार कर रहा हूं और अगर वहां सब कुछ ठीक हो जाता है, तो मैं पूरी प्रक्रिया का विस्तार से वर्णन करूंगा।

परिणाम

अब इसे संक्षेप में प्रस्तुत करना कठिन है। विकास प्रक्रिया के दौरान, मैंने एंड्रॉइड प्लेटफॉर्म की विशेषताओं का अच्छी तरह से अध्ययन किया,
एक अच्छा, टेस्ट-कवर और सबसे महत्वपूर्ण बात, क्रॉस-प्लेटफॉर्म बैकएंड विकसित किया।
वे कहते हैं कि आगे WinPhone और iPad के लिए एक प्रतियोगिता होगी। खैर, मैं केवल इंटरफेस बना सकता हूं।

कीड़े पर काम

"स्वयं पर ध्यान दें" जैसा कि वे कहते हैं। मैंने जो गलत किया उसके भविष्य पर सिर्फ टिप्पणी की।
1. डिजाइन की कमी। मैंने MTProto.Core को लगभग पूरी तरह से दो बार रिफलेक्ट किया। इसका कारण यह है कि मैं कागज के एक टुकड़े के साथ नहीं बैठा और पूरी तरह से आकर्षित नहीं किया कि यह कोर कैसे दिखना चाहिए। कई निर्णय अनायास और बिना भविष्य पर ध्यान दिए किए गए।
2. एंड्रॉयड प्लेटफॉर्म की खराब समझ। लंबे समय तक मैंने यह समझने की कोशिश की कि एंड्रॉइड सेवा के साथ बातचीत को कैसे व्यवस्थित किया जाए। सच कहूँ तो, मैं अभी भी इस बातचीत को सुनिश्चित करने का सबसे अच्छा तरीका नहीं जानता। आपको यह समझने की आवश्यकता है कि d.android.com गाइड यहां बेकार हैं, एंड्रॉइड के लिए सेवा की बात विशिष्ट है, लेकिन हमें प्लेटफ़ॉर्म से छुटकारा पाने और कुछ क्रॉस-प्लेटफ़ॉर्म करने की आवश्यकता है।
3. हठ और लालच। मुझे एक और प्रोग्रामर को आकर्षित करने का अवसर मिला, और शायद एक साथ हमने बेहतर परिणाम दिखाया। लेकिन मैं खुद, सब अपने आप से।

Xamarin का उपयोग करके पावेल डुरोव की प्रतियोगिता के लिए IM का विकास