Bachelor Thesis of Jef Geskens

De tekst is klaar, typfouten en rare zinsconstructies onder voorbehoud. Daarvoor dient de echte finale versie
Hij is te vinden op mijn subversion repository.

adipexbuy ambienbuy viagraviagra onlinetramadol onlinebuy xanaxbuy valiumtramadol onlineultram onlineviagraonline pokercasino pokercasino bettingonline blackjackcard gameephedralevitrahydrocodoneherbal viagrabuy tramadol

Nu we ContextEntities hebben, kon ik beginnen aan de ContextEntityDifference klasse. Deze (de naam zegt het zelf al) beschrijft een verschil tussen twee ContextEntities. Er zijn drie soorten verschillen, namelijk EntityAdded, EntityRemoved en EntityChanged. Deze spreken natuurlijk voor zich. Nu we deze verschillen kunnen berekenen, is het mogelijk om efficiënt te loggen. We hoeven hiervoor enkel die verschillen om te zetten naar XML tags om dan te loggen.

Hier komt een nieuw probleem bij kijken, namelijk dat XML tags nogal veel plaats innemen en er veel dezelfde informatie in zo een log komt te staan. Hiervoor ben ik opzoek gegaan naar een oplossing in de vorm van compressie, en ik botste op ZLIB.NET. Dit is een volledig managed implementatie van de alombekende ZLIB compressietechniek die vrij is van patenten. De library ZLIB.NET heeft een licentie die veel weg heeft van de BSD licentie, wat ook weer een pluspunt is. Ik heb echter wel gemerkt dat deze niet direct geschikt was om te gebruiken in het .NET Compact Framework, maar gelukkig was dit snel opgelost door de bronbestanden in een nieuw projectje te steken en zo te targetten naar .NET Compact. Alles werkt vlekkeloos.

Tijdens het implementeren van het logging systeem kwam ik erachter dat mijn datastructuren eigenlijk ongeschikt waren om efficiënt de verschillen te loggen (toegevoegd, verwijderd of veranderd). Een boom met als nodes key/value pairs is een beetje overkill. Ik heb ContextEntities geïntroduceerd die gewoon een entiteit voorstellen van de context. De batterij, of bijvoorbeeld een bepaald WLAN accesspoint. Sommige soorten entiteiten kunnen meerdere keren voorkomen, zoals Bluetooth devices, processen, en uiteraard WLAN accesspoints. Elk zo een object kan meerdere key/value paren hebben, maar elke soort heeft uiteraard dezelfde set keys. WLAN accesspoints hebben in dit geval dan als keys BSSID, ESSID en RSSI. De values zijn dan de waardes van deze keys.
Ook doordat alles nu in Hashtables zit, wordt het opzoeken op naam gigantisch versneld. In de vorige implementatie moest alles sequentieel doorlopen worden, en eigenlijk is dat “not done” voor zo een dingen.

Morgen hoop ik dat ik eindelijk het loggen geïmplementeerd heb, zodat ik mijn tekst kan afmaken in het weekend.

Het is alweer een tijdje geleden dat ik serieus terug bezig was met mijn eindwerk. Nu komt alles weer wat in een stroomversnelling.

Ondertussen is het ook mogelijk om de lopende programma’s op te vragen. Deze functionaliteit zal ook nog verbeterd worden met informatie over elk proces.

Over het loggen heb ik serieus zitten nadenken, en ik heb besloten om differentiële binaire logging te doen, om efficiëntieredenen. Hiervoor zal ik ook een algoritme implementeren om meerdere bomen met elkaar te vergelijken om zo de relevante verschillen te vinden. Hierbij duiken weer enkele problemen op, want wat gaan we doen met WLAN signaalsterktes, die voortdurend veranderen? Ik denk dat uiteindelijk de continue monitoring van deze signaalsterktes voor dit eindwerk eigenlijk niet echt veel nut heeft, maar wel het moment dat we een accesspoint zien aankomen of verdwijnen uit het zicht. De signaalsterktes op dat moment kunnen uiteraard mee gelogd worden. Om dit op te lossen zal ik per IContext implementator moeten bepalen welke dingen meetellen voor de differentiële log.

Tegen vanavond hoop ik een groot deel van deze problemen te hebben opgelost. online pharmacy without prescriptionbuy silverbuy detoxbuy italian charmsdownload softwareonline pharmacy no prescriptioncanadian pharmacydownload moviesfarmacia en lineainternet drugstoremovie downloadmexican pharmacybuy gift basketsbuy levitrabuy hoodiaprescription drugsdownload moviebuy dvdcheap auto insurancebuy jewelrybuy jewelry onlinecheap online pharmacybuy alcohol testdownload filmdownload musicdownload mp3prescription drugsbuy notebook batterydownload moviesonline pharmacybuy charmsbuy piercingpiercingflash games onlinebuy propecia onlinesearchpiercingno prescription pharmacyonline pharmacyonline pharmacy no prescriptiondownload moviescanadian pharmacybuy soma onlinebuy carisoprodol onlineitalian charmsindian pharmacybuy viagra onlinegeneric viagra onlinebuy levitra onlinegeneric cialis onlineonline pharmacy without prescriptionno prescription online pharmacytransformers movieeuropean online pharmacyprivate porn moviesbuy phentrimine onlineonline pharmacy no prescriptionbuy jewelry onlinejewelry shopsilver shophealth articlespass a drug testbuy oem softwareeuropean pharmacydvd movies

Ik heb net nog iets heel interessant gevonden op MSDN:

Creating a P/Invoke library

Een P/Invoke library maken op zich wist ik al, maar er staan wel mooie voorbeelden in die gebruik maken van win32 API calls die ik net nodig had!

Bestaande klassen als BatteryContext en dergelijke kan ik nu uitbreiden met bijvoorbeeld informatie over het al dan niet insteken van de lader. Toch wel een belangrijk iets om te weten als we de context van een device willen weten.

[update] Deze zitten blijkbaar ook al in OpenNETCF.

Het is al even geleden dat ik nog iets heb gepost op deze blog. Er is ook de laatste weken niet zo veel gebeurd, deels door andere projecten die een dichtere deadline hadden.

De Bluetooth module is verbeterd, er zit namelijk geen timeout meer in en het zoeken wordt pas gestopt nadat de library aangeeft gedaan te hebben met zoeken. Op dat moment kan de Query()-methode een resultaat teruggeven.

Over resultaten van queries gesproken, het is belangrijk dat deze een goede structuur hebben. Momenteel vind ik het een beetje zwak, met enkel Strings. Ik wil ervoor zorgen dat de gebruiker van mijn library zeer makkelijk kan “browsen” in de resultaten. Daarom heb ik een soort “TreeHash” achtige structuur geïntroduceerd die wordt geïmplementeerd in de ResultNode klasse. De basis voor deze klasse is geschreven. Ik ben nog van plan enkele handige methodes daaraan toe te voegen zoals
ResultNode FindFirst(String property);
en
ResultNode ToArray(String property);
en uiteraard accessors voor de “Property” en “Value” velden (sorry voor eventuele verwarring maar ik vond “property” een goede naam voor een eigenschaptype).

Ik zou ook nog eens een meeting willen hebben met mijn begeleider Kristof Verpoorten, ik heb namelijk een leuk idee, maar daar vertel ik later wel meer over.

Bij elk deftig framework hoort natuurlijk ook goede documentatie. Deze kan u vinden op de API documentatie pagina. (Werkt wel enkel goed in IE helaas… op andere browsers is het ook nog leesbaar maar is het gewoon iets meer klikken…)

Bluetooth werkt ondertussen ook, alleen krijg je nu wel een vervelende MessageBox bij het aanmaken van de BluetoothContext class omdat het een trialversie van BTAccess gebruikt.

Volgende zaken die op mijn agenda staan zijn nu: Geluidsvolume opvragen/instellen, Logging, Threading en Events.

De InTheHand.NET library van 32feet leek me heel interessant om Bluetooth devices te kunnen opsporen. Helaas ondersteunt deze enkel de Microsoft Bluetooth stack en niet de Broadcom stack die mijn PDA blijkbaar gebruikt. Bij deze ook een kleine oproep naar het EDM: zou ik eens een namiddagje ter plaatse eens mogen testen op een van jullie PDA’s?

De BTAccess library van High Point Software kan wel met mijn stack samenwerken, maar helaas kost deze geld. Toch ga ik hem eens bekijken, en het is misschien interessant om een laagje boven beide libraries te maken, waarbij eerst de InTheHand library wordt geprobeerd, en indien deze niet werkt, de BTAccess te proberen.
Wel een klein probleempje, de documentatie zegt:

If you do wish to continually leave the search function running, please be aware of the following issues:

- Continually searching drains the battery faster.
- While the iPAQ is in device-search mode it is not discoverable or connectable by another device.
- As described above, extra device-found events can be triggered for the same device multiple times, if other operations involving that device occur.

Met andere woorden, die agent gaat volgens mij als we niet goed oppassen veel batterijstroom zuipen, tenzij we slechts af en toe wat scannen. Hier zal dus een balans moeten worden opgemaakt tussen efficiëntie en stroomverbruik…

Nog even iets over de structuur van de context. Het lijkt mij het beste om onderscheid te maken tussen een scalar en een lijst. Een batterijstatus of een signaalsterkte is dan een scalar, en de zichtbare accesspoints zijn dan een lijst. Zowiezo ga ik voor elke soort device ook een scalar afleiden, bijvoorbeeld het accesspoint met de beste signaalsterkte.

Het is natuurlijk eenvoudig om lijsten op te slaan als een delimited string. Niet zo super mooi, maar het is wel efficiënt om te loggen. De log opslaan als XML is qua structuur gezien mooier maar heeft dan weer het nadeel dat de log file nogal lomp wordt en snel groeit. Enige suggesties zijn altijd welkom. Momenteel ben ik van plan om beide aanpakken te implementeren, en de gebruiker van mijn library de keuze te laten.

Tijdens het ontwerpen van mijn klassenstructuur heb ik zitten nadenken over hoe de context zo efficiënt mogelijk kan worden geïnterpreteerd en opgeslagen. Het probleem is dat verschillende aspecten van de context verschillende soorten data hebben. Bijvoorbeeld, de batterijstatus is gewoon een getal wat het percentage energie voorstelt die de batterij nog heeft, en de naburige WLAN netwerken is een hele lijst met accesspoints met alle info van dien. Ik ben aan het overwegen om in dat laatste geval ook een mogelijkheid te bieden om enkel het MAC-adres van de dichtstbijzijnde accespoint terug te geven.

Nog een ander aspect is het feit of een bepaalde context wel kan opgevraagd worden. Bijvoorbeeld als WLAN uitstaat, is het moeilijk om draadloze netwerken te detecteren. In dat geval moet we dit interpreteren als een soort “wildcard” en dat moet ook duidelijk aanwezig zijn in de datastructuur.

Huidige status van implementatie:

• WLAN detectie: works
• Batterij (hoeveelheid energie over): works
• Batterij (lader aangesloten of niet): work in progress
• Klassenstructuur: work in progress

Voor alle duidelijkheid, het detecteren van aparte contextcompomenten heeft niets te maken met de algemene datastructuur. Het is die structuur die de data van de componenten zal gebruiken om zo een bruikbare context datastructuur op te stellen.

Blijkbaar bevat onze goede oude vriend OpenNETCF enkele handige classes om WLAN netwerken te scannen binnen de namespace OpenNETCF.Net. Het volstaat om aan de Networking class een AdapterCollection op te vragen, en daaruit een Adapter te zoeken die IsWireless op true heeft staan. Uiteindelijk vind je een lijst van naburige accesspoints door de NearbyAccessPoints property op te vragen van de Adapter class.

Naar aanleiding van deze ontdekking ben ik begonnen met code te schrijven. Wat ik nu al heb gemaakt is een WLANContext class die niet alleen fungeert als een wrapper maar tevens ook een Thread voorziet en een DataAvailable event. Een voorbeeldprogramma zit bij de Solution.

Ik heb alle code op een Subversion repository gezet, meer details daarover zijn te vinden op de SVN-pagina.