Jump to content

Actie Black Friday: PIA VPN voor slechts €1,94 per maand & 3 maanden gratis

  • Hoog gebruiksgemak en snelle VPN
  • Goede kwaliteit voor de scherpste prijs
  • Torrents, Usenet en Netflix mogelijk!
  • Plus 3 maanden gratis en 30 dagen niet goed geld terug

En de handleiding: Private Internet Access :goed:

  • Sign Up


Leaderboard

Popular Content

Showing content with the highest reputation since 10/28/21 in Handleidingen

  1. Of je er een foto met zonnebloemen mee omturnt in een Van Gogh valt te bezien, maar met het gratis en portable FotoSketcher kun je foto’s wél makkelijk naar allerlei tekeningen en schilderijen converteren. Stap 1 Je kunt nagenoeg meteen aan de slag met FotoSketcher, maar het is geen slecht idee even op het vraagteken te klikken voor een online helpsectie met instructies en fraai beeldmateriaal. Je kunt nu een foton importeren via het mapicoon of met Ctrl+O. Stap 2 Er verschijnt een dialoogvenster waarin je de Tekenstijl selecteert, zoals Potloodtekening, Pentekening, Aquarel, Cartoon enzovoort (circa dertig modellen). Het resultaat kun je vervolgens met behulp van schuifknoppen en functies verder aanpassen. Een voorbeeldweergave toont meteen het effect. Stap 3 Bevestigen doe je met Teken!, maar misschien wil je die instellingen eerst bewaren. Dat doe je via Instellingen opslaan; weer ophalen kan met Instellingen laden. Klik op het tandwielpictogram als je meerdere acties in een script wilt vastleggen en bewaren. Je regelt die acties dan in één keer met Script uitvoeren. Stap 4 Via het T-icoon is het mogelijk tekst aan te brengen met een eigen lettertype, transparantie, kleur en locatie. Dit laatste kan tot op de pixel nauwkeurig. Met het schaartje kun je de bron- of doelafbeelding bijsnijden. FotoSketcher bewaart het resultaat standaard onder een andere naam, in jpg-, png- of bmp-formaat. Download FotoSketcher Diverse mogelijkheden onder deze link.
    2 points
  2. Wil je zelf mobiele apps bouwen? Hier laten we zien wat er allemaal komt kijken bij het bouwen en publiceren van een app. We gaan een Android-app maken met de ontwikkeltools van dit platform. Voordat de smartphone er was, had je alleen simpele mobieltjes om mee te bellen, hooguit met een handjevol extra’s. Zo kon je bijvoorbeeld op de Nokia 6110 uit 1997 het iconische spelletje Snake spelen. Dat wordt over het algemeen gezien als de eerste mobiele app. Verder had je enkele simpele toepassingen als een rekenmachine, agenda en valutaconverter. Bij hedendaagse smartphones is bellen bijzaak; de apps waar ze vol mee staan zijn interessanter en bieden eindeloze mogelijkheden. Met dank aan de kracht van de smartphone, die is volgestopt met elektronica, zoals een modem voor mobiel internet, wifi, bluetooth, gps, microfoon, luidspreker, camera en allerlei sensoren die zelfs de kleinste bewegingen registreren. Wat is een app? Een smartphone is eigenlijk een kleine computer, met een touchscreen als voornaamste bedieningsmethode. Het toestel heeft een mobiel besturingssysteem, specifiek ontwikkeld om de hardware te ondersteunen. Android is bijvoorbeeld nauw verwant aan Linux en gebruikt zelfs een Linux-kernel. Een app kun je eenvoudigweg zien als een softwareprogramma voor dat besturingssysteem. De term app is, dankzij het succes van de smartphone, tegenwoordig algemeen voor softwareprogramma’s. In deze cursus gaan we een app voor Android bouwen met de ontwikkeltools voor dit platform. Maar eerst verkennen we – in dit deel – ook andere bouwmogelijkheden. Een smartphone is volgebouwd met handige snufjes. Een app of een webapp? We zijn de hype weliswaar een beetje voorbij, maar het blijft voor velen een droom om een eigen app te maken. De potentie is enorm: vrijwel iedereen loopt met een smartphone rond. Mondiaal gaat het weliswaar om ‘slechts’ 45 procent van de wereldbevolking, maar in vrijwel alle meer ontwikkelde landen ligt dat percentage boven de 85 procent. Nederland blijkt zelfs koploper: meer dan 93 procent is hier in het bezit van een smartphone. Op de gemiddelde smartphone zijn 60 tot 90 apps geïnstalleerd. Verdient jouw app een plekje op al die toestellen? En op welke manieren kun je die app dan bouwen? Er worden al meer dan drie miljoen apps aangeboden in de Google Play Store. Slepen en neerzetten met app-builders Een speciale manier om een app te maken, is met zogeheten drag-and-drop app-builders. De meeste werken via een browser. Je kunt alle schermen van je app maken door onderdelen naar het venster te slepen en content toe te voegen, zonder dat je kennis van programmeren hoeft te hebben. Daarom noemen we ze ook wel no-code- of low-code-platforms. Bekende voorbeelden zijn Appy Pie, AppSheet en GoodBarber. Zulke tools zijn handig als je snel resultaat wilt, maar je bent wel gebonden aan standaardcomponenten of templates, en kunt het niet volledig naar je hand zetten. Bovendien zit je vaak aan een abonnement vast, waarvan de prijs flink kan oplopen als je niet genoeg hebt aan de basisfunctionaliteit. Met een app-builder kun je relatief snel een app bouwen met standaardcomponenten. Native app Een app die specifiek is ontwikkeld voor een bepaald mobiel besturingssysteem noemen we een native app. Dat is ook wat we in deze cursus gaan maken. Ze worden meestal gemaakt met de ontwikkelomgeving en programmeertaal die bij het platform hoort. Bij Android is de ontwikkelomgeving veelal Android Studio en de programmeertaal Kotlin of Java. Bij iOS heet de voornaamste ontwikkelomgeving Xcode en de programmeertaal doorgaans Swift of Objective-C. Je moet de ontwikkelomgeving én programmeertaal leren kennen, net als de ins en outs van het platform. Dat is best een uitdaging. Maar een native app kan wel álle mogelijkheden benutten en werkt vaak sneller, vloeiender en intuïtiever dan op andere manieren gebouwde apps. De integratie met andere apps is eveneens beter. Je merkt aan alles dat zo’n app specifiek voor het platform is gemaakt. Toch hoef je niet altijd zo’n native app te ontwikkelen. Soms heb je genoeg aan bijvoorbeeld een webapp of hybride app. Webapp Met webtechnologieën als html, css en JavaScript kun je websites maken die er op elk apparaat goed uitzien. Ze worden responsief genoemd omdat ze zich aan de scherm- of venstergrootte van het apparaat aanpassen. Je kunt nog een stapje verder gaan en een mooie app-achtige gebruikersinterface maken. Bibliotheken of frameworks voor JavaScript kunnen je daarbij helpen. Het resultaat noemen we een webapp. Een goed voorbeeld is Facebook: de gebruikersinterface van de website voelt in veel opzichten aan als een app. Het bouwen van een webapp is interessant als je ervaring hebt met webdesign. Wel blijft het resultaat altijd ‘gewoon’ een website die de gebruiker moet openen in de browser en niet een installeerbare app. Al kan er wel een mooi icoontje voor worden gemaakt voor op het beginscherm. De Facebook-website gedraagt zich in de browser als app. Website vermomt als app Als je een responsieve website hebt, zou je eventueel een native app kunnen maken die deze website in een kaal browservenster laat zien. Bij Android gebruik je daarvoor de component WebView. Het gebeurt in de praktijk, maar het is niet aanbevolen. De toegevoegde waarde voor een gebruiker is namelijk erg beperkt. Er is geen verschil als de website in een echte browser wordt geopend. Hybride app Een hybride app is in de basis een webapp, maar dan in het jasje van een app, geschikt voor zowel Android als iOS. Je kunt de app distribueren via de betreffende appstores. Een hybride app is eenvoudig voor meerdere platforms uit te brengen, ook wel cross-platform genoemd. Er zijn speciale frameworks voor het maken van hybride apps. De populairste zijn Ionic en React Native. Verder heb je bijvoorbeeld PhoneGab en Cordova. Vooral React Native is in opkomst. Het is een mooie optie als je veel ervaring hebt met JavaScript, waar het sterk op leunt. De apps die je hiermee bouwt zijn bijna niet te onderscheiden van native apps, maar kennen ook hun beperkingen. Zo kun je vaak niet alle hardware van de smartphone gebruiken. Een responsieve website past zich aan de grootte van het scherm aan. Android of iOS In de markt voor smartphones heerst al sinds jaar en dag een strijd tussen smartphones met Android en de iPhone van Apple – zonder duidelijke winnaar. Beide platforms bieden een eigen ontwikkelomgeving en gebruiken een andere programmeertaal. Wil je een native app maken, dan zul je dus moeten kiezen voor welk platform je die (in eerste instantie) gaat maken. In deze les zetten we de belangrijkste verschillen uiteen om je te helpen bij de keuze. Marktaandeel Android versus iOS Volgens StatCounter heeft Android in Nederland een marktaandeel van 56,94 procent, iOS moet het doen met 42,58 procent. Deze percentages schommelen wat door de jaren heen. Puur cijfermatig is de potentiële afzetmarkt met Android in Nederland het grootst. Als je je met jouw app op andere landen richt, zien de cijfers er anders uit. Maar ook dan heeft Android meestal de overhand, met een wereldwijd marktaandeel van 72,92 procent tegenover 26,53 procent voor iOS. Het marktaandeel van Android en iOS blijft redelijk stabiel. Besturingssystemen Android staat bekend om zijn aanpassingsmogelijkheden en keuzevrijheid, met dank aan bijna 400 fabrikanten die producten voor het platform maken. Kenmerkend voor iOS en de iPhone zijn de fijne gebruikservaring en het strakke ontwerp. Apple was zeker in het begin vaak de trendsetter wat betreft nieuwe functies, die later vaak in net wat andere vorm in Android verschenen. Tegenwoordig gebeurt dat meestal andersom. Maar alles bij elkaar opgeteld zijn de besturingssystemen nu behoorlijk vergelijkbaar. Beide bieden ze bijvoorbeeld een sterke beveiliging, volop voorzieningen om je privacy te bewaren, handige clouddiensten en rijke mogelijkheden voor notificaties en widgets. Bovendien worden zowel Android als iOS actief onderhouden met regelmatige updates en vernieuwingen. Verscheidenheid smartphones Een belangrijk verschil vanuit ontwikkelaarsoogpunt is dat je bij Android rekening moet houden met een enorme verscheidenheid aan fabrikanten en toestellen, met bijvoorbeeld uiteenlopende schermafmetingen en -verhoudingen of technische mogelijkheden. Daarnaast zijn er heel veel versies van Android in omloop. Fabrikanten zijn nooit heel trouw geweest met het uitbrengen van updates. Ook Apple heeft inmiddels een hele rits iPhones geproduceerd in verschillende soorten en maten waar je rekening mee moet houden, maar het aantal is veel beperkter, net als de onderlinge verschillen tussen de apparaten. Bovendien draait op het gros van – niet al te oude – apparaten gewoon de laatste iOS-versie. Dat maakt het als ontwikkelaar makkelijker om nieuwe functies te benutten. Bij elk platform moet je rekening houden met een verscheidenheid aan toestellen. Ontwikkelomgeving en hardware Google en Apple hebben elk een eigen gratis ontwikkelomgeving voor het maken van apps. Voor Android is dat Android Studio, beschikbaar voor Windows, macOS, Linux en Chrome OS. Apple stelt Xcode beschikbaar om apps voor iOS te maken. Deze software kun je alleen op macOS installeren. Je kunt die beperking eventueel omzeilen door een virtuele machine met macOS te gebruiken binnen je eigen besturingssysteem, zoals Windows. Dat kan bijvoorbeeld met de gratis Virtual Box-software van Oracle. Het druist wel tegen de licentievoorwaarden van Apple in. Een ander alternatief – het ‘nabouwen’ van een Mac (ook wel Hackintosh genoemd) – is ook een optie, maar is evenmin een officiële methode en door hardware-beveiligingen steeds lastiger. Wil je voor dit platform gaan ontwikkelen, dan ontkom je er bijna niet aan een Mac, MacBook of eventueel een losse Mac mini aan te schaffen. Breder ontwikkelen Je zult er veel tijd en moeite in moeten steken om een app voor een bepaald platform te maken. En wil je de app dan ook nog voor het andere platform uitbrengen, dan krijg je opnieuw met een vergelijkbare leercurve te maken. Het zogeheten cross-platform ontwikkelen is een manier om dat te voorkomen (zie kader ‘Cross-platform ontwikkelen?’), maar een nadeel is dat deze ontwikkelomgevingen meestal minder gebruiksvriendelijk zijn. Ook is het soms lastiger om de app te optimaliseren en om specifieke hardware- of software-eigenschappen van een platform te benutten. Je inspanningen worden dus zeker beloond als je je in Android óf iOS en in de toegepaste ontwikkelomgeving en programmeertaal verdiept. Je hoeft je daarbij zeker niet tot apps voor smartphones te beperken. Zonder al te veel moeite kun je dezelfde app geschikt maken voor tablets, zolang je hier rekening mee houdt bij het bouwen van de gebruikersinterface. En met smartphones en tablets houdt het nog lang niet op … De ontwikkelomgeving Xcode van Apple werkt alleen op een Mac. Cross-platform ontwikkelen? Wil je een native app maken die voor elk platform geschikt is? Dan kun je een cross-platform ontwikkelomgeving overwegen. Een bekend voorbeeld is Xamarin, waarin je met de programmeertaal C# werkt. Heb je ervaring met het maken van websites? Dan kun je zoals eerder aangehaald ook een hybride app overwegen met bijvoorbeeld React Native. Ook dan kun je het resultaat distribueren via appstores. Voor bovenstaande opties geldt echter dat je niet altijd alle mogelijkheden van het smartphoneplatform kunt benutten. Andere hardware Zowel Android als iOS wordt breed ingezet. Zo wordt Android bijvoorbeeld in de vorm van Android TV als besturingssysteem in diverse smart-tv’s en losse mediaspelers gebruikt. Ook bestaan er smartwatches – de zogenoemde wearables – met Wear OS, wat in feite een aangepaste editie van Android is. Ook op deze platforms kunnen apps geheel zelfstandig draaien. En al deze apps kun je met Android Studio maken. Voor Apple geldt bovenstaande ook. Zo kun je met dezelfde Xcode-ontwikkelomgeving apps maken voor Apple TV (dat tvOS gebruikt), voor Apple Watch (met watchOS) en ook voor macOS, het desktopbesturingssysteem. Natuurlijk komt alle hardware wel weer met zijn eigen uitdagingen, zodra je daar een app voor gaat maken. Maar je kunt eenvoudiger instappen. Niet alleen de ontwikkelomgeving en programmeertaal zijn dezelfde, ook de stappen voor het bouwen van de app hebben veel gemeenschappelijk. In no-time heb je er dus een nieuwe doelgroep bij. Hoe maak je een app? In deze cursus gaan we zoals gezegd een native app maken voor Android. Hoewel oefenen vooropstaat, kun je ook al wat nuttige apps maken. Dit hele proces wordt nog leuker als je al een idee voor een app hebt. In deze les geven we je alvast wat tips, die overigens ook bij het ontwikkelen voor iOS goed van toepassing zijn. Idee voor een app De gedachte om echt iets unieks te maken, moet je misschien loslaten. Er zijn immers al zo’n 3 miljoen apps voor Android uitgebracht. Veel apps zijn variaties op of combinaties van oude, bestaande ideeën. Maar daar is niets mis mee! Enkele tips om inspiratie op te doen: - Neem een bestaande app als uitgangspunt en kijk hoe je die beter kunt maken. Tussen de reviews van apps kun je ook lezen wat er volgens de gebruikers aan schort. - Bepaalde apps zijn in het buitenland een succes, maar niet aangepast aan de Nederlandse situatie. Wellicht kun je een variant maken voor onze markt. - Sommige apps zijn succesvol onder iOS-gebruikers, maar hebben geen goed alternatief voor Android. Misschien kun jij daar voor zorgen. - Een goede manier om ideeën op te doen, is via een brainstormsessie waarin je bijvoorbeeld praktische problemen in het dagelijkse leven als uitgangspunt neemt, waar een app bij kan helpen. - Je kunt ook kijken naar opensource-apps voor Android, waarvoor de broncode bijvoorbeeld op GitHub staat. Zo heb je relatief snel een kant-en-klare app die je daarna beter of mooier kunt maken. Probeer ideeën op te doen voor de app die je gaat ontwerpen. Idee uitwerken Heb je een idee voor een app, dan is het tijd dat verder uit te werken. Denk na over de mogelijkheden die de app moet bieden en kijk wat er technisch haalbaar is. Maak dan een eerste versie. Hiervoor hoef je niet alles uit de kast te trekken. Begin met een eenvoudige maar bruikbare app, in het Engels ook wel ‘minimum viable product’ genoemd. Je kunt de app daarna verder uitbreiden door de terugkoppeling van anderen samen te voegen met je eigen ideeën. Vraag vroeg in het ontwikkelproces ook kennissen en familieleden om feedback. Wees niet bang voor negatief commentaar, maar probeer hier je voordeel uit te halen door de app nog beter te maken. Het bouwen Als je de app gaat bouwen, ontwerp dan eerst de schermen van de app, ook wel gebruikersinterface genoemd. En denk na over de navigatie tussen de schermen. Daarna kun je de code gaan schrijven en interactie met elementen van de gebruikersinterface afhandelen. Dat is de lastigste stap, zeker als je nog niet zo veel programmeerervaring hebt. Er is gelukkig gedegen documentatie en je kunt talloze voorbeelden gebruiken. In deze cursus helpen we je op weg met het bouwen van je app en geven we je tips met hulpbronnen voor als je vastzit! Voor het ontwerpen van je gebruikersinterface kun je ouderwets papier gebruiken.
    2 points
  3. Wil je eens kennismaken met een ander besturingssysteem, zoals een bepaalde Linux-distributie of een Windows-previewbuild? Of wil je graag een testlab opzetten voor je experimenten met penetratietests of ethisch hacken. In beide gevallen biedt virtualisatie een uitweg. We laten hier zien hoe je met het gratis VirtualBox niet alleen virtuele machines, maar ook heuse virtuele netwerken opzet, voor diverse scenario’s. Code downloaden In dit artikel worden wat voorbeelden van stukken code gegeven. Omdat overtikken van code erg foutgevoelig is, kun je die code ook downloaden en daarna bekijken of kopiëren. Zie het bestand code-virtualbox.txt, beschikbaar via https://bit.ly/3wOkUY1. Een eenduidige definitie van virtualisatie geven is lastig, aangezien er diverse virtualisatietypen bestaan. De twee bekendste zijn applicatievirtualisatie (waarbij toepassingen worden geïsoleerd van het onderliggende besturingssysteem en van andere programma’s door ze in een zogenoemde sandbox te stoppen) en systeemvirtualisatie. Bij dit tweede type zorgt een virtuele-machinemanager (VMM), oftewel hypervisor, ervoor dat er meerdere besturingssystemen gelijktijdig op één fysieke machine kunnen draaien door voor elk besturingssysteem de nodige hardware te emuleren. Dat kan via een zogenoemde native of bare-metal-hypervisor, die rechtstreeks op de hardware draait zonder onderliggend besturingssysteem, zoals Microsoft Hyper-V en VMware vSphere/ESXi. Of je zet een hosted hypervisor in, die bovenop een conventioneel besturingssysteem draait, zoals VMware Workstation, Parallels Desktop en Oracle VM VirtualBox. Hypervisors van het eerste type zijn doorgaans stabieler en performanter, maar hypervisors van het tweede type laten zich makkelijker installeren en kunnen met meer diverse hardware overweg. In deze masterclass focussen we ons op dit tweede type, op het gratis VirtualBox om specifiek te zijn. We leggen eerst kort uit hoe je een virtuele machine (VM) installeert, maar de nadruk ligt verder vooral op het opzetten van virtuele netwerken. 01 Virtuele schijf Je vindt VirtualBox op www.virtualbox.org, voor diverse host-besturingssystemen. Wij gaan aan de slag met VirtualBox 6.1 voor Windows. Installeer het programma met de voorgestelde componenten en start de beheermodule op. Klik op Nieuw om een VM te maken en druk op de knop Expertmodus. Geef je VM een Naam en Machinemap (oftewel opslaglocatie) en selecteer Type en Versie voor het virtuele gast-besturingssysteem. Zie je in het uitklapmenu alleen 32bit-versies verschijnen terwijl je echt een x64-cpu en een 64bit-Windows hebt, lees dan eerst het kader ‘Check-up’. Stel een geschikte geheugengrootte in (besef wel dat de ingestelde hoeveelheid geheugen niet beschikbaar is voor je host-besturingssysteem zolang je VM draait), laat de optie Nieuwe virtuele harde schijf aanmaken geselecteerd en kies Aanmaken. Selecteer een geschikte bestandsgrootte voor de virtuele schijf. Je laat dit het best staan op Dynamisch gealloceerd, zodat de schijf tot het ingestelde plafond kan meegroeien naargelang de behoefte. Doorgaans kies je het standaardtype VDI voor je virtuele schijf. Bevestig met Aanmaken, waarna de schijf in het beheervenster opduikt. 01 De eerste stap: het aanmaken van een geschikte virtuele schijf. Check-up Hypervisors stellen doorgaans wel de nodige hardware-eisen, vooral wat de cpu betreft. Zo heb je meestal een 64bit-processor nodig die SLAT (Second Level Address Translation) en virtualisatie ondersteunt. Gelukkig ondersteunen de meeste moderne cpu’s van AMD en Intel die functies. Je controleert het best vooraf in je UEFI/BIOS of deze functie daadwerkelijk is ingeschakeld. Je vindt die ongetwijfeld in een menu als Advanced CPU Configuration, Northbridge of Chipset (bij items als AMD-V of Intel VT). Lukt het je toch niet om virtuele machines te starten, ga dan na of je al een bare-metal-hypervisor zoals Hyper-V hebt draaien, want die verhindert dat een hosted hypervisor zijn werk kan doen. In Windows 10 druk je hiervoor op Windows-toets+R, voer je optionalfeatures uit en kijk je bij Hyper-V. Een bare metal hypervisor haalt een hosted hypervisor doorgaans onderuit. 02 Virtueel besturingssysteem Geen VM zonder virtueel besturingssysteem natuurlijk en dat regel je als volgt. Selecteer de nieuw aangemaakte schijf en klik op Starten. Via het mapicoon en de knop Toevoegen verwijs je naar een (gedownload) schijfkopiebestand, bijvoorbeeld van een Linux-distributie (meestal een iso-bestand). In principe kun je ook naar een usb-stick met een live-besturingssysteem verwijzen (zie het kader ‘Usb-stick’). Selecteer het toegevoegde schijfkopiebestand, klik op Kiezen en op Start, waarna je het virtuele besturingssysteem op de gebruikelijke manier installeert. Goed om weten, is dat VirtualBox voor veel gastsystemen extra stuurprogramma’s en systeemtoepassingen biedt. Die installeert je als volgt: start je VM op, open het menu Apparaten en kies Invoegen Guest Additions CD-image. Dit cd-image verschijnt dan als een virtueel station in je gast-besturingssysteem. Open dit en voer VBoxWindowsAdditions uit. Je kunt nu bijvoorbeeld vanuit het menu Apparaten / USB-apparaten een usb-stick aan het besturingssysteem toewijzen, en het klembord en mappen delen tussen host en gast. 02 Vanuit het instellingenvenster kun je nog heel wat optimaliseren voor je virtuele machine. Usb-stick Met enige moeite (en met behulp van de opdrachtregelversie van VirtualBox) krijg je ook een live-besturingssysteem op een usb-stick in VirtualBox aan de praat. Plug de stick in je pc en open Windows Schijfbeheer (druk op Windows-toets+R en voer diskmgmt.msc uit), waar je het schijfnummer van de stick noteert (Schijf <x>). Start vervolgens de Opdrachtprompt als administrator op, navigeer naar de installatiemap van VirtualBox en voer het volgende commando uit: vboxmanage internalcommands createrawvmdk -filename c:\usb.vmdk -rawdisk \\.\PhysicalDrive# Hierbij vervang je het hekje (#) door het zojuist genoteerde schijfnummer. Vervolgens rechtsklik je op de snelkoppeling naar Oracle VM VirtualBox en kies je Als administrator uitvoeren. Creëer een nieuwe VM, en kiest tijdens de setup Gebruik een bestaand virtueel harde schijf bestand, waarbij je naar c:\usb.vmdk verwijst. Met enige moeite start je ook een live usb-stick in VirtualBox op (wij draaien hier een multiboot-stick op basis van Ventoy). Huidig besturingssysteem Het is ook mogelijk je huidige Windows-installatie te virtualiseren om er bijvoorbeeld op hetzelfde of een ander toestel mee te experimenteren. Dat kan met behulp van de al wat oudere tool Disk2vhd. Na de installatie start je de toepassing op en plaats je een vinkje bij je Windows-volume en bij het (kleine) systeemvolume. Haal het vinkje weg bij Use Vhdx, maar laat het staan bij Use Volume Shadow Copy. Vul een geschikte locatie en naam in, en bevestig met Create. Het hele proces kan behoorlijk lang duren. Na afloop start je dan VirtualBox op, maak je een nieuwe VM, kies je bij Harde schijf de optie Bestaand virtuele harde schijf-bestand gebruiken en verwijs je naar het vhd-bestand. Je kunt ook een actuele en draaiende Windows-installatie virtualiseren. 03 NAT Als je in de beheermodule van VirtualBox met rechts klikt op een (bij voorkeur afgesloten) VM en Instellingen / Netwerk selecteert, dan merk je dat VirtualBox één virtuele netwerkadapter heeft ingeschakeld en die heeft gekoppeld aan NAT (Network Address Translation). Klik je op Geavanceerd, dan zie je dat VirtualBox als adaptertype wellicht Intel PRO/1000 MT Desktop heeft ingesteld, omdat VirtualBox weet dat het betreffende gast-besturingssysteem de benodigde stuurprogramma’s voor die netwerkadapter heeft. NAT is het standaardtype, omdat dit een veilige en makkelijke netwerkconfiguratie is (waarbij zo goed als niets hoeft te worden ingesteld). De NAT-modus zorg er namelijk voor dat VirtualBox als een soort router fungeert, tussen elke VM en het host-besturingssysteem. Op deze manier kunnen de VM’s elkaar niet benaderen en kunnen externe toestellen evenmin de VM’s bereiken. In omgekeerde richting kan je VM doorgaans wel het externe netwerk en internet op. Zo kan je VM de zogenoemde loopback-interface van je host benaderen (via het standaardadres 10.0.2.2), evenals eventuele netwerkservices die op de host actief zijn. Dat kan nuttig zijn als bijvoorbeeld een applicatie op je VM een databaseserver nodig heeft die op je host draait. Een VM krijgt zijn ip-adres van een DHCP-service die actief is in VirtualBox. Bij de eerste netwerkadapter is dat standaard netwerk 10.0.2.0, schakel je een extra virtuele netwerkadapter in (open het tabblad Adapter 2, plaats een vinkje bij Netwerkadapter inschakelen en kies Gekoppeld aan: NAT), dan wordt die aan netwerk 10.0.3.0 gekoppeld enzovoort. NAT is het standaard netwerktype, omdat het praktisch en veilig afgeschermd is. 04 Poortdoorverwijzing Stel, je hebt een of andere netwerkservice op je VM draaien en die wil je nu toch ook bereikbaar maken voor de host of andere machines in je (fysieke) netwerk. Dat is niet zomaar mogelijk in NAT-modus, tenzij je portforwarding inschakelt. Open hiervoor Instellingen / Netwerk van je VM, klik op Geavanceerd / Poortdoorverwijzing en druk op het groene plusknopje. Geef je portforwarding-regel een naam, kies het protocol (TCP of UDP) en vul de velden Hostpoort en Gastpoort in. We nemen de simpele multi-platform MiniWeb HTTP Server als voorbeeld, omdat die zich in een paar seconden laat opzetten (handig voor kleinschalige experimenten). Deze draait standaard op poort 8000, maar wil je die bijvoorbeeld bereiken wanneer je op je host http://localhost:8088 invoert, dan vul je de velden van de portforwarding-regel als volgt in: MiniWeb HTTP Server, TCP, 8088, 8000. Je hoeft het veld Host IP alleen in te vullen als je het verkeer van een specifieke netwerkinterface op je host wilt doorsturen. Het veld Gast-IP is nodig als je de VM een statisch ip-adres hebt meegegeven. Je kunt dergelijke netwerkconfiguraties trouwens ook vanaf de Opdrachtprompt regelen via de meegeleverde tool VBoxManage.exe (zie ook het kader ‘Usb-stick’), met de volgende syntax: vboxmanage modifyvm "<vm-naam>" --natpf<x> "MiniWeb HTTP Server,<protocol>,<host-ip>,<host-poort>,<gast-ip>,<gast-poort>" Hierbij verwijst <x> naar het nummer van de virtuele netwerkadapter. Mocht je ooit een netwerkscenario willen opzetten met een vijfde virtuele netwerkadapter (acht is overigens het maximum), dan is VBoxManage de enige manier: vboxmanage modifyvm "<vm-naam>" –nic5 <netwerktype> In plaats van <netwerktype> kun je onder meer kiezen uit de opties nat, intnet, bridged, hostonly en natnetwork (in de komende paragrafen worden deze opties individueel besproken). Je kunt ook vanaf de Opdrachtprompt (en dus vanuit een batchbestand) poortdoorverwijzingsregels creëren. 05 Intern netwerk Een NAT-constructie is al behoorlijk veilig, maar wil je dat een VM alleen andere VM’s, maar geen externe systemen of internet mag benaderen, dan kies je het best voor Gekoppeld aan: Intern netwerk. Zo’n opzet vertoont flink wat overeenkomst met een Bridged adapter (zie paragraaf 6), maar bij deze laatste loopt alle verkeer over de fysieke netwerkinterface van je host. Dat maakt dat een netwerksniffer als Wireshark via deze weg ook het verkeer tussen je VM’s kan monitoren – wat in bepaalde gevallen juist je bedoeling kan zijn. Voor ons scenario selecteer je Intern netwerk en kies je de standaard beschikbare optie intnet. Of je tikt hier gewoon zelf de naam voor het internet netwerk in. Wil je andere VM’s van ditzelfde netwerk gebruik laten maken, dan moet je uiteraard ook daar diezelfde naam selecteren. In het kader ‘Whonix’ illustreren we een slim gebruik van zo’n intern netwerk. Intern netwerk: een netwerkje voor VM’s onderling. Whonix De gratis tool Whonix, bedoeld om anoniem te kunnen surfen, illustreert mooi het nut van een constructie met NAT en een intern netwerk. Download het ova-bestand van Whonix, een kant-en-klaar ‘Open Virtual Appliance’, en installeer het in VirtualBox via Bestand / Appliance importeren. Na een snelle import zie je twee VM’s: Whonix-Gateway-XFCE en Whonix-Workstation-XFCE. Bij de gateway zijn twee netwerkadapters ingeschakeld: één gekoppeld aan NAT (om internet te kunnen bereiken) en één gekoppeld aan een intern netwerk (met de naam Whonix). De workstation-VM bevat slechts één adapter, die aan het interne netwerk Whonix is gekoppeld. Je surft vanuit deze VM dan via de gateway, die alle verkeer mooi over het anonimiserende Tor-netwerk laat lopen. 06 Bridged adapter In paragraaf 5 hebben we al vermeld dat bij het type Bridged adapter alle verkeer via een fysieke netwerkinterface van je host loopt. Dat gebeurt via een zogenoemde netwerk-filter-driver op de host die data van de fysieke netwerkadapter filtert. Hierdoor kan VirtualBox pakketten van die adapter opvangen en ook data injecteren, zodat in zekere zin een softwarematige netwerkinterface wordt gecreëerd. Voor de host lijkt het alsof een VM fysiek aan de netwerkadapter is gekoppeld. De VM kan in principe in twee richtingen met de host communiceren en ook verbinding leggen naar het externe netwerk toe. Zo’n opzet kan bijvoorbeeld handig zijn als je netwerkservices op je VM draait die je bewust makkelijk bereikbaar wilt maken, zonder dat je met poortdoorverwijzing aan de slag moet. De configuratie is vrij eenvoudig: selecteer Bridged adapter en kies daarna de gewenste fysieke netwerkadapter op je host. Bridged adapter: bespaart je gepriegel met poortdoorverwijzingen. 07 Host-only adapter Wil je je host toegang geven tot je virtuele machines en moeten die ook onderling met elkaar kunnen praten, dan biedt VirtualBox daarvoor de functie Host-only adapter. Communiceren met externe systemen is dan niet zonder meer mogelijk, aangezien je VM’s in dit geval niet zijn verbonden met een fysieke netwerkinterface. Wel wordt op de host een zogenoemde loopback-interface gecreëerd. Deze setup zie je wel vaker opduiken bij vooraf geconfigureerde OVA-appliances waarbij de verschillende VM’s met elkaar moeten kunnen communiceren, zoals een webserver en een database. Wil je de webserver toch ook bereikbaar maken via internet, dan zou je hiervoor eventueel nog een bridged adapter kunnen instellen, zodat je database veilig afgeschermd blijft. De configuratie vergt net iets meer werk. Eerst moet je namelijk een geschikte host-only adapter instellen. Scrol in je VM-lijst helemaal naar boven, kies Tools, klik op het menuknopje (met de drie streepjes) en selecteer Netwerk. Klik eventueel op Aanmaken en bevestig met Ja. Selecteer de adapter en vul het gewenste ip-adres en netwerkmasker in. Open het tabblad DHCP-server en plaats eventueel een vinkje bij Server inschakelen, waarna je de velden Serveradres, Servermasker, Laagste adres en Hoogste adres instelt. Bevestig met Toepassen. Tot slot open je Instellingen / Netwerk van je VM, kies je Gekoppeld aan: Host-only adapter en selecteer je de juiste adapter in het uitklapmenu. Stel de adapter in en activeer eventueel ook een DHCP-server. 08 NAT-netwerk Wil je dat je virtuele machines onderling kunnen communiceren en ook het externe netwerk kunnen bereiken, dan koppel je best een NAT-service aan een intern netwerk, waar je vervolgens alle gewenste VM’s aan koppelt. Denk bijvoorbeeld aan een scenario met een pentesting-appliance (penetration testing) als Kali Linux. We kunnen ons voorstellen dat je deze in zo’n NAT-netwerk wilt onderbrengen, samen met de VM’s die je als doelwit voor deze pentester wilt gebruiken. Je maakt zo’n NAT-netwerk als volgt. Open het menu Bestand en kies Voorkeuren / Netwerk. Druk op het groene plusknopje en vervolgens op het oranje knopje Bewerk geselecteerd NAT-netwerk. Vul de velden Netwerknaam en Netwerk-CIDR in (bijvoorbeeld 192.168.1.0/24 voor het veld Netwerk-CIDR). Wellicht wil je het vinkje bij Ondersteunt DHCP laten staan. Onderaan in het venster staat de knop Poortdoorverwijzing. Zorg dat er een vinkje staat bij Inschakelen netwerk en bevestig met OK. Vervolgens open je de netwerkinstellingen van je VM, waar je Gekoppeld aan: NAT-netwerk selecteert en in het uitklapmenu het zojuist aangemaakte NAT-netwerk aanduidt. Herhaal dit voor de virtuele machines die je aan ditzelfde netwerk wilt koppelen. Samen gezellig in hetzelfde virtuele NAT-netwerk.
    1 point
  4. Eenvoudige apps bouwen is nog niet echt programmeren. We nemen een stapje terug en introduceren de programmeertaal Kotlin, waarvoor we eerst een ontwikkelomgeving installeren. Code downloaden In dit deel van de cursus Apps bouwen worden wat voorbeelden van stukjes code gegeven. Omdat overtikken van code erg foutgevoelig is, kun je die code ook downloaden en daarna bekijken of kopiëren. Zie het bestand code-appsbouwen-deel5.txt beschikbaar via www.pcmweb.nl/download. Kotlin is de officiële programmeertaal voor Android Studio. Wil je een volleerd Android-programmeur worden, dan zul je er waarschijnlijk niet genoeg aan hebben. Zo is het nuttig om bijvoorbeeld meer te leren over object-georiënteerd programmeren en ook wat kennis van Java op te doen, want daar werkt Android onder de motorkap mee. Ga je daadwerkelijk Android-apps bouwen, dan kun je zowel Kotlin als Java gebruiken. Ze werken naadloos samen en je kunt ze beide in je project gebruiken. Het voordeel van Kotlin is dat je efficiënter kunt werken, omdat er minder regels code nodig zijn om hetzelfde te doen. We geven je een basis van Kotlin, maar verdere verdieping is zeker gewenst. Ontwikkelen in Android Studio? Je kunt Android Studio gebruiken om te leren programmeren met Kotlin, maar het is niet de beste optie. Alles is daarin namelijk ingericht op het bouwen van apps. Oefenen met alleen Kotlin is wat omslachtig. Daarom gebruiken we hier het programma IntelliJ IDEA, dat we gewoon náást Android Studio installeren. In delen 2 en 4 van deze cursusreeks schreven we al dat Android Studio op deze software is gebaseerd, waardoor het er heel sterk op lijkt. Je zult er daarom snel mee overweg kunnen. En vrijwel alles wat je in deze software leert is in Android Studio toepasbaar! IntelliJ IDEA installeren Om IntelliJ IDEA te downloaden, ga je naar www.jetbrains.com/idea. Klik op Download en volg de downloadlink naar de gratis Community-editie. Start daarna de installatie. Zet op het scherm Installation Options onder Create Desktop Shortcut een vinkje bij 64-bit launcher. Heb je een (tegenwoordig vrij zeldzame) 32bit-versie van Windows, zet dan vinkjes bij alleen alle 32bit-opties! Onder Create Associations vink je alle opties aan, zodat je ondersteunde bestanden automatisch in IntelliJ IDEA kunt openen. Via een configuratiewizard kun je vervolgens enkele aanpassingen doen en extra’s installeren. Je kunt overal de standaardinstellingen accepteren. Na de installatie kun je IntelliJ IDEA direct openen. Zie je de optie Plugin Updates Available, dan raden we aan deze updates te installeren, zodat ze up-to-date zijn. Bij de installatie kiezen we enkele aangepaste opties. Instellingen aanpassen voor prettiger coderen We raden je aan om enkele instellingen aan te passen, zodat code wat beter leesbaar is. Dat kun je zowel in IntelliJ IDEA als in Android Studio doen! Dat kan in de openingsdialoog via Configure / Settings of (als je de software al hebt geopend) via het menu File / Settings. Blader dan naar Editor / General / Appearance. Zet hier de optie Show method seperators aan. Er wordt dan een horizontale scheidingslijn tussen functies gezet, zodat je ze makkelijker uit elkaar kunt halen. Ga vervolgens naar Editor / General / Code Folding en haal onder General de vinkjes weg bij File header en Imports. Doe hetzelfde onder Java bij One-line methodes, Closures en Generic constructor and method parameters. Als deze opties aanstaan, wordt veel code ingevouwen, terwijl je zulke code als je begint met programmeren liever altijd ziet. Andere instellingen die je eerder in Android Studio hebt doorgevoerd, zoals die onder Editor / General / Auto Import, zul je ook nog in IntelliJ IDEA moeten doen, als je ze wenst te gebruiken. Enkele kleine aanpassingen helpen je bij het schrijven van code. Aan de slag met IntelliJ IDEA Oefenen zonder Android Studio Met de installatie van IntelliJ IDEA heb je een ontwikkelomgeving waarin je los van Android Studio kunt oefenen met Kotlin. In deze les introduceren we de belangrijke aspecten van deze programmeertaal. We gaan beginnen met een eenvoudig basisprogramma. Start daarvoor IntelliJ IDEA en kies in de openingsdialoog New Project. Selecteer links Kotlin en kies rechts onder JVM de optie Console Application. Voer bij Name een naam in (bijvoorbeeld Demo) en bij Location een map waarin je projectbestanden wilt bewaren. Accepteer verder de standaardinstellingen, klik op Next en dan Finish. Links zie je je projectvenster (net als bij Android Studio). Open daarin onder src/main/kotlin het bestand main.kt. Hierin zie je de volgende regels: fun main(args: Array<String>) { println("Hello World!") } Wat je ziet is een verplichte functie main voor het hoofdprogramma, die meerdere strings als parameters (ofwel ‘argumenten’) accepteert. Die worden als zogenaamde array (een lijst met gegevens) ingelezen. De printopdracht toont daarna een tekst met println() op een hele regel. Er wordt overigens niets met eventuele argumenten gedaan, al kan dat natuurlijk wel (zie het kader ‘Programma starten met argumenten’). Probeer het te starten. Klik daarvoor met rechts op een lege plek in de editor en kies Run ‘MainKt’. Of gebruik het menu Run of druk op Shift+F10. Onderaan in de interface, in het venster Run, zie je de uitgevoerde tekst. We gaan aanpassingen doen in deze functie en houden steeds deze uitvoer in de gaten. Binnen de functie main schrijf je de gewenste code in Kotlin. Programma starten met argumenten Je kunt eenvoudig enkele parameters opgeven bij de programmastart. Ga hiervoor naar Run / Edit Configurations en voer achter Program arguments het argument in, bijvoorbeeld het woord welkom. Verander de printopdracht in de code dan naar println(args[0]), waarmee in feite het eerste element van de array wordt geprint, in dit geval de string welkom. Commentaar toevoegen Voordat we beginnen, staan we even stil bij het gebruik van commentaar waarmee je code kunt verduidelijken, bijvoorbeeld bepaalde functies of opdrachten. Dat is handig voor jezelf, maar ook voor iemand anders die jouw code onder ogen krijgt. Een regel met commentaar begin je eenvoudigweg met //. Je mag commentaar behalve op een eigen regel ook achter een opdracht zetten. Veel teksteditors, waaronder IntelliJ IDEA en Android Studio, bieden een snelle manier om meerdere regels als commentaar te beschouwen. Selecteer daarvoor de regels en klik op Ctrl+/. Met dezelfde toetscombinatie zet je het commentaar ook weer terug naar code. Verder kun je een heel blok als commentaar laten beschouwen door het blok te omsluiten met /* gevolgd door */. In de voorbeelden in dit cursusdeel gebruiken we commentaar om het resultaat van een printopdracht te laten zien, bijvoorbeeld: println("Hello World!") // Hello World! Takenlijstje voor wijzigingen Vaak zul je tijdens het programmeren al ideeën voor uitbreidingen hebben of heb je simpelweg geen tijd om een bepaalde functie af te ronden. In zo’n geval is het handig om de tekst todo in je commentaar op te nemen. Zulk commentaar wordt handig in soort takenlijstje opgenomen. Die vind je door links onderaan in de gebruikersinterface op TODO te klikken. Alle regels commentaar met de tekst todo worden hier opgesomd. Als je op een regel klikt, ga je direct naar de bewuste regel in je code. Dit werkt overigens ook in Android Studio. Voor openstaande wijzigingen in je code kun je handig een automatisch takenlijstje bijhouden. Variabelen en gegevenstypen Bij het programmeren zul je regelmatig gegevens moeten opslaan. Hiervoor gebruik je variabelen. Een variabele kun je zien als een naam voor een geheugenlocatie waar bepaalde gegevens zijn opgeslagen. Het gegevenstype bepaalt wat voor soort gegevens dat zijn, bijvoorbeeld een tekst of getal. Hier maken we als voorbeeld een variabele tekstWelkom met een korte welkomsttekst: var tekstWelkom = "Welkom!" Kotlin ziet aan de waarde die je aan de variabele toekent dat String als gegevenstype moet worden gebruikt. Je kunt het gegevenstype ook expliciet opgeven: var tekstWelkom: String = "Welkom!" Zeker als er onduidelijkheid over kan bestaan, moet je het gegevenstype noemen. Dat is onder andere het geval als je een variabele eerst declareert, waarna je pas later een waarde toekent. Kotlin kan niet raden om welk gegevenstype het gaat, dus moet je het benoemen, bijvoorbeeld: var tekstWelkom: String tekstWelkom = "Welkom!" Getallen Voor gehele getallen kent Kotlin de gegevenstypes Byte (8 bit), Short (16 bit), Int (32 bit) en voor heel grote getallen een Long (64 bit). Een leeftijd kun je bijvoorbeeld noteren als: var leeftijd = 30 Kotlin kiest zelf het gegevenstype en dat is voor gehele getallen (behalve bij heel grote getallen) een Int. In deze 32bit-ruimte kun je waarden van -2.147.483.648 tot en met 2.147.483.647 bewaren. Strikt genomen is een Short (-32.768 t/m 32.767) of zelfs een Byte (-128 t/m 127) genoeg om iemands leeftijd te bewaren. Die mag je dus ook gebruiken, al win je er op moderne computers in de praktijk weinig mee. Wil je zo’n kleiner gegevenstype gebruiken, dan zul je dat ook expliciet op moeten geven: var leeftijd: Byte = 30 Voor zwevende-kommagetallen zijn er twee gegevenstypen, namelijk de Float (32 bit) en (voor extra precisie) de Double (64 bit). De komma schrijf je bij het programmeren overigens altijd met een punt. Als je een getal met een punt toekent aan een variabele, zal Kotlin dat standaard als een Double beschouwen, bijvoorbeeld: var pi = 3.14 Wens je de hogere precisie van een Float, dan moet je dat opgeven met een f achter de waarde: var pi = 3.14f De f is overigens ook nog steeds nodig als je al expliciet het gegevenstype hebt benoemd: var pi: Float = 3.14f Een handigheidje is dat je een underscore (_) in de waarde mag gebruiken om lange getallen leesbaarder te maken: var langgetal = 1_000_000 Kotlin kent ook de zogeheten Boolean met true of false als mogelijke waarden. Een logisch voorbeeld waarin je het gebruikt, is een lamp die aan of uit kan staan: var lichtStaatAan: Boolean = true Werken met variabelen voor bijvoorbeeld teksten in Kotlin. Gebruik van var versus val Je ziet dat we hier steeds het sleutelwoord var hebben gebruikt om een variabele te declareren. Dat is het meest gangbaar. Je gebruikt het als de waarde nog kan veranderen nadat je die hebt toegekend. Als een waarde niet meer verandert, kun je beter het sleutelwoord val gebruiken. Dat is bijvoorbeeld van toepassing voor de waarde van pi: val pi = 3.14 Nadat je zoals hier de waarde voor pi met val hebt opgegeven, kun je deze verderop in je code niet meer veranderen. Als je het wel doet, geeft dat een foutmelding. Berekeningen Op getallen kun je berekeningen loslaten via zogeheten operators. De meeste spreken voor zich, zoals optellen (+), aftrekken (-), vermenigvuldigen (*) en delen (/😞 var leeftijd = 12 leeftijd = leeftijd + 1 Je kunt in dit voorbeeld ook de verkorte notatie leeftijd += 1 gebruiken of zelfs leeftijd++. In dit voorbeeld spreekt het overigens voor zich dat je met integers werkt en dat het resultaat een integer blijft, maar in andere gevallen moet je rekening houden met het gegevenstype. Heb je bijvoorbeeld de variabele salaris van het type Int en verhoging van het type Double, dan kun je ze niet zomaar bij elkaar optellen: var salaris = 12 var verhoging = 0.5 salaris = salaris + verhoging //foutmelding! Je kunt dit op verschillende manieren oplossen. Het meest logisch is in dit geval om salaris als Double te declareren. Dat kan eenvoudigweg door var salaris = 12.0 te schrijven, of, als je expliciet wilt zijn, met var salaris: Double = 12.0, maar de punt is in beide gevallen cruciaal. Meestal zal Kotlin voor het resultaat van een berekening het meest logische gegevenstype gebruiken. Vermenigvuldig je bijvoorbeeld twee variabelen van het type Int, dan levert dat een integer op. Vermenigvuldig je een Double met een Int, dan geeft dat een Double, zoals in onderstaand voorbeeld waarin we de omtrek van een cirkel berekenen: val pi = 3.14 var straal = 12 var omtrek = pi * 2 * straal println(omtrek) //75.36 Er zijn allerlei methodes om gegevenstypen te converteren. Wil je bijvoorbeeld graag een Int als resultaat, dan kun je dat oplossen door van pi een Int te maken met de methode toInt(): val pi=3.14 println(pi.toInt()*2*12) //72 Je kunt je afvragen waar methodes zoals toInt() vandaan komen. De achtergrond is dat Kotlin geen zogenaamde primitieve gegevenstypen kent. Als je een gegevenstype als Int of Float gebruikt, dan wordt hier intern een object voor gemaakt. En op zo’n object kun je allerlei ingebouwde methodes loslaten. Een methode die je heel vaak tegenkomt is toString(). Daarmee vraag je in feite om een bepaalde waarde als String te krijgen. Variabelen eenvoudig hernoemen Er is een eenvoudige manier om de naam van een variabele te veranderen. Daarvoor klik je rechts in je code op de variabele en kies je Refactor / Rename. Voer nu de nieuwe naam in; deze nieuwe naam wordt daarna overal in je code doorgevoerd. In Android Studio kom je dat ook tegen als je bijvoorbeeld de ID van een component in je lay-out verandert. De naam voor een variabele kun je eenvoudig overal laten aanpassen. Lijsten Vaak wil je meerdere gegevens bewaren die bij elkaar horen in een lijst. Dat kan in Kotlin met listOf(), bijvoorbeeld voor soorten fruit: var fruit = listOf("appel","peer","banaan") Je hoeft het gegevenstype niet op te geven, al mag dat wel: var fruit: List<String> = listOf("appel","peer","banaan") Nu je een lijst hebt gemaakt, kun je via de index een item uit deze lijst aanwijzen. Het eerste item begint bij 0. De waarde kun je laten zien met: println(fruit[0]) //appel Merk op dat je de inhoud van items in zo’n lijst niet kunt veranderen. Daar gebruik je een zogeheten array voor. Je kunt zo’n array declareren met de volgende opdracht: var fruit = arrayOf("appel","peer","banaan") Ook hier kun je optioneel het gegevenstype opgeven: var fruit: Array<String> = arrayOf("appel","peer","banaan") Bij een array kun je wel de waarde van items veranderen, zoals het tweede item: fruit[1] = "mandarijn" println(fruit[1]) //mandarijn Wil je ook nog items toe kunnen voegen aan een lijst of verwijderen? Dan kun je weer een ander soort lijst gebruiken, de zogenoemde MutableList: var fruit: MutableList<String> = mutableListOf("appel","peer","banaan") Hierna kun je een item toevoegen aan deze lijst door eenvoudigweg de methode add te gebruiken: fruit.add("mandarijn") Bij bovenstaande opdracht komt het item achteraan. Je kunt optioneel een index opgeven als het item op een bepaalde plek moet komen, bijvoorbeeld 0 voor in het begin: fruit.add(0, "mandarijn") Er zijn veel meer methodes, bijvoorbeeld om een item te verwijderen of te vervangen. Je hoeft niet altijd de index te gebruiken, maar kunt ook een bepaald element op naam verwijderen: fruit.remove("peer") Lijsten zul je vaak tegenkomen bij het bouwen van apps, dus het is goed hier wat ervaring mee op te doen. Je kunt ze niet alleen voor teksten gebruiken, maar ook bijvoorbeeld integers en objecten. Met lijsten kun je gegevensverzamelingen maken, bijvoorbeeld voor soorten fruit. Beslissingen, lussen en functies Beslissingsopdrachten Als je al wat ervaring met programmeren hebt, zul je veel dezelfde opdrachten tegenkomen, maar soms in iets andere vorm. Vrij herkenbaar zijn de beslissingsopdrachten. Als voorbeeld nemen we de eerdere Boolean en maken we een keuze afhankelijk van zijn waarde: var lichtStaatAan: Boolean = true if (lichtStaatAan) { println("Het licht staat aan!") } else { println("Het licht staat uit!") } Je kunt ook een vergelijking tussen haakjes zetten die – zoals we dat noemen – evalueert naar een Boolean: var leeftijd = 19 if (leeftijd >= 18) { println("Volwassen!") } Er zijn verschillende operatoren bruikbaar in vergelijkingen: < kleiner dan > groter dan == gelijk aan != niet gelijk aan <= kleiner dan of gelijk aan >= groter dan of gelijk aan Een handig ezelsbruggetje om te onthouden, is dat je van < (kleiner dan) de letter k kunt maken. Je kunt operatoren ook gebruiken in vergelijkingen, waarbij je het resultaat vervolgens direct toewijst aan een variabele van het gegevenstype Boolean. Je kunt het als verkorte beslissingsopdracht zien: var leeftijd = 19 var volwassen: Boolean = leeftijd >= 18 Documentatie voor Kotlin We gaan in sneltreinvaart door de belangrijkste eigenschappen van Kotlin. Op de website van Kotlin vind je hier een uitgebreidere beschrijving. Zo lees je bijvoorbeeld onder Basics / Control Flow hoe je beslissingen kunt nemen of lussen kunt inbouwen. Het is altijd handig dit als referentie erbij te gebruiken. Kotlin biedt online een uitgebreide referentie voor de programmeertaal. Lussen Lussen gebruik je om opdrachten te herhalen. In dit voorbeeld gebruiken we een lus om de getallen 1 tot en met 10 te doorlopen: for (x in 1..10) { println(x) } Een lus kun je handig gebruiken voor het doorlopen van een lijst: var fruit: MutableList<String> = mutableListOf("appel","peer","banaan") for (fruitsoort in fruit) { println(fruitsoort) } Functies We werken steeds in main, in feite het hoofdprogramma, maar je kunt hierin ook zelf functies schrijven. Aan zo’n functie kun je eventueel argumenten meegeven, zoals ook bij de functie main zelf gebeurt. Functies voeg je steeds toe binnen de functie main en pas nadat je de functie hebt geschreven kun je deze daadwerkelijk aanroepen. Als voorbeeld schrijven we een eenvoudige functie berekenSom() die twee gehele getallen accepteert en toekent aan de variabelen a en b van het type Int. Die variabelen kun je dan in je programma gebruiken om bijvoorbeeld de som van de getallen te printen: fun main(args: Array<String>) { fun berekenSom(a: Int, b: Int) { println(a + b) } berekenSom(12, 5) } Je kunt natuurlijk ook een lijst gebruiken om bijvoorbeeld voor een reeks getallen de som te laten berekenen. Dat kan er dan als volgt uitzien: fun telGetallenOp(getallen: Array<Int>) { var som: Int = 0 for (getal in getallen) { som = som + getal } println(som) // 20 } telGetallenOp(arrayOf(12, 5, 3)) In het bovenstaande voorbeeld printen we de som binnen onze functie, maar je kunt de som ook retourneren, zodat je er in je hoofdprogramma iets aan hebt. Daarvoor geef je in de functiedeclaratie op welk gegevenstype wordt geretourneerd, in dit voorbeeld een Int. De waarde ken je toe aan een variabele (in dit voorbeeld resultaat) als je de functie aanroept: fun main(args: Array<String>) { fun telGetallenOp(getallen: Array<Int>) : Int { var som: Int = 0 for (getal in getallen) { som = som + getal } return som } var resultaat = telGetallenOp(arrayOf(12, 5, 3)) println(resultaat) // 20 } Voorbeeld-apps gebruiken Je kunt GitHub gebruiken om je eigen code te verspreiden, zoals we later in deze cursus laten zien. Maar er zijn op GitHub ook veel apps waarvan je de broncode direct kunt downloaden en gebruiken. Dat is handig voor studiedoeleinden of zelfs als basis voor je eigen project. Als je net begint, kan zo’n kant-en-klaar project wel wat overweldigend zijn. Gebruik het als zo’n aanpak voor jou werkt. Als het gaat om het leren programmeren, is het vaak beter om je kennis stap voor stap op te bouwen. Op www.github.com/android vind je veel voorbeeld-apps van Google voor Android, die over het algemeen erg functioneel zijn. Enkele zijn opgebouwd in Java. Als je het prettig vindt, kun je filteren op de programmeertaal Kotlin. Om een project te gebruiken, bijvoorbeeld de app Sunflower, klik je op Code en dan Download zip. Pak het zip-bestand uit. In de openingsdialoog van Android Studio kies je vervolgens Open an Existing Project en blader je naar de bewuste map waar je de broncode opent. Soms moet je enkele aanvullende plug-ins installeren. Probeer voordat je aanpassingen gaat doen eerst eens of je de app gewoon kunt starten. Mogelijk moet je nog wat bijstellen voordat dit lukt. Google stelt verschillende voorbeelden voor Android-apps beschikbaar. Klik hier voor deel 1 Klik hier voor deel 2 Klik hier voor deel 3 Klik hier voor deel 4
    1 point
  5. Zeker als je app al wat vordert, zul je die niet alleen op een virtueel toestel, maar ook op een echt toestel willen testen en gebruiken. We laten zien hoe je dat kunt doen in deel 4 van de workshop Zelf mobiele apps bouwen. Code downloaden In dit deel van de cursus Apps bouwen worden wat voorbeelden van stukjes code gegeven. Omdat overtikken van code erg foutgevoelig is, kun je die code ook downloaden en daarna bekijken of kopiëren. Zie het bestand code-appsbouwen-deel4.txt beschikbaar. Om een Android-app op je eigen toestel te testen, zul je een verbinding met de pc moeten maken. Dat kan eventueel via wifi, maar in dit geval geven we de voorkeur aan een usb-verbinding. Het is hierbij in sommige gevallen nodig een speciale driver te installeren. Via deze link vind je een lijst met fabrikanten en een link naar deze drivers. Als je een Google-toestel hebt, kun je ook gewoon de SDK Manager gebruiken, die je opent via Tools / SDK Manager. Blader naar het tabblad SDK Tools, zet een vinkje bij Google USB Driver en kies Ok. Heb je moeite om drivers voor jouw toestel te vinden, dan kun je ook de universele drivers van https://adb.clockworkmod.com installeren. Die werken voor vrijwel elk toestel. Waar deze drivers voor zorgen, is dat via Android Debug Bridge (ADB) kan worden gecommuniceerd met de smartphone. Zo kan bijvoorbeeld je app worden geïnstalleerd en wordt informatie ontvangen die nodig is voor het debuggen. Op de website voor Android Studio kun je links naar drivers vinden. Telefooninstellingen Voordat je het toestel daadwerkelijk voor ontwikkeling kunt inzetten, is een aanpassing in de telefooninstellingen nodig. Open hiervoor de instellingen en blader naar Over de telefoon. Zoek naar Build-nummer en tik hier zeven keer op tot wordt aangegeven dat je ontwikkelaar bent. Ga dan één stapje terug en ga naar Systeem. Klap indien nodig Geavanceerd uit. Hier zie je Ontwikkelaarsopties tussen staan. Blader naar Stand-by en zet deze optie bij voorkeur aan. Het zorgt ervoor dat het scherm aan blijft tijdens het opladen en ook als het via usb met de pc is verbonden. Blader naar het kopje Foutopsporing en zet een vinkje bij USB-foutopsporing. Dat is nodig voor communicatie via ADB. App starten op toestel Sluit je toestel via een usb-kabel aan op de pc. Op je toestel verschijnt een venster genaamd USB-foutopsporing toestaan waarin je de toegang moet toestaan. Zet eerst een vinkje bij Altijd toestaan vanaf deze computer. Tik dan op Toestaan. Je hoeft dan voortaan geen toestemming meer te geven voor toegang vanaf deze pc. We gaan terug naar Android Studio. Zoals we eerder voor virtuele toestellen deden, kun je via de werkbalk je fysieke toestel selecteren onder Running Devices of via het menu Run / Select Device (Alt+Shift+F11). Klik je op het groene icoontje (of Shift+F10), dan wordt de app gecompileerd, en op je eigen toestel geïnstalleerd en gestart. Vooral de eerste keer dan dat wat langer duren. Starten op meerdere toestellen Je ziet in het menu een optie Run on Multiple Devices. Daarmee kun je zoals verwacht de app op meerdere (fysieke of virtuele) toestellen tegelijkertijd starten. Vink in het venster de gewenste toestellen aan en klik op Run. Je kunt zoveel toestellen aansluiten als je handig vindt en de app op al die toestellen tegelijkertijd starten. Een app kun je eventueel op meerdere toestellen tegelijkertijd starten. Logcat gebruiken: Debuggen Bij het ontwikkelen zul je vaak systeemberichten willen volgen of andere meldingen die voor het debuggen van je app van belang kunnen zijn. We laten zien hoe dat werkt bij Android. Het debuggen, ofwel het opsporen van fouten, speelt een belangrijke rol bij het ontwikkelen. Hiervoor kun je in Android Studio het venster Logcat gebruiken. Onderaan zie je een optie om het venster te openen. Linksboven in dit venster kun je kiezen voor welk actieve apparaat meldingen moeten worden getoond. Iets naar rechts kies je vanaf welk niveau (zoals Verbose, Debug, Info of Error) je meldingen wilt zien. Hierbij is Verbose het laagste niveau, waarbij dus meldingen van elk niveau worden getoond. Je kunt via het zoekveld filteren op tekst of zelfs reguliere expressies (voor complexere zoekopdrachten) gebruiken dankzij de optie Regex. Het onderdeel Logcat laat allerlei systeemmeldingen van je toestel zien. Logcat automatisch weergeven Wil je dat het Logcat-venster automatisch wordt getoond na het starten van de app, dan kun je de opties voor het starten van de app aanpassen via Run / Edit Configurations. Op het tabblad Miscellaneous vind je de optie voor het automatisch tonen (en eventueel leegmaken) van Logcat. Je kunt hier meer opties wijzigen. Op het tabblad General geef je achter Launch Options bijvoorbeeld aan dat een andere dan de standaard activity moet starten. Ook kun je zelf – met het plusteken – een configuratie maken. In de werkbalk kies je dan welke configuratie moet worden gebruikt in de plaats van de standaard configuratie app. Je kunt speciale configuraties maken voor het starten van je app. Loggen vanuit je app In je apps zul je Logcat regelmatig gebruiken om bepaalde meldingen te geven. Hierbij gebruik je een van de volgende opdrachten: - Log.e() voor een foutmelding (error); - Log.w() voor een waarschuwing (warning); - Log.i() voor een informatieve melding (information); - Log.d() voor foutopsporing (debug); - Log.v() voor aanvullende details (verbose). Deze opdrachten vereisen twee teksten (strings) als parameter, namelijk een titel en een omschrijving. Voor bijvoorbeeld de informatieve melding dat onCreate() is aangeroepen kun je de onderstaande regel toevoegen in de app die we begonnen zijn in deel 3 onder setContentView(): Log.i("levenscyclus","onCreate aangeroepen!") Nadat je deze regel toevoegt zal – afhankelijk van de instelling – automatisch of handmatig met Alt+Enter de bibliotheek daarvoor worden toegevoegd. Als je het gedeelte achter import uitvouwt via het plusteken, zie je dat via de onderstaande regel de bibliotheek wordt geïmporteerd: import android.util.Log Als je de app start, kun je Logcat in de gaten houden voor deze melding. Zorg dat het niveau Info of lager (Verbose, Debug) is geselecteerd om deze melding te kunnen zien. Gebruik eventueel het zoekveld om te filteren op levenscyclus. Aan de linkerkant in Logcat zie je een verticale knoppenbalk met extra opties. Je kunt hier bijvoorbeeld het logscherm leegmaken of instellen welke velden moeten worden getoond. Verder kun je met de optie Screen Capture een schermafbeelding maken van je toestel en met Screen Record een schermopname. Handleiding voor Android Studio Voor Android Studio kun je online hier een uitgebreide gebruikershandleiding vinden. Zo vind je bijvoorbeeld in het hoofdstuk Debug your app tips voor het opsporen van fouten, met onder Write and view logs aanwijzingen voor Logcat. Zo zijn er ook hoofdstukken over het schrijven, testen en publiceren van je app. Zoek je heel specifieke details over een bepaalde eigenschap van Android Studio, dan is dit een goede plek om te beginnen. Dobbelsteen-app We beginnen zo met het bouwen van een dobbelsteen-app, wat een goede demonstratie is voor de interactie tussen de gebruikersinterface en je code. We gebruiken daarvoor in de ontwikkelomgeving Android Studio de programmeertaal Kotlin: dit is veruit de populairste taal voor dit platform en sinds 2017 bovendien de officiële en aanbevolen taal. Het grootste voordeel van Kotlin ten opzichte van Java is dat je vaak minder regels code hoeft te schrijven. Het maakt je ook flexibeler naar de toekomst. Dankzij Kotlin Multiplatform kun je namelijk in één keer het fundament voor een Android- én iOS-app bouwen, omdat veel code gemeenschappelijk is. In deel 5 van deze cursus (in het volgende nummer van PCM) gaan we de ontwikkelomgeving IntelliJ IDEA gebruiken voor ontwikkeling in Kotlin, dat sterk overeenkomt met Android Studio. En we duiken dan sowieso wat verder de diepte in met een introductie van de programmeertaal Kotlin Maar nu is het tijd voor onze eerste eenvoudige, maar functionele app. We gaan een dobbelsteen-app maken. Via een klik op een button kun je een worp doen, waarna het resultaat op het scherm wordt getoond. We gebruiken Android Studio en starten een nieuw project via de optie Create New Project in de openingsdialoog. Je kunt ook de menuoptie File / New / New Project gebruiken. Kies als template een Empty Activity. We noemen de app Dobbelsteen, selecteren de programmeertaal Kotlin en kiezen bij Minimal SDK API-level 23. We beginnen met de gebruikersinterface. Open daarvoor in het Projectvenster het lay-outbestand activity_main.xml. Begin weer met een nieuw project in Android Studio. Lay-out converteren Er zijn meer manieren om een lay-out op te bouwen. Standaard wordt tegenwoordig een zogenoemde ConstraintLayout gekozen, dat je ook ziet in het venster Component Tree en in het xml-bestand onder Code. Hiermee kun je flexibeler vrij complexe lay-outs maken. We gaan er later in de cursus mee aan de slag. Voor onze dobbelsteen-app kiezen we een andere vorm: de LinearLayout. Daarbij worden componenten in feite gewoon achter elkaar gezet. Dat kan zowel horizontaal als verticaal. Goed om te weten is dat je nergens aan vastzit als je een app begint op basis van een template. Er wordt gewoon wat code vooraf ingevuld, maar je kunt alles naar voorkeur aanpassen. Zo kun je ook de standaard ConstraintLayout eenvoudig omzetten naar een LinearLayout: klik daarvoor in de Component Tree rechts op ConstraintLayout, kies Convert view, selecteer LinearLayout en kies Apply. Hiermee heb je de lay-out naar een LinearLayout omgezet. De lay-out kun je in enkele stappen converteren naar een andere vorm. Attributen voor LinearLayout We gaan een paar attributen voor de LinearLayout aanpassen. Klik daarvoor in de Component Tree op LinearLayout en open Attributes. Blader naar Orientation en verander deze naar vertical. Hiermee zorg je dat componenten verticaal en niet horizontaal onder elkaar worden gezet. Bij layout_width kies je match_parent. Daarmee zorg je ervoor dat alle beschikbare ruimte wordt benut – in dit geval (omdat er geen onderliggend element is) de volledige schermbreedte. Bij layout_height selecteer je wrap_content. De hoogte wordt dan aangepast aan de totale hoogte van de componenten die erin zijn opgenomen, ofwel de content. Deze verandering zie je overigens ook meteen plaatsvinden in je scherm. Klap vervolgens layout_gravity uit en zet een vinkje bij center_vertical, zodat de componenten binnen deze lay-out (gezamenlijk) verticaal worden gecentreerd. Op dit moment hebben we alleen een component TextView die je nu naar het midden van het scherm ziet verschuiven. Controleer eventueel onder Code hoe dat in het xml-bestand wordt weergegeven (zie afbeelding). Het eindresultaat van de code voor onze LinearLayout met verticale oriëntatie. Tekst opmaken We willen straks in de TextView-component de waarde weergeven die met de dobbelsteen is gegooid. Deze tekst willen we beter leesbaar maken. Selecteer de component (dat gaat omdat het zo klein is het makkelijkst via de Component Tree). Zorg dat het venster Attributes is geopend. Het attribuut id geven we de waarde text_worp. Via die naam kunnen we in onze code naar de component verwijzen. Het attribuut text veranderen we naar 0, de voorlopige dobbelsteenworp. Verander layout_width en layout_height naar 130dp. De component wordt dan groter, maar de tekst nog niet. Verander daarvoor ten slotte het attribuut autoSizeTextType naar uniform. Zo zorg je ervoor dat de tekst schaalt met de grootte van de component. Kies bij textAlignment voor center, zodat tekst binnen die ruimte wordt gecentreerd. Je kunt het vakje eventueel nog groter maken, wat ook in de weergave kan via de hoeken van de component. De tekst voor de dobbelsteenworp wat netter opgemaakt. Button toevoegen We gaan nu een button toevoegen voor de werking van de dobbelsteen. Sleep daarvoor vanuit het venster Palette een button naar je lay-out en zet die op of onder de TextView-component, zodat deze eronder wordt gezet (dankzij de verticale oriëntatie). Laat de component niet te ver naar onderen los, want daar zit je buiten de lay-out. Klik dan op de button om attributen aan te kunnen passen. Vul in het veld id de waarde button_werp in. Je krijgt na deze aanpassing een pop-upvenster te zien waarin wordt gevraagd of dit ook in de code moet worden doorgevoerd. Kies in zo’n geval Refactor, al is het hier (nog) niet van toepassing omdat we de waarde niet in code hebben gebruikt. Bij layout_width kies je wrap_content. Daarmee zorg je dat de breedte van de button wordt aangepast aan de tekst die erin staat. Die tekst verander je bij text in Werp dobbelsteen en je ziet dat de button meteen wat breder wordt. Zet voor zowel de TextView als Button bij het attribuut layout_gravity de optie center_horizontal aan. Dat kan in één keer als je eerst beide componenten selecteert (door Ctrl ingedrukt te houden, terwijl je op de linkermuisknop drukt) en daarna het attribuut verandert. Met deze optie zorg je ervoor dat componenten ook horizontaal mooi worden gecentreerd. Onze lay-out met een tekst en button voor het werpen van de dobbelsteen. Tekst als resource De tekst van de button hebben we via het attribuut text opgegeven, maar het is gebruikelijk om deze en andere teksten voor je app (ook wel strings genoemd) in een apart bestand als zogenoemde resource op te nemen. Dat helpt je ook als je de app later bijvoorbeeld meertalig gaat maken. Er is een handig trucje om dat voor onze button te doen: open de gebruikersinterface (activity_main.xml), ga naar Code en klik bij de button op de tekst Werp dobbelsteen. Druk dan op Alt+Enter of klik op het lampje vóór deze regel en kies Extract string resource. Vul een naam in voor deze resource, bijvoorbeeld werpbutton_label, verifieer de tekst en klik op Ok. De aanpassing zie je terug in het bestand strings.xml. Open deze via je Projectvenster onder res/values. Je ziet nu de extra regel: <string name="werpbutton_label">Werp dobbelsteen</string> Wil je in het vervolg de tekst voor de button veranderen, dan kun je dat doen via het bestand strings.xml. Merk op dat in dit bestand ook de naam van de app te vinden is. Teksten kun je beter als resource definiëren, waar een handig trucje voor is. Test je lay-out Je ziet dat het netjes afwerken van een LinearLayout toch tijd en aandacht vraagt. Het is slim om al tijdens het ontwerpen te controleren hoe het er bij andere schermgroottes of -oriëntaties uitziet. In de werkbalk boven je ontwerp kun je bijvoorbeeld een andere oriëntatie kiezen (portret of landschap) of de schermgrootte veranderen naar tablet, smartwatch of televisie, met de bijbehorende resolutie. Natuurlijk is het ook slim de app te starten in de emulator of op je eigen toestel. Hoewel de app nog niets doet, zie je wel al de gebruikersinterface. Dobbelsteen programmeren De gebruikersinterface is vooral grafisch erg eenvoudig, maar toereikend. Nu kunnen we de code schrijven om deze dobbelsteen werkend te krijgen! We hebben al een id toegekend aan zowel de button (button_werp) als het tekstveld (text_worp). We willen bepaalde code uitvoeren, zodra op de button is getikt. Eerst maken we de button beschikbaar als variabele. Open daarvoor MainActivity.kt en zet binnen onCreate() en onder setContentView() de volgende regel: val buttonWerp: Button = findViewById(R.id.button_werp) De benodigde bibliotheken worden weer automatisch geïmporteerd als je dat hebt ingesteld zoals besproken in deel 3 van deze cursus. We gaan nu een functie toevoegen die moet worden aangeroepen als er op de button wordt getikt. Zet deze binnen de MainActivity-class, maar onder het blok onCreate(). Voor nu laten we alleen een zogenoemde toast zien. private fun werpDobbelsteen() { Toast.makeText(this, "Je hebt een worp gedaan!", Toast.LENGTH_SHORT).show() } Een toast is een korte meldingsbalk. Er zijn drie parameters nodig: een zogenoemde Context (zie kader ‘Gebruik van Context binnen Android’), de tekst voor de melding en de periode waarin de melding zichtbaar blijft. Als laatste wordt de methode show() aangeroepen om de melding daadwerkelijk te laten zien. Gebruik van Context binnen Android De term Context kom je vaak tegen bij het ontwikkelen van Android-apps. De Context is een object waarin de huidige toestand van de activity (Activity Context genoemd) of – minder gangbaar – de app zelf (Application Context) wordt doorgegeven. In meerdere situaties moet je deze Context doorgeven. De aangeroepen functie kan het nodig hebben voor bijvoorbeeld toegang tot resources zoals lay-outs, strings of een database. Vaak wordt zoals in ons voorbeeld gewoon this gebruikt, wat in feite een referentie is naar de huidige activity. Reageren op buttonklik Om te zorgen dat de functie werpDobbelsteen() wordt aangeroepen zodra op de button wordt getikt, gebruiken we een methode die setOnClickListener() heet. Direct onder de declaratie van de button kun je deze methode toevoegen. Daarin noemen we ook de functie die bij een buttonklik moet worden aangeroepen: buttonWerp.setOnClickListener { werpDobbelsteen() } De hele MainActivity-class ziet er nu als volgt uit: class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) val buttonWerp: Button = findViewById(R.id.button_werp) buttonWerp.setOnClickListener { werpDobbelsteen() } } private fun werpDobbelsteen() { Toast.makeText(this, "Je hebt een worp gedaan!", Toast.LENGTH_SHORT).show() } } Wat nog ontbreekt, is het genereren van een willekeurig getal (1 t/m 6) en het weergeven van de worp via de TextView. We maken daar eerst een referentie en laten met drie stippen zien dat de dobbelsteen wordt gegooid: val textWorp: TextView = findViewById(R.id.text_worp) textWorp.text = "..." Vervolgens berekenen we een willekeurig getal van 1 t/m 6: val dobbelsteenInt = (1..6).random() Ten slotte laten we het resultaat na een korte vertraging van 500 ms zien: Handler(Looper.getMainLooper()).postDelayed({ textWorp.text = dobbelsteenInt.toString(); }, 500) Mogelijk wordt bij die laatste opdracht een keuze voor bibliotheken voorgelegd bij het (automatisch) importeren. De bibliotheken die je nodig hebt zijn android.os.Handler en android.os.Looper. Merk op dat we een integer hebben gegenereerd, waar we met de methode toString() een string van maken. Als je de app start, zul je zien dat bij elke tik op de button een nieuw willekeurig getal van 1 tot en met 6 wordt gegenereerd. De definitieve versie van de eenvoudige, maar functionele dobbelsteen-app. Recente bestanden en favorieten Regelmatig zul je in meerdere bestanden kleine wijzigingen maken. Wil je terug naar een ander bestand? Dan is de sneltoets Ctrl+E erg handig. Daarmee open je een dialoogvenster met een overzicht van recent geopende bestanden. Ook heel praktisch is dat je bestanden als favoriet kunt markeren. Ga daarvoor naar Projectvenster, klik rechts op een bestand, kies Add to Favorites en selecteer de favorietenlijst of maak een nieuwe lijst. Vanuit het tabje Favorites kun je dan je favorieten openen. Klik hier voor deel 1 Klik hier voor deel 2 Klik hier voor deel 3
    1 point
  6. In het vorige deel hebben we een nieuw project gemaakt. Hiermee heb je eigenlijk meteen een basis voor je app. We laten nu zien welke bestanden zijn aangemaakt en wat het doel van die bestanden is. Ook gaan we op twee manieren een tekst aanpassen: via de gebruikersinterface en via code. We gaan in dit deel verder met de app die we in deel 2 hadden opgezet. Herhaal als het nodig is de stappen door in Android Studio een nieuw project te beginnen met als template Empty Activity. Hiermee zijn al enkele mappen en bestanden voor de app gemaakt en ook al grotendeels ingevuld, zodat je in feite al een werkende app hebt. In het projectvenster zie je deze bestanden en mappen terug onder de map app. Het gaat om: - manifests: deze map bevat het belangrijke bestand AndroidManifest.xml, dat allemaal details over je app bevat. Er staat bijvoorbeeld in welke activity moet worden begonnen bij het starten van de app. Als toegang nodig is tot systeemonderdelen, zoals internet of de camera, vermeld je dat ook in dit bestand. Bij het uitbreiden van je app zul je hier zelf aanpassingen in maken; - java: deze map bevat alle broncode voor je app (in Kotlin of Java) in verschillende mappen. Hierbij gebruik je doorgaans de bovenste map (met de ‘package name’ als naam). De twee mappen daaronder bevatten testcode. Er is in de map al één bestand met de naam MainActivity.kt gemaakt, waarin al enkele regels code zijn ingevuld. Aan de extensie .kt kun je zien dat het in Kotlin is geschreven. - res: deze map bevat extra zogeheten resources (bronnen), verdeeld over mappen. In de map drawable vind je grafische bestanden. De map layout bevat alle lay-outs. Daarmee bedoelen we de schermen voor de app, ofwel grafische interfaces, waarop bijvoorbeeld teksten, afbeeldingen en buttons staan. Zo’n lay-out wordt beschreven in een xml-bestand en voor het eerste eenvoudige scherm is al een bestand activity_main.xml gegenereerd. De map values bevat andere resources, zoals variabelen die in de app worden gebruikt. Zo vind je in strings.xml de naam die je aan de app hebt gegeven terug. In het projectvenster zie je alle mappen en bestanden die bij je app horen. Lay-out openen Open de automatisch gegeneerde lay-out via het projectvenster door onder app/res/layout te dubbelklikken op activity_main.xml. Deze lay-out wordt dan aan de rechterkant geopend, waar het zoals elk geopend bestand een eigen tabblad krijgt. Bij het bewerken van een lay-out kies je rechtsboven uit de drie modi Code, Split en Design. Onder Code kun je het xml-bestand rechtstreeks bewerken. Via Design kan dit visueel door bijvoorbeeld elementen naar de app te slepen. Bij de modus Split heb je die twee opties naast elkaar. We beginnen met Design. Links in het venster Palette zie je alle componenten waarmee je de gebruikersinterface voor je app bouwt, zoals teksten, afbeeldingen en knoppen. Dat doe je door zulke componenten naar je scherm te slepen en daarop te positioneren. Er is al één component voor tekst geplaatst, ook wel TextView genoemd. In de gebruikersinterface zie je dat deze component al de tekst Hello World! bevat. Als je op die tekst klikt, is de TextView-component geselecteerd, wat je ook ziet in het venster Component Tree. Dat is een soort boomstructuur voor alle gebruikte componenten. De gebruikersinterface kun je via code bewerken of in de designmode. Tip: bestanden terugvinden Wil je voor een geopend bestand weten wáár het tussen je projectbestanden staat? Klik dan in het projectvenster op het icoontje Select Opened File. Eigenschappen aanpassen Elke component kent talloze eigenschappen die je kunt aanpassen, ook wel attributen genoemd. Zorg daarvoor eerst dat de component is geselecteerd, door erop te klikken in de gebruikersinterface of in de Component Tree. Selecteer als voorbeeld de TextView-component en open rechts (als het nog niet is geopend) het venster Attributes. Hierin vind je alle attributen voor deze component. De tekst voor de TextView is in eerste instantie Hello World! en vind je bij het attribuut met de naam text. De attributen waaraan reeds een waarde is toegekend, vind je altijd snel terug onder Declared Attributes. Er zijn nog talloze andere attributen. De volledige lijst vind je onder All Attributes. Veel attributen komen in latere delen aan bod, als we dieper ingaan op het bouwen van gebruikersinterfaces. We gaan alvast één belangrijke attribuut met de naam id invullen. Daarmee kunnen we straks in code de component aanwijzen. Dit attribuut vind je al direct bovenaan. Vul de gewenste naam in; als voorbeeld kiezen we text_welkom. Ga ten slotte rechtsboven naar Code om te zien hoe de lay-out er in het xml-bestand uitziet. Let daarin vooral op de TextView-component en de attributen text en id. Als je het handiger vindt, kun je ook altijd in het xml-bestand aanpassingen maken. Dat gaat in sommige gevallen sneller omdat je wat handiger kunt knippen, kopiëren en plakken. Via een venster kun je alle attributen voor een component wijzigen. Code schrijven volgens de richtlijnen Bij het programmeren is het altijd handig om bepaalde richtlijnen te volgen, zodat code voor iedereen herkenbaar en goed leesbaar is. Dat helpt je niet alleen bij de stijl van je code, maar ook bij de keuze van namen voor bijvoorbeeld ID’s en variabelen. Een voorbeeld van zulke richtlijnen voor Android vind je via www.bit.ly/andrguide. In deze cursus volgen we overwegend de richtlijnen. Zo nemen we voor de ID steeds de naam van de component als uitgangspunt, gevolgd door een underscore, zoals text_ voor een TextView, image_ voor een ImageView, button_ voor een Button en tot slot menu_ voor een Menu. De TextView-component waarop we de welkomsttekst laten zien, noemen we daarom text_welkom. Voor een variabele in de code die verwijst naar deze ID zou je dezelfde naam mogen gebruiken. In deze cursus gebruiken we voor de duidelijkheid een andere afgeleide naam, met een hoofdletter in plaats van het underscore-teken als afscheiding, bijvoorbeeld textWelkom. Bestaande code Je hebt gezien hoe je voor de TextView-component in je ontwerp de tekst aan kunt passen. De aanpassing kun je ook via code maken tijdens de uitvoering van je app. We laten zien hoe je dat doet. Open het bestand MainActivity.kt via het projectvenster. Dit bestand bevat een eenvoudige basis voor de (enige) activity van deze app, waaronder de volgende regels: class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) } } Belangrijk om te weten is dat er verschillende toestanden bestaan waarin een activity kan verkeren. Dit heet ook wel levenscyclus of lifecycle. Je kunt via zogenoemde ‘callbacks’ inhaken op elke (veranderende) toestand. In een van de komende delen gaan we hier uitgebreider op in door de levenscyclus en callbacks met een werkend voorbeeld te demonstreren. Hier gebruiken we zo’n callback voor de belangrijke onCreate() die optreedt zodra onze activity wordt gemaakt. Door hier zelf met sleutelwoord override een functie voor te maken, overschrijf je als het ware de bestaande code, waarbij je met super.onCreate(savedInstanceState) eerst de bestaande code (alsnog) kunt laten uitvoeren. Hierbij is savedInstanceState de bewaarde eerdere toestand van de app. Daaronder kun je dan je eigen aanvullende code schrijven. Je ziet daarin nu alleen de regel setContentView(R.layout.activity_main). Die regel zorgt ervoor dat de gewenste lay-out (in dit geval het bestand activity_main.xml) wordt geladen en op het scherm wordt getoond. Code toevoegen Voordat je code gaat schrijven, is het handig om een instelling te wijzigen, zodat de benodigde bibliotheken automatisch worden geïmporteerd als je ze gebruikt in je code (zie het kader ‘Importregels voor bibliotheken’). Vervolgens hoeven we maar twee regels toe te voegen om de tekst te veranderen. Zet de regels direct onder de regel setContentView(). Eerst zoeken we via de in de lay-out toegekende id de TextView-component op en maken we deze beschikbaar via de variabele die we textWelkom noemen: val textWelkom: TextView = findViewById(R.id.text_welkom) as TextView Hierna kunnen we eenvoudig de tekst veranderen: textWelkom.text = "Dit is een live aanpassing!" Als je geen automatische importregels hebt ingesteld, wordt gevraagd om op Alt+Enter te drukken om de bibliotheken te importeren, die nodig zijn voor deze app. Als je de app start, bijvoorbeeld in de emulator, zie je als het goed is de aangepaste tekst. Je merkt nergens dat de tekst via de code wordt aangepast. Dat is niet omdat het te snel zou gaan om op te vallen, maar omdat de bewuste activity binnen de onCreate() nog niet zichtbaar is gemaakt voor de gebruiker. Ook via het programma kun we de tekst van de component aanpassen. Importregels voor bibliotheken We raden je aan om voor de hand liggende bibliotheken automatisch toe te laten voegen. Om dat in te stellen, ga je naar File / Settings en dan Editor / General / Auto Import. Zet onder Kotlin en Java een vinkje bij Add unambigious imports on the fly. Dat zorgt ervoor dat de importregel automatisch wordt toegevoegd als je bijvoorbeeld de Log-opdracht schrijft. Ook de optie Optimize imports on the fly is handig. Deze instelling zal automatisch de importregels verwijderen voor bibliotheken die je niet meer raadpleegt. Je kunt importregels automatisch laten toevoegen en verwijderen. Testen in emulator Fysiek of virtueel Android-toestel Om je app te testen heb je een Android-toestel nodig. Je kunt hiervoor een fysiek toestel gebruiken (wat in deel 4 aan bod gaat komen), maar ook een virtueel toestel via de emulator te gebruiken. Die werkt tegenwoordig net zo snel of zelfs sneller dan een ‘echt’ toestel. Doorgaans zul je in de eerste fase van je ontwerp vooral de emulator gebruiken en in de laatste fase – voor het perfectioneren van de app – een echt toestel. Om virtuele toestellen voor de emulator te bekijken en te beheren, open je de AVD (Android Virtual Device) Manager via Tools / AVD Manager. Via een tool kun je virtuele toestellen voor de emulator beheren. Virtuele toestellen Bij een standaardinstallatie heb je een toestelconfiguratie gemaakt voor de Pixel 3a. Als voorbeeld voegen we een virtueel toestel toe via de optie Create Virtual Device. Je ziet dan verdeeld over categorieën als TV, Phone, Wear OS en Tablet allerlei profielen voor bekende apparaten die je als basis voor je virtuele toestel kunt gebruiken, al kun je ook zelf een profiel maken (zie het kader ‘Profielen voor apparaten maken’). Hier kiezen we onder Phone voor Pixel 4. Zoals je aan het icoontje in de kolom Play Store kunt zien, bevat dit virtuele toestel ook de Google Play Store. Je kunt dus (andere) apps op het toestel installeren vanuit de appstore van Android, net als op een echte telefoon. Klik op Next om verder te gaan. Nu kun je kiezen welke versie van Android moet worden geïnstalleerd. Onder Recommended zie je aanbevolen releases, maar je kunt ook andere systeem-images kiezen. Dit bepaalt de versie van Android. We gebruiken als voorbeeld de release genaamd Q oftewel Android 10. Klik indien nodig eerst op Download om het systeem-image te downloaden en te installeren. Daarna selecteer je het systeem-image en klik je op Next. Als laatste kun je het toestel een naam geven en een standaard schermoriëntatie kiezen (Portret of Landschap). Via Show Advanced Settings kun je extra details zien. Zo kies je bij Boot option voor Cold boot als het toestel steeds schoon moet starten, of Quick boot als het verder moet gaan in de toestand waarin je het de laatste keer hebt gebruikt. Klik ten slotte op Finish om de configuratie af te ronden. Het systeem-image bepaalt welke versie van Android op het toestel draait. Profielen voor apparaten maken De AVD Manager bevat profielen voor allerlei soorten apparaten, zoals smart-tv’s met Android TV en wearables met Wear OS. Zo’n profiel geeft bijvoorbeeld aan wat de schermgrootte, resolutie en pixeldichtheid zijn, maar ook hoeveel geheugen het apparaat heeft en wat voor sensoren erop zitten. Klik je op New Hardware Profile, dan kun je zo’n profiel zelf helemaal samenstellen. Je kunt bij het maken van een profiel ook een bestaand profiel uit de lijst als uitgangspunt nemen en deze aanpassen. Daarvoor klik je met rechts op een toestel en kies je Clone. Je kunt zelf een hardwareprofiel maken of bestaand profiel klonen. App starten op toestel Als je het virtuele toestel hebt gemaakt, start je deze vanuit het overzicht door op het groene speelicoontje te klikken. De eerste keer kan het opstarten wat langer duren. Als het toestel is opgestart, kun je het gebruiken zoals een echte Android-smartphone. Zo kun je bijvoorbeeld instellingen veranderen via het instellingenmenu en dankzij de Play Store na inloggen ook aanvullende apps installeren. De emulator zelf geeft je via een knoppenbalk nog diverse extra opties (zie het kader ‘Emulator aanpassen’). Ga je naar Android Studio, dan selecteer je het toestel in de werkbalk onder Running Devices. Dat kan ook via Run / Select Device (Alt+Shift+F11). Klik je op het groene icoontje (of Shift+F10), dan wordt de app gecompileerd en vervolgens op het virtuele toestel geïnstalleerd en gestart. Emulator aanpassen De emulator geeft je een knoppenbalk waarmee je allerlei opties kunt wijzigen. Denk aan het roteren van het scherm of wijzigen van het volume. Via de drie puntjes is een extra menu beschikbaar, waarin je nog veel meer details kunt veranderen. Dat gaat vooral om externe invloeden. Zo kun je bijvoorbeeld de gps-locatie wijzigen, een inkomend gesprek simuleren, de sensoren voor richting, beweging en versnelling beïnvloeden of het soort netwerkverbinding en signaalsterkte wijzigen. De emulator heeft een extra menu waarin je veel details kunt aanpassen. Klik hier voor deel 1 Klik hier voor deel 2
    1 point
  7. Voordat je kunt beginnen met mobiele apps bouwen heb je een ontwikkelomgeving nodig. Bij Android is dat Android Studio, dat alles bevat wat je nodig hebt. Je installeert Android Studio, en we laten zien hoe je extra onderdelen kunt installeren en hoe je je installatie up-to-date houdt. Daarna gaan we de ontwikkelomgeving verkennen. Android Studio werd aangekondigd tijdens Android I/O 2013 en de eerste versie verscheen eind 2014. Tot op dat moment werd vooral Eclipse met een plug-in gebruikt om Android-apps te bouwen. De basis voor Android Studio is de ontwikkelomgeving IntelliJ IDEA van JetBrains. Alles wat je nodig hebt om een app te ontwikkelen is al ingebouwd. Denk aan editors voor het schrijven van je code, een debugger voor het opsporen van fouten, tools om de gebruikersinterface te ontwerpen en mogelijkheden om je programma te testen in een emulator of op je eigen toestel. Bovendien is de software helemaal gratis. Android Studio is gebaseerd op IntelliJ IDEA van JetBrains. Welke versie? Google heeft met het besturingssysteem Android de afgelopen jaren grote stappen gezet. De laatste versie is Android 11 en daar kun je in Android Studio uiteraard mee gaan werken. Ook de ontwikkelomgeving zelf is steeds beter en completer geworden. In mei 2020 kwam Android Studio 4.0 uit, een flinke update met enkele interessante toevoegingen. Zo maak je met de Motion Editor eenvoudiger bewegende delen voor je gebruikersinterface. En met Layout Validation zie je snel hoe een app eruitziet bij verschillende schermgroottes en -verhoudingen. In oktober 2020 volgde versie 4.1 met onder andere een handige Database Inspector, waarmee je de inhoud van je database bekijkt en gegevens uit je database selecteert. Android Studio heeft de laatste jaren veel veranderingen ondergaan. Welke versie moet je gebruiken? Bij het maken van deze cursus hebben we Android Studio 4.1 onder Windows 10 (64 bit) gebruikt. We raden je aan om altijd de laatste versie van deze software te installeren, ook als die wat nieuwer is dan onze versie. Als er zogenoemde breaking changes zijn (veranderingen waardoor bepaalde functies niet meer werken), zullen we dat vermelden. Systeemeisen Android Studio ondersteunt behalve Windows 10 (32 of 64 bit) ook eerdere versies van Windows evenals macOS 10.10 (codenaam Yosemite) of hoger, Linux en Chrome OS. De systeemeisen kun je hier nalezen. Ze lopen niet ver uiteen voor deze besturingssystemen. Grofweg heb je nodig: - 4 GB geheugen, maar liever 8 GB of meer; - Ongeveer 4 GB schijfruimte of meer; - Een schermresolutie van 1280 × 800 pixels of hoger. Android Studio is een stevig pakket. Het heeft zeker nut om in een snelle processor (Intel of AMD) met meerdere rekenkernen te investeren, alleen al om het tussentijds compileren te versnellen. Bespaar ook niet op het werkgeheugen. Werk je aan een wat groter project of heb je meerdere programma’s of tools openstaan, dan is 16 of zelfs 32 GB geen overbodige luxe. Bedenk dat de emulator al zo’n 768 MB aan werkgeheugen vraagt. Een ssd is in onze ogen eveneens vrij essentieel: apps bevatten vaak grote aantallen kleine bestanden en een ssd is dan sneller. Een ouderwetse harde schijf doet er door de hogere toegangstijd aanzienlijk langer over om zulke bestanden te laden. Een groot scherm is ook handig of een opstelling met meerdere schermen. Vensters van Android Studio kun je neerzetten waar je ze handig vindt. De systeemeisen lopen voor de verschillende besturingssystemen weinig uiteen. Installatie software en drivers Android Studio Het pakket Android Studio geeft je alles wat nodig is om een app voor Android te ontwikkelen. Het is tegenwoordig niet meer nodig om de SDK (Software Development Kit) voor Android en de JDK (Java Development Kit) voor Java apart te installeren. Om de software te downloaden, ga je hier naartoe. Deze downloadlink geeft de laatste stabiele versie. Onder het tabblad Preview zijn ook recentere testversies beschikbaar, zoals de zogenoemde Canary-build. Deze bevatten de laatste vernieuwingen, maar zijn minder goed getest. Die zullen alleen in specifieke situaties de voorkeur krijgen. De meeste gebruikers zullen de downloadlink naar de laatste stabiele versie gebruiken. Installatie De installatie gaat vrij rechttoe rechtaan. De twee componenten (Android Studio en Android Virtual Device) worden beide standaard geïnstalleerd. Met Android Virtual Device wordt een virtuele toestelconfiguratie bedoeld voor de emulator (zie kader ‘Virtuele toestellen en de emulator’). Heb je de installatie van Android Studio afgerond en start je de software voor het eerst, dan kun je eventueel de instellingen van een eerdere installatie importeren. Hierna volgt een wizard voor een initiële configuratie waarmee je tevens aanvullende componenten kunt installeren. De installatie van Android Studio is eenvoudig. Virtuele toestellen en de emulator De emulator bij Android Studio is een hulpmiddel om apps binnen een venster op je eigen pc te draaien. Zo kun je apps die je ontwikkelt eenvoudig uitproberen. Je kunt meerdere virtuele toestelconfiguraties maken met steeds andere hardware, zoals een afwijkende processor, geheugencapaciteit of schermresolutie. Op die manier zie je snel hoe jouw app (bij benadering) op andere toestellen werkt. Standaard is voor de emulator een virtueel toestel op basis van de Google Pixel 3a gemaakt. Configuratiewizard Via de configuratiewizard richt je de ontwikkelomgeving verder in en installeer je extra componenten die je straks nodig hebt. Om de wizard te doorlopen, kies je steeds Next. Als type installatie kies je tussen Standard en Custom. We geven de voorkeur aan die laatste optie zodat je volledige controle hebt over wat er wordt geïnstalleerd. Hierna kun je aangeven welke JDK (Java Development Kit) moet worden gebruikt. Accepteer de standaardlocatie. Vervolgens kies je tussen een licht of donker thema, dat is persoonlijk. Een meerderheid van de programmeurs prefereert een donker thema omdat het minder vermoeiend zou zijn voor de ogen, maar de meningen lopen uiteen. Al deze keuzes kun je op een later moment wijzigen. Daarna kies je welke extra componenten moeten worden geïnstalleerd. In de wizard kun je onder meer kiezen tussen een licht of donker thema. Extra componenten Bij de eerste optie Android SDK raden we aan om de map bij Android SDK Location te veranderen naar een makkelijker te vinden map. Onder Windows is dat bijvoorbeeld C:\Android\sdk. Belangrijk is dat je geen spaties in dit pad hebt. Verder worden de platformbibliotheken voor de laatst beschikbare versie van Android geïnstalleerd – op het moment van schrijven API 30 ofwel Android 11.0 (R). De emulator maakt gebruik van een virtuele machine en de prestaties daarvan kun je dankzij hardwareversnelling flink verbeteren. Daarom raden we aan de voorgestelde zogenoemde hypervisor te installeren. Voor processors van Intel is dat HAXM (Hardware Accelerated Execution Manager) en voor AMD de Android Emulator Hypervisor Driver for AMD Processors. Voor deze tools accepteer je de standaardinstellingen, zoals de geheugentoewijzing. Ten slotte zie je een overzicht van alle instellingen en sluit je de configuratie af met Finish. Hierna worden alle gekozen onderdelen gedownload en geïnstalleerd, en dat duurt wel even. Installeer de voorgestelde hypervisor voor betere prestaties van je emulator. Virtualisatie activeren in het BIOS Voor het werken met virtuele machines en voor het versnellen van de emulator middels een hypervisor is een speciale BIOS-instelling nodig. Het BIOS bereik je door tijdens het bootproces op de juiste toets (veelal F2 of Del) te drukken. De optie waar je naar moet zoeken heet VT-x (Intel), SVM (AMD) of gewoon Virtualization Technology. Meestal vind je deze optie(s) onder de geavanceerde processorinstellingen. SDK Manager Als je Android Studio hebt opgestart, kun je in de openingsdialoog via Configure / SDK Manager handmatig de SDK Manager openen om extra onderdelen te installeren. De twee voornaamste tabbladen binnen dit hulpprogramma zijn SDK Platforms met alle platformbibliotheken en SDK Tools met extra software en drivers. Om meer details te zien voor softwareonderdelen zet je een vinkje bij Show Package Details. Onder SDK Platforms valt direct op hoe iedere platformversie een bepaald API-level heeft. Als je een app ontwikkelt, geef je aan welk API-level minimaal vereist is om die app te gebruiken. Een hoger API-level zorgt dat je meer nieuwe functies van Android kunt benutten, maar je sluit ook een gebruikersgroep met oudere versies van Android uit. Overigens is het in principe niet nodig om eerdere versies van platformbibliotheken te installeren. Met een nieuwere platformbibliotheek kun je ook gewoon een lager API-level als vereiste opgeven. Onder het tabje SDK Tools kun je extra’s installeren. Enkele hebben we al besproken. Als er extra onderdelen in latere delen van deze cursus nodig zijn, verwijzen we naar dit onderdeel van de SDK Manager. Via de SDK Manager kun je onder andere platformbibliotheken installeren. Updates installeren Via Configure / Check for Updates in de openingsdialoog van Android Studio controleer je of er een nieuwe versie van de ontwikkelomgeving beschikbaar is. In dat geval werk je de software snel en eenvoudig bij via een patch. Daarnaast laat ook de SDK Manager per onderdeel zien als er updates zijn. We raden je aan steeds alles bij te werken en regelmatig te controleren op updates. Dat laatste gebeurt overigens automatisch. Zeker voor Android Studio is het verstandig om vooraf de ‘release notes’ te lezen. Er kunnen zogenoemde breaking changes zijn (veranderingen waardoor bepaalde functies niet meer werken), maar natuurlijk ook interessante nieuwe functies die je helpen bij het ontwikkelen. Een enkele keer kunnen wat aanpassingen aan je app nodig zijn om compatibel te blijven. Ontwikkelomgeving verkennen Nieuw project We gaan Android Studio verkennen aan de hand van een nieuw project. Daarvoor kies je in het openingsscherm de optie Create New Project. Je kunt nu uit een van de sjablonen (templates) kiezen waarin een zogenoemde activity is gemaakt. Een activity kun je zien als een scherm van je app waarin de gebruiker iets kan doen, waarbij je minimaal één activity hebt als startpunt voor je app. De sjablonen bestaan er voor verschillende doeleinden. We kiezen hier voor Empty Activity, wat de eenvoudigste optie is om mee te beginnen. Klik dan op Next. Bij het maken van een project kun je een van de sjablonen kiezen. Configuratie In het volgende scherm kies je een configuratie. We maken een eenvoudige app genaamd Hallo Wereld. Achter Name vul je de naam voor de app in. De Package name moet een unieke naam zijn voor jouw app. Als je in de Google Play Store de pagina voor een app opent, zie je deze naam reeds in de url. In de voorgestelde naam com.example.hallowereld herken je de omgekeerde domeinnotatie. Als je zelf een domeinnaam hebt, kun je die in deze plaats gebruiken, zodat er bijvoorbeeld nl.domein.hallowereld staat. Dat raden we aan als je de app gaat verspreiden via Google Play, want het geeft je de zekerheid dat de naam uniek is. Omdat deze app alleen voor testdoeleinden dient, bedenk je zelf iets of je accepteert het voorstel. Achter Save location kies je de map waar de bestanden voor je app moeten worden opgeslagen. Let op dat er geen spaties in mogen staan. Onder Language heb je de keuze tussen Kotlin en Java. We kiezen Kotlin omdat het tegenwoordig de aanbevolen taal is (zie kader ‘Programmeertalen Kotlin en Java’). In de eerste stap configureer je de app voor je project. Programmeertalen Kotlin en Java Een relatief grote verandering binnen Android Studio de laatste jaren is de stap naar Kotlin als de aanbevolen programmeertaal boven Java. Kotlin is gemaakt door JetBrains, dat ook verantwoordelijk is voor de software achter Android Studio. We werken in deze cursus overwegend met Kotlin, omdat het de beste keuze is als je nu met een app begint. Bovendien zijn er veel overeenkomsten met Java. Heb je al een bestaande app of veel ervaring met Java? Dan kun je daarmee blijven werken, ook deze programmeertaal wordt nog gewoon ondersteund. Kotlin is inmiddels de officiële programmeertaal voor Android. Minimale Android-versie Achter Minimum SDK kies je de oudste versie van Android die de app moet ondersteunen. Deze keuze kun je op meerdere manieren benaderen. Kies je een oudere versie, dan kan de app op meer toestellen worden geïnstalleerd. Maar het kost je ook meer tijd om je app compatibel te maken met al die oudere toestellen. Bovendien kun je bepaalde functies van nieuwere versies van Android niet benutten. Je zult dus een balans moeten zoeken en daarbij ook kijken naar de doelgroep voor je app. De optie Help me choose kan je hierbij helpen. Het geeft een overzicht van alle versies van Android met het bijbehorende API-level. Als je op een bepaalde versie klikt, zie je welke functies daaraan zijn toegevoegd. In deze cursus kiezen we tenzij anders aangegeven API-level 23 ofwel Android 6.0 (codenaam Marshmallow). Dat lijkt hoog, maar het valt mee als je bedenkt dat het besturingssysteem inmiddels ook al ruim vijf jaar oud is. Als het dan toch nog nodig blijkt om oudere toestellen te ondersteunen, kun je de app daar altijd nog op aanpassen. Als je klaar bent met de configuratie, klik je op Finish. De helpfunctie laat zien welke functies bij welk API-level werden geïntroduceerd. Minimale SDK-versie op Twitter Een aardig detail is dat via het Twitter-account www.twitter.com/minsdkversion steeds een minimale SDK-versie voor de ‘praktische, rationele’ ontwikkelaar wordt geadviseerd. Hoewel het verder niet is onderbouwd, wordt het aangegeven API-level als een zinvol advies beschouwd en door veel ontwikkelaars daadwerkelijk toegepast. Via een account op Twitter wordt een minimale SDK-versie geadviseerd. Gebruikersinterface In Android Studio zie je aan de linkerkant het projectvenster genaamd Project. Het bevat alle ontwikkelbestanden voor je app. Zie het als een soort bestandsbeheerder. Bij de standaardweergave Android wordt echter niet de indeling van bestanden en mappen op schijf gevolgd. Wat je ziet is een vereenvoudigde weergave met de meest revelante bestanden. We werken in onze cursus voornamelijk in deze weergave. Wijzig je de weergave aan de bovenkant van het venster naar Project, dan komen ook andere details naar voren die je soms wilt zien. En dan wordt wel overwegend de indeling van bestanden en mappen op de schijf gevolgd. Naast het projectvenster heeft Android Studio nog veel meer vensters met nuttige tools. Deze kun je zichtbaar maken via View / Tool Windows. Een andere, snellere manier om vensters te openen of te sluiten is door je muis linksonder boven het icoontje met de twee vierkanten te houden. Verder kun je op een van de tabbladen klikken die je rondom het scherm van Android Studio ziet. De indeling kun je sterk naar je hand zetten, maar in deze cursus gebruiken we de standaardinstellingen. De gebruikersinterface van Android Studio met links het geopende projectvenster. Menu’s en instellingen Blader je door de menu’s, dan zijn de vele opties in het begin vermoedelijk wat overweldigend. Maar wees gerust: je hebt zeker in het begin maar een klein deel van al die functies nodig. En die komen gaandeweg aan bod, op het moment dat we ze nodig hebben. Datzelfde geldt voor het uitgebreide instellingenmenu onder File / Settings. Je kunt tot in detail alle instellingen van Android Studio aanpassen. Wat je vooraf al naar smaak aan zou kunnen passen, is het thema onder Appearance & Behavior / Appearance. Ook het lettertype en de tekstgrootte voor de editor kun je onder Editor / Font naar smaak aanpassen. Bij de cursus gaan we ook wat deze instellingen betreft uit van de standaardinstellingen, maar geven we tips voor aangepaste instellingen die het leven (als Android-ontwikkelaar) makkelijker kunnen maken. Android Studio kun je tot in detail geheel naar smaak instellen.
    1 point
  8. Je hebt heel wat muziek, foto’s, video’s en films op je pc opgeslagen en je zou die eigenlijk wel op je televisie of op een beamer willen afspelen. Dat kan! Naast een geschikte app op je mediaspeler, televisie of smartphone, heb je dan nog een mediaserver nodig. We stellen je twee gratis serveroplossingen voor Windows voor. Er zijn heel wat degelijke mediaservers beschikbaar voor diverse platformen. Tot de bekendste horen ongetwijfeld Plex, Kodi en Emby. In dit artikel gaan we ervan uit dat je alleen over een Windows-pc beschikt en dat je de voorkeur geeft aan een gratis oplossing. We komen dan uit bij twee uiteenlopende tools: de ingebouwde Windows Media Player, die we kort bespreken, en de externe en opensource Universal Media Server. Deze laatste biedt een ruime apparaat-ondersteuning en is ook beschikbaar voor Linux en macOS. Windows Media Player Inschakelen Veel gebruikers weten het niet, maar Windows 10 heeft alles in huis om allerlei media over je netwerk te streamen. Je moet de functie alleen inschakelen en configureren. Start hiervoor Windows Media Player op, open het menu Streamen en kies Mediastreaming inschakelen. Het venster Opties voor mediastreaming verschijnt waar je nogmaals op Mediastreaming inschakelen klikt. Geef een naam aan je mediabibliotheek. Nu verschijnen onderaan al een of meer DLNA/UPnP-compatibele apparaten die in je Lokaal netwerk zijn gedetecteerd. Bevestig met OK. Mocht je mediastreaming niet kunnen inschakelen, dan is waarschijnlijk de indexeringsservice van Windows uitgeschakeld. Die schakel je in als volgt: druk op Windows-toets+R en voer Services.msc uit. Scrol naar Windows Search en klik hier met rechts op. Kies Eigenschappen en stel het Opstarttype in op Automatisch (vertraagd starten). Klik op Starten en op OK. Om media vanuit Windows Media Player te kunnen streamen, moet je die functie eerst inschakelen. DLNA en UPnP We willen het bewust niet al te technisch maken in deze workshop, maar we kunnen moeilijk om de begrippen DLNA en UPnP heen. Beide duiken namelijk vaak op als je informatie opzoekt over mediaservers en streaming. UPnP (Universal Plug and Play) is een protocolset die het mogelijk maakt dat verschillende apparaten in een netwerk elkaar detecteren om zo de aangeboden diensten te kunnen gebruiken. DLNA (Digital Living Network Alliance) maakt hiervan gebruik om vooral mediabestanden als foto’s, muziek en video’s makkelijker te kunnen delen. Van DLNA-gecertificeerde apparaten mag je dus verwachten dat ze vlotjes media kunnen streamen. Dat geldt onder meer voor Windows-pc’s, de meeste Android-smartphones, blu-ray-spelers, tablets en smart-televisies. iPhones horen hier niet bij, die werken met de eigen AirPlay-technologie, maar gelukkig zijn er wel apps die deze functionaliteit alsnog toevoegen. Kijk hier bijvoorbeeld eens naar. Apparaten die DLNA-gecertificeerd zijn, hebben alles in huis om vlot media te streamen. Instellen Wanneer je nogmaals het menu Streamen opent op je pc, die nu als DLNA/UPnP-server fungeert, merk je de optie Meer streamingopties op. Deze optie geeft je opnieuw toegang tot het venster Opties voor mediastreaming. Om een gedetecteerd apparaat toch de toegang tot je gedeelde media te ontzeggen, hoef je bij dit apparaat alleen maar het vinkje te verwijderen naast Toegestaan. Je kunt ook aangeven welke mediatypes je met een apparaat wilt delen. Klik hiervoor op Aanpassen bij dit apparaat, verwijder het vinkje bij Standaardinstellingen gebruiken, selecteer Alleen: en laat een vinkje staan bij de gewenste media: Muziek, Afbeeldingen, TV-opnamen en Video. Om alleen media die je een bepaalde waardering hebt gegeven (bijvoorbeeld drie of meer sterren) toe te staan, geef je bij Selecteer sterwaardering de optie Alleen: aan en kies je Met [x] sterren of meer. Leg je keuzes vast met OK. Op je mediaserver houd je als beheerder nog wel alle touwtjes in handen. Afspelen Dan gaan we nu naar de apparaten die van je gedeelde mediabibliotheek willen gebruikmaken. Bij DLNA-gecertificeerde apparaten of apps moet dat geen probleem zijn. Open je bijvoorbeeld Windows Media Player op een andere pc in je netwerk, dan hoort in het linkervenster de naam van de gedeelde bibliotheek te verschijnen, met de media die klaarstaan om af te spelen. Laten we er als voorbeeld ook even een Android-smartphone bijnemen, met de gratis app BubbleUPnP for DLNA / Chromecast / SmartTV, beschikbaar in de Play Store. Na de installatie kies je de gewenste mediaspeler, zoals een Google Chromecast of de smartphone zelf (Local Renderer). Tik vervolgens op de oranje knop Select library en selecteer de gedeelde bibliotheek op je Windows-pc. Selecteer als dat nodig is een geschikte mediaspeler, bijvoorbeeld VLC for Android, en gaan met die banaan. De gedeelde bibliotheek van je server verschijnt direct in de mediaspeler van andere pc’s. Universal Media Server Installatie De mediaserver van Windows is alleen wel behoorlijk uitgekleed. Wil je een tool met meer pit en mogelijkheden? Dan kun je het gratis en opensourceproject Universal Media Server, kortweg UMS, overwegen. Je vindt die, onder meer voor Windows, op www.universalmediaserver.com. In ons geval is dat versie 10.6.0, maar er komen geregeld updates uit. Met een dubbelklik installeer je het gedownloade exe-bestand. Druk op Next (2x), laat het voorgestelde werkgeheugen ongemoeid en druk op Install. Bevestig met Ja / I Agree / Next / Install / Finish om ook AviSynth, een soort video-editor met filters, mee te installeren. Even later kun je de installatie met Finish afronden en UMS opstarten. De eerste keer vraagt UMS je om de gewenste interfacetaal; wij kozen voor Nederlands (Dutch). Bevestig met Selecteer, waarna UMS wordt opgestart. Je bent er nog niet helemaal, want je krijgt nog een configuratiewizard voor de kiezen, met een handvol vragen. Daar kun je je weliswaar makkelijk vanaf maken door Nee, gebruik de standaard instellingen te kiezen, maar als lezer van Computer!Totaal ben je waarschijnlijk meer geneigd Ja, ik wil eigen instellingen te selecteren. Dan toch eerst maar even langs die configuratiewizard. Basisconfiguratie De vragen van de wizard blijken trouwens mee te vallen. Of je UMS geminimaliseerd wilt starten? Of je de geavanceerde opties liever verborgen houdt? Of je bij het starten de gedeelde mediamappen wilt laten (her)scannen? Dit houdt de inhoud wel up-to-date, maar tijdens de scanronde kan UMS dan wel iets trager werken. Tot slot moet je nog een (basis)map kiezen voor de mediabestanden die je via UMS wilt delen; standaard is dit c:\Users\<accountnaam>\Documents. Even later start UMS door, een proces dat op het tabblad Logs te volgen is. Als het goed is, heeft de server direct enkele compatibele mediaspelers gedetecteerd en op het tabblad Status weergegeven. Het moet wel gezegd: UMS identificeert deze clients niet altijd vlekkeloos. ‘VLC for Desktop’ was bijvoorbeeld in ons geval ‘VLC op Android’, maar het ip-adres maakt in elk geval duidelijk om welk apparaat het gaat. Onze UMS-server heeft compatibele clients gedetecteerd, waarvan er enkele overigens al media aan het afspelen zijn. Webinterface: adres We komen straks nog wel terug op het configuratiescherm van UMS en bekijken eerst hoe je vanaf andere toestellen de media via UMS kunt afspelen. Om het uit te proberen plaats je een aantal mediabestanden in de map die je eerder als basismap hebt ingesteld. Je mag hier gerust ook submappen creëren, voor bijvoorbeeld audio, foto en video. Heeft het apparaat vanwaar je die media wilt bereiken een webbrowser, dan hoef je die maar af te stemmen op het ip-adres van je UMS-server. Het volstaat op die machine om naar de Opdrachtprompt te gaan en Ipconfig in te tikken om het lokale ip-adres te vinden. Stel, het ip-adres is 192.168.0.132, dan vul je in de adresbalk van je browser 192.168.0.132:9001 in. 9001 is de standaardpoort waarop de ingebouwde webservice van je UMS-installatie draait. De webserver van UMS toont standaard eerst een splashscreen. Webinterface: gebruik Na het UMS-log verschijnt dan je homepage met een overzicht van de beschikbare media op UMS. In het linkervenster vind je zowel de Media Library (met een automatische opdeling in rubrieken als Video, Audio en Foto) als de naam van je basismap terug. Je treft hier ook de ‘map’ Web aan. Deze bevat onderdelen als Pictures, Podcasts, Vodcasts en YouTube Channels en die blijken al met een aantal voorbeeldmedia te zijn gevuld. We vertellen je hier dadelijk meer over. Media afspelen is in elk geval niet moeilijker dan een rubriek te openen en het mediabestand of de online mediastream met een dubbelklik te openen in de ingebouwde speler. Gebruik je Chrome als browser en beschik je over een Google Chromecast? Dan kun je inhoud uiteraard ook gewoon doorsturen naar het apparaat, zoals een televisie, beamer of audioboxen, dat op de Chromecast is aangesloten. Druk hiervoor op het knopje met de drie puntjes, kies Casten en selecteer het apparaat. Handig is ook dat UMS automatisch ‘slimme’ sorterings- en selectiemappen bijhoudt voor de diverse media, zoals Op Artiest/Album, Op Datum, HD-video’s, Meest Gespeeld. Rechtsboven staan nog een zoekknop en een instellingenknop waarmee je onder meer een Subtitle translator kunt instellen om lokale ondertitelingsbestanden op te halen. Je kunt er ook een eigen account mee aanmaken bij Opensubitles.org. Ook vanuit je webbrowser krijg je toegang tot de mediabestanden van UMS. Andere client-apps Heb je geen browser beschikbaar op je apparaat, dan moet je aan de slag met een DLNA-compatibele client-app. Er zijn er heel wat, zoals een zoektocht met een term als DLNA apps for <system/device> op het internet je meteen duidelijk maakt. We beperken ons hier tot een aantal voorbeelden. Een populaire app, beschikbaar voor bijna alle desktop- en mobiele systemen, is VLC Media Player. We bekijken eerst de desktopversie voor Windows. Start VLC op, ga naar het menu Weergave en kies Afspeellijst (Ctrl+L). In het dialoogvenster kies je in het linkervenster, bij Lokaal netwerk, de optie Universele Plug’n’Play. Hier vind je de Universal Media Server waar je door te dubbelklikken toegang krijgt tot de beschikbare media. De mobiele versie van VLC – we nemen Android als voorbeeld – werkt op eenzelfde manier. Start de app en tik onderaan op Bladeren. Bij Lokaal netwerk hoort Universal Media Server te staan. Op iOS kun je bijvoorbeeld ook aan de slag met het gratis mconnectLite. Na de installatie hoef je slechts de Browser-knop onderaan te kiezen en vind je ook hier Universal Media Server terug. Toegegeven, bij sommige DLNA-apps is het soms wat zoeken naar de aangewezen manier om met je UMS te verbinden, maar Google en het UMS-forum zijn ook hier je vriend. Ook VLC Media Player (hier de desktopversie) detecteert feilloos de UMS-server binnen je lokale netwerk. Bronbeheer We keren nu even terug naar het configuratievenster van UMS. Op het tabblad Gedeelde inhoud tref je twee onderdelen aan: Map en Webcontent. Bij Map vind je je basismap voor mediabestanden terug en kun je via het mapicoon nog andere mappen toevoegen. Met de pijlknoppen bepaal je de volgorde en via het rode kruis verwijder je een map. Bij Webcontent merk je een handvol items op, bij Image feed (waaronder Flickr), Podcast (inclusief vodcasts) en Video feed (YouTube). Ook hier bepaal je welke items je wilt behouden en in welke volgorde. Eigen streams toevoegen kan ook. Druk op de plusknop, selecteer het type (Podcast, Video feed, Afbeelding feed, Audio stream of Video stream), kies de map(pen) en vul de juiste streaming-url in. UMS kan mediastreams rechtstreeks van het internet ophalen en doorsluizen. Extra configuratie Al tijdens de installatie had je de interfacetaal van UMS ingesteld, maar dat kun je nog aanpassen op het tabblad Algemene instellingen. Hier vind je trouwens nog enkele andere nuttige instellingen terug. Je kunt bijvoorbeeld de Servernaam aanpassen, aangeven of UMS samen met Windows moet starten en, via de knop Installeer als een Windows-service, ervoor zorgen dat je niet bij Windows hoeft te zijn aangemeld om toch met UMS te kunnen streamen. Verder zijn er nog de knop Controleren op updates en een reeks geavanceerde netwerk- en systeeminstellingen. Om de manier te wijzigen waarop je in UMS kunt navigeren, open je het tabblad Navigatie instellingen. Je geeft hier bijvoorbeeld aan of je miniaturen wilt genereren, wat de standaardsortering moet zijn (Alfanumeriek of Op datum) of welke bestandsextensies je wilt verbergen. Bij de algemene instellingen vind je diverse opstartopties en geavanceerde netwerkconfiguraties. Transcodering UMS fungeert ook als transcoder bij mediastreaming. Dat betekent dat die de codec van een bepaalde mediastream kan aanpassen of optimaliseren, zodat de client de media in goede orde ontvangt. Onderliggend maakt UMS hiervoor gebruik van allerlei externe, geïntegreerde tools. Als er meerdere van die tools zo’n transcodering op zich kunnen nemen, dan kun je zelf de volgorde bepalen waarin die tools door UMS worden aangesproken. In de rubriek Videobestand Engines bijvoorbeeld vind je normaliter het eerst FFmpeg Video terug, maar via de pijlknoppen zou je bijvoorbeeld AviSynth/MEncoder een hogere prioriteit kunnen meegeven. Je vindt de diverse transcoderingen dan vanuit je client-app terug via de ‘submap’ #-TRANSCODEER-#. Verder kun je elke engine ook afzonderlijk op allerlei manieren instellen. Dit vergt wel doorgedreven kennis van deze transcoders en we hebben helaas niet de ruimte hier verder op in te gaan. Ons advies: probeer het eerst met de standaardinstellingen. Als een bepaalde mediastream dan toch niet (optimaal) afspeelt, kun je aan de volgorde en de configuratie van de engines gaan sleutelen. Op het tabblad Help, bij Transcoding Settings vind je de nodige feedback over de diverse transcodeerinstellingen. Je kunt tot op zekere hoogte zelf bepalen hoe je een mediastream doorstuurt, dus met welke transcoder én opties.
    1 point
  9. Welkom bij het overzicht met Payservers welke gebruikt kunnen worden om te downloaden via nieuwsgroepen. Om gebruik te kunnen maken van nieuwsgroepen moet je ook verbonden zijn met een nieuwsserver. Op deze nieuwsserver staan de benodigde bestanden die je kunt downloaden In het overzicht hieronder proberen we alle prijzen van de Nederlandse usenetproviders op een rijtje te zetten. Per provider laten we de verkrijgbare abonnementen en de bijbehorende prijzen zien. Ook de specificaties van de abonnementen komen aan bod. Een payserver is een server die tegen betaling toegang geeft tot nieuwsgroepen. Het voordeel van een payserver tegenover een freeserver is dat deze een betere retentie, compleetheid en snelheid heeft dan de provider nieuwsservers. Ook ondersteunt een payserver vaak alle nieuwsgroepen, Met een payserver krijg je dus een breder aanbod op usenet en een betere downloadsnelheid. Meer uitleg over nieuwsgroepen vind je hier: Overzicht payservers, usenet providers Extreme Usenet Abonnement: maandelijks, kwartaal, halfjaar, jaar en twee jaar Kosten vanaf: €4,00 per maand Betalingswijze: iDeal, PaysafeCard, Overboeking, Creditcard, GiroPay, Mistercash Retentie: 1200 dagen Datalimiet: nee Server adres: news.extremeusenet.nl Newsconnection Abonnement: maandelijks, kwartaal, halfjaar en jaar Kosten vanaf: €5,95 per maand Betalingswijze: Creditcard, iDeal, Mr Cash, Sofort Banking 4 mbbit, 10 mbbit, 10 mbbit, 20 mbbit, 150+ mbbit. Retentie: 900 dagen Server adres: newsconnectioin.nl Download2Day = WonderNews.eu Abonnement: maandelijks, kwartaal, halfjaar en jaar Kosten vanaf: €4,95 per maand Betalingswijze: iDeal, PaysafeCard, Overboeking, Creditcard, Sofort, GiroPay, Mistercash, Direct Debit en Bitcoin Retentie: 900+ dagen Datalimiet: nee, alleen bij block pakketten Server adres: reader.wondernews.eu EasyUsenet Abonnement: maandelijks, kwartaal, halfjaar, jaar en twee jaar Kosten vanaf: €4,95 per maand Betalingswijze: iDeal, PaysafeCard, Overboeking, Creditcard, Sofort, GiroPay, Mistercash, Direct Debit en Bitcoin Retentie: 999+ dagen Datalimiet: nee Server adres: reader.easyusenet.nl YabNews Abonnement: maandelijks, kwartaal, halfjaar en jaar Kosten vanaf: €6,50 Betalingswijze: iDeal, PaysafeCard, Overboeking, Creditcard, Sofort, GiroPay, Mistercash, Direct Debit en Bitcoin Retentie: 999 dagen Datalimiet: Nee, alleen bij block pakketten Server adres: news.yabnews.nl PowerNews Abonnement: maandelijks, kwartaal en jaar Kosten vanaf: €2,95 Betalingswijze: iDeal, PaysafeCard, Overboeking, Creditcard, Sofort, GiroPay, Mistercash, Direct Debit en Bitcoin Retentie: 600+ dagen Datalimiet: nee, alleen bij block pakketten Server adres: reader.powernews.nl UsenetXL Abonnement: maandelijks, kwartaal, halfjaar en jaar Kosten vanaf: €8.95 per maand Betalingswijze: iDeal, PaysafeCard, Overboeking, Creditcard, Sofort, GiroPay, Mistercash, Direct Debit, Bitcoin en PayPal Retentie: 900 dagen Datalimiet: nee, alleen bij block pakketten Server adres: reader.usenetxl.nl XS News Abonnement: maandelijks, kwartaal, halfjaar en jaar Kosten vanaf: €3,70 per maand* (* = uitgaande van een jaarabonnement) Betalingswijze: iDeal, Creditcard, PaysafeCard, Mister Cash, Sofort, Bitcoin, PayPal en Automatische incasso (verlengt automatisch) Retentie: 877+ dagen Datalimiet: nee, alleen bij block abonnementen Server adres: reader.xsnews.nl 4UX Abonnement: maandelijks, kwartaal, halfjaar en jaar Kosten vanaf: €5,07 per maand Betalingswijze: iDeal, PaysafeCard, Overboeking, Creditcard, Sofort, GiroPay, Mistercash, Direct Debit en Bitcoin Retentie: 900+ dagen Datalimiet: nee Server adres: news.4ux.nl Astraweb Abonnement: maandelijks en kwartaal Kosten vanaf: $10 Betalingswijze: PayPal, Creditcard, iDeal, Sofort Retentie: 2704 dagen Datalimiet: nee, alleen bij block abonnementen Server adres: news.astraweb.com of news.europe.astraweb.com Eweka Abonnement: maandelijks Kosten vanaf: €7,50 Betalingswijze: PayPal, iDeal, GiroPay, Mister Cash, PaysafeCard, SMS, Carte BLEUE en overboeking Retentie: 2702 dagen Datalimiet: Nee Server adres: kan worden gevonden in 'Mijn Eweka' SunnyUsenet Abonnement: maandelijks, kwartaal, halfjaar en jaar Kosten vanaf: €1,43 per maand* (* = uitgaande van een jaarabonnement) Betalingswijze: Creditcard, iDeal, Bitcoin, Sofort, PaysafeCard en overboeking Retentie: 900 dagen Datalimiet: nee Server adres: news.sunnyusenet.com Op deze pagina zijn coupon en kortingscodes te vinden.: Deze pagina wordt regelmatig bijgewerkt door informatie van leden en gasten. Links / tips toevoegen of defecte links? Meld ze in de reacties.
    1 point
  10. Welkom bij de handleiding van Snail driver. Met dit programma is het mogelijk om drivers en stuurprogramma's van Windows te vinden en te installeren of bij te werken. In dit artikel geven we een introductie, gebruikers handleiding en de configuratie voor het optimaal gebruik maken van Snaildriver. Wat komt er aan bod deze handleiding? Wat is Snaildriver? Plus- en minpunten van Snaildriver Installatie in woord en beeld Configuratie en tips van Snaildriver na de installatie voor optimaal gebruik Wat is Snaildriver? Stuurprogramma's updaten kan vaak voor de nodige problemen zorgen, gelukkig bestaat er software die u een helpt zoals SnailDriver. Als u al eens op zoek geweest bent naar een stuurprogramma, weet u dat er veel rotzooi op het internet te vinden is. Software die u veel beloofd om stuurprogramma's downlloaden en ze te installeren. Maar dan wordt u gevraagd te registreren, te betalen of andere rommel te installeren. Gelukkig bestaat er ook software dat wel doet wat het beloofd: SnailDriver. Om goed te kunnen functioneren moet Windows communiceren met allerlei losse onderdelen die in je pc zitten of erop aangesloten zijn. Dat gebeurt door middel van stuurprogramma’s en die zijn – zoals je weet – soms niet meer actueel. Het programma ziet er overzichtelijk uit en doet zijn taak razendsnel. Binnen een minuut zie je welke onderdelen aan vervanging toe zijn en kunt je die klus vervolgens met een enkele muisklik klaren. Plus- en minpunten van SnailDriver Pluspunten Het is een lichtgewicht en snel programma Drivers updaten met één klik Meer dan 350.000 apparaat drivers in database SnailDriver is een gratis programma minpunten Toont niet de gegevens van de release van het nieuwe stuurprogramma Installatie in woord en beeld Download het programma Snaildriver of hier Installeer het programma. Start het installatie programma. Druk op Next. Kies een locatie voor de installatie en druk op Next. Maak eventueel een snelkoppeling op uw desktop, quicklaunch en start menu en druk op Next. Druk op Install om de applicatie te installeren De applicatie is geïnstalleerd, druk op Finish om de applicatie te starten. Configuratie en tips van programma-naam na de installatie voor optimaal gebruik Het programma is gestart en bevat een aantal opties. Voordat wij gaan scannen naar stuurprogramma's gaan we eerst de instellingen van SnailDrive veranderen. Druk op het tandwiel icoon. Standaard staat de optie aan in de applicatie om deze automatisch te starten als Windows start. Wij vinden deze optie overbodig, tenslotte ga je de applicatie alleen gebruiken als je opzoek bent naar stuurprogramma's of stuurprogramma's wilt bijwerken. Zet de optie "Launch automatically when Windows startup" uit en druk op Apply. We zijn klaar om de computer te voorzien van missende of nieuwe stuurprogramma's. Druk op de grote SCAN knop. Even geduld. SnailDriver geeft bij ons aan dat er twee verouderde stuurprogramma's zijn. Beide kunnen worden bijgewerkt, eventueel missende stuurprogramma's van hardware word ook gevonden en weergegeven. Druk op Update. Even geduld, de stuurprogramma's worden gedownload, bijgewerkt en automatisch geïnstalleerd. SnailDriver is klaar met de update en geeft een overzicht weer met de acties. In ons geval zijn de stuurprogramma's succesvol bijgewerkt. Wel geeft de applicatie aan dat er een herstart nodig is van het systeem. Herstart het systeem zodat alle stuurprogramma's juist zijn bijgewerkt. Vragen of opmerkingen kunnen in de reacties of als losse vragen in het forum van Duken.nl
    1 point
This leaderboard is set to Amsterdam/GMT+01:00
×
×
  • Create New...