Backend as a Service

Backend as a Service
Apinauten GmbH | Hainstraße 4 | 04109 Leipzig
Was ist Backend as a Service?
Backend as a Service ist ein weiterer Baustein, um die Softwareentwicklung effektiver und schneller zu
machen. Genau wie Ford vor ca. 100 Jahren die Massenproduktion von Automobilen ermöglichte, ist
Backend as a Service ein Ansatz, um die Produktion von Backends weitestgehend zu automatisieren und
in jedem Falle zu vereinfachen und zu beschleunigen. Statt das Backend deiner App selbst aufzusetzen
(Server mieten, Programmieren, Administration, usw.) beauftragst du jemanden damit, der das genauso
automatisiert macht wie Autoteile herstellen. Dabei sagst du was du für Teile brauchst und wie sie in
dein Auto bzw. deine App passen sollen.
Kosten für Backend
Welche Vorteile bietet Backend as a Service?
kleine App mittlere App große App
Du sparst Zeit! Das automatisierte Erstellen des Backends benötigt nur
einen Bruchteil der Zeit die notwendig wäre, um ein selbst erstelltes
Backend aufzusetzen. Ohne Backend as a Service dauert es oft mehrere
Tage bis Wochen bis ein Server eingerichtet ist. Der zweite Vorteil ist
der, dass die laufenden Kosten viel geringer sind als beim eigenen
Hosting. Zusätzlich kann der Appentwickler apiOmat selbst bedienen
und sich auf seine Kernkompetenz, der Frontendentwicklung, konzentrieren.
Backend as a Service
eigenes Hosting
Backend as a Service mit dem apiOmat
Wir bieten eine schnelle und unkomplizierte Alternative um das Backend deiner App in 10 Minuten
zu erstellen. Dafür wird keine zusätzliche Software benötigt, denn die Erstellung deiner Klassen erfolgt
in einer grafischen Oberfläche im Browser und das in wenigen Schritten und Minuten! Deine erste App,
die du dir einfach zusammen klickst, kannst du sofort mit einem der fertigen Features versehen. Dafür
bietet apiOmat zwei Arten von Modulen an:
1. Module die an die API eines Dritten anknüpfen und damit deren Daten und Funktionen liefern:
•
•
•
•
•
Mandrill Module
Evalanche Module
Facebook Module
Tumblr Module
Twitter Module
•
•
•
•
Wordpress Module
Paymill Module
Google Analytics Module
Piwik Module
2
2. Module die den Funktionsumfang von apiOmat erweitern:
•
•
•
•
•
Push Module
Chat Module
Messaging Module
Servercode Module
Webhosting Module
• Restore Module
• CSV Module
• XML Module
Darüber hinaus hast du auch die Möglichkeit individuelle Datenstrukturen objektorientiert zu modellieren. Das heißt für dich, dass du schnell ein lauffähiges Backend hast, ohne dich wochenlang mit
Servern, Backend-Coding, Testen und Skalierbarkeit herumzuschlagen. Von dir selbst erstellte Klassen
kannst du ganz einfach über das Dashboard verwalten. Dort kannst du sofort Securityeinstellungen
und die Klassenattribute festlegen. Mühseliges Rumsuchen im Code? Fehlanzeige!
Mit apiOmat musst du dich nicht auf eine Plattform festlegen, denn wir bieten SDKs für die am häufigsten
benutzten Systeme an:
•
•
•
•
iOS
Android
PHP
python
• Java
• JavaScript
• Titanium
Jedes dieser SDKs wird automatisch generiert. Somit sind Änderungen in deinem Datenmodell sofort
in den SDKs enthalten. Diese musst du dann nur noch herunterladen und in dein Frontendprojekt einbinden. Du musst dich also nie mehr mit nervigen Protokollen und Anbindungen an Schnittstellen herumschlagen. Ganz nebenbei definierst du dein Datenmodell auch nur ein einziges Mal!
Doch damit nicht genug:
Die in deinem Backend angelegten Daten kannst du bequem im Dashboard ansehen und editieren. Im
Falle, dass du Veränderungen an deinem Backend vornehmen möchtest, bieten wir dir drei Entwicklungsumgebungen an: Test, Staging, Live. Damit kannst du deine Änderungen testen ohne, das die
Nutzer deiner App das mitbekommen. Wenn dann all deine Änderungen funktionieren genügt ein Mausklick um das Ganze sofort Live zu stellen. Das alles kannst du allein mit deinem Browser unter
apiomat.com machen.
Und das Beste zum Schluss:
Die apiOmat Cloud steht ausschließlich in Deutschland. Deine Daten und die deiner Nutzer sind also
durch eines der besten Datenschutzgesetze der Welt geschützt und können nicht einfach so von
Regierungsbehörden eingesehen werden.
3
Und los geht‘s
1. Geh auf apiomat.com und logge dich mit deinem Account ein. Zum Login-Formular kommst du
über die Schaltfläche „LOG IN“ oben rechts. Solltest du noch keinen Account haben, lege einen an,
indem du auf die Schaltfläche „SIGN UP“ klickst.
2. Du befindest dich nun im Dashboard. Solltest du bis jetzt keine App erstellt haben, wirst du aufgefordert deiner ersten App einen Namen und wenn du möchtest eine kurze Beschreibung zu geben.
In unserem Beispiel heißt die App „FacebookandPush“. Für deine App solltest du allerdings einen
unverwechselbaren Namen verwenden.
3. Auf der ersten Dashboard-Seite siehst du eine Darstellung aller verfügbaren Module. Zuerst wählst
du das Facebook-Modul aus, indem du auf das „+“ neben dem Namen des Moduls klickst.
4
welche konfigurationsmöglichkeiten habe ich?
Am Beispiel einer Android-App möchten wir dir nun zeigen, wie leicht apiOmat zu benutzen ist. Dafür
verwenden wir das Facebook- und das Pushmodul.
Das Facebook-Modul
Das Facebook Modul ermöglicht es jedem deiner Benutzer mit seinem Facebook-Account zu kommunizieren. Dies kann er direkt aus der App heraus machen, sobald er sein Benutzerkonto einmalig mit
Facebook verbunden hat.
Konfiguration
Facebook / Scope
Dieses Attribut bestimmt die Zugriffsrechte, die die verknüpfte Facebook App fordert. Die Standardwerte
hier sind “email, read_stream”, die du auch nicht ändern solltest bis weitere Funktionen in das Modul
integriert sind. Eine Auflistung aller möglichen Zugriffsrechte findest du in der Facebook API.
Facebook App Secret
Mit den App Secrets können Daten abgefragt werden, die der Nutzer der App freigegeben hat. Willst du
darauf zugreifen, musst du die App Secrets hier eingeben.
Facebook App ID
Das ID Attribut gibt die ID der App an mit der der Facebookzugang verknüpft ist. Die Standardwert ist
hier die ID der apiOmat-Facebook-App. Wenn du eine eigene Facebook-App hast, kannst du deren ID hier
eingeben.
Das Push-Modul
Das Push-Modul ermöglicht es dir, Push-Nachrichten zu Usern deiner App, die ein Android oder iOS Gerät
besitzen, zu senden. Außerdem können auch andere Module, die für Push zugelassen sind darüber Benachrichtigungen senden.
Konfiguration
GCM Api Key
Hier wird der Google Cloud Messaging API Key für Android eingetragen, der dazu dient deiner App
Zugang zu deinem GCM-Projekt zu gewähren. Wo du diesen findest, erfährst du im Anhang oder in der
GCM Dokumentation von Google®.
APNS certificate password
Hier trägst du das Passwort für dein Apple Push Notification Service Zertifikat ein.
APNS certificate
Diese Position dient dem Hochladen des mit PKCS#12 verschlüsseltem APNS-Zertifikats, das du von
Apple bekommst. Solltest du Hilfe dabei brauchen ein Zertifikat zu bekommen, kannst du hier nachschauen.
5
4. Im nun erscheinenden Dialog kannst du die weiter oben erklärten Einstellungen eintragen. Für
dieses Tutorial lässt du die Facebook App ID so wie sie ist. Das Feld für Facebook App Secret lässt
du leer und für Facebook Scope trägst du „publish_actions“ ein. Dies erlaubt dir u.a. Einträge an
deine Pinnwand zu posten. Bestätige das Ganze mit „OK“.
5. Wähle nun das Push-Modul.
6. Wie beim Facebook Modul erscheint ein Pop-Up mit einer Eingabemaske. Für dich ist aber nur der
GCM API Key wichtig. Wie du diesen bekommst, erfährst du im Anhang oder in der GCM Dokumentation von Google®. Trage den Key ein und bestätige mit „OK“.
7. Klicke nun auf „Deploy“ damit das Backend erstellt wird.
8. Wechsle auf den Tab „SDK“. Hier kannst du alle SDKs, die wir anbieten, herunterladen.
6
9. Du benötigst das SDK für Android. Klicke zum Herunterladen einfach auf den Button „Download
SDK“ im dazugehörigen Rahmen. Die heruntergeladene ZIP-Datei enthält alle Klassen und Ressourcen die du brauchst. Entpacke die ZIP-Datei an einen beliebigen Ort auf deiner Festplatte. Damit ist
im Dashboard erst einmal alles erledigt.
10.Öffne die IDE deiner Wahl und lege ein neues Android-Projekt an. Achte darauf, dass du mindest
Android-SDK Version 8 (2.2 Froyo) angibst.
11.Öffne jetzt im Dateimanager den Ordner, in den du die ZIP-Datei entpackt hast.
12.Kopiere die beiden Ordner in den „src“-Ordner (Source) deiner App. Damit beginnt die Programmierung des Frontends.
7
Das Layout
Zunächst erstellst du das Layout mit allen Elementen, die du für die App brauchst; keine Angst es sind
nicht viele.
1. Öffne die Layoutdatei deiner main activity. Diese befindet sich im Ordner „layout“ im Ordner „res“
(Resources). Die XML-Datei trägt den Namen, den du deiner main activity gegeben hast.
2. Standardmäßig legt das Android SDK ein Relative Layout an. Dieses ist aber etwas umständlich.
Daher löschen wir den gesamten Code und fügen ein Linear Layout ein.
<LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android“
xmlns:tools=“http://schemas.android.com/tools“
android:layout_width=“match_parent“
android:layout_height=“match_parent“
tools:context=“.MainActivity“
android:orientation=“vertical“>
</LinearLayout>
3. Nun legst du einen Button an, der mit „Anmelden“ beschriftet sein soll und einen Listener für die
Methode „anmelden“ enthält. Das sieht so aus:
<Button
android:text=“Anmelden“
android:layout_width=“fill_parent“
android:layout_height=“wrap_content“
android:onClick=“anmelden“/>
* Beachte dabei, dass Buttons, Textfelder, etc. Kindelemente von LinearLayout sein müssen. Normalerweise werden alle Strings in Android in eine extra Datei eingetragen.(strings.xml im Ordner „values“) Dies ergibt in dieser Beispielapp aber wenig Sinn. Daher wird hier der Text direkt eingetragen.
4. Unter dem Button soll ein Eingabefeld, oder wie es bei Android heißt: EditText, stehen. Dieses
bekommt zwar keinen Text oder Listener, dafür aber eine ID. Wofür die ID gut ist, sehen wir später.
<EditText
android:layout_width=“fill_parent“
android:layout_height=“wrap_content“
android:id=“@+id/et_main_post“/>
5. Darauf folgt ein zweiter Button. Dieser soll mit „Text posten!“ beschriftet sein und die Methode
„posten“ auslösen.
<Button
android:text=“Text posten!“
android:layout_width=“fill_parent“
android:layout_height=“wrap_content“
android:onClick=“posten“/>
6. Ein weitere Button soll die Anmeldung beim Push-Service ermöglichen. Verknüpft ist dieser mit
der Methode „push“:
8
<Button
android:layout_width=“fill_parent“
android:layout_height=“wrap_content“
android:text=“Push vorbereiten“
android:onClick=“push“/>
7. Damit wir nach der Push-Message, die wir empfangen wollen, nicht im Log suchen müssen, legst du
noch ein Textfeld an. Dieses erhält eine ID, einen Standardtext und eine Angabe für die Textgröße:
<TextView
android:text=“Hier steht die Nachricht deiner Pushmessage“
android:layout_width=“fill_parent“
android:layout_height=“wrap_content“
android:textSize=“17sp“
android:id=“@+id/tx_main_push“/>
8. Als letztes musst du noch eine WebView einfügen. Eine WebView ist eine Art reduzierter Browser:
<WebView
android:layout_width=”wrap_content“
android:layout_height=”wrap_content“
android:id=”@+id/main_wv_webview”/>
Erstellen eines Users
1. Öffne nun deine main activity im src-Ordner. Diese ist bis jetzt ziemlich leer und beinhaltet bis jetzt:
• Den Packetnamen, zu dem die Activity gehört.
• Die Imports. (Solltest du Probleme mit den Imports haben, schau im Kasten rechts nach.)
• Die Klasse, die nach der Activity benannt ist mit den Methoden „onCreate“ und „onCreateOptionsMenu“.
2. Lösche die „onCreateOptionsMenu“-Methode. (Diese Methode hat zur Folge, dass in der oberen
rechten Ecke der App ein Menübutton angezeigt wird. Da wir aber kein Menü anlegen möchten,
wäre dies ein sogenannter „menu button of shame“ ohne Funktion.
3. Als nächstes legst du eine Instanz der Klasse User als globales Objekt an:
final static User user = new User();
4. Desweiteren brauchen wir eine klassenübergreifende Variable für den
Text der Push-Nachricht:
public static TextView pushtext;
5. Wechsle nun in die „onCreate“-Methode und ergänze diese um folgende
Funktionen:
pushtext = (TextView) findViewById(R.id.tx_main_push);
user.setUserName(“BENUTZERNAME“);
user.setPassword(“PASSWORT“);
Datastore.configure(user);
9
6. Mit dem nächsten Codeblock wird der „user“ an den Server übergeben. Dabei erfolgt eine Abfrage,
ob der „user“ mit dem angegebenen Nutzernamen schon existiert. Sollte dies nicht der Fall sein,
wird er angelegt.
user.loadMeAsync(new AOMEmptyCallback() {
@Override
public void isDone(ApiomatRequestException exception) {
if (exception != null) {
user.saveAsync(new AOMEmptyCallback() {
@Override
public void isDone(ApiomatRequestException exception) { }
});
}
}});
Imports verwalten
Bei der Verwendung mancher Klassen (z.B. einer TextView) und Methoden kann es notwendig sein Pakete zu importieren. Sollte ein
Fehler auftauchen und als Lösungsvorschlag so etwas angegeben werden: „import Toast (android.widget)“ klicke einfach darauf. In
Eclipse kannst du auch einfach STRG+SHIFT+O drücken damit Eclipse die Imports korrigiert. Solltest du beim Import die Wahl aus
mehreren Paketen haben, wähle immer das Paket, welches mit dem Android SDK geliefert wurde. Diese erkennst du an der Bezeichnung dahinter(android. ...)
* Ersetze dabei BENUTZERNAME und PASSWORT durch deine gewünschten Angaben. Mit der letzten Zeile wird die
Verbindung zum Backend initialisiert.
Mit Facebook Verknüpfen
1. Nun muss der „user“ mit Facebook verknüpft werden. Dazu erstellen wir die Methode „anmelden“:
public void anmelden(View view) { [...] }
2. Um die Verknüpfung herstellen zu können, brauchst du die UserID. Diese holen wir uns aus der
Referenz-URL:
int start = user.getHref().lastIndexOf(“/“);
String id = user.getHref().substring(start + 1);
*Wahlweise kann statt der UserID auch der UserUserName benutzt werden.
3. Nun muss eine WebView erzeugt und mit der WebView aus dem Layout verknüpft werden:
WebView webview =(WebView) findViewById(R.id.main_wv_webview);
4. Die letzte Aktion der Methode besteht darin die Authentifizierungs-URL mit der WebView aufzurufen:
webview.loadUrl(
“http://apiomat.org/yambas/rest/modules/Facebook/spec/NAMEDEINERAPP/auth?memberId=“ + id + “&usedSystem=“ +User.system);
*Ersetzte dabei NAMEDEINERAPP durch den Namen deiner App auf dem Server.
10
Etwas an deine Facebook-Pinnwand posten
1. Nun legen wir die Methode „posten“ an, die den im Textfeld eingegeben Text auf deine Pinnwand postet.
public void posten(View view) { [...] }
2. In der Methode legen wir zunächst eine Instanz von FBUser an. FBUser repräsentiert deinen FacebookAccount.
FBUser me = new FBUser();
3. Jetzt muss der User gespeichert werden um eine gültige href zu erhalten. Um eventuell auftretende
Fehler abzufangen, umgeben wir den Codeblock mit einem try-catch Statement.
try {
me.saveAsync(new AOMEmptyCallback() {
@Override
public void isDone(ApiomatRequestException exception) {[...]}
});
}
catch (Exception e) {
e.printStackTrace();
}
4. Um einen Post zu erstellen musst du zunächst eine Instanz der Klasse FBPost anlegen. Wie du
schon richtig vermutest, repräsentiert diese Klasse deine Posts. Man könnte auch sagen du erstellst
einen neuen Post.
FBPost newPost = new FBPost();
5. Nun kannst du theoretisch etwas an deine Pinnwand schreiben. Da wir aber keinen festen String
benutzen wollen, musst du zunächst den Inhalt des Textfeldes einlesen lassen. Dabei hilft uns die
festgelegte ID:
EditText etext;
etext = (EditText) findViewById(R.id.et_main_post);
String posttext = etext.getText().toString();
6. Jetzt setzt du den String „posttext“ als Inhalt für deinen Post fest.
newPost.setMessage(posttext);
7. Um den Post zu veröffentlichen, muss die Instanz nur noch gesichert werden. Da auch hier
wieder ein Fehler auftreten kann setzten wir das ebenfalls in ein try-catch-Statement:
newPost.saveAsync(new AOMEmptyCallback() {
@Override
public void isDone(ApiomatRequestException exception) { }
});
11
8. Zuletzt müssen wir noch eine Möglichkeit bieten, die ContentView der Activity wieder zurück
auf das normale Layout zu setzen. Dazu überschreibst du die „onBackPressed“-Methode:
@Override
public void onBackPressed() {
setContentView(R.layout.activity_main);
}
Push per Button einrichten
Um GCM zu nutzen musst du dein Gerät erst bei GCM registrieren. Wechsle dazu wieder in die main_
activity deiner App.
1. Zuerst legen wird die Methode „push“ an:
public void push (View view){ [...] }
2. Nun gehen wir in die Methode und legen einen String „regID“ an, in dem wir die abgefragte
Registration-ID speichern. Diese ist vom Gerät abhängig und kann auch nur über die angegebene
Methode gefunden werden:
final String regId = GCMRegistrar.getRegistrationId(this);
3. Jetzt fehlt noch die Registrierung bei deinem GCM Projekt. Das geht folgendermaßen:
if (regId.equals(““)) {
GCMRegistrar.register(this, “APIPROJECTNUMBER“);}
else {
Log.v(“push“, “Already registered“);
MainActivity.user.setRegistrationId(regId);
MainActivity.user.saveAsync(new AOMEmptyCallback() {
@Override
public void isDone(ApiomatRequestException exception) { }
});
}
* Ersetze APIPROJECTNUMBER durch die Project Number deines GCM Projekts.
4. Damit wir auch sehen, dass die Registrierung erfolgreich war, wollen wir uns einen Toast anzeigen lassen:
Toast.makeText(getApplicationContext(), “Registrierung erfolgreich!“, Toast.LENGTH_LONG).show();
5. Wechsle in die Klasse „GCMIntentService“, die du im Zuge der Einrichtung von GCM erstellt haben
solltest.
6. Suche dort die Methode „onMessage“ und ergänze sie wie folgt:
@Override
protected void onMessage(Context arg0, Intent msg) {
final String gcmMessage = msg.getExtras().getString(“payload“);
Log.d(“GCMIntenService“, gcmMessage);
12
Handler h = new Handler(Looper.getMainLooper());
h.post(new Runnable() {
@Override
public void run() {
MainActivity.pushtext.setText(gcmMessage);}
});
}
7. Zuletzt musst du die „onRegistered“-Methode noch ausbauen:
@Override
protected void onRegistered(Context arg0, String regId) {
MainActivity.user.setRegistrationId(regId);
MainActivity.user.saveAsync(new AOMEmptyCallback() {
@Override
public void isDone(ApiomatRequestException exception) {
// TODO Auto-generated method stub
}
});
}
Um Erlaubnis fragen
Eine Android App darf von Grund auf erst mal gar nichts, besonders nicht auf das Internet zugreifen.
Damit unsere App das doch kann, müssen wir sie um Erlaubnis fragen lassen. Dies geschieht im Android Manifest.
1. Öffne die AndroidManifest.xml im Hauptverzeichnis deiner App.
2. Füge diese Zeile direkt nach dem <manifest [...]> Tag ein:
<uses-permission android:name=“android.permission.INTERNET“/>
*Es kann sein, dass du diese Berechtigung schon bei der Einrichtung von GCM eingetragen hast.
Damit ist das Frontend deiner App eingerichtet!
13
Ran an die App
Zum Testen müssen wir in der App noch die Facebook Authentifizierung ausführen und eine PushMessage vom Dashboard aus senden.
1. Starte die App auf deinem Android Smartphone.
2. Berühre den Button „Anmelden“. Dadurch sollte sich der Browser öffnen. Auf der Internetseite
wirst du gebeten deine Facebookdaten einzugeben, da die apiOmat-Facebook-App Berechtigungen
einfordert.
3. Melde dich mit deinen Facebookdaten an und drücke anmelden. Nun bist du mit Facebook verknüpft.
14
4. Drücke auf die Back-Taste deines Smartphones bis die Oberfläche der Android App wieder erscheint.
5. Im Textfeld darunter gibst du jetzt einen beliebigen Text ein, z.B. „Der apiOmat ist super!“ und
drückst den Button „Text Posten!“ Wenn du jetzt auf deine Facebookseite schaust, wird da dein
eingegebener Text stehen.
6. Drücke den Button „Push vorbereiten“. Dadurch erscheint der Toast mit der Schrift: „Registrierung
erfolgreich!“. Damit ist das Gerät bei GCM registriert.
7. Wechsle nun wieder ins Dashboard des apiOmaten.
8. Klicke auf den Reiter „Tool“ und dann auf den Button „Send Push Message“.
9. Wähle im linken Fenster den einzigen Benutzer aus und gib im rechten Feld deine Nachricht ein.
10.Klicke auf „Send Message to 1 User“
11.Schau jetzt wieder auf deine Android-App. Im Textfeld steht jetzt die von dir eingegebene PushNachricht.
15
Apinauten GmbH
Wir sind ein Start-up mit Sitz im Herzen von Leipzig. Zusammengefunden haben wir uns im Januar 2011
mit der Idee einfach, schnell und kostengünstig Backends zu erstellen. Doch wie kam es dazu? Zuvor
haben wir schon jahrelang Backends für die unterschiedlichsten Apps erstellt. Doch so unterschiedlich diese auch waren, eines hatten sie alle gemeinsam: die Programmierung des Backends war immer
umständlich und frustrierend. Für jede App musste mindestens ein neuer Server eingerichtet werden.
Darauf wurden z.B. MySQL-Datenbanken eingerichtet die über Hibernate mit der Business Logic verbunden und eigene Proto... im Ernst, interessiert dich das alles wirklich?
Natürlich kam dann irgendwann der Gedanke auf „Das muss doch auch einfacher gehen!“ Mit noSQL
kam der erste Ansatz um die Dinge einfacher zu handhaben.
Doch das war uns noch nicht genug. Wir wollten etwas anbieten, dass das Leben aller Entwickler
erheblich einfacher macht.
Wer steckt dahinter?
Marcel Etzel
CEO, Controller, Geek, Designer, Networker, und Team Player. In
Marcel stecken viele Fähigkeiten, wenn du glaubst ihn zu kennen
wird er dich überraschen. Um den apiOmat erfolgreich in Europa
zu etablieren, geht er ans Äußerste. Mit großem Enthusiasmus
verfolgt Marcel das Ziel den apiOmat als Top Player im BaaS Markt
zu etablieren.
Dr. Lutz Kohl
Unser Doktor der Informatik ist für das Produktmanagement von
apiOmat verantwortlich. Mit seinem technischen Know-How und
seinem rhetorischen Fähigkeiten ist er der Master im Präsentieren.
Bühnen der Welt macht euch bereit für unseren Doktor der euch zeigt
wie cool apiOmat ist.
Andreas Fey
Unser CTO. Gebt ihm eine zunächst unlösbar scheinende Aufgabe
und eine Minute Zeit darüber nachzudenken. Wir haben es mit einer
Trompete versucht und heute ist er Musiker. Wir gaben ihn auf ein
Blatt Papier gekritzelt die Idee die hinter apiOmat steckt und heute
ist er CTO. Alles was er anfasst wird mit viel Perfektionismus umgesetzt. Selbst seine Pflanzen im Garten sind mit QR-Codes getaggt,
gibt es irgendetwas nerdigeres?
16
Philipp Michel
ist unser erster Entwickler. Seine Muttersprache ist Objective C
und Java. Seit Jahren gehören zu seinem festen Freundeskreis
Android, GWT und Java. Bald darauf lernte er den Dude iOS kennen und eins ist sicher: das ist eine Freundschaft fürs Leben. Neben
seinen außergewöhnlichen Programmierfähigkeiten ist Philipp
ein cooler Typ mit dem man gerne mal ein Bierchen trinkt.
Saskia Wittau
Sie wird dich mit Ihren Marketing und Social Media Kenntnissen
überraschen. Als einzige Frau im Team ist Sie das kreative Zentrum
von apiOmat. Sie treibt die Meute zusammen und schafft es Geeks
die Geheimnisse der großen weiten Marketingwelt zu erklären.
17
Anhang: Ein GCM Projekt erstellen
Solltest du noch kein Google Cloud Messaging Projekt besitzen, müssen wir zunächst eines anlegen.
1. Gehe auf die „Getting Started“-Seite der GCM Dokumenation.
2. Klicke dort im ersten Handlungsschritt auf den Hyperlink „Google APIs Console page“.
3. Hier musst du dich jetzt mit deinem Google-Account anmelden. Solltest du noch keinen Google-Account haben, musst du dir erst einen erstellen.
4. Klicke im darauf folgenden Fenster auf den Button „Create project...“
5. Jetzt befindest du dich im Dashboard deines GCM Projekts. Solltest du dich noch nicht bei dem
Unterpunkt „Services“ befinden, klicke links in der Navigation darauf.
6. Suche in der Liste der möglichen Services den Punkt „Google Cloud Messaging for Android“ und
aktiviere ihn. Dadurch öffnet sich das Fenster „Terms of Service“
7. Ließ dir die Nutzungsbedingunen aufmerksam durch und bestätige sie, indem du den Haken bei „I
agree to these terms.“ aktivierst und anschließend auf „Accept“ klickst.
8. Wiederhole dies bei der zweiten Nutzungsbedingung.
9. Klicke in der Navigation links auf „API Access“. Dort werden die Keys für den Zugriff auf dein Projekt
verwaltet.
18
10.Klicke auf „Create new Server key ...“ Dadurch erscheint folgendes Fenster:
11.Klicke auf „Create“, damit der Key erzeugt wird. Schreibe dir die Nummer deines Projekts und den API Access Key auf, da wir diese später brauchen.
Hilfsbibliotheken installieren
Um GCM in einer Android-App zu nutzen, brauchen wir die entsprechenden Bibliotheken.
1. Rufe dazu den Android SDK Manager auf. Öffne dazu das Installationsverzeichnis deines Android-SDKs. (Das SDK von Google nicht das von apiOmat!)
2. Öffne den SDK-Manager.
*Falls du das Android Plugin bereits in deine IDE integriert hast, kannst du den SDK-Manager auch von dort aus aufrufen.
3. Suche den Punkt „Google Cloud Messaging for Android Library“ und markiere den Haken links
daneben.
4. Klicke auf „Install 1 packages“ und warte bis die Installation abgeschlossen ist.
19
Hilfsklasse gcm.jar importieren
Damit wir fortfahren können müssen wir noch die Hilfsklasse gcm.jar in unser Projekt einbinden.
1. Öffne den Dateimanager und gehe noch einmal in den Ordner des Android-SDKs. Die gcm.jar-Datei
befindet sich in:
extras → google → gcm → gcm-client → dist
2. Kopiere die Datei „gcm.jar“ in den „libs“-Ordner deines Android-Projekts.
* Dadurch sollte deine IDE die Datei selbstständig als Library einbinden. Ist dies nicht der Fall, musst du das manuell nachholen.
Die Klasse GCMIntentService einrichten
1. Wechsle wieder zu deiner IDE.
2. Lege eine neue Klasse mit dem Namen „GCMIntentService“ im Package deiner App an. Diese
soll von der Klasse „GCMBaseIntentService“ erben. Außerdem sollen alle abstrakten Methoden
der Klasse gleich mit erstellt werden.
20
Manifest
1. Öffne die AndroidManifest.xml im Hauptverzeichnis deiner App.
2. Füge diese Zeilen direkt nach dem <manifest [...]> Tag ein:
<!-- App receives GCM messages. -->
<uses-permission android:name=”com.google.android.c2dm.permission.RECEIVE” />
<!-- GCM connects to Google Services. -->
<uses-permission android:name=”android.permission.INTERNET” />
<!-- GCM requires a Google account. -->
<uses-permission android:name=”android.permission.GET_ACCOUNTS” />
<!-- Keeps the processor from sleeping when a message is received. -->
<uses-permission android:name=”android.permission.WAKE_LOCK” />
3. Füge die beiden folgenden Berechtigungen ein und ersetzte in deren Bezeichnung „my_app_
package“ durch den Namen des Packages deiner App:
<permission android:name=”my_app_package.permission.C2D_MESSAGE” android:protectionLevel=”signature” />
<uses-permission android:name=”my_app_package.permission.C2D_MESSAGE” />
4. Trage diesen IntentService als Kindelement von „application“ ein:
<service android:name=”.GCMIntentService” />
5. Als letztes brauchen wir noch einen Broadcast-Receiver. Dieser muss ebenfalls ein Kindelement von
„application“ sein:
<receiver android:name=”com.google.android.gcm.GCMBroadcastReceiver” android:permission=”com.google.
android.c2dm.permission.SEND” >
<intent-filter>
<action android:name=”com.google.android.c2dm.intent.RECEIVE” />
<action android:name=”com.google.android.c2dm.intent.REGISTRATION” />
<category android:name=”my_app_package” />
</intent-filter>
</receiver>
* Achte auch hier darauf, dass du „my_app_package“ durch den Namen des Packages deiner App ersetzt.
21