• Intro
• Downloads
• Community
• Development
• News
• TALK

Documentation/Maemo 5 Developer Guide/Using Data Sharing/Sharing Plug-in

Revision as of 11:56, 6 October 2009

Sharing Plug-in Creation

Maemo 5 introduces a new library for handling Sharing related information and services. This chapter will walk you through the process of creating a sharing plug-in using a template plug-in as example. Basic knowledge of debian development and working in scratchbox environment is needed in order to follow these guides.

Plugin example is located here Data Sharing Plugin example

Detailed API documentation is available in sharing-plugin-doc package in gtk-doc format.

Sharing User Interfaces

Sharing application abstracts the file sharing and implements common parts needed for file sharing application. Sharing Application service support can be extended by using Sharing Plug-ins. These plug-ins can be created by any 3rd party developer. The plug-ins should implement the Sharing Plug-in API functions and define some parameters to service definition XML file.

Figure 1 below shows Sharing accounts dialog opened from the control panel. With the Sharing accounts, you can create a new Sharing account or edit an existing one. If you install a custom Sharing plug-in, you can see the service it provides in the "Select service list" when creating a new Sharing account.

Figure 1: Sharing Accounts

Figure 2 shows the Sharing Dialog user interface that is used to share images to the selected account on some service. The images displayed can come for example from Photos application or from the device camera. You can choose the account created for your service from the "Account" combo box which holds all existing Sharing accounts.

Figure 2: Sharing Dialog User Interface

Getting Familiar With Target Service API

Many web services provide APIs that are available for 3rd party developers. In this tutorial, we focus on services that provide APIs for image and video uploads. It is possible to give title, description and tags for the images using the common service API. Sharing supports image scaling and meta data filtering as common options for any service. Sharing Plug-ins can have service specific options, like privacy. These settings can be accessed through Options dialog (in Figure 2.)

Getting Your Dummy Plugin To Sharing Menus

As a pre-requisite, you will need a working Maemo 5 SDK to continue further. We will first install the Sharing Plug-in template:

• Obtain the template source code sharing-plugin-template-0.1.tar.gz from <URL HERE>. It contains a good start up file structure for the plug-in creation.
• Extract and build the package from the folder using command:

./autogen.sh; dpkg-buildpackage -rfakeroot -d

• Install the package built to your Scratchbox environment or to device if it was build with ARM target.
• The template dummy service should be now visible in the Sharing account when creating new accounts.

Editing Template Plug-in

In this section, we peek under the hood by opening the files found from the template plug-in and get familiar with Sharing classes that are used in the Sharing Plugin API functions.

Sharing Internals

Figure 3 shows the general overview of how Sharing Plug-in connects to Sharing Application using the Sharing Plug-in API. The basic plug-in components are the service definition file and the plug-in library. The Application Sharing-Dialog is used to create SharingEntries that are shared by SharingManager. Sharing Account Manager implements the Sharing Accounts. Libsharing is library for all common Sharing functionality.

Figure 3: Sharing Plugin API

Figure 4 shows the common Sharing classes found in libsharing that you would use while creating the plug-in. SharingTransfer is the object that contains all the data of sharing task, overall status of the transfer process for one set of shared files. SharingEntry contains the the SharingEntryMedia that are the selected files. It also knows the SharingAccount that is the target of sharing. SharingAccount contains the username and password along with other parameters that you have to save for your service's accounts. It also has the information about SharingService which is registered to the SharingAccount.

Figure 4: Libsharing classes

To see more detail the sharing classes you can browse to: <PUT URL TO Sharing plug-in dev TO HERE>.

Service XML File

Service definition file, data/template.service.xml.in is the starting point for plug-in loading. It defines the library that implements Sharing Plug-in API functions, the sign up URL for totally new account creation by using web browser, service name, icon file names and some basic information from plug-in.

<?xml version="1.0" encoding="UTF-8"?> 
<service plugin="libtemplate.so" provider="Me"> 

   <accounts plugInSetup="0" plugInEdit="0">
     <signup>www.maemo.org</signup> 
     <password maxlen="32"/> 
   </accounts> 

   <ui> 
       <name>Template</name>  
       <icon type="post">@servicesdir@/template-post.png</icon> 
       <icon type="setup">@servicesdir@/template-setup.png</icon> 
       <options> 
       	<option id="privacy" type="enumeration" default="private"> 
               <caption domain="osso-sharing-ui" key="share_bd_options_privacy"/> 
               <value id="private" domain="osso-sharing-ui" key="share_fi_options_privacy_private"/> 
               <value id="public" domain="osso-sharing-ui" key="share_fi_options_privacy_public"/>
               </option>
        </option>
    </ui>
</service>

File 1: Example service definition XML file

The prefix of name "template.service.xml.in", "template" in this case, defines the id of the plugin. The "plugin" value in the service definition defines the library that implements the Sharing Plug-in API. In this example file the library is libtemplate.so in the above example. "Provider" is the developer name, nick etc. In "accounts", you define the plug-in account setup and edit flows described more in detail in the coming sections. Sign up URL is the URL that is opened in the browser when a new account is being created for a service.

Account Setup User Interface Flow

Sharing accounts can either create a default flow where "username" and "password" parameters are set to the account or an optional custom flow. In File 1, the "accounts" tag has a parameter "plugInSetup". If it is set to "1", Sharing Accounts will call the Sharing Plugin API function "sharing_plugin_interface_account_setup" to create UI flow; it will use the default flow. You can see the difference between UI flows when creating Flickr and Ovi account. Ovi uses the default flow and Flickr uses it's own UI flow.

SharingPluginInterfaceAccountSetupResult sharing_plugin_interface_account_setup (GtkWindow* parent, SharingService* service, SharingAccount** worked_on, osso_context_t* osso)

If you decide to create your own account setup flow, please try to keep the same UI look as in other Sharing dialogs.

Account Validation

Account validation is needed to reduce error cases in actual sending process. Of course you can use the dummy function at template plug-in, but for better user experience this function is recommended to be implemented so that Sharing Account account information is really validated against the service when new account is created.

Next function is called after sharing_plugin_interface_account_setup call ends or when default account setup flow is done (=when "Validate" button is pressed).

SharingPluginInterfaceAccountValidateResult sharing_plugin_interface_account_validate (SharingAccount* account, ConIcConnection* con, gboolean *cont, gboolean* dead_mans_switch)

In the last phase of account creation, the account must be validated. Sharing Plug-in API sharing_plugin_interface_test_account is the function called in the validation phase of the account creation flow. Usually web services have a phase in account creation where you have put the needed information from your account, only then you get the actual credentials to upload images if your account information is valid. This is the phase that is implemented in the Sharing Plug-in API function.

Account Editing User Interface Flow

Sharing Accounts support here too either default flow where “username” and “password” parameters are edited or optional custom edit UI flow. The wanted flow can be set by setting the parameter "plugInEdit" from the service definition file either to "0" or to "1" where "0" means the default flow and "1" plug-in flow.

The default flow can be used when you need only username and password to get needed information for sending. The plug-in flow is used when you need more than this or customised account validation flow. You can see the difference between UI flows here too when editing Flickr and Ovi accounts.

Next function must be implemented only when plug-in account setup is used (when "plugInSetup" is set to "1"):

SharingPluginInterfaceEditAccountResult sharing_plugin_interface_edit_account (GtkWindow* parent, SharingAccount* account, ConIcConnection* con, gboolean* dead_mans_switch)

Sending Functionality

SharingPluginInterfaceSendResult sharing_plugin_interface_send (SharingTransfer* transfer, ConIcConnection* con, gboolean* dead_mans_switch)

After pressing the 'Share' button in Sharing dialog (Figure 2.), the data is put into the Sharing Outbox (can be seen under /home/user/MyDocs/.sharing/outbox/). Sharing manager process is started and the status menu gets the icon to process the new Sharing Entry. SharingHTTP provides an API to create common HTTP requests. In order to create a better user experience following things are good to be implemented after you get the basic functionality working in your plug-in:

• Set progress of sending with sharing_transfer_set_progress between 0 and 1 to estimate the current transfer time / total transfer time.
• Set sent to SharingEntryMedia with sharing_entry_media_set_sent when file sending is done and check the send value with sharing_entry_media_get_sent to prevent sending same files multiple times for example in reboot scenarios.
• Poll cancel flag time to time, for example in curl or SharingHTTP progress function to end transferring when needed. Use sharing_transfer_continue to get the continue flag bit.
• If you are using libcurl instead of SharingHTTP, please listen to conic events to disconnect transfer when no connection available. It returns with 'no connection' return value in this case.

Next some example source for common tasks found in usual sending functionality:

Example sending loop

When you process SharingEntryMedias from the SharingEntry you propably end up with loop where you go the list of SharingEntryMedias through. Here is a raw example, where some example lines commented out with "//".

for (GSList* p = sharing_entry_get_media (entry); p != NULL; p = g_slist_next(p)) {
   SharingEntryMedia* media = p->data;
   /* Process media */
   if (!sharing_entry_media_get_sent (media)) {
       /* Post media */
       //guint result = my_send_task_post_function (my_send_task, media);
       /* Process post result */
       if (result == 0 /* EXAMPLE: MY_SEND_RESULT_SUCCESS */) {
           /* If success mark media as sent */
           sharing_entry_media_set_sent (media, TRUE);
           /* And mark process to your internal data structure */
           //my_send_task->upload_done += sharing_entry_media_get_size (media); 
       } else {
           /* We have sent the file in last sharing-manager call */
           //my_send_task->upload_done += sharing_entry_media_get_size (media);
       }
   }
}

Example tags string

Usually services accept the tags in their API to be added to images. Here is example source to create nice string about tag information to be put where ", " string used as separator. If service supports also geo tagging you should develop this source further by checking the tag type also.

static gchar* create_tags_str (const GSList* tags)
{
   gchar* ret = NULL;
   for (const GSList* p = tags; p != NULL; p = g_slist_next (p)) {
       SharingTag* tag = (SharingTag*)(p->data);
       const gchar* tmp = sharing_tag_get_word (tag);
       if (tmp != NULL) {
           gchar* new_ret = NULL;
           if (ret != NULL) {
               new_ret = g_strdup_printf ("%s, %s", ret, tmp);
               g_free (ret); /* old return is freed */
           } else {
               new_ret = g_strdup (tmp);
           }
           ret = new_ret;
       }
   }
   return ret;
}
gchar* tags = create_tags_str (sharing_entry_media_get_tags (media));

SharingHTTP example

SharingHTTP is ment to be used for HTTP transfers. It is probably easier to use this than libcurl and libconic straightly in common cases. Give it a try at least if you are not familiar with libcurl!

SharingHTTP * http = sharing_http_new ();
SharingHTTPRunResponse res;
res = sharing_http_run (http, "http://example.com/post");
if (res == SHARING_HTTP_RUNRES_SUCCESS) {
 g_print ("Got response (%d): %s\n", sharing_http_get_res_code (http),
    sharing_http_get_res_body (http, NULL));
} else {
    g_printerr ("Couldn't get stuff from service\n");
}
sharing_http_unref (http); 

Uninstallation

Libsharing provides sharing-account-remover binary that can be used to clean Sharing Accounts created for your plugin. This binary is run by debian/ dir's prerm script. Prerm scripts are run just before the package is uninstalled. Change the plugin id from sharingplugintemplate to match your plug-in id in the script. Your plug-in's id is the service definitions files prefix. For template.service.xml, the prefix is "template".

Example prerm script:

#!/bin/sh
# You can use sharing-account-remover to remove the accounts at plugin
# uninstallation
if [ "$1" = "remove" ]; then
	/usr/bin/sharing-account-remover template
fi

Testing your plugin

After setting up your scratchbox environment you can start using and testing your own plugin.

Sharing framework consists following packages:

libsharing-plugin-dev
libsharing0
sharing-manager
sharing-account-manager
sharing-dialog

All the needed packages should be installed along with nokia-binaries.

Important: When testing inside scratchbox remember to start the signond daemon after the desktop is started. Signond is used for storing the account information and it's needed in order to get Sharing framework working properly

[sbox] > signod &

Also remember to install the debian .deb package build from your sources.

Creating sharing account is started from setting.

settings -> Sharing accounts -> New

Select your service and create new account. After one account is created you can use ImageViewer for sharing images and MediaPlayer for sharing video files.

Sharing your plugin with others

Maemo Extras repository is the best place for your plug-in if you want to get users for it. More information on how you can upload packages to Extras repository can be found [here].

Before uploading plugin to public repositories make sure you have updated the debian configuration files to match your information under ./debian folder.

Also make sure that the section is set to user/other. This way the package will be installable by application manager. Below example version of debian control file.

Source: sharing-plugin-template
Section: user/other
Priority: optional
Maintainer: Maemo Team <xxxx@maemo.org>
Build-Depends: debhelper (>= 5.0.0), 
   libgtk2.0-dev, libglib2.0-dev, 
   libconic0-dev, libosso-dev, 
   libsharing-plugin-dev
Standards-Version: 3.8.0