Abou Chleih

{the magic lies between the brackets}

Menü Schließen

Kategorie: Windows Phone

SQL Datenbanken in Windows Phone 8 nutzen

Man kann Daten in Projekten auf vielfältige Arten speichern, eine davon ist die Hinterlegung der Daten in einer Datenbank.
Dazu gibt es in Windows Phone mehrere Optionen. Das bekannteste und weit verbreitetste Datenbank-Datenbanksystem  ist SQLite.
Sie ist open-source und kann kostenfrei in Projekten eingesetzt werden. Zudem hat SQLite den Ruf sehr stabil und schnell zu laufen.

Wieso soll ich denn überhaupt eine Datenbank nutzen?

Das muss man nicht, aber ab einer bestimmten Komplexität der Daten/Informationen, ist eine Datenbank sinniger, als ein „plumpes“ Hinterlegen der Informationen in Dateien, bspw. über XML oder JSON.

Beginnen wir…
Grundsätzlich gibt es eine Vielzahl von Anbietern, welche SQLite Zugriffe bereitstellen, bspw. SQLite-Net, SQLitePCL, uvm…

Ich habe mich für SQLitePCL entschieden, da ich hier den „simplen“ SQL Syntax nutzen kann und nicht – wie bei SQLite-NET – über LINQ gehen muss.

Installieren wir uns nun also SQLitePCL. Hierbei handelt es sich um ein NuGet-Paket, welches wir in VisualStudio mit über den NuGet Paket Manager installieren können.
Hier gibt es zwei Wege:

  • GUI:
    Rechtsklick auf das Projekt -> NuGet-Pakete verwalten.
    Jetzt aktivieren wir auf der linken Seite die Option „Online“ und suchen nach SQLite-PCL. Hier installieren wir die „Portable Class Library for SQLite“.
    Sobald gefunden, installieren wir sie.
  • Kommandozeile (Nuget-Console):
    Wir öffnen die Kommandozeile und geben folgendes ein: Install-Package SQLitePCL

SQLitePCL_Nuget_Install

 

Danach installieren wir noch die benötigte Windows Library „SQLite for Windows Phone“, hierbei handelt es sich NICHT um ein NuGet-Paket sondern eine Windows SDK Extension:

SQLitePCL_SDK_Install.png

 

Nun installieren wir die Library und fügen eine/n Referenz/Verweis unserem Projekt hinzu.

Anschließend können wir endlich anfangen.

Ganz allgemein sieht ein SQLite-Befehl so aus – wie man die Verbindung (conn) aufbaut, erfahrt ihr gleich:

 
                using (var command = conn.Prepare("INSERT INTO MyTable(VALUE1) VALUES (?);"))
                {
                    command.Bind(1, MeinWert); //1-indexed parameter
                    command.Step(); //Absetzen des Befehls an die Datenbank
                }

Grundsätzlich muss man erst einmal eine Datenbank anlegen.

[spoiler title=“Datenverbindung erstellen“ style=“fancy“ anchor=“Datenbank“]

        public DatabaseConn()
        {
            SQLiteConnection conn = new SQLiteConnection("mydatabase.db");
        }

[/spoiler]
Dies legt die Datenbank in einer Datei namens „mydatabase.db“ ab oder öffnet diese.
Jetzt müssen wir – falls noch nicht geschehen – die Datenbank mit Tabellen füllen:
[spoiler title=“Tabellen-Erstellung“ style=“fancy“ anchor=“Tabelle“]

        public void LoadOrCreateDatabase()
        {
            string sql = @"CREATE TABLE IF NOT EXISTS 
                        MyTable
                        (Id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
                         Header VARCHAR(255),
                         Text VARCHAR(4096),
                         Position INTEGER);";

            using (var statement = conn.Prepare(sql))
            {
                statement.Step();
            }
        }

[/spoiler]

Um Daten aus der Datenbank abzurufen, muss man erstmal differenzieren.

  • Bekommt man einen Datensatz zurück?
  • Bekommt man mehrere Datensätze zurück?

Für den ersten Fall können wir einfach eine Abfrage absetzen und die Spalten des ersten Datensatzes durchlaufen:

[spoiler title=“Select-Einzeldatensatz“ style=“fancy“ anchor=“Einzeldatensatz“]

using (var command = conn.Prepare("SELECT Id, Header, Text, Position FROM MyTable WHERE Id = ?"))
                {
                    command.Bind(1, ID); //Fill the first (one-indexed!) parameter
                    if (command.Step() == SQLiteResult.ROW || command.Step() == SQLiteResult.DONE) // Überprüfe, ob Reihe existiert oder Step ausgeführt
                    {
                        MyTableObject obj= new MyTableObject ()
                        {
                            id = (long)command["Id"],
                            header = (string)command["Header"],
                            text = (string)command["Text"],
                            position = (long)command["Position"]
                        };
                        return obj;
                    }
                }

[/spoiler]

Für den zweiten Fall müssen wir durch alle Zeilen laufen und diese Daten in unsere Objekte laden:

[spoiler title=“Select mehrerer Datensätzen“ style=“fancy“ anchor=“Mehrfachdatensätze“]

                using (var command = conn.Prepare("SELECT Id, Header, Text, Position FROM MyTable "))
                {
                    while (SQLiteResult.ROW == command.Step()) //Solange noch eine Reihe verfügbar ist, mache weiter
                    {
                        MyTableObject obj= new MyTableObject ()
                        {
                            id = (long)command["Id"],
                            header = (string)command["Header"],
                            text = (string)command["Text"],
                            position = (long)command["Position"]
                        };
                        this.list.Add(obj);
                    }
                }

[/spoiler]

Und zu guter Letzt Befehle ohne Rückgabe. Diese sind sehr einfach und lassen sich

[spoiler title=“Befehle ohne Rückgabe“ style=“fancy“ anchor=“Ohne-Rückgabe“]

                using (var command = conn.Prepare("DELETE FROM MyTable WHERE Id = ?;"))
                {
                    command.Bind(1, "MEINWERT");
                    command.Step(); //Absetzen des Befehls
                }

[/spoiler]

Das war’s. Jetzt könnt ihr eure Datenbank füllen und mit ihr arbeiten.

Lumia Cyan Update (Windows Phone 8.1) auf dem Lumia 520 installieren

Vor einigen Tagen wurde der Status des Cyan Updates für das Lumia 520 auf der Nokia Seite auf „Avaliable“ geändert und sollte somit den Nutzern zur Verfügung stehen.
Die bisherigen Updates, auch die der Developer Preview wurden über das Windows Phone eigene Updatemenü installiert.
Allerdings fand das Lumia dieses Cyan Update einfach nicht – zumindest nicht als OTA.
Im Netz ist dieses Problem kaum beschrieben. Da aber die Versionen in Mitteleuropa alle die gleichen sind und das Update in anderen Ländern wohl ohne Probleme ausgerollt wurde, muss es entweder etwas mit dem deutschen Server zu tun haben, oder mit meinem Smartphone.
Wie bekomme ich also das Update auf mein Lumia?
Microsoft hat das sogenannte Nokia Software Recovery Tool still und heimlich veröffentlicht.
Mit diesem Tool kann man das Update dann aufspielen, aber ACHTUNG! Es werden alle Daten auf dem Gerät gelöscht. Deshalb vorher ein Backup über die Windows Phone eigene Backup-Funktion ausführen. Dieses kann man dann nach der Installation einspielen.
1. Nokia Software Recovery Tool (NSRT) herunterladen und installieren.
2. Lumia 520 mit dem Rechner über ein microUSB Kabel verbinden
3. Das NSRT starten, es erkennt dann automatisch das angeschlossene Gerät und sucht das aktuellste Update für dieses.

Nokia Software Recovery Tool Update found
4. Das Gerät muss  über mindestens 1,7GB freien Speicher verfügen (lokal, nicht auf der SD Karte)

Anschließend einfach den Anweisungen folgen. Das Update ist 1,56GB groß, d.h. der Download kann je nach Downloadgeschwindigkeit dauern.

Danach kann man das Handy neu einrichten, solltet ihr das Backup getätigt haben, so wird euch dieses bei der Ersteinrichtung angezeigt und ihr könnt es zurückspielen.

Das war’s, nun habt ihr das Lumia Cyan Update auf eurem Lumia 520.

Lumia_Cyan_520

Windows Phone 8.1 – Project my Screen

Mit Windows Phone 8.1 ist neben den bereits genannten Funktionen eine neue Funktion namens „Project my Screen“ hinzugekommen.
Diese ermöglicht es den Bildschirminhalt des Smartphones per USB Verbindung auf den Desktop zu übertragen.

Voraussetzung dafür ist die Applikation für den Windows-PC, welche über die Microsoft-Download-Seite zu beziehen ist.

Was anfänglich irritiert ist, dass die Dekstopapplikation standardmäßig im Vollbild läuft und keinerlei Schaltflächen oder eine Maus besitzt.
Die Bedienung ist deshalb im Vollbild sehr unhandlich. Ein Druck auf die Escape, die F-Taste oder Alt-Enter lässt uns dann aber das Programm verkleinern/vergrößern.
Hier kann man dann aber auch die Maus zum Navigieren benutzen.
Über den dann sichtbaren Menüpunkt „Help“ lassen sich dann auch die Key-Shortcuts herausfinden:
Shortcuts_Project_my_Screen

Ich kann mich den Meinungen der User und der Presse hier nur anschließen.
Das Programm ist wirklich praktisch und schnell – es tritt kaum eine merkliche Verzögerung bei der Bildschirmübertragung auf (USB 2.0) .

Project_my_screen_menu

Windows Phone 8.1 – Neuerungen im Überblick

Wie bereits vielen bekannt, befindet sich Windows Phone 8.1 in der finalen Phase und wird voraussichtlich am 14.April für die Hersteller und Entwickler freigegeben.

Hier ein kleiner  Überblick über die Neuerungen:
1. Statusleiste
2. Cortana (Pendant zu Siri)
3. VPN
4. Internet Explorer 11 (mit Button zum Tabwechsel und Sync)
5. Storage Sense (Speicherverbrauchsanzeige)
6. Getrennte Lautstärke für Medien und Signale (Anrufe etc.)
7. App2SD (Apps auf Speicherkarte installieren)

Kleinere Neuerungen:
1. Man kann nun Apps auch mit einem Wisch nach unten beenden
2. Der Kalender hat nun auch eine Wochenansicht
3. Es gibt nun s.g. Ruhezeiten, also Zeiten in denen das Handy nicht schellt
4. Die Kamera-App wurde überarbeitet.
5. Mehr Tiles im Hauptmenü (6 Spalten)

[WP8] PDF-Datei aus dem Web laden und per App anzeigen

Eine PDF-Datei aus dem Web herunterzuladen und anzuzeigen ist relativ einfach.
Folgender Methoden laden die Webseite, laden die PDF-Datei herunter, speichern diese in den Isolated Storage und starten die externe App mit dem Pfad der Datei.

Folgende Links geben weitere Informationen zu folgendem Code:

WebClient pdfDownloader = null;
string LastFileName = ""; //Speichert den Dateinamen der zuletzt gesicherten Datei

private void StartPDFDownload()
{
    pdfDownloader = new WebClient(); //prevents that the OpenReadCompleted-Event is called multiple times
    pdfDownloader.OpenReadCompleted += DownloadPDF; //Create an event handler
    pdfDownloader.OpenReadAsync(new Uri("Your URL as string with HTTP://")); //Start to read the website
}

async void DownloadPDF(object sender, OpenReadCompletedEventArgs e)
{
    byte[] buffer = new byte[e.Result.Length]; //Gets the byte length of the pdf file
    await e.Result.ReadAsync(buffer, 0, buffer.Length); //Waits until the rad is completed (Async doesn't block the GUI Thread)

    using (IsolatedStorageFile ISFile = IsolatedStorageFile.GetUserStoreForApplication())
    {
        try
        {
            LastFileName = "tempPDF" + DateTime.Now.Ticks + ".pdf";
            using (IsolatedStorageFileStream ISFileStream = ISFile.CreateFile(LastFileName))
            {
                await ISFileStream.WriteAsync(buffer, 0, buffer.Length);
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message + Environment.NewLine + ex.HResult,
                ex.Source, MessageBoxButton.OK);
            //Catch errors regarding the creation of file
        }
    }
    OpenPDFFile();
}

private async void OpenPDFFile()
{
    StorageFolder ISFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
    try
    {
        IStorageFile ISFile = await ISFolder.GetFileAsync(LastFileName);
        await Windows.System.Launcher.LaunchFileAsync(ISFile);
            //http://msdn.microsoft.com/en-us/library/windowsphone/develop/jj206987%28v=vs.105%29.aspx
    }
    catch (Exception ex)
    {
        //Catch unknown errors while getting the file
        //or opening the app to display it
    }
}

[WP7] Der erste Tag/Systemvoraussetzungen

Da ich gerade an einer App für das mobile Betriebssystem Windows Phone 7(genauer 7.8) arbeite, dachte ich, dass ich meine ersten Eindrücke und Erfahrungen bei der Entwicklung dieser Applikation schildere.

Zum Entwicklung benötigen wir zuallererst Windows Phone SDK 7.1 oder 8 und zum Entwickeln für Windows Phone 7.8 das SDK Update[560MB,English](dieses ist mit beiden Versionen des SDK kompatibel).

Ich persönlich verwende SDK 8, da ich in Zukunft auch für Windows Phone in der Version 8 programmieren möchte.

Systemvoraussetzungen für SDK:

  • Windows 8 x64 (die Zeiten von 32-bit neigen sich wohl dem Ende)
  • 6,5 GB Festplattenspeicher
  • 4 GB Ram, wobei ich meiner VM nur 3 gegeben habe und bisher keine Probleme sehe

Zusätzliche Systemvoraussetzungen für den Emulator:

  • Windows 8 Pro oder höher
  • Prozessor mit SLAT(Second Level Address Translation)
    • Prozessoren, welche SLAT unterstützen:
    • Intel(hier EPT genannt): Intel Core i3, i5, i7 ab Nehalem(komplette Liste)
    • AMD(hier RVI genannt): Prozessoren ab der dritten Generation von Opteron(Prozessorenliste)

Da ich „nur“ einen Intel C2Q Q6600 in meinem Prozessor verbaut habe, musste ich leider auf den Emulator verzichten(da ich ein fürs Entwickeln freigeschaltenes Phone besitze, war das aber kein Problem)

© 2018 Abou Chleih. Alle Rechte vorbehalten.

Thema von Anders Norén.