Verbinden und Steuern eines Arduino Boards mit Cascades, Teil II

IMG_20140220_124315Im zweiten Teil will ich erklären, wie es möglich ist einen Arduino über ein Z30 zu steuern. Bevor das getan werden kann muss der Arduino vom Gerät erkannt werden. Die notwendigen Schritte sind hier im ersten Teil dokumentiert.

Nachdem der Arduino verbunden ist, muss zunächst der Pfad geöffnet werden, der in der Klasse Peripheral gespeichert ist (Siehe blog Teil I). Ich benutze einen Button um die Kommunikation zu öffnen, weil der Arduino etwas Zeit zum Starten braucht und ich es einfach halten möchte :-) Falls versucht wird den Pfad zu früh zu öffnen, kann es sein, dass es nicht funktionieren.

Wenn der Button gedrückt wird, wird eine Funktionen aufgerufen, die die Kommunikation beginnt. Die Variable m_serial wird dazu genutzt um zu überprüfen, ob bereits eine serielle Kommunikation geöffnet ist und verhindert, dass der Pfad jedesmal geöffnet wird, wenn der Button gedrückt wird. In diesem Fall wird die Funktion beendet. Anderenfalls wird der Pfad ausgelesen und im read/write Modus mit open() geöffnet. Vergiss nicht zu überprüfen, ob der Pfad gültig ist.

Die nächsten Zeilen sind dazu nötig, die Attribute für die Kommunikation festzulegen: Die Bauderrate und der Mode, die im struct termios gespeichert sind. Die Bauderate legt die Übertragungsgeschwindigkeit fest und muss die selbe sein wie für den Arduino. Schau nach welche im Arduinoprogramm verwendet wurde (hier 9600). Anderenfalls wird es nicht funktionieren. Der TRANSNOW Modus ist dafür da, die Nachricht sofort zu senden:

Um zu sehen, ob wir erfolgreich waren wird der erste Befehl zum einschalten der LED gesendet:

Die Variable m_value legt die Intensität fest und sollte zwischen 0 und 255 liegen (0 bedeutet aus). m_lastWrite beinhaltet den letzten Wert, der an den Arduino gesendeten wurde. Auf diese Weise vermeiden wir unnötige neue Sendungen mit dem selben Wert.

Jetzt benötigen wir etwas mehr UI (außer den Button), um die Intensität der LED zu ändern. Ich habe dafür eine Radio Group verwendet, um verschiedene Helligkeiten wählen zu können (an, halb an, aus). Erstelle diese in der qml-Datei und benutzte eine invoke Funktion wenn das Signal onSelectedIndexChanged() empfangen wird:

Jedes mal wenn der Nutzer die Auswahl ändert, wird  writeSerial() aufgerufen. In dieser Funktion muss zunächst überprüft werden welcher Index gewählt wurde und die Intensität dementsprechend eingestellt werden. Ich habe das über eine switch-case-Anweisung getan und die Helligkeit manuell geändert.

Da wir den Wert nur an den Arduino senden wollen, wenn dieser verbunden ist und der Pfad geöffnet ist, muss die Variable m_serial überprüft werden. In Teil I dieses Blogs wird die Variable im Konstruktor auf -1 gesetzt. Ebenso wenn der Arduino getrennt wird. Wenn der Arduino verbunden ist senden wir den neuen Wert indem wir write() aufrufen.

Jetzt hast du gelernt, wie man einen Arduino an ein BlackBerry 10 Gerät anschließen und steuern kann. Damit kann ein eigenes kleines Protokoll geschrieben werden, was der Arduino interpretiert. Weiter Informationen können hier auf der Website gefunden werden.

Hier ist das gesamte Projekt.

Verbinden und Steuern eines Arduino Boards mit Cascades

IMG_20140228_094623Hallo, hier ist @leaschnherr und heute will ich im Rahmen von Mobile Computing Plattformen erklären, wie man den USB Host Mode des Z30 nutzen kann um ein Arduino Uno Board zu steuern. Um es einfach zu halten, war zunächst mein Ziel die Intensität einer LED zu kontrollieren.

Der Code für den Arduino kann unverändert aus dem Dimmer Beispiel von Arduino übernommen werden, das du hier mit hilfreichen Erklärungen findest.

Wenn du das erste mal mit einen Arduino arbeitest, lese die Anweisungen auf der Website hier. Stelle sicher, dass das Programm korrekt läuft und teste einige Beispiele, um dich an die Umgebung zu gewöhnen.

Der Code für die BlackBerry 10 App ist etwas komplexer und im ersten Teil will ich nur erklären, wie USB Geräte erkannt werden und wie man auf diese zugreift.

Nachdem ein neues Cascades Projekt erstellt worden ist, muss zunächst die Peripheral Discovery Library hinzugefügt werden. Wenn Momentics verwendet wird, kann diese einfach durch einen Rechtsklick auf den Projektordner hinzugefügt werden. Dann wähle aus: configure->Add Library->Standard BlackBerry platform library und auf ‘next’. In der Suche libperipheral_discovery eingeben und diese anschließend auswählen und auf ‘finish’ klicken. Dann wird die Library automtaisch in der config.pri Datei hinzugefügt, die in die .pro Datei eingebunden wird.

Im ersten Teil wird noch keine GUI benötigt, so das wir uns nicht darum kümmern brauchen. Ich werde diese dann im zweiten Teil erklären. Das einzige was getan werden muss, ist eine Instanz einer Klasse zu erstellen, die ich Discover genannt habe. Hier ist der Konstruktor dieser Klasse:

Die Funkion bps_initialize() muss aufgerufen werden, wenn irgendein Service der BPS Schicht verwendet wird. Für unser Projekt brauchen wir den Peripheral Discovery Service. Dann muss dieser Service selbst initialisiert werden, indem pd_initialize(0) aufgerufen wird. Um zu erkennen wenn der Arduino verbunden oder getrennt wird, wird im nächsten Schritt ein Signal Handler (m_sigEvent) und eine dazugehörige Funktion (signalHandler()) mittels bps_add_sigevent_handler() verbunden. signalHandler() wird nun jedes mal aufgerufen, wenn zuvor definierte Ereignisse auftreten.

Danach muss überprüft werden, ob der USB Host Mode unterstützt wird:

Das kann über die Funktion pd_is_bus_supported() getestet werden. Die App wird auch auf anderen Geräten laufen, allerdings wird es nicht möglich sein ein externes USB Gerät zu steuern. Wenn die Anfrage erfolgreich war und das BlackBerry 10 Gerät den USB Host Mode unterstützt, ist der nächste Schritt, die benötigten Events zu registrieren:

Bevor irgendeine Funktion mit pd_class_t als Parameter aufgerufen wird, muss die Methode pd_is_class_supported() aufgerufen werden. In diesem Fall mit PD_CLASS_SERIAL als Parameter, für Serielle Kommunikation. Wenn kein Fehler zurück gegeben wird, ist es möglich, m_sigEvent mit PD_CLASS_SERIAL zu registrieren. Die Variable m_sigEvent ist vom Typ struct sigevent und der Signal Handler (siehe Konstruktor). Nach diesen Schritten wird jedes mal wenn ein USB Gerät angeschlossen oder getrennt wird, die im Konstruktor definierte Funktion signalHandler() aufgerufen:

Da die signalHandler() Funktion static sein muss und es somit nicht möglich ist nicht-static Variablen zu nutzen, wird einfach ein Funktionspointer zu einer anderen Funktion verwendet. Diese überprüft, ob der Arduino angeschlossen oder getrennt wurde:

Wenn das Gerät angeschlossen wurde, wird eine Peripherie mit der erkannten pd_peripheral_t allokiert (Weiter Erklärungen, siehe unten). Im anderen Fall, wenn das Gerät getrennt wurde, wird die pd_free_peripheral() Methode aufgerufen und andere Vorbereitungen für die nächste Verbindung getroffen (Die Variable m_serial, welche für die spätere Kommunikation benötigt wird, wird auf -1 gesetzt).

Unser angeschlossenes Gerät wird in einer Klasse Peripheral gespeichert. Diese einfache Klasse beinhaltet den Pfad, welcher von der zuvor allokierten  pd_peripheral_t Variable ausgelesen werden kann. Später ist es möglich, diese Klasse auch für weiter Informationen zu verwenden. Im Konstruktor werden eine Reihe von Anweisungen aufgerufen, die nötig sind um den Pfad herauszufiltern.

Der Pfad ist eine Eigenschaft aus einer Liste von Eigenschaften. Also ist das erste was getan werden muss die gesamte Liste zu lesen. Anschließend wird jede Eigenschaft angeschaut und nach Variablentyp gefiltert: Der Pfad ist der einzige String, so sehen wir wenn es sich um die richtige Eigenschaft handelt. Gute Programmierer würden natürlich noch den String überprüfen, z. B. ob er “/dev” beinhaltet :-)

Jetzt ist es möglich den Arduino zu Verbinden und zu erkennen. Wie diese Schnittstelle verwendet wird um Anweisungen an den Arduino zu senden wird in Teil II erklärt.

How to Connect and Control an Arduino Board with Cascades, Part II

IMG_20140220_124315

In this second part I want to explain, how to control a connected Arduino via a Z30 device. Before you can do this, the Arduino has to be discovered by the device. The necessary steps are documented here in the first part.

After setting up a successful connection between Z30 and Arduino the path, which is saved in our Peripheral class (see blog part I) needs to be opened to perform any communication. I use a button to open the communication, because the Arduino needs some time to boot and I like to do it simple :-) If you try to open the path too early it might not work.

When the button is pressed, a method is called, which starts the communication. The variable m_serial is used to check, if a serial connection is already open and avoid us to open the path on each button click. In this case, the function returns immediately. Otherwise the path is read out and opened for read/write mode with open(). Don’t forget to check if the path is valid and return if it is not.

The next lines are to set the attributes for communication: The baude rate and the mode, which are saved in the  struct termios. The baude rate sets the communication rate and must be the same as for the Arduino. Look up which one you used for your Arduino program (here 9600), otherwise it won’t work. The TRANSNOW mode is used to transmit the message immediately:

To check if the steps above were successful, we write the first command, to switch the LED on:

The variable m_value sets the intensity and should be between 0 and 255 (0 is off). m_lastWrite contains the last value which was send to the Arduino. This way we avoid useless re-sending of the same value again and again .

Now we need a little more UI beside the button to be able to change the LED intensity. I decided to use a radio group to select different brightnesses (off, middle, full). Create them in the qml File an use an invoked method, when the onSelectedIndexChanged signal is received:

Each time the user select a different button writeSerial() is called. In this method the first thing is to verify which index was selected and set the intensity accordingly. I checked it with a switch-case-instruction and changed the intensity manually.

Because we only want to send the value to the Arduino, when it is connected and the path is open, the variable m_serial need to be checked. As you might remember from the part I of this blog m_serial is set to -1 in the constructor and after each disconnection. If the Arduino is connected, we send the new brightness value by calling write().

Now you learned how to connect the Arduino to your BlackBerry 10 device and how to control it. With that you can write an own little protocol which the Arduino can interpret. Further information can be found here at the website.

Download the whole project here.

How to Connect and Control an Arduino Board with Cascades

IMG_20140228_094623Hey, here is @leaschnherr and today in the context of mobile computing platform I want to explain to you how can use the USB host mode of a Z30 device to control an Arduino Uno Board. To keep it simple, my aim was just to manipulate the intensity of an external LED connected to a GPIO.

The code running on the Arduino can be used unchanged from the Dimmer example of Arduino, which you can find here with helpful explanation.

If you work with an Arduino for the first time, read the introduction at the website here. Be sure the program is running correctly and try out some examples to get used to the environment.

The Code for the BlackBerry 10 App  is a little more complex and in the first part I only want to explain, how to recognize and handle a connected USB device:

After creating a new Cascades project the first thing which has to be done is to add the Peripheral Discovery Library. In the Momentics environment just click right on the Project folder. Then choose configure->Add Library->Standard BlackBerry platform library and click ‘next’. Search for libperipheral_discovery, select it and click ‘finish’. The Library is now added automatically to the config.pri file, which gets included to the .pro file.

In the first part no GUI is needed, so you don’t have to care about it during the recognition and I’m going to explain it in the second part. The only thing which has to be done is to create an instance of a class which I called Disvover. Here is the constructor of this class:

The function bps_initialize() has to be called as once you need any services from the BPS layer. For our project we need with the Peripheral Discovery Service. Then we need to initialize the Peripheral Discovery Service themselves by calling pd_initialize(0). Then to detect connection and disconnection of the Arduino board, we need to register for the m_sigEvent and a corresponding handler (signalHandler()) via the bps_add_sigevent_handler() function. signalHandler() is now called each time, when defined events occur.

After that it is necessary to check, if the USB host mode is supported:

This could be done with a simple function called  pd_is_bus_supported()The app will run on other devices, too, but it won’t be possible to control an external USB device. If the request was successful, and the Blackberry 10 Device supports the USB host mode, the next step is to register the necessary events:

Before any method with pd_class_t as parameter is used, the function pd_is_class_supported() should be called.  In this case with PD_CLASS_SERIAL as Parameter, this is for serial communication. When this call doesn’t return an error, we go ahead and register m_sigEvent with PD_CLASS_SERIAL. Now every time, when a USB device is connected or disconnected to the Blackberry 10 device,  signalHandler() is called (see constructor):

Because the signalHandler() function has to be a static and doesn’t allow to use non-static variables, we simply use a function pointer to another function, which checks for us, whether the Arduino was connected or disconnected:

In case of a connection, a peripheral is allocated with the detected pd_peripheral_t as Parameter (For further explanation see next section). In the other case, when the Arduino was disconnected, the pd_free_peripheral() method is called and other preparations for the next connection are made (the variable m_serial is set to -1 , which is required for communication).

Our peripheral is saved as class Peripheral. This simple class contains the path, which is a property of  pd_peripheral_t itself. Later it is possible to use this class for further information. In the constructor the path is read out by a couple of constructions, which are necessary to filter the right property:

The path is one property in a long list of properties. So the first thing to do is to fetch the whole list. Then we look at each property and use the type as filter: Because our currently path the only string we will know we have the right property. Of course good programmers would check the string for example if it includes “/dev” :-)

Now it will be possible, to connect and recognize the Ardunio. How we use this interface to send instructions to the Arduino is explained in part II.

Make your App Social with BBM, Part II

Hier ist wieder @leaschnherr mit dem zweiten Teil, indem ich beschreibe wie dein BBM Profil via App verändert werden kann. Dafür muss die App zunächst bei BBM registriert sein. Eine Beschreibung der notwendigen Schritte ist hier zu finden, im ersten Teil dieser Serie. Um Zugriff auf das Profil zu bekommen und es zu ändern ist für jeden Parameter der gleiche Prozess notwendig. Manche Parameter können allerdings nur gelesen werden, aber nicht überschrieben werden. Der Status, die Status Nachricht und das Bild können über eine externe App geändert werden. Hierfür zeige ich die Vorgehensweise in einem Beispiel, welches dann für alle Parameter nach dem gleichen Prinzip durchgeführt werden kann.

Vor dem C++ Code müssen zwei einfach qml Dateien erstellt werden. Die erste zeigt einfach die aktuellen Profil Parameter. In diesem Beispiel werden nur der Name, die Status Nachricht und das Beschäftigt Flag verwendet. Hier ist der qml Code, der als Beispiel genutzt werden kann:

Wichtig ist nur die visible Property vom ImageView und die text Properties vom Name Label und Status Message Label. In diesen Zeilen bekommen die Komponenten die aktuellen Werte aus dem Profil. Es spielt später keine Rolle, welche Quelle die Werte ändert, die Properties werden automatisch aktualisiert.  _profile stammt aus dem C++ Code und wird weiter unten erläutert.

Auch wichtig ist, dass die ganze Page von einem navigationPane umgeben ist, damit über ein action item die nächste qml Datei gepusht werden kann. Dafür darf nicht vergessen werden diese Datei unter attachedObjects hinzuzufügen (hier update.qml genannt).

Diese zweite qml Datei wird dazu genutzt die Profil Daten zu ändern:

Es wird eine checkBox genutzt, um das Beschäftigt Flag zu ändern und ein TextField für die Status Nachricht. Diese Datei sieht sehr ähnlich aus wie die profile.qml, nur dass zusätzlich ein Button zum speichern benötigt wird. Dieser Button nutzt das onClicked() Signal um eine Funktion mit den Properties als Eingabe Parameter aufzurufen (Die Funktion wird später erklärt). Die zweite Zeile stellt sicher, dass zu profile.qml zurückgesprungen wird.

Nachdem die qml Dateien vorbereitet sind werden nur noch wenige Zeilen C++ Code benötigt. In der Profile.hpp werden Macros verwendet um die angezeigten Parameter automatisch zu ändern:

Der erste Wert ist immer der Name, der aus der qml Datei aufgerufen wird. Der nächste Parameter, nach READ, ist die dazugehörige getFunktion um den Wert der Variable zu liefern, welche in der selben Klasse definiert werden muss. Der letzte Parameter, nach NOTIFY, nutzt das Signal profileChanged(), welches in der Header Datei definiert sein muss (als public Signal). Diese Konstruktion sorgt dafür, dass die angezeigten Werte automatisch geändert werden, wenn das Signal profileChanged() aufgerufen wird.

Im ersten Teil dieser Serie wird ein Slot showProfile() aufgerufen. Das ist der Punkt, an dem profile.qml eingefügt wird:

Die Klasse UserProfile ist eine private Variable unserer Klasse, die das aktuelle BBM Profil beinhaltet. Die nächsten Zeilen sind sehr wichtig: Hier wird unser profileChanged() Signal aufgerufen, wenn sich die Parameter im BBM Profil geändert haben, die wir nutzten.

Dann wird die UI erstellt und angezeigt. Hier geben wir dem QmlDocument eine Referenz zu unserer Klasse mit. So ist diese als _profile in der qml Datei bekannt, wie sie zuvor schon genutzt wurde.

Der Button zum speichern update.qml nutzt einen public Slot der noch definiert werden muss:

In der Funktion werden die neuen Werte mit den alten Werten verglichen und für den Fall, dass sich ein Wert geändert hat wird ein Request zum ändern dieses Wertes aufgerufen. Der Vergleich der alten und neuen Werte sieht etwas kompliziert aus, da bevor der Wert tatsächlich geändert wird der Nutzer diese über eine Message Box bestätigen muss. Diese erscheint aus  der UserProfile Klasse. Um also zu vermeiden, dass eine solche Abfrage kommt, obwohl nichts geändert wurde werden in der if-Abfrage alle möglichen Kombination überprüft. Die Parameter werden jetzt im BBM Profil und in der App geändert.

Make your App Social with BBM, Part II

IMG_00000016This is @leaschnherr again, with the second part, where I describe how to modify your BBM Profile via an app. For that the app need to be registered at BBM. A description of the necessary steps can you find here in the first part of this series. To get access to the profile and change it, it is the same procedure for each parameter. Some parameters can only be read but not be overwritten. The status, personal message and the picture can be changed by an extern app. Therefore I show you the steps in an example, which can be duplicated for all parameters.

Before starting with the C++ code, we create two simple qml files. The first only shows your current Profile parameters. In this sample we only use the displayed name, the status message and the busy flag. Here is some qml code which you can use as pattern:

Important are only the visible property of the ImageView and the text properties of the Name Label and the status Message Label. In these lines you get the current values from the profile. Later it doesn’t matter which source change the values, the properties are updated automatically via  _profile, which comes from the C++ code and is explained later.

Important is also, that the whole page is wrapped by a navigationPane, cause we use an action item to push the second qml file. Therefore don’t forget to attach the other qml file (called update.qml).

The second qml file is used to change the profile datas:

A CheckBox is used to modify the busy flag and a TextField for the status message. It looks very similar to the profile.qml, but additionally a button is used to save the new values. This button uses the onClicked signal to call a method with the properties as input parameters  (This method is declared later). The second line in this signal ensures the jump back to the profile.qml.

After preparing the qml files only a few lines of code are required.  In the Profile.hpp macros are used to automatically change the displayed parameters:

The first value is always the parameter, which is called out of the qml file. The next parameter, after READ, is the associated getFunction to returns the variable  (need to be defined in your class). The last parameter, after NOTIFY, use the signal profileChanged() signal, which must be declared in this header file as public signal. This construction now automatically updates the properties in the qml file when the variable in the c++ code changed.  We only have to use the profileChanged() signal.

In the first part of this series a slot showProfile() was used. This is the point the new profile.qml is inserted:

The class UserProfile is a private variable of our class which includes the current BBM profile. The next lines are very important: Here we call our signal profileChanged() when the parameters we use are updated in the BBM profile, so that our displayed datas are changed. Next the UI is created. Here we give the pointer of our class to the QmlDocument. Now the class is known as  _profile in the qml file, which already is used, as you see.

The save button in the update.qml uses a slot which need to be declared as public slot:

Here the value from the input is compared with old value and, in case, a request to change the value is send. The comparison looks a little complicated, because before the profile actually is changed the user has to accept this in a message box, which appears out from the UserProfile class. To avoid the message box if the user changed nothing, the if-construction checks all possible combinations. The parameters are now changed in both, the BBM Profile and the app.

Make your App Social with BBM

Hier ist @leaschnherr, eine Studentin die mit @Klajili im Tech Center Bochum arbeitet. Ich werde euch heute zeigen wie man eine App auf eine sehr einfache Art und Weise bei BBM registriert. Das hilft seine App zu verbreiten und die Downloadzahlen zu erhöhen.

Screen Shot 2013-10-31 at 5.05.45 PMDas erste was getan werden muss, ist die Erlaubnis in der bar-descriptor.xml Datei zu setzten. Wenn du Momentics benutzt, kannst du diese einfach durch einen Doppelklick öffnen und unter dem Application Tab findest du alle Permissions.

Als nächstes muss noch die BBM Library zum Projekt hinzugefügt werden, z. b. indem die Zeile LIBS += -lbbplatformbbm  in die .pro Datei kopiert wird. Alternativ kann man auch auf das Projekt rechtsklicken und Project->Configure->Add Library…  auswählen. Dann auf Standard BlackBerry platform library und als nächstes nach ”libbbplatformbbm” suchen. Wähle diese Library und klicke auf finish. Das ändert automatisch die .pri Datei.

Um BBM zu nutzen braucht man eine UUID. Diese wird benötigt, um deine App bei BBM zu identifizieren. So eine bekommst du z. B. hier: http://www.guidgenerator.com. Jede App braucht ihre eigene einzigartige UUID und es sollte die gleiche verwendet werden, wenn eine neue Version der App veröffentlicht wird.

Los gehts es mit main.cpp:

wie du siehst werden nur einige Zeilen benötigt. Neben der UUID kann eine einfache GUI erzeugt werden um den Benutzer zu zeigen was passiert. Nun werden nur noch drei weitere Zeilen benötigt. Das Erstellen der Klasse Registration und der Klasse Profile (Diese Klasse wird später benötigt um das Profil anzuzeigen). Die dritte Zeile verbindet das Signal der Registration Klasse (dieses wird gesendet, wenn die Registrierung erfolgreich war) und das Slot welches die nächste Page anzeigt.

Die Klasse Registration  registriert die App bei BBM. Dieser Schritt wird nur beim ersten Ausführen der App durchgeführt. Somit muss im erste Teil gecheckt werden in welchem Zustand sich die App befindet. Hierfür wir die Klasse Context und ihr Objekt  RegistrationState verwendet.  RegistrationState beinhaltet ein Enum mit 15 möglichen Zuständen (Die möglichen Zustände sind hier dokumentiert). In der App muss der aktuelle Zustand herausgefunden werden und abhängig von diesem die App registriert werden. Hier wurde das über eine switch-case-Anweisung gemacht, allerdings nicht alle möglichen Zustände berücksichtigt. Stattdessen wurde eine qDebug Ausgabe verwendet, um den Registrierungprozess zu verfolgen und, für den Fall, zusehen, was schief gegangen ist.

Da der Zustand sich mehrmals ändern kann muss registrationStatus() als Slot mit dem Signal registerStateUpdated() der Context Klasse verbunden werden.

Um den Prozess zu starten muss registrationStatus() einmal aufgerufen werden. Jetzt wird die App entweder die Registrierung anfordern oder ein Signal aussenden, was anzeigt, dass sie bereits registriert ist. Die Dritte Möglichkeit ist, dass ein Fehler aufgetreten ist. In diesem Fall muss die Konsolenausgabe gelesen werden um den Fehler zu beseitigen. Wenn alles gut läuft zeigt BBM eine Toast Nachricht an.

IMG_00000015

Make your App Social with BBM

This is @leaschnherr, a student working in the Tech Center Bochum with @Klajili. Happy to show you today how to register your app to BBM in a very simple way. This will help your app getting viral and increase the downloads considerably.

Screen Shot 2013-10-31 at 5.05.45 PM

First thing you need to do is to set the permission for BlackBerry Messenger in your app bar-descriptor.xml file. If you use momentics, you can double click on it and go to the Application tab to see and set the permission.

Second you will need to add the BBM platform libraries to your project by adding the line LIBS += -lbbplatformbbm in the .pro file or rigth click on your Project->Configure->Add Library… . Choose Standard BlackBerry platform library, click next an search for “libbbplatformbbm”. Select this library an click finish. This will modifiy your .pri file.

To use BBM you need an UUID. This is needed to identify your app to BBM. You can for example get one at: http://www.guidgenerator.com. Every app needs its own unique UUID and you should use the same UUID when you release a new version of your app.

Let’s modify main.cpp first:

As you can see, just few lines of code are required. Besides the UUID you can show a GUI to indicate the user what is happening. Now only three other lines are needed. The creation of the Registration class and Profile class (This class will be filled later to show the profile). The third line connects the signal of the Registration class (which is emitted when registration is ready) and the slot which shows the next page.

The class Registration registers the app to BBM. This step is only required when you start the app for the first time. So the first part of the code is to check in which state the app is. For this the class Context and its property RegistrationState is used. RegistrationState concludes an enum with 15 possible states of your app (The possible states are documented here). In your code you have to check the current state of your app and possibly, according to your state, request to register your app. Here it is done by a method with a switch case instruction, but does not considering all possible states. Instead a qDebug output is used, to follow the registration process and see, in case, what went wrong.

Because the state could switch several times you have to connect registrationStatus() as slot  with the signal registerStateUpdated() from the Context class.

To kick off registration registrationStatus() has to be called at least one time. Either the app is now request to register or a signal emits to indicate, that the app is already registered. The third option is that an error is occurred. In this case read the state in your console to fix the error. When everything went right, BBM shows a Toast .

IMG_00000015

This Toast appears automatically after registration

Welcome BlackBerry Developer Group Ruhr in Bochum/Germany

bbdevgrp_bochum1Congratulations to Andreas (@Andi_Gabel) and Kai (http://kuchenbecker.me ) who really did an awesome and professional job preparing the first meet up of the BlackBerry Developer Group Ruhr in Bochum/Germany.  They kicked off the event by welcoming the around 15 guys and introducing themselves to the crowd. Then gave me the stage to talk about BlackBerry 10. I gave an overview on our whole eco-system and did some demo to show the BlackBerry 10 user experience because surprisingly some of the attendees didn’t yet get a chance to play a round with one of our awesome BlackBerry 10 devices but very keen to learn how to build apps for our platform.

bbdevgrp_bochum2I really was impressed by some of the attendees like Jörg, Marcel and Michael who took a long journey of 60+ KM to attend our meet-up. Champion was Georg (@gpheheise) who came along the way down from Hamburg to attend. He is by the way the lead of the BlackBerry Developer Group in north Germany and didn’t want to miss that special event of launching a new developer group in Germany.

I really enjoyed the evening with those BlackBerry Fans and I am looking forward to be present at the upcoming meetings of the group, at least when I am around in my home city Bochum.

 

Thanks Andreas, Thanks Kai and good luck leading the group.

 

If you wish to get in touch here you go: www.bbruhr.de  | @BBDevRuhr  | hello@bbruhr.de

 

Kamel

 

Cascades Workshop in Muscat/Oman

It was a gently recommendation by my colleague Nafeesa from the BlackBerry® Academic Program to drive this one day Cascades workshop organized by the IT-Authority in Muscat/Oman for University stuff and others. So I used the opportunity to be in the region for the KSA Jam and continued the journey to Oman.

Mrs Azhaar from the ITA did a great job to set up everything for the workshop: The location, the invitations, the setup at the Venue, etc… We started quite early in the morning with around 15 attendees, all of them equipped  with laptops and 2 of them even with a BlackBerry 10 device. After an introduction to BlackBerry 10 including a demo on the most important features, we started by installing the SDK, the Simulator, etc… It took quite long time until everyone was setup. Unfortunately the Network connection was not so good and thus I zipped my Momentics folder and distributed it to them. Which was a bit challenging for the laptops to get it unzipped. But all went well. The setup is an important step of getting started and I wanted to make sure they all run out with a working simple app and that was reached. I introduced them to topics like localization, active covers, List management etc… I planned to talk about the invocation framework and integrate the camera in the sample we built but that had to be a homework for attendees as they all received my presentation and the demo projects.

I met a small team from the private Technology university and we talked about building the first BlackBerry dev group in Oman. They wanted to check with their Students and come back to me. I will be very happy to get that setup as by then we will have 6 Communities around the Middle East.

muscat_omanThank you very much Mrs Azhaar and your ITA organization for this opportunity. Thanks to all the participants for a nice Day in Muscat. I am looking forward to connect with you all soon and plan our next engagement in your lovely country.

Kamel