Share
Het is verbazingwekkend om te bedenken dat bijna tien jaar geleden, toen Mono officieel werd vrijgegeven, C # -ontwikkelaars het overgrote deel van het mobiele landschap bij de hand hadden. Ik herinner me precies waar ik was. Het was zomer 2004 en ik legde de laatste hand aan een fat-client desktop-applicatie met .NET Framework 2.0.
Ik was bezig met het maken van een applicatie voor visualisatie van datacenters in Visio en het automatisch genereren van migratieplannen en checkpoints voor het virtualiseren van hun omgevingen. Het was baanbrekend, als je het mij vraagt.
Ik probeerde zo goed mogelijk op de top van .NET te blijven, dus toen ik hoorde dat er een open versie zou zijn, dacht ik "netjes". Misschien zou ik mijn applicatie op een Linux-computer kunnen uitvoeren. Maar ik werkte in een Microsoft-winkel en zag er niet veel gebruik in, dus heb ik het een tijdje verworpen.
Ongeveer een jaar voordat Mono live ging, werd het bedrijf dat het creëerde, Ximian, gekocht door Novell en ging het verder met zijn producten. Onder deze producten was Mono. In zijn tijd onder de paraplu van Novell, bleef Mono nauwlettend worden gevolgd door de groei en functionaliteit van .NET Framework via Microsoft.
Gedurende deze tijd arriveerden twee zeer grote vorderingen in de mobiele ruimte met betrekking tot Mono, MonoTouch en Mono voor Android werden uitgebracht in respectievelijk 2009 en 2011. Tot grote verbazing van de .NET-community konden we nu mobiele apps schrijven die gericht waren op de iOS- en Android-platforms in een taal die we kenden. Helaas werd dit niet meteen met open armen ontvangen.
Hoewel het Android-platform hier geen problemen mee leek te hebben, was Apple aan de andere kant niet zo ontvankelijk. Medio 2010 heeft Apple de voorwaarden van hun iOS-ontwikkelaarsprogramma bijgewerkt die ontwikkelaars verboden apps te schrijven in andere talen dan C, C ++ en Objective-C, en elke soort laag tussen het iOS-platform en iOS-applicaties heeft beperkt.
Dit had zeker een ramp voor MonoTouch kunnen voorspellen. Gelukkig verloor Apple eind 2010 de taalbeperkingen en de toekomst van MonoTouch zag er opnieuw goed uit, al was het maar kort.
Toen de vooruitzichten voor MonoTouch-gebruikers weer helder werden, was er nog een probleem. Begin 2011 heeft Attachmate Novell gekocht en honderden ontslagen aangekondigd van de Novell-medewerkers. Onder die ontslagen waren verschillende van de oprichters van het originele Mono-raamwerk, evenals de architecten en ontwikkelaars van zowel MonoTouch als Mono voor Android. Wederom maakten we ons zorgen over de toekomst van ons vermogen om C # -apps te maken die op deze nieuwe platforms worden uitgevoerd.
Bijna een maand nadat hij was ontslagen, creëerde Miguel de Icaza een nieuw bedrijf genaamd Xamarin en zwoer hij om de ontwikkeling en ondersteuning van Mono voort te zetten. Novell en Xamarin kondigden aan dat een eeuwigdurende licentie voor Mono, MonoTouch en Mono voor Android zou worden verleend en dat Xamarin nu officieel het project zou overnemen. We hadden opnieuw de sleutels van het koninkrijk.
Ongeveer drie jaar na de oprichting van Xamarin blijven er enkele opmerkelijke hulpmiddelen over. Deze tools zijn niet alleen opmerkelijk vanwege het feit dat ze ons toestaan om C # -toepassingen te schrijven die op niet-Microsoft-platforms worden uitgevoerd, maar ze zijn ook uiterst eenvoudig om aan de slag te gaan.
Om aan de slag te gaan, gaat u gewoon naar de Xamarin-website, schrijft u zich in voor een account als u er nog geen hebt en bezoekt u de downloadpagina. Met elk account krijg je een gratis proefversie van 30 dagen van de zakelijke editie van Xamarin, die je alles biedt wat je nodig hebt.
In de afgelopen jaren is het installatieproces van Xamarin enorm verbeterd ten opzichte van de dagen van MonoTouch en Mono voor Android. Het is een volledig onafhankelijke installatie die de vereiste software en hun versies detecteert om aan de slag te gaan, inclusief de juiste versie van de Android SDK.
Het belangrijkste kenmerk van de Business- (en Enterprise-) editie is volgens mij de ondersteuning voor Visual Studio. Dit betekent dat je al je iOS- en Android-applicaties kunt schrijven met niet alleen een IDE waar je je prettig bij voelt, maar ook het extra voordeel krijgt van andere plug-ins of extensies voor Visual Studio die je misschien gebruikt, bijvoorbeeld Resharper.
Ik weet het niet van je, maar ik krijg zeker een schok van opwinding wanneer ik Visual Studio open, selecteer Bestand> Nieuw project en staar recht tegenover de opties om een iOS- of Android-applicatie te maken.
Als uw 30-daagse gratis proefversie van de zakelijke editie is verlopen op het moment dat u dit leest, kunt u eenvoudigweg downgraden naar de startersversie en blijven spelen met Xamarin. Er zijn echter een aantal nadelen aan de startersversie.
Als u eenvoudig de starterseditie gebruikt om met Xamarin te spelen, zijn deze beperkingen geen probleem. Als je echter aan de volgende grote app werkt, moet je pony voor de Business of Enterprise Edition. Elke editie wordt ook geleverd met een gratis IDE, Xamarin Studio.
Xamarin Studio is een uitgebreide IDE die vele functies bevat die u ook in Visual Studio vindt, dus u hoeft absoluut geen kortgeslotenheid te voelen als u ervoor kiest om Xamarin Studio te gebruiken. Ik voel me erg comfortabel om het te gebruiken en het is echt een genot om mee te werken.
Het leuke is dat de oplossing en projectstructuren onderling uitwisselbaar zijn met die van Visual Studio. Dit betekent dat als u een licentie hebt voor een editie van Xamarin waarmee u Visual Studio kunt gebruiken, u in elke IDE aan dezelfde oplossing kunt werken. Dit maakt samenwerking tussen teams mogelijk tussen ontwikkelaars die een op Windows of Mac gebaseerd systeem gebruiken. Er is geen behoefte aan virtualisatiesoftware, omdat Xamarin Studio beschikbaar is voor zowel Windows als OS X..
Wanneer u met Xamarin aan de slag gaat, is het belangrijk om op de hoogte te zijn van de configuratieopties. Selecteer om in de basisconfiguratie te komen Hulpmiddelen> Opties van Visual Studio of Xamarin Studio.
Ik heb momenteel alleen Xamarin.Android geïnstalleerd. Als je ook hebt geïnstalleerd Xamarin.iOS, je zult meer configuratie-opties zien. Aan de rechterkant van het dialoogvenster Opties ziet u de volgende opties in Visual Studio.
In Xamarin Studio zijn vergelijkbare opties verdeeld over de SDK-locaties, Debugger, en Android tree view items in de projecten sectie. Ik zal u de verschillende configuratieopties laten zien.
Zoals je misschien al geraden hebt, worden deze instellingen gebruikt om de locatie van de Android-bits op je computer in te stellen. Ik vind het meestal niet nodig om deze en meestal een schone installatie van Xamarin te wijzigen-soms met een update of twee-download en installeer ik alle geschikte versies op de juiste locaties. Als u een meer ervaren Android-ontwikkelaar bent die toegang moet hebben tot meerdere versies en heen en weer kan schakelen, hebt u die mogelijkheid.
Dit is waarschijnlijk de configuratieoptie die ik het meest gebruik. Wanneer ik een toepassing schrijf die werkt met lokale sandbox-gegevens op een apparaat of in de emulator, zoals bestanden of een database, zal ik dit vak eventueel aanvinken.
Tijdens de implementatie van een toepassing op een apparaat of de emulator worden alle bestaande gegevens, inclusief databasebestanden, verwijderd en moeten ze opnieuw worden gemaakt. In de vroege stadia van ontwikkeling, wanneer ik zeker wil zijn dat de database met succes wordt aangemaakt, is dit prima. Na dat punt wil ik echter werken met een bevolkte database en niet elke keer dat die toepassing wordt ingezet die gegevens hoeft in te stellen.
Tijdens de ontwikkelingscyclus implementeert u uw debug-build op een apparaat of op de emulator. Gebundeld met uw toepassing zijn standaard uw foutopsporingssymbolen waarmee u fouten kunt opsporen, onderbrekingspunten in uw eigen code kunt instellen en door lijnen kunt lopen terwijl de toepassing wordt uitgevoerd. Met deze optie hebt u ook toegang tot de foutopsporingssymbolen in de gedeelde Mono runtime en de basisklasse-bibliotheken om u meer informatie te geven over wat er in die gebieden gebeurt, evenals uw eigen code.
Dit wordt alleen gebruikt voor foutopsporingsdoeleinden. Een vergelijkbare optie is te vinden in Xamarin Studio. Je kunt het vinden onder de Debugger optie als Debug alleen projectcode; stap niet in de kadercode. U moet dit selectievakje uitschakelen om in het Mono-framework te stappen.
Als u de Android-emulator wilt aanpassen aan de extra instellingen die u normaal gesproken handmatig kunt instellen tijdens het uitvoeren, kunt u met deze optie deze argumenten rechtstreeks doorgeven aan de emulator via Visual Studio of Xamarin Studio.
De Xamarin-software is voortdurend in ontwikkeling en wordt bijgewerkt. Het loont echt de moeite om op de hoogte te blijven van alle wijzigingen in de versie die u momenteel gebruikt, evenals wat er gaat komen. Hier kunt u instellen van welke typen updates u op de hoogte wilt worden gehouden. U wordt gevraagd om nieuwe versies te downloaden en te installeren als u dit selectievakje aanvinkt.
Ik blijf meestal met stabiele releases voor applicaties die gepland zijn voor release, maar ik vind het leuk om een alfa- of bèta-versie te hebben om mee te spelen. Er is een vergelijkbare optie in Xamarin Studio, maar op een andere locatie. Het is te vinden onder Help> Controleren op updates. Hier kunt u kiezen voor Kanaal updaten zoals Stal, beta, of Alpha, net als in Visual Studio.
Met deze optie kan logboekregistratie van apparaatimplementatie worden ingeschakeld. Wanneer deze optie is ingeschakeld, leidt Visual Studio de uitvoer vanuit het implementatielog naar de monodroid.log bestand gevonden op uw bureaublad. Deze optie is niet beschikbaar in Xamarin Studio, althans niet als een configuratie.
Xamarin Studio schrijft altijd logboeken voor apparaatimplementatie, maar ze zijn een beetje moeilijker te vinden. In Windows kunt u ze vinden in de \ LOCALAPPDATA \ XamarinStudio- VERSION \ Logs map waar VERSIEis de versie van Xamarin Studio die u gebruikt. De bestanden worden in die map gemaakt met de naamconventie van AndroidTools- DATA __ TIME waar DATUMis de huidige datum van de implementatie en TIJDis het daadwerkelijke tijdstip van de implementatie.
Voordat ik de schoonheid van deze code behandel, en jongen is het mooi, is het belangrijk dat je begrijpt dat alleen omdat je iOS- en Android-applicaties kunt schrijven in C #, niet betekent dat je alleen iOS- en Android-applicaties in C # kunt schrijven. Het Xamarin-team heeft fantastisch werk verricht waardoor ontwikkelaars met een achtergrond in C # de vermogenom iOS- en Android-applicaties te maken. Het probleem ligt in kennis. Laat me dit in meer detail uitleggen.
Je hebt misschien de C # -kennis die je nodig hebt, maar tenzij je in het verleden hebt gelet op de ontwikkeling van iOS of Android, heb je geen kennis van het platform. Om Xamarin bruikbaar te maken voor alle niveaus van iOS- en Android-ontwikkelaars, heeft het Xamarin-team de taalconstructies en klassenstructuren van Objective-C voor iOS en Java voor Android in C # in kaart gebracht.
Dus wat betekent dat? Het betekent dat u op zijn minst een basiskennis moet hebben van het iOS- en Android-programmeermodel en SDK's om te kunnen profiteren van Xamarin. Dat betekent dat de AVFoundation klasse in Objective-C is de MonoTouch.AVFoundation klasse in C #. De Activiteit klasse op Java is de Android.App.Activity les in C #.
Als u geen ervaring hebt met iOS of Android, laat dan niet toe dat uw gebrek aan kennis u ervan weerhoudt om Xamarin te gebruiken. U hoeft geen maanden, dagen of zelfs uren door te brengen op het iOS Dev Center of de Android Developer-website. Het punt is dat het bekend raken met het platform waar je aan werkt, je tijd meer dan waard is als het je ambitie is om een product van hoge kwaliteit te creëren.
Mijn suggestie is om rechtstreeks naar het Xamarin Developer Center te gaan en snel aan de slag te gaan. U zult documentatie, voorbeeldtoepassingen, tutorials, video's en API-referenties vinden. Alles nadat je bent begonnen, is simpelweg onderzoeken hoe je bepaalde taken kunt uitvoeren. Zodra u de API's en de ontwikkelstroom goed onder de knie hebt, kunt u teruggaan naar de iOS- en Android-bronnen voor meer informatie over de platforms..
Nu dat u de benodigde hulpmiddelen hebt gedownload en geïnstalleerd, laten we ze een tijdje draaien. Om mee te gaan, kunt u Visual Studio of Xamarin Studio gebruiken, omdat ik me zal concentreren op de code, niet op de IDE. Voor deze tutorial gebruik ik Visual Studio 2013 op Windows, maar het staat u vrij om IDE te gebruiken op Windows of Xamarin Studio op OS X. We zullen een eenvoudige Android-applicatie maken die de huidige nieuwsfeed leest van Xamarin en we zullen het noemen XamFeed.
Begin zoals bij elke andere C # -applicatie door een nieuw project / nieuwe oplossing te maken en deze een naam te geven XamFeed. Typische naamgevingsconventies voor een dergelijke toepassing zouden worden toegevoegd .Android tot het einde van de naam. Dit is om de naam van deze applicatie te onderscheiden van elke andere platformspecifieke versie die u later kunt maken (zoals .iOS, .Mac, .Windows telefoon, enz).
Dit zal een heel eenvoudige applicatie zijn, dus we zullen de naam ook eenvoudig houden. U kunt elk gewenst Android-sjabloon kiezen, Android-toepassing, Android Honeycomb-toepassing of Android Ice Cream Sandwich-toepassing. Deze hebben zojuist de basisversie van Android ingesteld die onze applicatie zal targeten. Ik zal de basis gebruiken Android-applicatie sjabloon.
In de Solution Explorer, open de Hoofdactiviteit klasse, die het belangrijkste toegangspunt van onze applicatie zal zijn. Ik wil dit graag hernoemen Activiteit om het doel waarvoor het moet dienen beter weer te geven, dus ga je gang en hernoem het naar FeedActivity.
Als u niet bekend bent met activiteiten, bedenk dan een Activiteit als een scherm of weergave in uw Android-applicatie. Elk scherm dat u nodig hebt in uw toepassing heeft een bijbehorende klasse die erft van de Activiteit basisklasse.
In de FeedActivity klasse, kunt u een aantal methoden overschrijven die u standaard worden aangeboden. De enige waarover we ons zorgen maken, is het OnCreate methode die wordt aangeroepen wanneer ons scherm is gemaakt en toegankelijk is voor de gebruiker.
Het eerste wat we zullen doen is een nieuwe klasse maken die de feed vertegenwoordigt. Je kunt dit duidelijk uitbreiden, maar alles wat we nu nodig hebben is het Titel, pubDate, Schepper, en Link naar de inhoud van het item.
public class RssItem public string Title get; vast te stellen; public string PubDate get; vast te stellen; public string Creator get; vast te stellen; openbare string Link get; vast te stellen;
We kunnen nu de implementatie van de OnCreate methode binnen onze Hoofdactiviteit klasse om de gegevens van de Xamarin-feed te krijgen. Vervang de OnCreate implementatie met het volgende:
Accentsconagua
[Activiteit (Label = "XamFeed", MainLauncher = true, Icon = "@ drawable / icon")] public class FeedActivity: ListActivity private RssItem [] _items; protected async override void OnCreate (bundelbundel) base.OnCreate (bundle); using (var client = new HttpClient ()) var xmlFeed = wacht op client.GetStringAsync ("http://blog.xamarin.com/feed/"); var doc = XDocument.Parse (xmlFeed); XNamespace dc = "http://purl.org/dc/elements/1.1/"; _items = (van item in doc.Descendants ("item") selecteer nieuw RssItem Title = item.Element ("title"). Waarde, PubDate = item.Element ("pubDate"). Waarde, Creator = item.Element ( dc + "creator"). Waarde, Link = item.Element ("link"). Waarde). ToArray (); ListAdapter = nieuwe FeedAdapter (this, _items); beschermde override void OnListItemClick (ListView l, View v, int position, long id) base.OnListItemClick (l, v, position, id); var second = new Intent (this, typeof (WebActivity)); second.PutExtra ("link", _items [positie] .Link); StartActivity (seconde); Laten we dit codefragment regel voor regel doorlopen om te zien wat er aan de hand is.
[Activity (Label = "XamFeed", MainLauncher = true, Icon = "@ drawable / icon")]
De ActivityAttribute dat siert het FeedActivity klasse is het mechanisme dat Xamarin.Android gebruikt om het doelapparaat of de emulator te laten weten dat dit een is Activiteit (of scherm) dat toegankelijk is binnen de applicatie. Dit is voor iedereen nodig Activiteit klassen binnen uw applicatie.
privé RssItem [] _items;
We gaan alle feeditems die we van de Xamarin-website halen in een variabele opslaan om te voorkomen dat we voortdurend HTTP-verzoeken doen. U kunt dit misschien anders aanpakken, afhankelijk van of u dit scherm later wel of niet wilt bijwerken met nieuwe inhoud. In onze eenvoudige toepassing zullen we dit niet doen.
protected async override void OnCreate (bundelbundel) ongeldig
Vervolgens overschrijven we de OnCreate methode die wordt getoond via de Activiteit basisklasse in onze FeedActivity klasse. Deze methode wordt elke keer dit genoemd Activiteit wordt geïnstantieerd door de. Zoals u kunt zien, kunnen we ook de nieuwe C # 5.0 gebruiken async / af te wachten functie om deze methode asynchroon te maken.
base.OnCreate (bundel);
Zorg ervoor dat u de. Belt base.OnCreate methode op de basis Activiteit klasse. Dit zorgt ervoor dat elke verwerking van de basisklasse tijdens de OnCreate methode zal blijven draaien.
using (var client = new HttpClient ())
Om de RSS-gegevens van de Xamarin-website op te halen, gaan we de HttpClient klasse omdat het een aantal handige asynchrone methoden biedt om gegevens via HTTP op te halen.
var xmlFeed = wacht op client.GetStringAsync ("http://blog.xamarin.com/feed/"); var doc = XDocument.Parse (xmlFeed);We roepen vervolgens de GetStringAsync methode op de HttpClient klasse om de feedgegevens en ontleden het in een XDocument object om wat te doen Linq2XML magie.
XNamespace dc = "http://purl.org/dc/elements/1.1/"; _items = (van item in doc.Descendants ("item") selecteer nieuw RssItem Title = item.Element ("title"). Waarde, PubDate = item.Element ("pubDate"). Waarde, Creator = item.Element ( dc + "creator"). Waarde, Link = item.Element ("link"). Waarde). ToArray ();Correct ophalen van elementen uit de resulterende XDocument object, moeten we een instantie van de. maken XNamespace klasse die een deel van de aangepaste opmaak vertegenwoordigt die wordt gebruikt in de Xamarin RSS-feed. We kunnen dan een LINQ-query uitvoeren met de XDocument om alle items eruit te trekken en nieuwe exemplaren van de. te maken RssItem klasse op basis van de itemeigenschappen.
ListAdapter = nieuwe FeedAdapter (this, _items);
Ten slotte gebruiken we een aangepaste adapter om het te vullen Lijstweergave van de FeedActivity, die is gedefinieerd in de Main.axml document in de Resources / lay-out map. Denk aan adapters in Android als een mechanisme om bepaalde op maat gemaakte opmaak van elementen of widgets in de gebruikersinterface te bieden. Alle gebruikersinterfacecomponenten die adapters gebruiken, zoals a Lijstweergave, gebruik standaardadapters als u dit niet expliciet opgeeft, maar u kunt ze altijd vervangen door die van uzelf.
Het laatste stukje van de puzzel voor de FeedActivity klasse is om het te negeren OnListItemClick methode zodat we een nieuw kunnen openen Activiteit die ons de werkelijke inhoud van de afzonderlijke feeditems laat zien die we aanraken.
base.OnListItemClick (l, v, positie, id);
Nogmaals noemen we de methode van de basisklasse om er zeker van te zijn dat alle normale bewerkingen worden uitgevoerd.
var second = new Intent (this, typeof (WebActivity)); second.PutExtra ("link", _items [positie] .Link); StartActivity (seconde);We volgen nu het Android-ontwerppatroon voor het doorgeven van gegevens naar een nieuw Activiteit. Dit zal u heel bekend voorkomen naarmate u meer applicaties maakt die meerdere schermen omvatten. We creëren een nieuw voornemen object, dat is de Android-manier om gegevens naar een nieuw te verzenden Activiteit. We geven het twee objecten door die de context weergeven van waar de oproep vandaan komt, deze, en de Type bezwaar tegen waar het naartoe gaat.
Zodra we het nieuwe hebben voornemen object, wij leggen dingen, meestal snaren, erin en geef het door. In dit geval gebruiken we de PutExtra methode om een toe te voegen sleutel waarde koppelen aan de voornemen, en start het overgangsproces naar de WebActivity scherm met de startActivity methode.
Gebaseerd op de code die betrokken is bij het maken van de FeedActivity scherm, moeten we nu een maken FeedAdapter klasse die het. opvult en opmaakt RssItem gegevens in onze Lijstweergave en een WebActivity klasse om het volgende scherm weer te geven. Laten we beginnen met de FeedAdapter klasse.
public class FeedAdapter: BaseAdapterprivate RssItem [] _items; privéactiviteit _context; public FeedAdapter (Activiteitscontext, RssItem [] items): base () _context = context; _items = items; openbare overschrijving RssItem deze [int positie] krijg return _items [positie]; openbare override int Count krijg return _items.Count (); openbare overschrijving lang GetItemId (int positie) terugkeerpositie; publieke override View GetView (int position, View convertView, ViewGroup parent) var view = convertView; if (view == null) view = _context.LayoutInflater.Inflate (Android.Resource.Layout.SimpleListItem2, null); view.FindViewById (Android.Resource.Id.Text1) .Text = _items [positie] .Title; view.FindViewById (Android.Resource.Id.Text2) .Text = string.Format ("0 on 1", _items [position] .Creator, _items [position] .PubDate); terugkeer bekijken;
Yikes. Dat is veel code. Het is eigenlijk vrij eenvoudig. We moeten vier methoden / eigenschappen op de basisklasse overschrijven, BaseAdapter. In ons geval zal de generieke parameter onze zijn RssItem klasse. De eerste drie zijn redelijk voor de hand liggend.
deze [int positie] retourneert een RssItem op de gegeven positie in de array.tellen geeft het aantal terug RssItem objecten in de array.GetItemId geeft het ID kaart van een RssItem op een gegeven positie, de positie in ons voorbeeld.De laatste, en iets gecompliceerder, override is de GetView methode. Deze methode krijgt een exemplaar van de Lijstweergave binnen onze Activiteit en opblazen het als een SimpleListItem2, wat een type is ListItem weergave binnen Android waarmee twee rijen tekst in één item kunnen worden gebruikt. Vervolgens stellen we de eerste rij tekst in op de RssItem.Title eigenschap en de tweede rij tekst aan een aaneenschakeling van de RssItem.Creator eigendom en de RssItem.PubDate eigendom.
Met de adapterset kunnen we ons concentreren op het tweede scherm van onze applicatie, WebActivity.
[Activity (Label = "WebActivity")] public class WebActivity: Activity protected override void OnCreate (bundelbundel) base.OnCreate (bundle); SetContentView (Resource.Layout.WebActivity); WebView-weergave = FindViewById(Resource.Id.DetailView); view.LoadUrl (Intent.GetStringExtra ( "link"));
De structuur is vergelijkbaar met die van de FeedActivity klasse. We gebruiken opnieuw de ActivityAttribute om de te versieren WebActivity klasse. Er zijn slechts drie licht verschillende lijnen in deze methode die we eerder niet hebben ontmoet.
SetContentView (Resource.Layout.WebActivity);
De SetContentView methode is een leuke hulpmethode die onze C # in kaart brengt Activiteit klasse naar het opgegeven lay-outbestand. In dit voorbeeld verwijzen we naar de WebActivity.axml het dossier.
WebView-weergave = FindViewById(Resource.Id.DetailView); view.LoadUrl (Intent.GetStringExtra ( "link"));
De laatste twee regels zijn specifiek voor de WebView controle binnen onze lay-out. Wij gebruiken de FindViewById methode om een verwijzing naar de opgegeven te krijgen WebView controle en bel de LoadUrl methode en geef deze door aan de gegevens die hier naartoe zijn verzonden Activiteit, via een voornemen, van de FeedActivity klasse.
De laatste stukjes van de puzzel zijn de lay-outbestanden die de plaatsing en naamgeving van bedieningselementen op de afzonderlijke schermen definiëren. De eerste is de Main.axml bestand in de Resources / lay-out map in uw oplossing. Vervang gewoon de inhoud door het volgende:
Maak vervolgens een nieuw Android-lay-outbestand in de Resources / lay-out map, noem het WebActivity.axml, en vervang de inhoud ervan door het volgende:
Zodra u alle onderdelen van deze toepassing hebt gemaakt, kunt u de toepassing met succes bouwen en in de Android Emulator implementeren. Het bouwproces is net als elke andere toepassing die u in Visual Studio hebt gemaakt. U kunt uw toepassing debuggen door op F5 te drukken of uw applicatie uit te voeren met behulp van Control-F5. Het enige verschil is dat u een aantal implementatie-opties hebt die u kunt configureren. Voor deze zelfstudie zijn we geïnteresseerd in het uitvoeren van de toepassing in de Android Emulator, maar als u een fysiek apparaat heeft, kunt u uw toepassing ook daar uitvoeren..
In de Xamarin.Android-werkbalk heb je verschillende opties. U hebt een vervolgkeuzemenu waarmee u de Android-versie kunt opgeven die de emulator moet uitvoeren. Voor deze toepassing heb ik ervoor gekozen om op het moment van schrijven de nieuwste versie van Android, Android_API_19 of KitKat te gebruiken.
Als u niet de nieuwste versie van de SDK hebt zoals ik hier, kunt u de Android SDK Manager openen en de versie downloaden waarop u uw toepassing wilt uitvoeren. Als u de Android SDK Manager opent, kunt u kiezen uit een overvloed aan verschillende Android SDK-versies en een paar extra hulpprogramma's.
U hebt ook de mogelijkheid om de beschikbare emulators te configureren of uw eigen emulators te maken. Dit gebeurt via de Android Emulator Manager waarin u emulators kunt maken, bewerken, kopiëren en verwijderen.
Door op te klikken nieuwe of Bewerk knop aan de rechterkant, krijgt u een dialoogvenster te zien waarmee u de emulator kunt configureren.
Zodra alles is geconfigureerd zoals jij dat wilt, is het tijd voor het moment van de waarheid, waarop je je Android-applicatie draait. Druk op F5 en wacht tot de emulator wordt gestart, wat enige tijd kan duren. Het is daarom een goed idee om de emulator open te laten, zodat u niet hoeft te wachten totdat deze elke keer dat u uw applicatie implementeert, opstart. Zodra uw toepassing in de emulator wordt uitgevoerd, ziet u zoiets als dit.
Uw weergave kan enigszins verschillen, afhankelijk van hoe u de emulator hebt geconfigureerd. Door op een van de titels te tikken of te klikken, gaat u naar een webweergave in uw toepassing die er ongeveer uitziet als hieronder.
Daar heb je het. Je hebt met succes een Android-applicatie gemaakt met behulp van Visual Studio, C # en een beetje hulp van je vrienden bij Xamarin.
Vanaf hier kunt u een aantal stappen nemen. U kunt deze toepassing aanpassen om hem helemaal zelf te maken of hem te laten zoals hij is en indruk te maken op uw vrienden. Hoe dan ook, je hebt een grote stap gezet in de wereld van de mobiele ontwikkeling van niet-Microsoft met behulp van Microsoft-tools. Dat is op zichzelf best cool als je het mij vraagt.
De volgende keer pakken we de wereld van iOS-ontwikkeling aan met Xamarin.iOS, een proces dat erg op elkaar lijkt, met slechts enkele verschillen. Opgewonden? Ik weet dat ik dat ben. Tot de volgende keer en gelukkige codering.
Als je meer wilt weten over Xamarin, bekijk dan onze cursus Bouwen met meerdere platform-apps met C # in Xamarin.
In de cursus leert u hoe u een platformonafhankelijke toepassing kunt maken op basis van één code die op drie duidelijk verschillende platforms wordt uitgevoerd: iOS, Android en Windows Phone 8. Denkt u dat dit niet mogelijk is? Binnen een korte tijd zul je het zelf doen. Laten we aan de slag gaan.
Je kunt het meteen nemen met een helemaal gratis 14 dagen proef van een Tuts + abonnement. Bekijk onze abonnementsopties om aan de slag te
