Displaying a landmark in Maps app via AIW API from Qt application

Under cut you can find a video demonstration and source code of the small Qt app which is able to launch preinstalled Nokia Maps application and display a landmark with custom description in it. Tested with Maps 3.06 and N8-00. Sample can be easely ported back to Symbian C++.

This sample uses AIW API and built in Qt SDK 1.1.3 with Qt 4.7.3.
Only basic capabilities required.

AIW API is an old approach of maps services usage. I would recommend to use Maps APIs everywhere where possible.

Map and Navigation AIW services header file (mnaiwservices.h) has been taken from PDK 3.0.4.

Same sample could be easely changed to perform NavigateTo and SelectFromMap actions.

Locator.sis

Locator.zip

Using Places API (extra feature: geolocation)

In the earliest version of the application, I was using a hard
coded location (Pariser Platz in Berlin) for the search, however this made the
application quite useless, unless you were looking for places near Pariser
Platz.


So GPS Positioning was the first of the things that I thought of improving
after the Meeting Point application was more or less working.
The idea was to use the phone GPS to get the current location of the phone, and
then start every search for places in this current position.



To achieved that we needed two things:



- The geolocation  API of platform services



- The searchCenter property of the SearchBox.



The idea was pretty simple, we just had to get the position
using the API, put it in the right format and give it to the SearchBox, using
it’s searchCenter attribute. The following code does all this:

var position
= {latitude: 52.516274,longitude: 13.377678}; //default position is Berlin

// callback function for geolocation.
function fillPositionFromGPS(pos)
{
    //
position coordinates
    var
lng = pos.coords.longitude;
    var
lat = pos.coords.latitude;
       position
= {  latitude: lat, longitude: lng };
       alert("geolocation set
to: "
+lng+"  ; "+lat);
}

function getPosition()
{
     
       try
       {

              so
= nokia.device.load("geolocation");
              try {
                  // timeout at
60000 milliseconds (60 seconds)
                  var
options = {timeout:60000};
                  // get the
current position
                  so.getCurrentPosition(fillPositionFromGPS, errorCB, options);
             
}
              catch(e) {
                  alert(extraDebug(e));
             
}
       }
       catch(e){
              alert("cannot load geolocation service"+extraDebug(e));
       }
}

var sb
= new
nokia.places.SearchBox({
         targetNode: ‘searchContainer’,
         template: ‘nokia.mobileHTML5.searchbox’,
         locale: ‘en-gb’,
         suggestions: {
             showAddress: true
         },
         searchCenter: function
() {
             return position;
         },
         onResults: onResults
});

 

 

You can see that, in case the geolocation
doesn’t work or while we are waiting for an answer (as it’s an asynchronous
call we are doing), we are positioned by default in Berlin.
Note also that we can’t pass the position attribute directly to the SearchBox
searchCenter, we need a function that returns an object with the position
coordinates.
Both the geolocation API and the Places API use the coordinates in
international system. So everything just fits perfectly and we don’t have to
worry about any conversion.

 

 

Start NFC Development with the Qt SDK today!

Qt NFCWith the current Qt SDK (1.2.0 or newer) the scope of Nokia’s NFC developer offering took a significant step forward. It features the final environment for developing NFC apps on Symbian and Harmattan using Qt.

In order to enable you to take full advantage of the Qt / NFC development options, read this small guide that will make your first steps easier. For more information, please also check out the NFC technology pages at Nokia Developer!

Windows, Linux, Mac

You can develop NFC apps for the Nokia N9 with MeeGo Harmattan on all platforms supported by the Qt SDK: Windows, Linux and Mac OS X.

Tools Installation

When you download and install the Qt SDK, ensure the following are selected:

  • Development Tools -> Symbian Toolchains -> Symbian Anna
  • Development Tools -> Harmattan

In case you forgot to enable for example the Harmattan package during installation, start the "SDK Maintenance Tool" to download and add these components to your existing Qt SDK installation.

Device Setup

Follow the instructions for all devices you want to enable for working with NFC:

  • Nokia N9 / MeeGo Harmattan: The device already ships with Qt Mobility 1.2; no installation is needed. The Nokia N950 is running the same MeeGo Harmattan platform, but lacks NFC hardware.
  • Nokia C7-00 with Symbian^3: NFC hardware comes with every C7 in the market, but you need Symbian Anna to enable NFC functionality. Therefore, make sure you run the "SW update" on the device, or use the Nokia (Ovi) Suite to start the firmware and the following application update! Your device should have software version Symbian Anna / 022.014 or newer (enter *#0000# in the dialer to check).
  • Nokia C7-00 with Symbian Anna: the device is ready for NFC development using Java ME or Symbian native C++. In order to use Qt for NFC development, you need to update the device environment to the latest version, in case the new Qt versions are not already on your phone:
    • Install Qt 4.7.4: C:\QtSDK\Symbian\sis\Symbian_Anna\Qt\4.7.4\Qt-4.7.403-for-Anna.sis
    • Qt WebKit: C:\QtSDK\Symbian\sis\Symbian_Anna\Qt\4.7.4\QtWebKit-4.8.1-for-Anna.sis
    • Qt Mobility 1.2.1: C:\QtSDK\Symbian\sis\Symbian_Anna\QtMobility\1.2.1\QtMobility-1.2.1-for-Anna.sis
    • (Recommended) Qt Quick Components: C:\QtSDK\Symbian\sis\Symbian_Anna\QtQuickComponents\1.1\QtQuickComponents-1.1-for-Anna-Belle.sis
  • Nokia 603 / 700 / 701 / C7-00 / 808 PureView with Nokia Belle or newer: if you’re lucky enough to have a NFC capable device with Nokia Belle +, you don’t need to do anything to enable Qt NFC development. Qt 4.7.4+ and Qt Mobility 1.2+ are already pre-installed and work out of the box. Do not overwrite the existing Qt / Qt Mobility installation with files from the Qt SDK that are intended for the Symbian Anna version only!

In addition, make sure you make your phone ready for communication with the Qt Creator IDE and on-device-debugging. This involves installing the "CODA" debug agent on all Symbian devices (no matter which version), or the "SDK Connectivity" tool on the Nokia N9. See the help of Qt Creator for more details.

Development

In general, it is highly recommended to use Qt Quick Components for developing the UI of your NFC application. Qt Quick Components are supported on all NFC capable Symbian and MeeGo phones. More information, for example on NFC availability detection, is available on the NFC technology pages.

Nokia N9 / MeeGo Harmattan: simply select the MeeGo Harmattan target to build and deploy your application to the Nokia N9.

Symbian: select the "Qt 4.7.4 for Symbian Anna" target of Qt Creator to develop your application to any Symbian^3 / Anna / Belle phone.
Note: Qt SDK offers a Symbian Belle specific SDK. The apps developed with the Anna target are also compatible to Belle; you only need the Belle SDK in case you access native Symbian libraries (=> non-Qt) unique to Nokia Belle.

Examples to get started

The best way to get started is reading through the Nokia NFC Development with Qt Mobility presentation. It explains the basics of NFC specifications, how the Qt Mobility APIs provide easy access to the technology and then walks you through two hands-on examples.

The three recommended sample-projects to check — all of them are working on Symbian and on MeeGo Harmattan:

  • Nfc Info: Shows all information about NFC tags available through Qt Mobility APIs. Includes reusable convenience classes for handling additional record types: Smart Poster, Image and vCard.
  • Nfc Corkboard: Extends the Qt Quick Corkboards example of the Qt SDK with NFC functionality: touch a tag and its NDEF contents appear as a new note on the screen. Press the NFC flag of a note on the screen and its contents will be written to the tag. Parses URI, text, Smart Poster and vCard records and shows a generic post-it for all other tag types. Includes NDEF autostart support for MeeGo Harmattan PR 1.1+.
  • Nfc Chat: The Nfc Chat is a sample app that demonstrates how to use the NFC LLCP protocol to create a peer-to-peer connection between two compatible NFC Forum devices and how to send messages between those devices.

More information can be found on the NFC technology pages.

Nokia Store Deployment

Deploying NFC apps to the Nokia store is fully supported on the Nokia Store. For more details on the deployment of NFC applications, make sure to check our NFC developer pages!

Known Limitations

To save you some time, the known limitations at this time:

  • No raw, tag-specific access on Symbian Anna: this doesn’t mean that the phone cannot interact with specific tags; reading and writing NDEF messages always works fine.
    Each tag type platform (e.g., NFC Forum Type 1 Tag Platform) has its own low-level protocol, where you can send commands as byte-arrays, and then parse the byte-array returned from the tag. This raw access does work fine on Symbian Belle, but is unsupported using the current Qt Moblity 1.2.1 version on Symbian Anna.
  • No raw, tag-specific access on MeeGo Harmattan: as described in the Qt Mobility documentation, tag-type specific access as described above is not supported on MeeGo Harmattan.
  • Qt Simulator: the simulator has a very powerful editor to create your own NDEF messages and records. You can use it to test your Qt application.
    Note that the two-step method of reading messages consisting of listening for targets and then asking the target for its contents does not work as expected. If you use the direct one-step process through QNearFieldManager::registerNdefMessageHandler(), the simulator works fine.
  • NFC QML Bindings: even though Qt Mobility 1.2 includes QML bindings to make the Qt/C++ NFC-APIs available in the QML environment, it’s recommended to use only the Qt/C++ APIs. The documentation and features supported by the QML bindings are very limited. It’s easy to combine a C++ NFC-handler class with your QML user interface code — all three Qt NFC examples linked above (Nfc Info, etc.) demonstrate how to do this. You can then take the NFC-handling C++ class and simply plug it into any QML project you wish.

Update (22. November 2011): Adapted the article with the latest status following the release of the Qt SDK 1.1.4.

Update (6. March 2012): Added Nokia 808 PureView to compatibility, updated references to Qt SDK 1.2.

NFC Device Kit available

While development and testing of applications can be done using simulators and emulators, nothing beats running and debugging your application on a real device. For this purpose we are making a special Nokia NFC Device Kit available for developers

For applications utilising NFC the need for a physical device is even more important. To be able to test how 2 devices react to each other with your application running, how well they react to different tags and different content stored on those tags, having access to a physical device is paramount.

For that reason we have made avaialable a dedicated NFC device KIT for developers. The kit includes:

  • 1 X Nokia C7 (with Sybmian Anna software supporting NFC)
  • 12 X Type 1 NFC tags (Topaz 96 bytes) 
  • 12 X Type 2 NFC tags (Ultralight C 64 bytes)
  • 1 X Special offer voucher for NFC products in TopTunniste webshop

The price of the NFC device Kit is 180 Euros. Note: the device indended use is for development and testing and thus special sales terms apply.

The Device Kit is available to Nokia Developer PRO and Launchpad program members (companies/organizations only). If your company/organization does not have a membership yet, not to worry -> we are offering a 1 year Nokia Developer Launchpad subscription FREE OF CHARGE. Go here and register.

 

 

NFC Device Kit available

While development and testing of applications can be done using simulators and emulators, nothing beats running and debugging your application on a real device. For this purpose we are making a special Nokia NFC Device Kit available for developers

For applications utilising NFC the need for a physical device is even more important. To be able to test how 2 devices react to each other with your application running, how well they react to different tags and different content stored on those tags, having access to a physical device is paramount.

For that reason we have made avaialable a dedicated NFC device KIT for developers. The kit includes:

  • 1 X Nokia C7 (with Sybmian Anna software supporting NFC)
  • 12 X Type 1 NFC tags (Topaz 96 bytes) 
  • 12 X Type 2 NFC tags (Ultralight C 64 bytes)
  • 1 X Special offer voucher for NFC products in TopTunniste webshop

The price of the NFC device Kit is 180 Euros. Note: the device indended use is for development and testing and thus special sales terms apply.

The Device Kit is available to Nokia Developer PRO and Launchpad program members (companies/organizations only). If your company/organization does not have a membership yet, not to worry -> we are offering a 1 year Nokia Developer Launchpad subscription FREE OF CHARGE. Go here and register.

 

 

Using Places API (Part III: WRT issues and App demo)

In this post I will talk mainly about the part that gave me
the worsts headaches when coding the application:  Platform Services 2.0.
While I was coding the place search and selection (using Places API) everything
was more or less progressing smoothly, but when you need to access the phone
things get a bit messy.

When you start programming using Nokia WDE, one of the first
things you notice is that there is no way of debugging Symbian WRT applications
when using the simulator.
For example: you can’t put breakpoints to see the variable values. So you have
to debug “old style” using alerts and your own var_dump functions.

While you don’t use the phone services, you can just run
your webApp on your web browser and debug it as any other. But this comes to an
end the second you start using in your code the Platform Services functions to
access the phone.

So to debug I often use this var_dump function that I found
somewhere online. I just changed a little bit the code to suit my needs:

function inspect(obj, maxLevels, level){

    var
str = , type, msg;
    //
Start Input Validations
    //
Don’t touch, we start iterating at level zero

    if
(level == null)
        level
= 0;
 
  
// At least you want to show the first level

    if
(maxLevels == null)
        maxLevels
= 1;
    if
(maxLevels < 1)
        return ‘<span
style="color:red;">Error: Levels number must be >
0</span>’
;
    //
We start with a non null object
    if
(obj == null)
        return
‘<span style="color:red;">Error:
Object <b>NULL</b></span>’
;
    //
End Input Validations
   
    // Each
Iteration must be indented
    str
+= ‘<ul
style="list-style:circle;padding:15px;">’
;

    // Start
iterations for all objects in obj
    for
(property in obj) {
        try {

            // Show
"property" and "type property"
            type = typeof(obj[property]);

            str
+= ‘<li
>(‘
+ type
+ ‘) ‘ + property +
            ((obj[property] == null) ? (‘: <b>null</b>’) : ()) + ((type != ‘object’) ? (‘: ‘+obj[property]) : ()) +
            ‘</li>’;

            // We keep
iterating if this property is an Object, non null
            // and we are inside the required number of levels
            if ((type == ‘object’) && (obj[property] != null) && (level + 1 < maxLevels))

                str
+= inspect(obj[property], maxLevels, level + 1);
        }

        catch
(err) {
            // Is there some properties in obj we can’t access? Print
it red.
            if (typeof(err) == ‘string’)

                msg
= err;
            else
                if (err.message)
                    msg = err.message;
                else
                    if (err.description)
                        msg = err.description;
                    else

                        msg = ‘Unknown’;

           str
+= ‘<li><span
style="color:red;">(Error) ‘
+
property + ‘: ‘ + msg + ‘</span></li>’;

        }

    }   

    // Close indent
    str
+= ‘</ul>’;   
    return
str;
}

 

I had some other issues
with the Platform Services (2.0  version),
the most important being that the Contacts API doesn’t seem to work at all in
the latest version of Symbian (Symbian Anna). 

For those who also
encounter issues with PS 2.0, it seems the official recommendation is to switch
to the old version, the PS 1.0 (as
said here
). Unfortunately it didn’t work in my case, just loading the 1.0 Contacts
API instantly crashed the application.

For that reason I
developed a version of the application getting the Friends list from the
outgoing calls log, instead of the phone contacts.

I put the code here:

Contacts version

 

//Gets the contacts list using
platformservices 2.0
function showContacts()
{
    try
{
       cal
= nokia.device.load("contacts");    
       try{
              if (typeof contacts
== "undefined") nokia.device.load("contacts");
              var
transactionID =
cal.getContacts(result_contacts,null,null,errorCB);          
      
}
       catch(e){ errorCB(e); extraDebug(e);}   
   
}
    catch
(e) {alert("cannot load contacts service"+extraDebug(e));}
}

//Success callback function for
the getContacts call
function result_contacts(outPut)
{
    var
entry = null;   
    try
{
        eligible_contacts
= new
Array();
        while ((entry = outPut.next()) != null) {
            //I keep the contacts in a list.
            eligible_contacts.push(entry);
        }
        selected_contacts
= new
Array();
        showEntryList(eligible_contacts, false, false);      
    }

    catch(err){extraDebug(err);}   
}

Call Logs version

 

//Gets the contacts using the log of outgoing calls, currently without Date
restriction.
function callLog(){
    if
(eligible_contacts
=== null) {
              alert("using outgoing calls log to fill the friends
list"
);//we
only alert the first time
              try {

                     var
commlog = nokia.device.load("commlog");
                     // Retrieves the specified number of logs.                          
                     var transactionId
= commlog.getList(showLogContatcs, {
                           type: "CALL",
                           flag: "OUTGOING"
                     }, errorCB);
             
}
              catch (e) {alert(e.toString());}
      
}     
}

//callback function for commlog, it fills the eligible_friends list with
the numbers retrived from your call log.
function showLogContatcs(outPut)
{
       var
entry=null;
       var
log;
       var
i=-1; // used for the id of the entry.
       try
{
        eligible_contacts
= new
Array();
        while ((log = outPut.next()) != null) {
            entry = new Object();
                     entry.id=i;
                     entry.tel= new Object();
                     entry.tel.mobile=log.phoneNumber;
                     entry.name= new Object();
                     entry.name.first=log.contactName;
       //I keep
the contacts in a list only if they are not repeated. In that case I keep the
one with name.
                     keepLogEntry(entry);      

                     i–;
        }

        selected_contacts
= new
Array();
        showEntryList(eligible_contacts, false, false);
    }

    catch(err){ extraDebug(err);}
}

 

Another bug appeared using the 2.0 Contacts API (in Symbian
older than Anna),  when iterating through
the results, but as it might be due to the phone I was using I will not dwell
into details, if you are interested look at this post
for more information.

However, after all the headaches were solved I finally had
the application up and running. Here I leave you some images to see how it
looks:

IMAGE 1: Here you can search for a place, either by category (like
restaurants or shops) or directly by name in the searchbar. Assume that we clicked the restaurants category.

IMAGE 2: After that, you look in the results and choose a place of
your liking, by clicking on it.

IMAGE 3: Here you take a detailed look at the place
that you chose and click on the "meet" icon to select this place as the
meeting point.

IMAGE 4: Then you choose the people that will be attending the meeting
(form your contacts  list or call log
depending on the version).

IMAGE 5: You pick a time for the meeting. And press the “Create
Meeting” button. Then the application will create an event in your phone calendar, also
an iCalendar file that will be attached to the MMS message sent to all the
numbers you previously choose.

IMAGE 6: Finally if all went well you’ll see a summary screen like
this.

Using Places API (Part II: the Coding)

After designing the application and collecting all the
components, it was time to code. But with the coding came the first
difficulties. The very first being a bug in the platform services 2.0. The
application would instantly crash when using both Platform Services and Places
API together.

There are two ways to avoid this:

Short
way:  just include the platform services
library before you include the Places API library. Like this:

 

      <script type="text/javascript" src="script/platformservices.js" charset="utf-8" ></script>

      <script
type="text/javascript"
src="http://api.maps.ovi.com/places/alpha3/jsPlacesAPI-en_GB.js"></script>

 

Longer way (better): you will correct the bug in the library. Look for
the initialitzation of the nokia.device object at the beginning of the library.

 

Replace this line:  if((typeof nokia.device)!="undefined")

For
this other line: if((typeof nokia.device)=="undefined")

After either one of those options, the library should work correctly.

For the Meeting Point application, I just needed the
Searchbox template (to search for a place), the placeList template (to display
the results) and the Place template (display the chosen meeting place)
My first idea was to use the default Places API templates, but when I displayed
them on the mobile phone they didn’t look nice and lots of elements were not in
the appropriate size.

Luckily I had one coworker developing some Places API
templates for mobile phones, so I took his work for my application :P (you can
see the code below)

For the searchbox and the placelist the default mobile
template was perfect for me.  Below there
are the template definitions, and the UI widgets declarations.

          PLACELIST
TEMPLATE

       
<div module="List">

            <ul each="{results[].place}"
rel="list-data" class="nokia-place-list">

                <li class="nokia-place-list-elem"
rel="nokia-place-item">

                    <img url="{categories[0].iconURL}"
class="nokia-place-category">

                    <div class="nokia-place-list-elem-content">

                        <p fill="{name}"
rel="nokia-place-name" class="nokia-place-name"></p>

                        <div class="nokia-place-address">

                            <span fill="{street()}"></span>, <span fill="{locality()}"></span>

                        </div>

                        <div tpl="nokia.general.rating"
if={placeId} class="nokia-places-mobile-rating-widget"></div>

                    </div>

                </li>

            </ul>

            <div rel="list-pagination"></div>

        </div>

           SEARCHBOX
TEMPLATE

       
<div module="SearchBox"
class="nokia-searchbox">

            <div class="nokia-searchbox-input-wrapper"
>

                <input class="nokia-searchbox-input"
type="text" rel="searchbox-input"/>

            </div>

            <input class="nokia-searchbox-button"
type="button" rel="searchbox-button"
value="Search"/>

            <div rel="searchbox-list"
class="nokia-searchbox-list">

            </div>

        </div>

Here you can find the
css file for the templates: ovi-places-mobileHTML5.css

 

 

        var placeList
= new
nokia.places.PlaceList({

               targetNode: ‘placeListContainer’,

               template: ‘nokia.mobileHTML5.placelist’,

               perPage: 100,

               locale: ‘en-gb’,

              
events:
[ {

                   rel: 'nokia-place-item',

                   name: 'click',

                   handler: function(jsonObject){

                       if
(jsonObject.placeId) {

                           place.setPlaceId(jsonObject.placeId);                               

                       }else{

                           place.setData(jsonObject);

                       }               

                       pageController("selectPlace");

                                 

                   }

               }]

           })

           var
onResults =
function(data){

                            placeList.setData(data);

                     searchType = "placelist";

                     showSearchPlace();

           }

 

         var
sb = new nokia.places.SearchBox({

               targetNode: ‘searchContainer’,

               template: ‘nokia.mobileHTML5.searchbox’,

               locale: ‘en-gb’,

               suggestions: {

                   showAddress: true

               },

               searchCenter: function
() {

                   return
position;

               },

               onResults: onResults

           });

As you can see the mobile templates are pretty much the same
as the “normal” templates, it’s the css that has the major changes.
Note also, that to use the mobile templates, I declare the UI Widgets in the
standard way, and the only thing that I need to change is the template
parameter.

I also wanted my application to erase the text on the
SearchBox when on the search page and the back button is pressed.
To achieve this small change you need the following piece of code:

 

function previousPageKey()
{
       if (actual == "searchPlace") document.getElementsByClassName(‘nokia-searchbox-input’)[0].value = "";   

}

 

function init(){            

window.menu.setRightSoftkeyLabel(‘Back’,
previousPageKey);

}

-       To change the behavior of the Back key in
Symbian you need to use this line of code:

window.menu.setRightSoftkeyLabel(‘Back’, previousPageKey);

As you also have to define the function
that will be triggered when the Back key is pressed.
more info

-      To know how to select the input field in the
searchBox. The quickest way is to use firefox + firebug and explore the html
content or use the html explorer of the simulator.

The
next step was to adapt the mobile place template, because I needed it to do
some specific things for my application. To be precise I wanted to add a button
for creating a meeting in the selected place.

You
can see the code for my mobile place template here:

<script id="mobilePlaceWidget"
type="text/template">  

<div tpl="nokia.mobileHTML5.map"
class="nokia-place-right"></div>

<div tpl="nokia.mobileHTML5.name" class="nokia-place-header"></div>

 

 

<div class="nokia-place-header
nokia-places-mobileHTML5-menu"
>

       <div class="nokia-place-menu">

              <ul>

                     <li class="nokia-place-menu-element
nokia-place-menu-phone"
>

                           <a url="{primaryPhoneCall()}">Call</a>

                     </li>

                     <li class="nokia-place-menu-element
nokia-place-menu-share"
>

                           <a url="{primaryPhoneSMS()}">Share</a>

                     </li>

                     <li onclick="pageController(‘selectFriends’);" class="nokia-place-menu-element
nokia-place-menu-route"
>

                           <a>Meet</a>

                     </li>

                     <li class="nokia-place-menu-element
nokia-place-menu-web"
>

                           <a url="{primaryURL()}">Web</a>

                     </li>

              </ul>

       </div>

</div>

 

     

<div tpl="nokia.mobileHTML5.gallery" class="nokia-place-header"></div>

 

<div if="{businessInformation.openingHours}">

    <p c

Using Places API (Part I: the Thinking)

After getting a little familiar with Places API,
it was time to put the
api to good use. So I came up with a simple idea, that would also bring
me for
first time to mobile phone applications. In this post and the two
following  ones I will tell you how I easily turned this "simple idea"
into a really nice app.

So, I wanted to create a Meeting Point application for
Symbian phones. The outline of the application would be very simple:

1-     
Search and choose a place for the meeting

To do that I could use Places API:

-         
A SearchBox and a Placelist templates for
searching.

-         
A Place template to choose the place.

2-     
Choose the friends you want to meet

The possible friends would be the list of the contacts in the phone.

3-     
Select a time for the meeting.

4-     
Create the meeting.

In your own phone: create an iCalendar event

Share
it: sending an MMS message to all the selected friends with the iCalendar event
attached.

 

The first difficulties came when I was looking on how I
would access the phone, because if you remember, Places API runs on a web
browser, so I needed this application to be a webapp. But could webapps access
the phone?
Luckily my coworkers pointed me to Nokia Web Developing and
there I found the answer: the nokia
WRT widgets
and the Platform Services library .

The WRT widgets are (quoting Nokia): "a type of Web application in which the HTML,
CSS and Javascript files are packaged and installed locally on the device
instead of being hosted on a remote server
".
So essentially they’re like a web application but you have to install it and
run it locally with the Symbian WRT (Web Runtime). More
info

Platform Services is a JavaScript API that allows you to
access the phone services through the WRT, so you can use these services when
programming widgets.

With those two things I had my main problem solved, I could
create a webapp with access to the phone, but I found one last thing in the
Nokia page: a developing environment. It is specifically for Symbian web
applications, the Nokia
Web Tools
, is based on Eclipse, so if you have ever used it you’ll feel
like home. The great thing is that it comes with a simulator to test your
mobile applications before deploying them to an actual phone.

So I had Places API, the Widgets + platform services and the
development environment, I was all set to start.

 

Nokia Car Mode announced

Today at the IAA (Internationale Automobil Ausstellung), Nokia announced Nokia Car Mode, a standalone application optimized for the in-car use of Nokia smartphones. Nokia Car Mode features an optimized user interface simplifying the access and use of Nokia Drive (voice-guided car navigation with Nokia Maps), traffic updates, music and voice calls while driving.

Nokia Car Mode is the first commercially available solution supporting MirrorLink, formerly known as Terminal Mode. MirrorLink is a standard smartphone-to-car connectivity platform driven by over 20 major global brands from across different industries within the Car Connectivity Consortium (CCC). With MirrorLink, smartphones can be connected to in-car displays, car controls systems, and car audio systems. Thus consumers can control their smartphones via the car dashboard, as if the device and its apps were integrated into the car itself.

Full press release at http://press.nokia.com/2011/09/13/nokia-car-mode-drives-fusion-of-cars-with-smartphone-services/

Video presenting the Nokia Car Mode based on Mirrorlink solution from Alpine and Nokia is avilable at http://www.youtube.com/watch?v=EdHBFsy930A

 

MirrorLink™ trademark launched

The Car Connectivity Consortium announced yesterday the launch of its MirrorLink™ trademark. The first MirrorLink products will be presented by multiple member companies at the IAA International Motor Show, taking place in Frankfurt, Germany, September 15-25, 2011. Press release is available at http://www.carconnectivity.org/en/Communication/pressrelease.